// bslstl_variant_cpp03.h                                             -*-C++-*-

// Automatically generated file.  **DO NOT EDIT**

#ifndef INCLUDED_BSLSTL_VARIANT_CPP03
#define INCLUDED_BSLSTL_VARIANT_CPP03

//@PURPOSE: Provide C++03 implementation for bslstl_variant.h
//
//@CLASSES: See bslstl_variant.h for list of classes
//
//@SEE_ALSO: bslstl_variant
//
//@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 Mon Mar 16 12:05:58 2026
// Command line: sim_cpp11_features.pl bslstl_variant.h

#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'.

/// 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 <bool t_VALID, size_t t_INDEX, class t_ARG, class t_VARIANT>
struct Variant_GetIndexReturnTypeImpl {
};

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;
};

/// 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.
template <size_t t_INDEX,
          class  t_ARG,
          class  t_VARIANT = typename BloombergLP::bslmf::MovableRefUtil::
              Decay<t_ARG>::type>
struct Variant_GetIndexReturnType;

#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

/// 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 <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 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_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 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 <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 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_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;
#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 BloombergLP {
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 {

#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
#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 0
    template <class t_HEAD>
    static bsl::variant<t_HEAD>& asVariant(
                                            bsl::variant<t_HEAD>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 1
    template <class t_HEAD, class t_TAIL_01>
    static bsl::variant<t_HEAD, t_TAIL_01>& asVariant(
                                            bsl::variant<t_HEAD, t_TAIL_01>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 2
    template <class t_HEAD, class t_TAIL_01,
                            class t_TAIL_02>
    static bsl::variant<t_HEAD, t_TAIL_01,
                                t_TAIL_02>& asVariant(
                                            bsl::variant<t_HEAD, t_TAIL_01,
                                                                 t_TAIL_02>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 2

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 3
    template <class t_HEAD, class t_TAIL_01,
                            class t_TAIL_02,
                            class t_TAIL_03>
    static bsl::variant<t_HEAD, t_TAIL_01,
                                t_TAIL_02,
                                t_TAIL_03>& asVariant(
                                            bsl::variant<t_HEAD, t_TAIL_01,
                                                                 t_TAIL_02,
                                                                 t_TAIL_03>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 3

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 4
    template <class t_HEAD, class t_TAIL_01,
                            class t_TAIL_02,
                            class t_TAIL_03,
                            class t_TAIL_04>
    static bsl::variant<t_HEAD, t_TAIL_01,
                                t_TAIL_02,
                                t_TAIL_03,
                                t_TAIL_04>& asVariant(
                                            bsl::variant<t_HEAD, t_TAIL_01,
                                                                 t_TAIL_02,
                                                                 t_TAIL_03,
                                                                 t_TAIL_04>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 4

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 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>
    static bsl::variant<t_HEAD, t_TAIL_01,
                                t_TAIL_02,
                                t_TAIL_03,
                                t_TAIL_04,
                                t_TAIL_05>& asVariant(
                                            bsl::variant<t_HEAD, t_TAIL_01,
                                                                 t_TAIL_02,
                                                                 t_TAIL_03,
                                                                 t_TAIL_04,
                                                                 t_TAIL_05>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 5

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 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>
    static bsl::variant<t_HEAD, t_TAIL_01,
                                t_TAIL_02,
                                t_TAIL_03,
                                t_TAIL_04,
                                t_TAIL_05,
                                t_TAIL_06>& asVariant(
                                            bsl::variant<t_HEAD, t_TAIL_01,
                                                                 t_TAIL_02,
                                                                 t_TAIL_03,
                                                                 t_TAIL_04,
                                                                 t_TAIL_05,
                                                                 t_TAIL_06>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 6

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 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>
    static 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>& asVariant(
                                            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>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 7

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 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>
    static 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>& asVariant(
                                            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>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 8

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 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>
    static 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>& asVariant(
                                            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>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 9

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 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>
    static 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>& asVariant(
                                            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>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 10

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 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>
    static 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>& asVariant(
                                            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>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 11

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 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>
    static 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>& asVariant(
                                            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>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 12

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 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>
    static 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>& asVariant(
                                            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>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 13

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 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>
    static 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>& asVariant(
                                            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>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 14

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 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>
    static 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>& asVariant(
                                            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>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 15

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 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>
    static 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>& asVariant(
                                            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>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 16

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 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>
    static 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>& asVariant(
                                            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>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 17

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 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>
    static 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>& asVariant(
                                            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>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 18

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 0
    template <class t_HEAD>
    static const bsl::variant<t_HEAD>& asVariant(
                                      const bsl::variant<t_HEAD>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 1
    template <class t_HEAD, class t_TAIL_01>
    static const bsl::variant<t_HEAD, t_TAIL_01>& asVariant(
                                      const bsl::variant<t_HEAD, t_TAIL_01>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 2
    template <class t_HEAD, class t_TAIL_01,
                            class t_TAIL_02>
    static const bsl::variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02>& asVariant(
                                      const bsl::variant<t_HEAD, t_TAIL_01,
                                                                 t_TAIL_02>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 2

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 3
    template <class t_HEAD, class t_TAIL_01,
                            class t_TAIL_02,
                            class t_TAIL_03>
    static const bsl::variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03>& asVariant(
                                      const bsl::variant<t_HEAD, t_TAIL_01,
                                                                 t_TAIL_02,
                                                                 t_TAIL_03>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 3

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 4
    template <class t_HEAD, class t_TAIL_01,
                            class t_TAIL_02,
                            class t_TAIL_03,
                            class t_TAIL_04>
    static const bsl::variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04>& asVariant(
                                      const bsl::variant<t_HEAD, t_TAIL_01,
                                                                 t_TAIL_02,
                                                                 t_TAIL_03,
                                                                 t_TAIL_04>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 4

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 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>
    static const bsl::variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05>& asVariant(
                                      const bsl::variant<t_HEAD, t_TAIL_01,
                                                                 t_TAIL_02,
                                                                 t_TAIL_03,
                                                                 t_TAIL_04,
                                                                 t_TAIL_05>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 5

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 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>
    static const bsl::variant<t_HEAD, t_TAIL_01,
                                      t_TAIL_02,
                                      t_TAIL_03,
                                      t_TAIL_04,
                                      t_TAIL_05,
                                      t_TAIL_06>& asVariant(
                                      const bsl::variant<t_HEAD, t_TAIL_01,
                                                                 t_TAIL_02,
                                                                 t_TAIL_03,
                                                                 t_TAIL_04,
                                                                 t_TAIL_05,
                                                                 t_TAIL_06>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 6

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 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>
    static 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>& asVariant(
                                      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>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 7

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 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>
    static 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>& asVariant(
                                      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>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 8

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 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>
    static 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>& asVariant(
                                      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>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 9

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 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>
    static 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>& asVariant(
                                      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>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 10

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 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>
    static 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>& asVariant(
                                      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>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 11

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 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>
    static 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>& asVariant(
                                      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>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 12

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 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>
    static 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>& asVariant(
                                      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>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 13

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 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>
    static 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>& asVariant(
                                      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>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 14

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 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>
    static 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>& asVariant(
                                      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>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 15

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 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>
    static 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>& asVariant(
                                      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>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 16

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 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>
    static 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>& asVariant(
                                      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>& v)
    {
        return v;
    }
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 17

#if BSLSTL_VARIANT_VARIADIC_LIMIT_G >= 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>
    static 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>& asVariant(
                                      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>& v)
    {
        return v;
    }
#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 <class t_HEAD, class... t_TAIL>
    static bsl::variant<t_HEAD, t_TAIL...>& asVariant(
                                            bsl::variant<t_HEAD, t_TAIL...>& v)
    {
        return v;
    }
    template <class t_HEAD, class... t_TAIL>
    static const bsl::variant<t_HEAD, t_TAIL...>& asVariant(
                                      const bsl::variant<t_HEAD, t_TAIL...>& v)
    {
        return v;
    }
// }}} END GENERATED CODE
#endif

#if defined(BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES) \
 && defined(BSLS_COMPILERFEATURES_SUPPORT_VARIADIC_TEMPLATES)
    /// Returns a reference to the specified `v`.
    template <class t_HEAD, class... t_TAIL>
    static bsl::variant<t_HEAD, t_TAIL...>&& asVariant(
                                           bsl::variant<t_HEAD, t_TAIL...>&& v)
    {
        return std::move(v);
    }
    template <class t_HEAD, class... t_TAIL>
    static const bsl::variant<t_HEAD, t_TAIL...>&& asVariant(
                                     const bsl::variant<t_HEAD, t_TAIL...>&& v)
    {
        return std::move(v);
    }
#endif

    /// 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.

    /// 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 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 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 moveVisit(t_VISITOR& visitor, 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.
    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);

#endif  // BSL_VARIANT_FULL_IMPLEMENTATION

#ifndef BSL_VARIANT_FULL_IMPLEMENTATION
    // Implementation notes
    // --------------------
    // 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.

    /// 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_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 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.
    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);

#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_H
#define BSLSTL_VARIANT_VARIADIC_LIMIT_H 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_H >= 0
        , class t_TAIL_0 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 1
        , class t_TAIL_1 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 2
        , class t_TAIL_2 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 2

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 3
        , class t_TAIL_3 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 3

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 4
        , class t_TAIL_4 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 4

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 5
        , class t_TAIL_5 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 5

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 6
        , class t_TAIL_6 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 6

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 7
        , class t_TAIL_7 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 7

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 8
        , class t_TAIL_8 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 8

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 9
        , class t_TAIL_9 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 9

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 10
        , class t_TAIL_10 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 10

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 11
        , class t_TAIL_11 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 11

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 12
        , class t_TAIL_12 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 12

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 13
        , class t_TAIL_13 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 13

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 14
        , class t_TAIL_14 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 14

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 15
        , class t_TAIL_15 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 15

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 16
        , class t_TAIL_16 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 16

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 17
        , class t_TAIL_17 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 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_H >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 2

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 3

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 4

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 5

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 6

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 7

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 8

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 9

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 10

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 11

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 12

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 13

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 14

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 15

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 16

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 17

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 18


template <class t_TYPE, class t_VARIANT>
struct Variant_ConvertIndex;

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 2

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 3

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 4

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 5

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 6

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 7

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 8

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 9

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 10

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 11

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 12

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 13

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 14

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 15

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 16

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 17

#if BSLSTL_VARIANT_VARIADIC_LIMIT_H >= 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_H >= 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
/// 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`.
template <class t_VARIANT, class t_STD_VARIANT>
constexpr bool variant_constructsFromStd =
  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)...};
};

# if !defined(BSLS_COMPILERFEATURES_SUPPORT_INLINE_VARIABLES)
// 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)];
# endif
#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_I
#define BSLSTL_VARIANT_VARIADIC_LIMIT_I 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_I >= 0
        , class t_UNUSED_0 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 1
        , class t_UNUSED_1 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 2
        , class t_UNUSED_2 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 2

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 3
        , class t_UNUSED_3 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 3

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 4
        , class t_UNUSED_4 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 4

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 5
        , class t_UNUSED_5 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 5

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 6
        , class t_UNUSED_6 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 6

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 7
        , class t_UNUSED_7 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 7

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 8
        , class t_UNUSED_8 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 8

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 9
        , class t_UNUSED_9 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 9

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 10
        , class t_UNUSED_10 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 10

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 11
        , class t_UNUSED_11 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 11

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 12
        , class t_UNUSED_12 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 12

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 13
        , class t_UNUSED_13 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 13

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 14
        , class t_UNUSED_14 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 14

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 15
        , class t_UNUSED_15 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 15

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 16
        , class t_UNUSED_16 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 16

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 17
        , class t_UNUSED_17 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 17
        , class = BSLS_COMPILERFEATURES_NILT>
struct Variant_VTable;


#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 2

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 3

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 4

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 5

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 6

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 7

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 8

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 9

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 10

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 11

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 12

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 13

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 14

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 15

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 16

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 17

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 2

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 3

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 4

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 5

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 6

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 7

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 8

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 9

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 10

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 11

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 12

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 13

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 14

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 15

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 16

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 17

#if BSLSTL_VARIANT_VARIADIC_LIMIT_I >= 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_I >= 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
}  // close enterprise 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),
                                 ImpUtil::asVariant(
                                            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>
auto visit(t_VISITOR&& visitor, t_VARIANT&& variant) ->
typename bsl::invoke_result<
    t_VISITOR&&,
    decltype(get<0>(BloombergLP::bslstl::Variant_ImpUtil::
                    asVariant(std::forward<t_VARIANT>(variant))))>::type
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
    typedef decltype(ImpUtil::asVariant(std::forward<t_VARIANT>(variant)))
                                                             VariantFwdRefType;
    typedef typename bsl::invoke_result<
        t_VISITOR&&,
        decltype(get<0>(ImpUtil::
                      asVariant(std::forward<t_VARIANT>(variant))))>::type RET;

    static_assert(
        BloombergLP::bslstl::
          Variant_IsSameReturnType<RET, t_VISITOR&&, VariantFwdRefType>::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),
                               ImpUtil::asVariant(
                                            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)
{
    typedef BloombergLP::bslstl::Variant_ImpUtil ImpUtil;
    return visit<t_RET>(visitor,
                        ImpUtil::asVariant(std::forward<t_VARIANT>(variant)));
}
#else  // 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`.  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.
template <class t_RET, class t_VISITOR, class t_VARIANT>
t_RET visitR(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>(visitor, ImpUtil::asVariant(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.
template <class t_RET, class t_VISITOR, class t_VARIANT>
t_RET visitR(t_VISITOR&                                visitor,
             BloombergLP::bslmf::MovableRef<t_VARIANT> variant)
{
    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, ImpUtil::asVariant(lvalue));
}

/// 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.
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)
{
    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, ImpUtil::asVariant(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.
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)
{
    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, ImpUtil::asVariant(lvalue));
}

#endif  // BSL_VARIANT_FULL_IMPLEMENTATION

}  // close namespace bsl

namespace BloombergLP {
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:
/// ```
///  struct SomeType
///  {
///      SomeType(int, const std::string &s = "default"){}
///  };
///
///  variant<SomeType> o(1, {});
/// ```
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.
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);

    /// 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).
    BSLS_KEYWORD_CONSTEXPR_CPP14 t_TYPE& value() &;
    BSLS_KEYWORD_CONSTEXPR_CPP14 t_TYPE&& value() &&;

    // ACCESSORS

    /// 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).
    BSLS_KEYWORD_CONSTEXPR_CPP14 const t_TYPE& value() const&;
    BSLS_KEYWORD_CONSTEXPR_CPP14 const t_TYPE&& value() const&&;
};

/// 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

    /// Create a `Variant_Union` object having no active alternative.
    Variant_Union() = default;

    /// 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.
    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
/// 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.
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

    /// Create a `Variant_DataImp` object that holds an empty buffer.
    //! Variant_DataImp() = default;

    // MANIPULATOR

    /// 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`).
    t_TYPE& value();

    // ACCESSORS

    /// 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`).
    const t_TYPE& value() const;
};

#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 = void
#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 0
        , class t_TAIL0_0 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 1
        , class t_TAIL0_1 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 2
        , class t_TAIL0_2 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 2

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 3
        , class t_TAIL0_3 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 3

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 4
        , class t_TAIL0_4 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 4

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 5
        , class t_TAIL0_5 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 5

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 6
        , class t_TAIL0_6 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 6

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 7
        , class t_TAIL0_7 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 7

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 8
        , class t_TAIL0_8 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 8

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 9
        , class t_TAIL0_9 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 9

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 10
        , class t_TAIL0_10 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 10

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 11
        , class t_TAIL0_11 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 11

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 12
        , class t_TAIL0_12 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 12

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 13
        , class t_TAIL0_13 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 13

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 14
        , class t_TAIL0_14 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 14

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 15
        , class t_TAIL0_15 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 15

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 16
        , class t_TAIL0_16 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 16

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 17
        , class t_TAIL0_17 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 17
        , class = BSLS_COMPILERFEATURES_NILT
#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>
union Variant_Union;


template <>
union Variant_Union<void, void> {
};

template <>
union Variant_Union<BloombergLP::bsls::CompilerFeaturesNilT> {
};

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 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_J >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 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_J >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 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_J >= 2

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 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_J >= 3

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 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_J >= 4

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 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_J >= 5

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 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_J >= 6

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 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_J >= 7

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 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_J >= 8

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 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_J >= 9

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 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_J >= 10

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 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_J >= 11

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 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_J >= 12

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 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_J >= 13

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 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_J >= 14

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 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_J >= 15

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 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_J >= 16

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 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_J >= 17

#if BSLSTL_VARIANT_VARIADIC_LIMIT_J >= 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_J >= 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`.
template <class t_VARIANT_BASE>
class Variant_CopyConstructVisitor {

  private:
    // DATA
    t_VARIANT_BASE *d_variant_p;

  public:
    // CREATORS

    /// Create a `Variant_CopyConstructVisitor` object that, when invoked, will
    /// copy-construct an alternative in the specified `variant`.
    explicit Variant_CopyConstructVisitor(t_VARIANT_BASE *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`.
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`.
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`.
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`.
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`.
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_K
#define BSLSTL_VARIANT_VARIADIC_LIMIT_K BSLSTL_VARIANT_VARIADIC_LIMIT
#endif
template <class t_HEAD
#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 0
        , class t_TAIL_0 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 1
        , class t_TAIL_1 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 2
        , class t_TAIL_2 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 2

#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 3
        , class t_TAIL_3 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 3

#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 4
        , class t_TAIL_4 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 4

#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 5
        , class t_TAIL_5 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 5

#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 6
        , class t_TAIL_6 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 6

#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 7
        , class t_TAIL_7 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 7

#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 8
        , class t_TAIL_8 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 8

#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 9
        , class t_TAIL_9 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 9

#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 10
        , class t_TAIL_10 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 10

#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 11
        , class t_TAIL_11 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 11

#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 12
        , class t_TAIL_12 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 12

#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 13
        , class t_TAIL_13 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 13

#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 14
        , class t_TAIL_14 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 14

#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 15
        , class t_TAIL_15 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 15

#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 16
        , class t_TAIL_16 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 16

#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 17
        , class t_TAIL_17 = BSLS_COMPILERFEATURES_NILT
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 17
        , class = BSLS_COMPILERFEATURES_NILT>
struct Variant_Base;

#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 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_K >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 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_K >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_K >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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
}  // close enterprise 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_L
#define BSLSTL_VARIANT_VARIADIC_LIMIT_L BSLSTL_VARIANT_VARIADIC_LIMIT
#endif
#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 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 t_FIRST = t_HEAD,
              class         = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }

    template <
        class t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<t_FIRST>::value> >
    variant(bsl::allocator_arg_t,
            allocator_type allocator,
            const variant& original)
    : Variant_Base(bsl::allocator_arg_t(), allocator, original)
    {
    }

    template <
        class t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<t_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_L >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 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 t_FIRST = t_HEAD,
              class         = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }

    template <
        class t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<t_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 t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<t_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_L >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_L >= 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 t_FIRST = t_HEAD,
              class         = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }

    template <
        class t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<t_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 t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<t_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_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>
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 t_FIRST = t_HEAD,
              class         = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }

    template <
        class t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<t_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 t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<t_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_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>
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 t_FIRST = t_HEAD,
              class         = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }

    template <
        class t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<t_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 t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<t_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_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>
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 t_FIRST = t_HEAD,
              class         = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }

    template <
        class t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<t_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 t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<t_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_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>
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 t_FIRST = t_HEAD,
              class         = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }

    template <
        class t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<t_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 t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<t_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_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>
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 t_FIRST = t_HEAD,
              class         = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }

    template <
        class t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<t_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 t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<t_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_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>
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 t_FIRST = t_HEAD,
              class         = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }

    template <
        class t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<t_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 t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<t_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_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>
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 t_FIRST = t_HEAD,
              class         = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }

    template <
        class t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<t_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 t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<t_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_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>
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 t_FIRST = t_HEAD,
              class         = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }

    template <
        class t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<t_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 t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<t_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_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>
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 t_FIRST = t_HEAD,
              class         = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }

    template <
        class t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<t_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 t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<t_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_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>
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 t_FIRST = t_HEAD,
              class         = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }

    template <
        class t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<t_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 t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<t_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_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>
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 t_FIRST = t_HEAD,
              class         = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }

    template <
        class t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<t_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 t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<t_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_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>
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 t_FIRST = t_HEAD,
              class         = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }

    template <
        class t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<t_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 t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<t_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_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>
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 t_FIRST = t_HEAD,
              class         = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }

    template <
        class t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<t_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 t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<t_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_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>
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 t_FIRST = t_HEAD,
              class         = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }

    template <
        class t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<t_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 t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<t_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_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>
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 t_FIRST = t_HEAD,
              class         = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }

    template <
        class t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<t_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 t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<t_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_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>
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 t_FIRST = t_HEAD,
              class         = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }

    template <
        class t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<t_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 t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<t_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_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>
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 t_FIRST = t_HEAD,
              class         = typename bsl::enable_if_t<
                  std::is_default_constructible<t_FIRST>::value> >
    variant(bsl::allocator_arg_t, allocator_type allocator)
    : Variant_Base(bsl::allocator_arg_t(), allocator)
    {
    }

    template <
        class t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsCopyConstructibleAll<t_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 t_FIRST = t_HEAD,
        class         = typename bsl::enable_if_t<
            BloombergLP::bslstl::
                Variant_IsMoveConstructibleAll<t_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 BloombergLP {
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_M
#define BSLSTL_VARIANT_VARIADIC_LIMIT_M BSLSTL_VARIANT_VARIADIC_LIMIT
#endif
#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_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>
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_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>
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_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>
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_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>
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_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>
inline
Variant_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_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>
inline
Variant_Base<t_HEAD, 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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     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_M >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_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>
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_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>
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_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>
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_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>
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_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>
inline
Variant_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_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>
inline
Variant_Base<t_HEAD, 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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     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_M >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_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>
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_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>
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_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>
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_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>
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_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>
inline
Variant_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_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>
inline
Variant_Base<t_HEAD, 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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     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_M >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_M >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_M >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_M >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_M >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_M >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_M >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_M >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_M >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_M >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_M >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_M >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_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>
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_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>
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_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>
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_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>
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_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>
inline
Variant_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_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>
inline
Variant_Base<t_HEAD, 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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     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_M >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_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>
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_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>
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_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>
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_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>
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_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>
inline
Variant_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_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>
inline
Variant_Base<t_HEAD, 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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     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_M >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_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>
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_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>
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_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>
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_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>
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_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>
inline
Variant_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_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>
inline
Variant_Base<t_HEAD, 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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     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_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>
inline
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     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_M >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_M >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_M >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_M >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_M >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_M >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_M >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_M >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_M >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_M >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_M >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_M >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_M >= 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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
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_N
#define BSLSTL_VARIANT_VARIADIC_LIMIT_N BSLSTL_VARIANT_VARIADIC_LIMIT
#endif
#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 0
template <class t_HEAD>
Variant_Base<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::~Variant_Base()
{
    reset();
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 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_N >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_N >= 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_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>
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_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>
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_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>
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_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>
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_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>
Variant_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_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>
Variant_Base<t_HEAD, 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_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>
Variant_Base<t_HEAD, t_TAIL_01,
                     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_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>
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     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_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>
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     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_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>
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     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_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>
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     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_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>
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     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_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>
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     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_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>
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     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_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>
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     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_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>
Variant_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     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_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>
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_O
#define BSLSTL_VARIANT_VARIADIC_LIMIT_O BSLSTL_VARIANT_VARIADIC_LIMIT
#endif
#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_O >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_O >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_O >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_O >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_O >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_O >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_O >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_O >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_O >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_O >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_O >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_O >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_O >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_O >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_O >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_O >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_O >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_O >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_O >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_O >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_O >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_O >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_O >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_O >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_O >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_O >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_O >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_O >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_O >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_O >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_O >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_O >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_O >= 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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
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_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_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_P >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 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_P >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 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_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_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_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_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_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_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_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_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_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_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_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_Base<t_HEAD, 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_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_Base<t_HEAD, t_TAIL_01,
                     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_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_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     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_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_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     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_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_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     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_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_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     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_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_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     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_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_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     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_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_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     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_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_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     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_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_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     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_P >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 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_P >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 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_P >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 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_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_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_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_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_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_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_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_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_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_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_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_Base<t_HEAD, 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_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_Base<t_HEAD, t_TAIL_01,
                     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_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_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     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_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_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     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_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_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     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_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_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     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_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_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     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_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_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     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_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_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     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_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_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     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_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_Base<t_HEAD, t_TAIL_01,
                     t_TAIL_02,
                     t_TAIL_03,
                     t_TAIL_04,
                     t_TAIL_05,
                     t_TAIL_06,
                     t_TAIL_07,
                     t_TAIL_08,
                     t_TAIL_09,
                     t_TAIL_10,
                     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_P >= 18

#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 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_P >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 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_P >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_P >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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_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
}  // close enterprise 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_Q
#define BSLSTL_VARIANT_VARIADIC_LIMIT_Q BSLSTL_VARIANT_VARIADIC_LIMIT
#endif
#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 0
template <class t_HEAD>
inline
variant<t_HEAD, BSLS_COMPILERFEATURES_FILLT(18)>::variant()
: Variant_Base()
{
}
#endif  // BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                BSLS_COMPILERFEATURES_FILLT(15)>::variant()
: Variant_Base()
{
}
#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
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_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
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_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
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_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
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_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
variant<t_HEAD, 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_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
variant<t_HEAD, t_TAIL_01,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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
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_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
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_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
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_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
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_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
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_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
variant<t_HEAD, 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_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
variant<t_HEAD, t_TAIL_01,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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
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_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
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_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
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_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
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_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
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_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
variant<t_HEAD, 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_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
variant<t_HEAD, t_TAIL_01,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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
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_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
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_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
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_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
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_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
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_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
variant<t_HEAD, 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_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
variant<t_HEAD, t_TAIL_01,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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
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_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
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_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
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_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
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_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
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_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
variant<t_HEAD, 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_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
variant<t_HEAD, t_TAIL_01,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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
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_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
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_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
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_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
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_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
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_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
variant<t_HEAD, 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_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
variant<t_HEAD, t_TAIL_01,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_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>
template <class t_TYPE,
          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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <class t_TYPE,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_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>
template <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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_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>
template <size_t t_INDEX,
          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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_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>
template <size_t t_INDEX,
          class t_ARG_01,
          class t_ARG_02,
          class t_ARG_03,
          class t_ARG_04,
          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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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
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_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
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_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
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_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
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_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
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_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
variant<t_HEAD, 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_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
variant<t_HEAD, t_TAIL_01,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                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_Q >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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
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_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
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_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
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_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
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_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
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_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
variant<t_HEAD, 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_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
variant<t_HEAD, t_TAIL_01,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                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_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
variant<t_HEAD, t_TAIL_01,
                t_TAIL_02,
                t_TAIL_03,
                t_TAIL_04,
                t_TAIL_05,
                t_TAIL_06,
                t_TAIL_07,
                t_TAIL_08,
                t_TAIL_09,
                t_TAIL_10,
                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_Q >= 18

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_Q >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_Q >= 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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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>
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_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
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_R
#define BSLSTL_VARIANT_VARIADIC_LIMIT_R BSLSTL_VARIANT_VARIADIC_LIMIT
#endif
#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 2

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 3

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 4

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 5

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 6

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 7

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 8

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 9

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 10

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 11

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 12

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 13

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 14

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 15

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 16

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 17

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 2

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 3

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 4

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 5

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 6

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 7

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 8

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 9

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 10

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 11

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 12

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 13

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 14

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 15

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 16

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 17

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 2

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 3

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 4

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 5

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 6

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 7

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 8

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 9

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 10

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 11

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 12

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 13

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 14

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 15

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 16

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 17

#if BSLSTL_VARIANT_VARIADIC_LIMIT_R >= 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_R >= 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_V
#define BSLSTL_VARIANT_VARIADIC_LIMIT_V BSLSTL_VARIANT_VARIADIC_LIMIT
#endif
#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 2

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 3

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 4

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 5

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 6

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 7

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 8

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 9

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 10

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 11

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 12

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 13

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 14

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 15

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 16

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 17

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 2

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 3

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 4

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 5

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 6

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 7

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 8

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 9

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 10

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 11

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 12

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 13

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 14

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 15

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 16

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 17

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 2

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 3

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 4

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 5

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 6

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 7

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 8

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 9

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 10

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 11

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 12

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 13

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 14

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 15

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 16

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 17

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 2

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 3

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 4

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 5

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 6

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 7

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 8

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 9

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 10

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 11

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 12

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 13

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 14

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 15

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 16

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 17

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 2

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 3

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 4

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 5

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 6

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 7

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 8

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 9

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 10

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 11

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 12

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 13

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 14

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 15

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 16

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 17

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 2

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 3

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 4

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 5

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 6

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 7

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 8

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 9

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 10

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 11

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 12

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 13

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 14

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 15

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 16

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 17

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 2

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 3

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 4

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 5

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 6

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 7

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 8

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 9

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 10

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 11

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 12

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 13

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 14

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 15

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 16

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 17

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 2

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 3

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 4

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 5

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 6

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 7

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 8

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 9

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 10

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 11

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 12

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 13

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 14

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 15

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 16

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 17

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 18


#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 2

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 3

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 4

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 5

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 6

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 7

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 8

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 9

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 10

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 11

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 12

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 13

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 14

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 15

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 16

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 17

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 18


#if defined BSLS_COMPILERFEATURES_SUPPORT_THREE_WAY_COMPARISON &&             \
    defined BSLS_LIBRARYFEATURES_HAS_CPP20_CONCEPTS

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 0

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 1

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 2

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 3

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 4

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 5

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 6

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 7

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 8

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 9

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 10

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 11

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 12

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 13

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 14

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 15

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 16

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 17

#if BSLSTL_VARIANT_VARIADIC_LIMIT_V >= 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_V >= 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 ----------------------------------
