// Copyright (c) 2015, Just Software Solutions Ltd
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or
// without modification, are permitted provided that the
// following conditions are met:
//
// 1. Redistributions of source code must retain the above
// copyright notice, this list of conditions and the following
// disclaimer.
//
// 2. Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials
// provided with the distribution.
//
// 3. Neither the name of the copyright holder nor the names of
// its contributors may be used to endorse or promote products
// derived from this software without specific prior written
// permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
// CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// Copied from https://bitbucket.org/anthonyw/variant/src (5bce47fa788648f79e5ea1d77b0eef2e8f0b2999)

// Modified to make it compile with exceptions disabled.

#pragma once

#include <functional>
#include <limits.h>
#include <new>
#include <stddef.h>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <utility>
#include <wtf/Compiler.h>
#include <wtf/StdLibExtras.h>

#if COMPILER(MSVC)
#pragma warning(push)
#pragma warning(disable:4245)
#pragma warning(disable:4521)
#pragma warning(disable:4522)
#pragma warning(disable:4814)
#endif

#if !COMPILER(CLANG) || WTF_CPP_STD_VER >= 14

namespace WTF {

#if COMPILER_SUPPORTS(EXCEPTIONS)
#define __THROW_EXCEPTION(__exception) throw __exception;
#define __NOEXCEPT noexcept
#define __NOEXCEPT_(__exception) noexcept(__exception)
#else
#define __THROW_EXCEPTION(__exception) do { (void)__exception; CRASH(); } while (0);
#define __NOEXCEPT
#define __NOEXCEPT_(...)
#endif

struct __in_place_private{
    template<typename>
    struct __type_holder;

    template<size_t>
    struct __value_holder;
};


struct in_place_tag {
    in_place_tag() = delete;
};

using in_place_t = in_place_tag(&)(__in_place_private&);

template <class _Type>
using in_place_type_t = in_place_tag(&)(__in_place_private::__type_holder<_Type>&);

template <size_t _Index>
using in_place_index_t = in_place_tag(&)(__in_place_private::__value_holder<_Index>&);

in_place_tag in_place(__in_place_private&);

template <class _Type>
in_place_tag in_place(__in_place_private::__type_holder<_Type> &) {
    __THROW_EXCEPTION(__in_place_private());
}

template <size_t _Index>
in_place_tag in_place(__in_place_private::__value_holder<_Index> &) {
    __THROW_EXCEPTION(__in_place_private());
}

class bad_variant_access: public std::logic_error{
public:
    explicit bad_variant_access(const std::string& what_arg):
        std::logic_error(what_arg)
    {}
    explicit bad_variant_access(const char* what_arg):
        std::logic_error(what_arg)
    {}
};

template<typename T>
NO_RETURN_DUE_TO_CRASH inline T __throw_bad_variant_access(const char* what_arg){
    __THROW_EXCEPTION(bad_variant_access(what_arg))
}

template<ptrdiff_t _Offset,typename _Type,typename ... _Types>
struct __type_index_helper;

template<ptrdiff_t _Offset,typename _Type,typename _Head,typename ... _Rest>
struct __type_index_helper<_Offset,_Type,_Head,_Rest...>{
    static constexpr ptrdiff_t __value=
        __type_index_helper<_Offset+1,_Type,_Rest...>::__value;
};

template<ptrdiff_t _Offset,typename _Type,typename ... _Rest>
struct __type_index_helper<_Offset,_Type,_Type,_Rest...>{
    static constexpr ptrdiff_t __value=_Offset;
};

template<typename _Type,typename ... _Types>
struct __type_index{
    static constexpr ptrdiff_t __value=
        __type_index_helper<0,_Type,_Types...>::__value;
};

template<ptrdiff_t _Index,typename ... _Types>
struct __indexed_type;

template<typename _Head,typename ... _Rest>
struct __indexed_type<0,_Head,_Rest...>{
    typedef _Head __type;
};

template<typename _Head,typename ... _Rest>
struct __indexed_type<-1,_Head,_Rest...>{
    typedef void __type;
};

template<ptrdiff_t _Index,typename _Head,typename ... _Rest>
struct __indexed_type<_Index,_Head,_Rest...>{
    typedef typename __indexed_type<_Index-1,_Rest...>::__type __type;
};

template<ptrdiff_t _Index,typename ..._Types>
struct __next_index{
    static constexpr ptrdiff_t __value=
        (_Index>=ptrdiff_t(sizeof...(_Types)-1))?-1:_Index+1;
};

template<typename ... _Types>
class Variant;

template<typename>
struct variant_size;

template <typename _Type>
struct variant_size<const _Type> : variant_size<_Type> {};

template <typename _Type>
struct variant_size<volatile _Type> : variant_size<_Type> {};

template <typename _Type>
struct variant_size<const volatile _Type> : variant_size<_Type> {};

template <typename... _Types>
struct variant_size<Variant<_Types...>>
    : std::integral_constant<size_t, sizeof...(_Types)> {};

template<size_t _Index,typename _Type>
struct variant_alternative;

template<size_t _Index,typename _Type>
using variant_alternative_t=typename variant_alternative<_Index,_Type>::type;

template <size_t _Index, typename _Type>
struct variant_alternative<_Index, const _Type>{
    using type=std::add_const_t<variant_alternative_t<_Index,_Type>>;
};

template <size_t _Index, typename _Type>
struct variant_alternative<_Index, volatile _Type>{
    using type=std::add_volatile_t<variant_alternative_t<_Index,_Type>>;
};

template <size_t _Index, typename _Type>
struct variant_alternative<_Index, volatile const _Type>{
    using type=std::add_volatile_t<std::add_const_t<variant_alternative_t<_Index,_Type>>>;
};

template<size_t _Index,typename ... _Types>
struct variant_alternative<_Index,Variant<_Types...>>{
    using type=typename __indexed_type<_Index,_Types...>::__type;
};

constexpr size_t variant_npos=-1;

template<typename _Type,typename ... _Types>
constexpr _Type& get(Variant<_Types...>&);

template<typename _Type,typename ... _Types>
constexpr _Type const& get(Variant<_Types...> const&);

template<typename _Type,typename ... _Types>
constexpr _Type&& get(Variant<_Types...>&&);

template<typename _Type,typename ... _Types>
constexpr const _Type&& get(Variant<_Types...> const&&);

template<ptrdiff_t _Index,typename ... _Types>
constexpr typename __indexed_type<_Index,_Types...>::__type& get(Variant<_Types...>&);

template<ptrdiff_t _Index,typename ... _Types>
constexpr typename __indexed_type<_Index,_Types...>::__type&& get(Variant<_Types...>&&);

template<ptrdiff_t _Index,typename ... _Types>
constexpr typename __indexed_type<_Index,_Types...>::__type const& get(
    Variant<_Types...> const&);

template <ptrdiff_t _Index, typename... _Types>
constexpr const typename __indexed_type<_Index, _Types...>::__type &&
get(Variant<_Types...> const &&);

template<typename _Type,typename ... _Types>
constexpr std::add_pointer_t<_Type> get_if(Variant<_Types...>&);

template<typename _Type,typename ... _Types>
constexpr std::add_pointer_t<_Type const> get_if(Variant<_Types...> const&);

template<ptrdiff_t _Index,typename ... _Types>
constexpr std::add_pointer_t<typename __indexed_type<_Index,_Types...>::__type> get_if(Variant<_Types...>&);

template<ptrdiff_t _Index,typename ... _Types>
constexpr std::add_pointer_t<typename __indexed_type<_Index,_Types...>::__type const> get_if(
    Variant<_Types...> const&);

template<ptrdiff_t _Index,typename ... _Types>
struct __variant_accessor;

template<size_t __count,
         bool __larger_than_char=(__count>SCHAR_MAX),
    bool __larger_than_short=(__count>SHRT_MAX),
    bool __larger_than_int=(__count>INT_MAX)>
struct __discriminator_type{
    typedef signed char __type;
};

template<size_t __count>
struct __discriminator_type<__count,true,false,false>{
    typedef signed short __type;
};

template<size_t __count>
struct __discriminator_type<__count,true,true,false>{
    typedef int __type;
};
template<size_t __count>
struct __discriminator_type<__count,true,true,true>{
    typedef signed long __type;
};

template<typename _Type>
struct __stored_type{
    typedef _Type __type;
};

template<typename _Type>
struct __stored_type<_Type&>{
    typedef _Type* __type;
};

template<typename ... _Types>
struct __all_trivially_destructible;

template<>
struct __all_trivially_destructible<> {
    static constexpr bool __value=true;
};

template<typename _Type>
struct __all_trivially_destructible<_Type> {
    static constexpr bool __value=
        std::is_trivially_destructible<typename __stored_type<_Type>::__type>::value;
};

template<typename _Head,typename ... _Rest>
struct __all_trivially_destructible<_Head,_Rest...> {
    static constexpr bool __value=
        __all_trivially_destructible<_Head>::__value &&
        __all_trivially_destructible<_Rest...>::__value;
};

template<typename _Target,typename ... _Args>
struct __storage_nothrow_constructible{
    static const bool __value=
        std::is_nothrow_constructible<_Target, _Args...>::value;
};

template<typename ... _Types>
struct __storage_nothrow_move_constructible;

template<>
struct __storage_nothrow_move_constructible<> {
    static constexpr bool __value=true;
};

template<typename _Type>
struct __storage_nothrow_move_constructible<_Type> {
    static constexpr bool __value=
        std::is_nothrow_move_constructible<
        typename __stored_type<_Type>::__type>::value;
};

template<typename _Head,typename ... _Rest>
struct __storage_nothrow_move_constructible<_Head,_Rest...> {
    static constexpr bool __value=
        __storage_nothrow_move_constructible<_Head>::__value &&
        __storage_nothrow_move_constructible<_Rest...>::__value;
};

template<ptrdiff_t _Index,typename ... _Types>
struct __other_storage_nothrow_move_constructible;

template<typename _Head,typename ... _Rest>
struct __other_storage_nothrow_move_constructible<0,_Head,_Rest...>{
    static const bool __value=__storage_nothrow_move_constructible<_Rest...>::__value;
};

template<typename _Head,typename ... _Rest>
struct __other_storage_nothrow_move_constructible<-1,_Head,_Rest...>{
    static const bool __value=
        __storage_nothrow_move_constructible<_Head,_Rest...>::__value;
};

template<ptrdiff_t _Index,typename _Head,typename ... _Rest>
struct __other_storage_nothrow_move_constructible<_Index,_Head,_Rest...>{
    static const bool __value=
        __storage_nothrow_move_constructible<_Head>::__value &&
        __other_storage_nothrow_move_constructible<_Index-1,_Rest...>::__value;
};

template<ptrdiff_t _Index,typename ... _Types>
struct __backup_storage_required{
    static const bool __value=
        !__storage_nothrow_move_constructible<
        typename __indexed_type<_Index,_Types...>::__type>::__value &&
        !__other_storage_nothrow_move_constructible<_Index,_Types...>::__value;
};

template<ptrdiff_t _Index,ptrdiff_t _Count,typename ... _Types>
struct __any_backup_storage_required_impl{
    static const bool __value=
        __backup_storage_required<_Index,_Types...>::__value ||
        __any_backup_storage_required_impl<_Index+1,_Count-1,_Types...>::__value;
};

template<ptrdiff_t _Index,typename ... _Types>
struct __any_backup_storage_required_impl<_Index,0,_Types...>{
    static const bool __value=false;
};

template<typename _Variant>
struct __any_backup_storage_required;

template<typename ... _Types>
struct __any_backup_storage_required<Variant<_Types...> >{
    static const bool __value=
        __any_backup_storage_required_impl<0,sizeof...(_Types),_Types...>::__value;
};

template<typename ... _Types>
union __variant_data;

template<typename _Type,bool=std::is_literal_type<_Type>::value>
struct __variant_storage{
    typedef _Type __type;

    static constexpr _Type& __get(__type& __val){
        return __val;
    }
    static constexpr _Type&& __get_rref(__type& __val){
        return std::move(__val);
    }
    static constexpr const _Type& __get(__type const& __val){
        return __val;
    }
    static constexpr const _Type&& __get_rref(__type const& __val){
        return std::move(__val);
    }
    static void __destroy(__type&){}
};

template<typename _Type>
struct __storage_wrapper{
    typename std::aligned_storage<sizeof(_Type),alignof(_Type)>::type __storage;

    template<typename ... _Args>
    static constexpr void __construct(void* __p,_Args&& ... __args){
        new (__p) _Type(std::forward<_Args>(__args)...);
    }

    template <typename _Dummy = _Type>
    __storage_wrapper(
        typename std::enable_if<std::is_default_constructible<_Dummy>::value,
        void (__storage_wrapper::*)()>::type = nullptr) {
      __construct(&__storage);
    }

    template <typename _Dummy = _Type>
    __storage_wrapper(
        typename std::enable_if<!std::is_default_constructible<_Dummy>::value,
        void (__storage_wrapper::*)()>::type = nullptr) {
    }
    
    template<typename _First,typename ... _Args>
    __storage_wrapper(_First&& __first,_Args&& ... __args){
        __construct(&__storage,std::forward<_First>(__first),std::forward<_Args>(__args)...);
    }

    _Type& __get(){
        return *static_cast<_Type*>(static_cast<void*>(&__storage));
    }
    constexpr _Type const& __get() const{
        return *static_cast<_Type const*>(static_cast<void const*>(&__storage));
    }
    void __destroy(){
        __get().~_Type();
    }
};

template<typename _Type>
struct __storage_wrapper<_Type&>{
    _Type* __storage;

    template<typename _Arg>
    constexpr __storage_wrapper(_Arg& __arg):
        __storage(&__arg){}

    _Type& __get(){
        return *__storage;
    }
    constexpr _Type const& __get() const{
        return *__storage;
    }
};

template<typename _Type>
struct __variant_storage<_Type,false>{
    typedef __storage_wrapper<_Type> __type;

    static constexpr _Type& __get(__type& __val){
        return __val.__get();
    }
    static constexpr _Type&& __get_rref(__type& __val){
        return std::move(__val.__get());
    }
    static constexpr const _Type& __get(__type const& __val){
        return __val.__get();
    }
    static constexpr const _Type&& __get_rref(__type const& __val){
        return std::move(__val.__get());
    }
    static void __destroy(__type& __val){
        __val.__destroy();
    }
};

template<typename _Type,bool __b>
struct __variant_storage<_Type&,__b>{
    typedef _Type* __type;

    static constexpr _Type& __get(__type& __val){
        return *__val;
    }
    static constexpr _Type& __get_rref(__type& __val){
        return *__val;
    }
    static constexpr _Type& __get(__type const& __val){
        return *__val;
    }
    static constexpr _Type& __get_rref(__type const& __val){
        return *__val;
    }
    static void __destroy(__type&){}
};

template<typename _Type,bool __b>
struct __variant_storage<_Type&&,__b>{
    typedef _Type* __type;

    static constexpr _Type&& __get(__type& __val){
        return static_cast<_Type&&>(*__val);
    }
    static constexpr _Type&& __get_rref(__type& __val){
        return static_cast<_Type&&>(*__val);
    }
    static constexpr _Type&& __get(__type const& __val){
        return static_cast<_Type&&>(*__val);
    }
    static constexpr _Type&& __get_rref(__type const& __val){
        return static_cast<_Type&&>(*__val);
    }
    static void __destroy(__type&){}
};

template<>
union __variant_data<>{
    constexpr __variant_data(){}
};

template<typename _Type>
union __variant_data<_Type>{
    typename __variant_storage<_Type>::__type __val;
    struct __dummy_type{} __dummy;

    constexpr __variant_data():__dummy(){}

    template<typename ... _Args>
    constexpr __variant_data(in_place_index_t<0>,_Args&& ... __args):
        __val(std::forward<_Args>(__args)...){}

    _Type& __get(in_place_index_t<0>){
        return __variant_storage<_Type>::__get(__val);
    }
    /*constexpr*/ _Type&& __get_rref(in_place_index_t<0>){
        return __variant_storage<_Type>::__get_rref(__val);
    }
    constexpr const _Type& __get(in_place_index_t<0>) const{
        return __variant_storage<_Type>::__get(__val);
    }
    constexpr const _Type&& __get_rref(in_place_index_t<0>) const{
        return __variant_storage<_Type>::__get_rref(__val);
    }
    void __destroy(in_place_index_t<0>){
        __variant_storage<_Type>::__destroy(__val);
    }
};

template<typename _Type>
union __variant_data<_Type&>{
    typename __variant_storage<_Type&>::__type __val;
    struct __dummy_type{} __dummy;

    constexpr __variant_data():__dummy(){}

    template<typename ... _Args>
    constexpr __variant_data(in_place_index_t<0>,_Args&& ... __args):
        __val(&std::forward<_Args>(__args)...){}

    _Type& __get(in_place_index_t<0>){
        return __variant_storage<_Type&>::__get(__val);
    }
    constexpr _Type& __get(in_place_index_t<0>) const{
        return __variant_storage<_Type&>::__get(__val);
    }

    _Type& __get_rref(in_place_index_t<0>){
        return __variant_storage<_Type&>::__get_rref(__val);
    }
    constexpr _Type& __get_rref(in_place_index_t<0>) const{
        return __variant_storage<_Type&>::__get_rref(__val);
    }
    
    void __destroy(in_place_index_t<0>){
        __variant_storage<_Type&>::__destroy(__val);
    }
};

template<typename _Type>
union __variant_data<_Type&&>{
    typename __variant_storage<_Type&&>::__type __val;
    struct __dummy_type{} __dummy;

    constexpr __variant_data():__dummy(){}

    template<typename _Arg>
    __variant_data(in_place_index_t<0>,_Arg&& __arg):
        __val(&__arg){}

    _Type&& __get(in_place_index_t<0>){
        return __variant_storage<_Type&&>::__get(__val);
    }
    constexpr _Type&& __get(in_place_index_t<0>) const{
        return __variant_storage<_Type&&>::__get(__val);
    }
    _Type&& __get_rref(in_place_index_t<0>){
        return __variant_storage<_Type&&>::__get_rref(__val);
    }
    constexpr _Type&& __get_rref(in_place_index_t<0>) const{
        return __variant_storage<_Type&&>::__get_rref(__val);
    }
    void __destroy(in_place_index_t<0>){
        __variant_storage<_Type&&>::__destroy(__val);
    }
};

template<typename _Head,typename ... _Rest>
union __variant_data<_Head,_Rest...>{
    __variant_data<_Head> __head;
    __variant_data<_Rest...> __rest;

    constexpr __variant_data():
        __head(){}

    template<typename ... _Args>
    constexpr __variant_data(in_place_index_t<0>,_Args&& ... __args):
        __head(in_place<0>,std::forward<_Args>(__args)...){}
    template<size_t _Index,typename ... _Args>
    constexpr __variant_data(in_place_index_t<_Index>,_Args&& ... __args):
        __rest(in_place<_Index-1>,std::forward<_Args>(__args)...){}

    _Head& __get(in_place_index_t<0>){
        return __head.__get(in_place<0>);
    }

    /*constexpr*/ _Head&& __get_rref(in_place_index_t<0>){
        return __head.__get_rref(in_place<0>);
    }
    
    constexpr const _Head& __get(in_place_index_t<0>) const{
        return __head.__get(in_place<0>);
    }

    constexpr const _Head&& __get_rref(in_place_index_t<0>) const{
        return __head.__get_rref(in_place<0>);
    }
    
    template<size_t _Index>
    typename __indexed_type<_Index-1,_Rest...>::__type& __get(
        in_place_index_t<_Index>){
        return __rest.__get(in_place<_Index-1>);
    }

    template<size_t _Index>
    /*constexpr*/ typename __indexed_type<_Index-1,_Rest...>::__type&& __get_rref(
        in_place_index_t<_Index>){
        return __rest.__get_rref(in_place<_Index-1>);
    }
    
    template<size_t _Index>
    constexpr const typename __indexed_type<_Index-1,_Rest...>::__type& __get(
        in_place_index_t<_Index>) const{
        return __rest.__get(in_place<_Index-1>);
    }

    template<size_t _Index>
    constexpr const typename __indexed_type<_Index-1,_Rest...>::__type&& __get_rref(
        in_place_index_t<_Index>) const{
        return __rest.__get_rref(in_place<_Index-1>);
    }
    
    
    void __destroy(in_place_index_t<0>){
        __head.__destroy(in_place<0>);
    }
    template<size_t _Index>
    void __destroy(in_place_index_t<_Index>){
        __rest.__destroy(in_place<_Index-1>);
    }
};


template<ptrdiff_t... _Indices>
struct __index_sequence{
    typedef __index_sequence<_Indices...,sizeof...(_Indices)> __next;
    static constexpr size_t __length=sizeof...(_Indices);
};

template<typename ... _Types>
struct __type_indices;

template<>
struct __type_indices<>{
    typedef __index_sequence<> __type;
};

template<typename _Type>
struct __type_indices<_Type>{
    typedef __index_sequence<0> __type;
};

template<typename _Type,typename ... _Rest>
struct __type_indices<_Type,_Rest...>{
    typedef typename __type_indices<_Rest...>::__type::__next __type;
};

template<typename _Variant>
struct __variant_indices;

template<typename ... _Types>
struct __variant_indices<Variant<_Types...>>{
    typedef typename __type_indices<_Types...>::__type __type;
};

template<typename _Variant,
         typename _Indices=typename __variant_indices<_Variant>::__type>
struct __move_construct_op_table;

template<typename _Variant,ptrdiff_t ... _Indices>
struct __move_construct_op_table<_Variant,__index_sequence<_Indices...>>{
    typedef void(* const __func_type)(_Variant*,_Variant&);
    
    template<ptrdiff_t _Index>
    static void __move_construct_func(
        _Variant * __lhs,_Variant& __rhs){
        __lhs->template __emplace_construct<_Index>(
            std::move(get<_Index>(__rhs)));
    }

    static const __func_type __apply[sizeof...(_Indices)];
};

template<typename _Variant,ptrdiff_t ... _Indices>
const typename __move_construct_op_table<_Variant,__index_sequence<_Indices...>>::
__func_type
__move_construct_op_table<_Variant,__index_sequence<_Indices...>>::__apply[
    sizeof...(_Indices)]={
        &__move_construct_func<_Indices>...
    };

template<typename _Variant,
         typename _Indices=typename __variant_indices<_Variant>::__type>
struct __move_assign_op_table;

template<typename _Variant,ptrdiff_t ... _Indices>
struct __move_assign_op_table<_Variant,__index_sequence<_Indices...>>{
    typedef void(* const __func_type)(_Variant*,_Variant&);
    
    template<ptrdiff_t _Index>
    static void __move_assign_func(
        _Variant * __lhs,_Variant& __rhs){
        get<_Index>(*__lhs)=std::move(get<_Index>(__rhs));
    }

    static const __func_type __apply[sizeof...(_Indices)];
};

template<typename _Variant,ptrdiff_t ... _Indices>
const typename __move_assign_op_table<_Variant,__index_sequence<_Indices...>>::
__func_type
__move_assign_op_table<_Variant,__index_sequence<_Indices...>>::__apply[
    sizeof...(_Indices)]={
        &__move_assign_func<_Indices>...
    };

template<typename _Variant,
         typename _Indices=typename __variant_indices<_Variant>::__type>
struct __copy_construct_op_table;

template<typename _Variant,ptrdiff_t ... _Indices>
struct __copy_construct_op_table<_Variant,__index_sequence<_Indices...>>{
    typedef void(* const __func_type)(_Variant*,_Variant const&);
    
    template<ptrdiff_t _Index>
    static void __copy_construct_func(
        _Variant * __lhs,_Variant const& __rhs){
        __lhs->template __emplace_construct<_Index>(
            get<_Index>(__rhs));
    }

    static const __func_type __apply[sizeof...(_Indices)];
};

template<typename _Variant,ptrdiff_t ... _Indices>
const typename __copy_construct_op_table<_Variant,__index_sequence<_Indices...>>::
__func_type
__copy_construct_op_table<_Variant,__index_sequence<_Indices...>>::__apply[
    sizeof...(_Indices)]={
        &__copy_construct_func<_Indices>...
    };

template<typename _Variant,
         typename _Indices=typename __variant_indices<_Variant>::__type>
struct __copy_assign_op_table;

template<typename _Variant,ptrdiff_t ... _Indices>
struct __copy_assign_op_table<_Variant,__index_sequence<_Indices...>>{
    typedef void(* const __func_type)(_Variant*,_Variant const&);
    
    template<ptrdiff_t _Index>
    static void __copy_assign_func(
        _Variant * __lhs,_Variant const& __rhs){
        get<_Index>(*__lhs)=get<_Index>(__rhs);
    }

    static const __func_type __apply[sizeof...(_Indices)];
};

template<typename _Variant,ptrdiff_t ... _Indices>
const typename __copy_assign_op_table<_Variant,__index_sequence<_Indices...>>::
__func_type
__copy_assign_op_table<_Variant,__index_sequence<_Indices...>>::__apply[
    sizeof...(_Indices)]={
        &__copy_assign_func<_Indices>...
    };

template<typename _Variant,
         typename _Indices=typename __variant_indices<_Variant>::__type>
struct __destroy_op_table;

template<typename _Variant,ptrdiff_t ... _Indices>
struct __destroy_op_table<_Variant,__index_sequence<_Indices...>>{
    typedef void(* const __func_type)(_Variant*);
    
    template<ptrdiff_t _Index>
    static void __destroy_func(
        _Variant * __self){
        if(__self->__index>=0){
            __self->__storage.__destroy(in_place<_Index>);
        }
    }

    static const __func_type __apply[sizeof...(_Indices)];
};

template<typename _Variant,ptrdiff_t ... _Indices>
const typename __destroy_op_table<_Variant,__index_sequence<_Indices...>>::
__func_type
__destroy_op_table<_Variant,__index_sequence<_Indices...>>::__apply[
    sizeof...(_Indices)]={
        &__destroy_func<_Indices>...
    };

template<typename _Variant,
         typename _Indices=typename __variant_indices<_Variant>::__type>
struct __swap_op_table;

template<typename _Variant,ptrdiff_t ... _Indices>
struct __swap_op_table<_Variant,__index_sequence<_Indices...>>{
    typedef void(* const __func_type)(_Variant&,_Variant&);
    
    template<ptrdiff_t _Index>
    static void __swap_func(
        _Variant & __lhs,_Variant & __rhs){
        swap(get<_Index>(__lhs),get<_Index>(__rhs));
    }

    static const __func_type __apply[sizeof...(_Indices)];
};

template<typename _Variant,ptrdiff_t ... _Indices>
const typename __swap_op_table<_Variant,__index_sequence<_Indices...>>::
__func_type
__swap_op_table<_Variant,__index_sequence<_Indices...>>::__apply[
    sizeof...(_Indices)]={
        &__swap_func<_Indices>...
    };

template<typename _Variant,
         typename _Indices=typename __variant_indices<_Variant>::__type>
struct __equality_op_table;

template<typename _Variant,ptrdiff_t ... _Indices>
struct __equality_op_table<_Variant,__index_sequence<_Indices...>>{
    typedef bool(* const __compare_func_type)(_Variant const&,_Variant const&);
    
    template<ptrdiff_t _Index>
    static constexpr bool __equality_compare_func(
        _Variant const& __lhs,_Variant const& __rhs){
        return get<_Index>(__lhs)==get<_Index>(__rhs);
    }

    static constexpr __compare_func_type __equality_compare[sizeof...(_Indices)]={
        &__equality_compare_func<_Indices>...
    };
};

template<typename _Variant,ptrdiff_t ... _Indices>
constexpr typename __equality_op_table<_Variant,__index_sequence<_Indices...>>::
__compare_func_type
__equality_op_table<_Variant,__index_sequence<_Indices...>>::__equality_compare[
    sizeof...(_Indices)];

template<typename _Variant,
         typename _Indices=typename __variant_indices<_Variant>::__type>
struct __less_than_op_table;

template<typename _Variant,ptrdiff_t ... _Indices>
struct __less_than_op_table<_Variant,__index_sequence<_Indices...>>{
    typedef bool(* const __compare_func_type)(_Variant const&,_Variant const&);
    
    template<ptrdiff_t _Index>
    static constexpr bool __less_than_compare_func(
        _Variant const& __lhs,_Variant const& __rhs){
        return get<_Index>(__lhs)<get<_Index>(__rhs);
    }

    static constexpr __compare_func_type __less_than_compare[sizeof...(_Indices)]={
        &__less_than_compare_func<_Indices>...
    };
};

template<typename _Variant,ptrdiff_t ... _Indices>
constexpr typename __less_than_op_table<_Variant,__index_sequence<_Indices...>>::
__compare_func_type
__less_than_op_table<_Variant,__index_sequence<_Indices...>>::__less_than_compare[
    sizeof...(_Indices)];

template<typename _Variant>
struct __variant_storage_type;

template<typename _Derived,bool __trivial_destructor>
struct __variant_base
{
    ~__variant_base(){
        static_cast<_Derived*>(this)->__destroy_self();
    }
};

template<typename _Derived>
struct __variant_base<_Derived,true>{
};


template<ptrdiff_t _Offset,typename _CurrentSequence,
         typename _Type,typename ... _Types>
struct __all_indices_helper;

template<ptrdiff_t _Offset,ptrdiff_t ... _Indices,
         typename _Type,typename ... _Rest>
struct __all_indices_helper<
    _Offset,__index_sequence<_Indices...>,
    _Type,_Type,_Rest...>{
    typedef typename __all_indices_helper<
        _Offset+1,__index_sequence<_Indices...,_Offset>,_Type,_Rest...>::__type
        __type;
};

template<ptrdiff_t _Offset,typename _CurrentSequence,
         typename _Type,typename _Head,typename ... _Rest>
struct __all_indices_helper<_Offset,_CurrentSequence,_Type,_Head,_Rest...>{
    typedef typename __all_indices_helper<
        _Offset+1,_CurrentSequence,_Type,_Rest...>::__type __type;
};

template<ptrdiff_t _Offset,typename _CurrentSequence,typename _Type>
struct __all_indices_helper<_Offset,_CurrentSequence,_Type>{
    typedef _CurrentSequence __type;
};

template<typename _Type,typename ... _Types>
struct __all_indices{
    typedef typename __all_indices_helper<
        0,__index_sequence<>,_Type,_Types...>::__type __type;
};

template<typename ... _Sequences>
struct __combine_sequences;

template<ptrdiff_t ... _Indices1,ptrdiff_t ... _Indices2>
struct __combine_sequences<
    __index_sequence<_Indices1...>,__index_sequence<_Indices2...>>{
    typedef __index_sequence<_Indices1...,_Indices2...> __type;
};

template<typename _Sequence,typename ... _Rest>
struct __combine_sequences<_Sequence,_Rest...>{
    typedef typename __combine_sequences<
        _Sequence,
        typename __combine_sequences<_Rest...>::__type>::__type __type;
};

template<typename _Indices>
struct __first_index;

template<ptrdiff_t _FirstIndex,ptrdiff_t ... _Rest>
struct __first_index<__index_sequence<_FirstIndex,_Rest...>>{
    static constexpr ptrdiff_t __value=_FirstIndex;
};

template<ptrdiff_t _Offset,typename _CurrentSequence,
         typename _Type,typename ... _Types>
struct __constructible_matches_helper;

template<ptrdiff_t _Offset,typename _Sequence,typename _Type>
struct __constructible_matches_helper<
    _Offset,_Sequence,_Type>{
    typedef _Sequence __type;
};

template<bool _Accept,ptrdiff_t _Entry>
struct __sequence_or_empty{
    typedef __index_sequence<> __type;
};

template<ptrdiff_t _Entry>
struct __sequence_or_empty<true,_Entry>{
    typedef __index_sequence<_Entry> __type;
};

template<ptrdiff_t _Offset,typename _CurrentSequence,
         typename _Type,typename _Head,typename ... _Rest>
struct __constructible_matches_helper<
    _Offset,_CurrentSequence,_Type,_Head,_Rest...>{
    typedef
    typename __constructible_matches_helper<
        _Offset+1,
        typename __combine_sequences<
            _CurrentSequence,
            typename __sequence_or_empty<
                std::is_constructible<_Head,_Type>::value,
                _Offset>::__type>::__type,
        _Type,_Rest...>::__type __type;
};

template<typename _Type,typename ... _Types>
struct __constructible_matches{
    typedef typename __constructible_matches_helper<
        0,__index_sequence<>,_Type,_Types...>::__type __type;
};

template<typename _Type,typename ... _Types>
struct __type_index_to_construct{
    typedef typename __all_indices<_Type,_Types...>::__type __direct_matches;
    typedef typename __all_indices<
        typename std::remove_const<
            typename std::remove_reference<_Type>::type
            >::type,_Types...>::__type __value_matches;
    typedef typename __all_indices<
        _Type,
        typename std::remove_const<
            typename std::remove_reference<_Types>::type
            >::type...>::__type __rref_matches;

    typedef typename __constructible_matches<_Type,_Types...>::__type
    __constructibles;

    static_assert(
        (__direct_matches::__length>0) ||
        (__value_matches::__length>0) ||
        (__rref_matches::__length>0) ||
        (__constructibles::__length==1),
        "For conversion construction of variants, exactly one type must be constructible");
    
    typedef typename __combine_sequences<
        __direct_matches,__value_matches,__rref_matches,
        __constructibles>::__type __all_matches;
    
    static constexpr ptrdiff_t __value=__first_index<__all_matches>::__value;
};

struct __replace_construct_helper{
    template<
        ptrdiff_t _Index,
        bool __construct_directly,
        bool __indexed_type_has_nothrow_move,
        bool __other_types_have_nothrow_move>
    struct __helper;

    template<typename _Variant,
             typename _Indices=typename __variant_indices<_Variant>::__type>
    struct __op_table;
};

template<
    ptrdiff_t _Index,
    bool __other_types_have_nothrow_move>
struct __replace_construct_helper::__helper<
    _Index,false,true,__other_types_have_nothrow_move>{

    template<typename _Variant,typename ... _Args>
    static void __trampoline(_Variant& __v,_Args&& ... __args){
        __v.template __two_stage_replace<_Index>(__args...);
    }
};

template<
    ptrdiff_t _Index,
    bool __indexed_type_has_nothrow_move,
    bool __other_types_have_nothrow_move>
struct __replace_construct_helper::__helper<
    _Index,true,__indexed_type_has_nothrow_move,
    __other_types_have_nothrow_move>{

    template<typename _Variant,typename ... _Args>
    static void __trampoline(_Variant& __v,_Args&& ... __args){
        __v.template __direct_replace<_Index>(std::forward<_Args>(__args)...);
    }
};


template<
    ptrdiff_t _Index>
struct __replace_construct_helper::__helper<
    _Index,false,false,true>{

    template<typename _Variant,typename ... _Args>
    static void __trampoline(_Variant& __v,_Args&& ... __args){
        __v.template __local_backup_replace<_Index>(std::forward<_Args>(__args)...);
    }
};

template<
    ptrdiff_t _Index>
struct __replace_construct_helper::__helper<
    _Index,false,false,false>{

    template<typename _Variant,typename ... _Args>
    static void __trampoline(_Variant& __v,_Args&& ... __args){
        __v.template __direct_replace<_Index>(std::forward<_Args>(__args)...);
    }
};

template<typename _Variant,ptrdiff_t ... _Indices>
struct __replace_construct_helper::__op_table<_Variant,__index_sequence<_Indices...>>{
    typedef void(* const __move_func_type)(_Variant*,_Variant&);
    typedef void(* const __copy_func_type)(_Variant*,_Variant const&);
    
    template<ptrdiff_t _Index>
    static void __move_assign_func(
        _Variant * __lhs,_Variant& __rhs){
        __lhs->template __replace_construct<_Index>(std::move(get<_Index>(__rhs)));
        __rhs.__destroy_self();
    }

    template<ptrdiff_t _Index>
    static void __copy_assign_func(
        _Variant * __lhs,_Variant const& __rhs){
        __lhs->template __replace_construct<_Index>(get<_Index>(__rhs));
    }
    
    static const __move_func_type __move_assign[sizeof...(_Indices)];
    static const __copy_func_type __copy_assign[sizeof...(_Indices)];
};

template<typename _Variant,ptrdiff_t ... _Indices>
const typename __replace_construct_helper::__op_table<
    _Variant,__index_sequence<_Indices...>>::__move_func_type
__replace_construct_helper::__op_table<
    _Variant,__index_sequence<_Indices...>>::__move_assign[
    sizeof...(_Indices)]={
        &__move_assign_func<_Indices>...
    };

template<typename _Variant,ptrdiff_t ... _Indices>
const typename __replace_construct_helper::__op_table<
    _Variant,__index_sequence<_Indices...>>::__copy_func_type
__replace_construct_helper::__op_table<
    _Variant,__index_sequence<_Indices...>>::__copy_assign[
    sizeof...(_Indices)]={
        &__copy_assign_func<_Indices>...
    };

template<ptrdiff_t _Index,ptrdiff_t _MaskIndex,typename _Storage>
struct __backup_storage_ops{
    static void __move_construct_func(
        _Storage * __dest,_Storage& __source){
        new(__dest) _Storage(
            in_place<_Index>,
            std::move(__source.__get(in_place<_Index>)));
    }
    static void __destroy_func(_Storage * __obj){
        __obj->__destroy(in_place<_Index>);
    };
};

template<ptrdiff_t _Index,typename _Storage>
struct __backup_storage_ops<_Index,_Index,_Storage>{
    static void __move_construct_func(_Storage *,_Storage&){
        __THROW_EXCEPTION(std::bad_alloc());
    };
    static void __destroy_func(_Storage *){
        __THROW_EXCEPTION(std::bad_alloc());
    };
};

template<ptrdiff_t _MaskIndex,typename _Storage,typename _Indices>
struct __backup_storage_op_table;

template<ptrdiff_t _MaskIndex,typename _Storage,ptrdiff_t ... _Indices>
struct __backup_storage_op_table<
    _MaskIndex,_Storage,__index_sequence<_Indices...> >
{
    typedef void (*__move_func_type)(_Storage * __dest,_Storage& __source);
    typedef void (*__destroy_func_type)(_Storage * __obj);
    
    template<size_t _Index>
    struct __helper{
        typedef __backup_storage_ops<_Index,_MaskIndex,_Storage> __ops;
    };

    static const __move_func_type __move_ops[sizeof...(_Indices)];
    static const __destroy_func_type __destroy_ops[sizeof...(_Indices)];
};

template<ptrdiff_t _MaskIndex,typename _Storage,ptrdiff_t ... _Indices>
const typename __backup_storage_op_table<
    _MaskIndex,_Storage,__index_sequence<_Indices...> >::__move_func_type
__backup_storage_op_table<
    _MaskIndex,_Storage,__index_sequence<_Indices...> >::__move_ops[
        sizeof...(_Indices)]={
        &__helper<_Indices>::__ops::__move_construct_func...
    };

template<ptrdiff_t _MaskIndex,typename _Storage,ptrdiff_t ... _Indices>
const typename __backup_storage_op_table<
    _MaskIndex,_Storage,__index_sequence<_Indices...> >::__destroy_func_type
__backup_storage_op_table<
    _MaskIndex,_Storage,__index_sequence<_Indices...> >::__destroy_ops[
    sizeof...(_Indices)]={
        &__helper<_Indices>::__ops::__destroy_func...
    };

template<ptrdiff_t _Index,typename ... _Types>
struct __backup_storage{
    typedef __variant_data<_Types...> __storage_type;

    typedef __backup_storage_op_table<
        _Index,__storage_type,typename __type_indices<_Types...>::__type>
    __op_table_type;

    ptrdiff_t __backup_index;
    __storage_type& __live_storage;
    __storage_type __backup;

    __backup_storage(ptrdiff_t __live_index_,__storage_type& __live_storage_):
        __backup_index(__live_index_),__live_storage(__live_storage_){
        if(__backup_index>=0){
            __op_table_type::__move_ops[__backup_index](
                &__backup,__live_storage);
            __op_table_type::__destroy_ops[__backup_index](
                &__live_storage);
        }
    }
    void __destroy(){
        if(__backup_index>=0)
            __op_table_type::__destroy_ops[__backup_index](
                &__backup);
        __backup_index=-1;
    }
    
    ~__backup_storage(){
        if(__backup_index>=0){
            __op_table_type::__move_ops[__backup_index](
                &__live_storage,__backup);
            __destroy();
        }
    }
};

template<typename ... _Types>
struct __all_move_constructible;

template<typename _Head,typename ... _Rest>
struct __all_move_constructible<_Head,_Rest...>
{
    static constexpr bool value=std::is_move_constructible<_Head>::value && __all_move_constructible<_Rest...>::value;
};

template<>
struct __all_move_constructible<>:
    std::true_type{};

template<typename ... _Types>
struct __all_move_assignable;

template<typename _Head,typename ... _Rest>
struct __all_move_assignable<_Head,_Rest...>
{
    static constexpr bool value=std::is_move_assignable<_Head>::value && __all_move_assignable<_Rest...>::value;
};

template<>
struct __all_move_assignable<>:
    std::true_type{};

template<typename ... _Types>
struct __all_copy_assignable;

template<typename _Head,typename ... _Rest>
struct __all_copy_assignable<_Head,_Rest...>
{
    static constexpr bool value=std::is_copy_assignable<_Head>::value && __all_copy_assignable<_Rest...>::value;
};

template<>
struct __all_copy_assignable<>:
    std::true_type{};

namespace __swap_test_detail{
using std::swap;

template<typename _Other>
struct __swap_result{};

template<typename>
static char __test(...);
template <typename _Other>
static std::pair<char, std::pair<char, __swap_result<decltype(
    swap(std::declval<_Other &>(),std::declval<_Other &>()))>>>
__test(_Other *);
}

template <typename _Type> struct __is_swappable {
    static constexpr bool value =
        sizeof(__swap_test_detail::__test<_Type>(0)) != 1;
};

template<typename ... _Types>
struct __all_swappable;

template<typename _Head,typename ... _Rest>
struct __all_swappable<_Head,_Rest...>
{
    static constexpr bool value=__is_swappable<_Head>::value && __all_swappable<_Rest...>::value;
};

template<>
struct __all_swappable<>:
    std::true_type{};

template<bool _MoveConstructible,typename ... _Types>
struct __noexcept_variant_move_construct_impl{};

template<typename _Head,typename ... _Rest>
struct __noexcept_variant_move_construct_impl<true,_Head,_Rest...>{
    static constexpr bool value=noexcept(_Head(std::declval<_Head&&>())) && __noexcept_variant_move_construct_impl<true,_Rest...>::value;
};

template<>
struct __noexcept_variant_move_construct_impl<true>{
    static constexpr bool value=true;
};

template<typename ... _Types>
struct __noexcept_variant_move_construct:
__noexcept_variant_move_construct_impl<__all_move_constructible<_Types...>::value,_Types...>
{};

template<bool _MoveAssignable,typename ... _Types>
struct __noexcept_variant_move_assign_impl{};

template <typename _Head, typename... _Rest>
struct __noexcept_variant_move_assign_impl<true, _Head, _Rest...> {
    static constexpr bool value =
        std::is_nothrow_move_assignable<_Head>::value &&
        std::is_nothrow_move_constructible<_Head>::value &&
        __noexcept_variant_move_assign_impl<true, _Rest...>::value;
};

template<>
struct __noexcept_variant_move_assign_impl<true>{
    static constexpr bool value=true;
};

template <typename... _Types>
struct __noexcept_variant_move_assign
    : __noexcept_variant_move_assign_impl<
          __all_move_assignable<_Types...>::value &&
              __all_move_constructible<_Types...>::value,
          _Types...> {};

template<typename ... _Types>
struct __all_copy_constructible;

template<typename _Head,typename ... _Rest>
struct __all_copy_constructible<_Head,_Rest...>
{
    static constexpr bool value=std::is_copy_constructible<_Head>::value && __all_copy_constructible<_Rest...>::value;
};

template<>
struct __all_copy_constructible<>:
    std::true_type{};

template<bool _CopyConstructible,typename ... _Types>
struct __noexcept_variant_const_copy_construct_impl{};

template<typename _Head,typename ... _Rest>
struct __noexcept_variant_const_copy_construct_impl<true,_Head,_Rest...>{
    static constexpr bool value=noexcept(_Head(std::declval<_Head const&>())) && __noexcept_variant_const_copy_construct_impl<true,_Rest...>::value;
};

template<>
struct __noexcept_variant_const_copy_construct_impl<true>{
    static constexpr bool value=true;
};

template<typename ... _Types>
struct __noexcept_variant_const_copy_construct:
__noexcept_variant_const_copy_construct_impl<__all_copy_constructible<_Types...>::value,_Types...>
{};

template<bool _CopyNon_Constructible,typename ... _Types>
struct __noexcept_variant_non_const_copy_construct_impl{};

template<typename _Head,typename ... _Rest>
struct __noexcept_variant_non_const_copy_construct_impl<true,_Head,_Rest...>{
    static constexpr bool value=noexcept(_Head(std::declval<_Head&>())) && __noexcept_variant_non_const_copy_construct_impl<true,_Rest...>::value;
};

template<>
struct __noexcept_variant_non_const_copy_construct_impl<true>{
    static constexpr bool value=true;
};

template<typename ... _Types>
struct __noexcept_variant_non_const_copy_construct:
__noexcept_variant_non_const_copy_construct_impl<__all_copy_constructible<_Types...>::value,_Types...>
{};

template<bool _Swappable,typename ... _Types>
struct __noexcept_variant_swap_impl{};

template <typename _Head, typename... _Rest>
struct __noexcept_variant_swap_impl<true, _Head, _Rest...> {
    static constexpr bool value =
        noexcept(swap(std::declval<_Head&>(),std::declval<_Head&>())) &&
        __noexcept_variant_swap_impl<true, _Rest...>::value;
};

template<>
struct __noexcept_variant_swap_impl<true>{
    static constexpr bool value=true;
};

template<typename ... _Types>
struct __noexcept_variant_swap:
__noexcept_variant_swap_impl<__all_swappable<_Types...>::value,_Types...>
{};

template<typename ... _Types>
class Variant:
        private __variant_base<
    Variant<_Types...>,__all_trivially_destructible<_Types...>::__value>
{
    typedef __variant_base<Variant<_Types...>,__all_trivially_destructible<_Types...>::__value> __base_type;
    friend __base_type;
    friend struct __copy_construct_op_table<Variant>;
    friend struct __copy_assign_op_table<Variant>;
    friend struct __move_construct_op_table<Variant>;
    friend struct __move_assign_op_table<Variant>;
    friend struct __destroy_op_table<Variant>;
    
    template<ptrdiff_t _Index,typename ... _Types2>
    friend struct __variant_accessor;

    friend struct __replace_construct_helper;

    typedef __variant_data<_Types...> __storage_type;
    __storage_type __storage;
    typename __discriminator_type<sizeof ... (_Types)>::__type __index;

    template<size_t _Index,typename ... _Args>
    size_t __emplace_construct(_Args&& ... __args){
        new(&__storage) __storage_type(
            in_place<_Index>,std::forward<_Args>(__args)...);
        return  _Index;
    }
    
    void __destroy_self(){
        if(valueless_by_exception())
            return;
        __destroy_op_table<Variant>::__apply[index()](this);
        __index=-1;
    }
    
    ptrdiff_t __move_construct(Variant& __other){
        ptrdiff_t const __other_index=__other.index();
        if(__other_index==-1)
            return -1;
        __move_construct_op_table<Variant>::__apply[__other_index](this,__other);
        __other.__destroy_self();
        return __other_index;
    }

    ptrdiff_t __copy_construct(Variant const& __other){
        ptrdiff_t const __other_index=__other.index();
        if(__other_index==-1)
            return -1;
        __copy_construct_op_table<Variant>::__apply[__other_index](this,__other);
        return __other_index;
    }

    template<size_t _Index,typename ... _Args>
    void __replace_construct(_Args&& ... __args){
        typedef typename __indexed_type<_Index,_Types...>::__type __this_type;
        __replace_construct_helper::__helper<
            _Index,
            __storage_nothrow_constructible<__this_type,_Args...>::__value ||
            (sizeof...(_Types)==1),
            __storage_nothrow_move_constructible<__this_type>::__value,
            __other_storage_nothrow_move_constructible<
                _Index,_Types...>::__value
            >::__trampoline(*this,std::forward<_Args>(__args)...);
    }

    template<size_t _Index,typename ... _Args>
    void __two_stage_replace(_Args&& ... __args){
        typedef typename __indexed_type<_Index,_Types...>::__type __type;
        __variant_data<__type> __local(
            in_place<0>,std::forward<_Args>(__args)...);
        __destroy_self();
        __emplace_construct<_Index>(
            std::move(__local.__get(in_place<0>)));
        __index=_Index;
        __local.__destroy(in_place<0>);
    }

    template<size_t _Index,typename ... _Args>
    void __local_backup_replace(_Args&& ... __args){
        __backup_storage<_Index,_Types...> __backup(__index,__storage);
        __emplace_construct<_Index>(std::forward<_Args>(__args)...);
        __index=_Index;
        __backup.__destroy();
    }
    
    template<size_t _Index,typename ... _Args>
    void __direct_replace(_Args&& ... __args) {
        __destroy_self();
        __emplace_construct<_Index>(std::forward<_Args>(__args)...);
        __index=_Index;
    }

    struct __private_type{};

public:
    constexpr Variant()
        __NOEXCEPT_(noexcept(typename __indexed_type<0,_Types...>::__type())):
        __storage(in_place<0>),
        __index(0)
    {}

    constexpr Variant(typename std::conditional<__all_move_constructible<_Types...>::value,Variant,__private_type>::type&& __other)
    __NOEXCEPT_(__noexcept_variant_move_construct<_Types...>::value):
        __index(__move_construct(__other))
    {}

    constexpr Variant(typename std::conditional<!__all_move_constructible<_Types...>::value,Variant,__private_type>::type&& __other)=delete;
    
    constexpr Variant(typename std::conditional<__all_copy_constructible<_Types...>::value,Variant,__private_type>::type& __other)
    __NOEXCEPT_(__noexcept_variant_non_const_copy_construct<_Types...>::value):
        __index(__copy_construct(__other))
    {}

    constexpr Variant(typename std::conditional<!__all_copy_constructible<_Types...>::value,Variant,__private_type>::type& __other)=delete;

    constexpr Variant(typename std::conditional<__all_copy_constructible<_Types...>::value,Variant,__private_type>::type const& __other)
    __NOEXCEPT_(__noexcept_variant_const_copy_construct<_Types...>::value):
        __index(__copy_construct(__other))
    {}

    constexpr Variant(typename std::conditional<!__all_copy_constructible<_Types...>::value,Variant,__private_type>::type const& __other)=delete;
    
    template<typename _Type,typename ... _Args>
    explicit constexpr Variant(in_place_type_t<_Type>,_Args&& ... __args):
        __storage(
            in_place<__type_index<_Type,_Types...>::__value>,
            std::forward<_Args>(__args)...),
        __index(__type_index<_Type,_Types...>::__value)
    {
        static_assert(std::is_constructible<_Type,_Args...>::value,"Type must be constructible from args");
    }

    template<size_t _Index,typename ... _Args>
    explicit constexpr Variant(in_place_index_t<_Index>,_Args&& ... __args):
        __storage(in_place<_Index>,std::forward<_Args>(__args)...),
        __index(_Index)
    {
        static_assert(std::is_constructible<typename __indexed_type<_Index,_Types...>::__type,_Args...>::value,"Type must be constructible from args");
    }
    
    template<typename _Type>
    constexpr Variant(_Type&& __x):
        __storage(
            in_place<
            __type_index_to_construct<_Type,_Types...>::__value>,
            std::forward<_Type>(__x)),
        __index(__type_index_to_construct<_Type,_Types...>::__value)
    {}

    template<typename _Type,
             typename _Enable=
             typename std::enable_if<
                 (__constructible_matches<std::initializer_list<_Type>,_Types...>::__type::__length>0)
             >::type>
    constexpr Variant(std::initializer_list<_Type> __x):
        __storage(
            in_place<
            __type_index_to_construct<std::initializer_list<_Type>,_Types...>::__value>,
            __x),
        __index(__type_index_to_construct<std::initializer_list<_Type>,_Types...>::__value)
    {}
    
    template<typename _Type>
    Variant& operator=(_Type&& __x){
        constexpr size_t _Index=
            __type_index_to_construct<_Type,_Types...>::__value;
        if(_Index==__index){
            get<_Index>(*this)=std::forward<_Type>(__x);
        }
        else{
            __replace_construct<_Index>(std::forward<_Type>(__x));
        }
        return *this;
    }

    Variant &operator=(
        typename std::conditional<
            !(__all_copy_constructible<_Types...>::value &&
              __all_move_constructible<_Types...>::value &&
              __all_copy_assignable<_Types...>::value),
            Variant, __private_type>::type const &__other) = delete;

    Variant &operator=(
        typename std::conditional<
            __all_copy_constructible<_Types...>::value &&
                __all_move_constructible<_Types...>::value &&
                __all_copy_assignable<_Types...>::value,
            Variant, __private_type>::type const &__other) {
        if (__other.valueless_by_exception()) {
            __destroy_self();
        }
        else if(__other.index()==index()){
            __copy_assign_op_table<Variant>::__apply[index()](this,__other);
        }
        else{
            __replace_construct_helper::__op_table<Variant>::__copy_assign[
                __other.index()](this,__other);
        }
        return *this;
    }
    Variant &operator=(
        typename std::conditional<
            !(__all_copy_constructible<_Types...>::value &&
              __all_move_constructible<_Types...>::value &&
              __all_copy_assignable<_Types...>::value),
            Variant, __private_type>::type &__other) = delete;

    Variant &operator=(
        typename std::conditional<
            __all_copy_constructible<_Types...>::value &&
                __all_move_constructible<_Types...>::value &&
                __all_copy_assignable<_Types...>::value,
            Variant, __private_type>::type &__other) {
        if(__other.valueless_by_exception()){
            __destroy_self();
        }
        else if(__other.index()==index()){
            __copy_assign_op_table<Variant>::__apply[index()](this,__other);
        }
        else{
            __replace_construct_helper::__op_table<Variant>::__copy_assign[
                __other.index()](this,__other);
        }
        return *this;
    }
    Variant &operator=(
        typename std::conditional<
            !(__all_move_constructible<_Types...>::value &&
              __all_move_assignable<_Types...>::value),
            Variant, __private_type>::type &&__other) = delete;

    Variant &operator=(
        typename std::conditional<__all_move_constructible<_Types...>::value &&
                                      __all_move_assignable<_Types...>::value,
                                  Variant, __private_type>::type &&
            __other) __NOEXCEPT_(__noexcept_variant_move_assign<_Types...>::value) {
        if (__other.valueless_by_exception()) {
            __destroy_self();
        }
        else if(__other.index()==index()){
            __move_assign_op_table<Variant>::__apply[index()](this,__other);
            __other.__destroy_self();
        }
        else{
            __replace_construct_helper::__op_table<Variant>::__move_assign[
                __other.index()](this,__other);
        }
        return *this;
    }

    template<typename _Type,typename ... _Args>
    void emplace(_Args&& ... __args){
        __direct_replace<__type_index<_Type,_Types...>::__value>(
            std::forward<_Args>(__args)...);
    }
    
    template<size_t _Index,typename ... _Args>
    void emplace(_Args&& ... __args){
        __direct_replace<_Index>(std::forward<_Args>(__args)...);
    }
    
    constexpr bool valueless_by_exception() const __NOEXCEPT{
        return __index==-1;
    }
    constexpr ptrdiff_t index() const __NOEXCEPT{
        return __index;
    }

    void swap(
        typename std::conditional<
            __all_swappable<_Types...>::value &&
                __all_move_constructible<_Types...>::value,
            Variant, __private_type>::type
            &__other) __NOEXCEPT_(__noexcept_variant_swap<_Types...>::value) {
        if (__other.index() == index()) {
            if(!valueless_by_exception())
                __swap_op_table<Variant>::__apply[index()](*this,__other);
        }
        else{
            Variant __temp(std::move(__other));
            __other.__index=__other.__move_construct(*this);
            __index=__move_construct(__temp);
        }
    }
};

template<>
class Variant<>{
public:
    Variant()=delete;
    
    constexpr bool valueless_by_exception() const __NOEXCEPT{
        return true;
    }
    constexpr ptrdiff_t index() const __NOEXCEPT{
        return -1;
    }

    void swap(Variant&){}
};

template <typename... _Types>
typename std::enable_if<__all_swappable<_Types...>::value &&
                            __all_move_constructible<_Types...>::value,
                        void>::type
swap(Variant<_Types...> &__lhs, Variant<_Types...> &__rhs) __NOEXCEPT_(
    __noexcept_variant_swap<_Types...>::value) {
    __lhs.swap(__rhs);
}

template<ptrdiff_t _Index,typename ... _Types>
struct __variant_accessor{
    typedef typename __indexed_type<_Index,_Types...>::__type __type;
    static constexpr __type& get(Variant<_Types...>& __v){
        return __v.__storage.__get(in_place<_Index>);
    }
    static constexpr __type const& get(Variant<_Types...> const& __v){
        return __v.__storage.__get(in_place<_Index>);
    }
    static constexpr __type&& get(Variant<_Types...>&& __v){
        return __v.__storage.__get_rref(in_place<_Index>);
    }
    static constexpr const __type&& get(Variant<_Types...> const&& __v){
        return __v.__storage.__get_rref(in_place<_Index>);
    }
};

template<typename _Type,typename ... _Types>
constexpr _Type& get(Variant<_Types...>& __v){
    return get<__type_index<_Type,_Types...>::__value>(__v);
}

template<typename _Type,typename ... _Types>
constexpr _Type&& get(Variant<_Types...>&& __v){
    return get<__type_index<_Type,_Types...>::__value>(std::move(__v));
}

template<typename _Type,typename ... _Types>
constexpr _Type const& get(Variant<_Types...> const& __v){
    return get<__type_index<_Type,_Types...>::__value>(__v);
}

template<typename _Type,typename ... _Types>
constexpr const _Type&& get(Variant<_Types...> const&& __v){
    return get<__type_index<_Type,_Types...>::__value>(std::move(__v));
}


template<ptrdiff_t _Index,typename ... _Types>
constexpr typename __indexed_type<_Index,_Types...>::__type const& get(Variant<_Types...> const& __v){
    return *(
        (_Index!=__v.index())
            ? std::addressof(__throw_bad_variant_access<typename __indexed_type<_Index,_Types...>::__type const&>("Bad Variant index in get"))
            : std::addressof(__variant_accessor<_Index,_Types...>::get(__v))
    );
}

template<ptrdiff_t _Index,typename ... _Types>
constexpr typename __indexed_type<_Index,_Types...>::__type& get(Variant<_Types...>& __v){
    return *(
        (_Index!=__v.index())
            ? std::addressof(__throw_bad_variant_access<typename __indexed_type<_Index,_Types...>::__type&>("Bad Variant index in get"))
            : std::addressof(__variant_accessor<_Index,_Types...>::get(__v))
    );
}

template<ptrdiff_t _Index,typename ... _Types>
constexpr typename __indexed_type<_Index,_Types...>::__type&& get(Variant<_Types...>&& __v){
    return __variant_accessor<_Index,_Types...>::get(
        (((_Index!=__v.index()) ? __throw_bad_variant_access<int>("Bad Variant index in get") : 0), std::move(__v))
    );
}

template<ptrdiff_t _Index,typename ... _Types>
constexpr const typename __indexed_type<_Index,_Types...>::__type&& get(Variant<_Types...> const&& __v){
    return __variant_accessor<_Index,_Types...>::get(
        (((_Index!=__v.index()) ? __throw_bad_variant_access<int>("Bad Variant index in get") : 0), std::move(__v))
    );
}

template<typename _Type,typename ... _Types>
constexpr std::add_pointer_t<_Type> get_if(Variant<_Types...>& __v){
    return (__type_index<_Type,_Types...>::__value!=__v.index())?nullptr:std::addressof(get<_Type>(__v));
}

template<typename _Type,typename ... _Types>
constexpr std::add_pointer_t<_Type const> get_if(Variant<_Types...> const& __v){
    return (__type_index<_Type,_Types...>::__value!=__v.index())?nullptr:std::addressof(get<_Type>(__v));
}

template<ptrdiff_t _Index,typename ... _Types>
constexpr std::add_pointer_t<typename __indexed_type<_Index,_Types...>::__type> get_if(Variant<_Types...>& __v){
    return ((_Index!=__v.index())?nullptr:
        std::addressof(__variant_accessor<_Index,_Types...>::get(__v)));
}

template<ptrdiff_t _Index,typename ... _Types>
constexpr std::add_pointer_t<typename __indexed_type<_Index,_Types...>::__type const> get_if(
    Variant<_Types...> const& __v){
    return ((_Index!=__v.index())?nullptr:
        std::addressof(__variant_accessor<_Index,_Types...>::get(__v)));
}

template<typename _Type,typename ... _Types>
constexpr bool holds_alternative(Variant<_Types...> const& __v) __NOEXCEPT{
    return __v.index()==__type_index<_Type,_Types...>::__value;
}

template<typename _Visitor,typename ... _Types>
struct __visitor_return_type;

template<typename _Visitor>
struct __visitor_return_type<_Visitor>{
    typedef decltype(std::declval<_Visitor&>()()) __type;
};

template<typename _Visitor,typename _Head,typename ... _Rest>
struct __visitor_return_type<_Visitor,_Head,_Rest...>{
    typedef decltype(std::declval<_Visitor&>()(std::declval<_Head&>())) __type;
};

template<typename _Visitor,typename ... _Types>
struct __visitor_table{
    typedef Variant<_Types...> __variant_type;
    typedef typename __visitor_return_type<_Visitor,_Types...>::__type __return_type;
    typedef __return_type (*__func_type)(_Visitor&,__variant_type&);

    template<typename _Type>
    static __return_type __trampoline_func(_Visitor& __visitor,__variant_type& __v){
        return __visitor(get<_Type>(__v));
    }

    static const __func_type __trampoline[sizeof...(_Types)];
};

template<typename _Visitor,typename ... _Types>
const typename __visitor_table<_Visitor,_Types...>::__func_type __visitor_table<_Visitor,_Types...>::__trampoline[sizeof...(_Types)]={
        &__trampoline_func<_Types>...
    };

template<typename _Visitor,typename ... _Types>
constexpr typename __visitor_return_type<_Visitor,_Types...>::__type
visit(_Visitor&& __visitor,Variant<_Types...>& __v){
    return (__v.valueless_by_exception())
        ? __throw_bad_variant_access<typename __visitor_return_type<_Visitor,_Types...>::__type>("Visiting of empty Variant")
        : __visitor_table<_Visitor,_Types...>::__trampoline[__v.index()](__visitor,__v);
}

template<typename _Visitor,typename ... _Variants>
struct __multi_visitor_return_type{
    typedef decltype(std::declval<_Visitor&>()(get<0>(std::declval<_Variants>())...))
    __type;
};

template<size_t _VariantIndex,typename _Indices>
struct __visit_helper;

template<ptrdiff_t ... _Indices>
struct __visit_helper<0,__index_sequence<_Indices...>>{
    template<typename _Visitor,typename ... _Variants>
    static constexpr typename __multi_visitor_return_type<_Visitor,_Variants...>::__type
    __visit(_Visitor& __visitor,_Variants& ... __v){
        return __visitor(get<_Indices>(__v)...);
    }
};

template<size_t _Index,typename ... _Args>
struct __arg_selector_t;

template<typename _Head,typename ... _Rest>
struct __arg_selector_t<0,_Head,_Rest...>{
    typedef _Head __type;

    static constexpr __type& __select(_Head& __head,_Rest& ...){
        return __head;
    }
};

template<size_t _Index,typename _Head,typename ... _Rest>
struct __arg_selector_t<_Index,_Head,_Rest...>{
    typedef typename __arg_selector_t<_Index-1,_Rest...>::__type __type;
    static constexpr __type& __select(_Head&,_Rest& ... __rest){
        return __arg_selector_t<_Index-1,_Rest...>::__select(__rest...);
    }
};

template<size_t _Index,typename ... _Args>
constexpr typename __arg_selector_t<_Index,_Args...>::__type&& __arg_selector(_Args&& ... __args){
    return std::forward<typename __arg_selector_t<_Index,_Args...>::__type>(
        __arg_selector_t<_Index,_Args...>::__select(__args...));
}

template<ptrdiff_t _Index,size_t _VariantIndex,ptrdiff_t ... _Indices>
struct __visit_helper2{
    template<typename _Visitor,typename ... _Variants>
    static constexpr typename __multi_visitor_return_type<_Visitor,_Variants...>::__type
    __visit(_Visitor& __visitor,_Variants&& ... __v){
        return (__arg_selector<_VariantIndex-1>(__v...).index()==_Index)
            ? __visit_helper<_VariantIndex-1,__index_sequence<_Index,_Indices...>>::__visit(__visitor,std::forward<_Variants>(__v)...)
            : __visit_helper2<_Index-1,_VariantIndex,_Indices...>::__visit(__visitor,std::forward<_Variants>(__v)...);
    }
};

template<size_t _VariantIndex,ptrdiff_t ... _Indices>
struct __visit_helper2<-1,_VariantIndex,_Indices...>{
    template<typename _Visitor,typename ... _Variants>
    static constexpr typename __multi_visitor_return_type<_Visitor,_Variants...>::__type
    __visit(_Visitor&,_Variants&& ...){
        return __throw_bad_variant_access<typename __multi_visitor_return_type<_Visitor,_Variants...>::__type>("Visiting of empty Variant");
    }
};

template<typename _Variant>
struct __variant_type_count;

template<typename ... _Types>
struct __variant_type_count<Variant<_Types...>>{
    static constexpr size_t __value=sizeof...(_Types);
};

template<typename _Variant>
struct __variant_type_count<_Variant&>{
    static constexpr size_t __value=__variant_type_count<_Variant>::__value;
};

template<typename _Variant>
struct __variant_type_count<_Variant const&>{
    static constexpr size_t __value=__variant_type_count<_Variant>::__value;
};

template<size_t _VariantIndex,ptrdiff_t ... _Indices>
struct __visit_helper<_VariantIndex,__index_sequence<_Indices...>>{

    template<typename _Visitor,typename ... _Variants>
    static constexpr typename __multi_visitor_return_type<_Visitor,_Variants...>::__type
    __visit(_Visitor& __visitor,_Variants&& ... __v){
        return __visit_helper2<
            __variant_type_count<
                typename __arg_selector_t<
                    _VariantIndex-1,_Variants...>::__type>::__value-1,
            _VariantIndex,_Indices...>::__visit(
                __visitor,std::forward<_Variants&&>(__v)...);
    }
};

template<typename _Visitor,typename ... _Variants>
constexpr typename __multi_visitor_return_type<_Visitor,_Variants...>::__type
visit(_Visitor&& __visitor,_Variants&& ... __v){
    return __visit_helper<sizeof...(_Variants),__index_sequence<>>::__visit(
        __visitor,std::forward<_Variants>(__v)...);
}

template<typename ... _Types>
constexpr bool operator==(Variant<_Types...> const& __lhs,Variant<_Types...> const& __rhs){
    return (__lhs.index()==__rhs.index()) &&
        ((__lhs.index()==-1) ||
         __equality_op_table<Variant<_Types...>>::__equality_compare[__lhs.index()](
             __lhs,__rhs));
}

template<typename ... _Types>
constexpr bool operator!=(Variant<_Types...> const& __lhs,Variant<_Types...> const& __rhs){
    return !(__lhs==__rhs);
}

template<typename ... _Types>
constexpr bool operator<(Variant<_Types...> const& __lhs,Variant<_Types...> const& __rhs){
    return (__lhs.index()<__rhs.index()) ||
        ((__lhs.index()==__rhs.index()) &&
         ((__lhs.index()!=-1) &&
          __less_than_op_table<Variant<_Types...>>::
          __less_than_compare[__lhs.index()](__lhs,__rhs)));
}

template<typename ... _Types>
constexpr bool operator>(Variant<_Types...> const& __lhs,Variant<_Types...> const& __rhs){
    return __rhs<__lhs;
}

template<typename ... _Types>
constexpr bool operator>=(Variant<_Types...> const& __lhs,Variant<_Types...> const& __rhs){
    return !(__lhs<__rhs);
}

template<typename ... _Types>
constexpr bool operator<=(Variant<_Types...> const& __lhs,Variant<_Types...> const& __rhs){
    return !(__lhs>__rhs);
}

struct Monostate{};

constexpr inline bool operator==(Monostate const&,Monostate const&){ return true;}
constexpr inline bool operator!=(Monostate const&,Monostate const&){ return false;}
constexpr inline bool operator>=(Monostate const&,Monostate const&){ return true;}
constexpr inline bool operator<=(Monostate const&,Monostate const&){ return true;}
constexpr inline bool operator>(Monostate const&,Monostate const&){ return false;}
constexpr inline bool operator<(Monostate const&,Monostate const&){ return false;}

struct __hash_visitor{
    template<typename _Type>
    size_t operator()(_Type const& __x){
        return std::hash<_Type>()(__x);
    }
};

// -- WebKit Additions --

template<class V, class... F>
auto switchOn(V&& v, F&&... f) -> decltype(visit(makeVisitor(std::forward<F>(f)...), std::forward<V>(v)))
{
    return visit(makeVisitor(std::forward<F>(f)...), std::forward<V>(v));
}

} // namespace WTF

namespace std {

template<>
struct hash<WTF::Monostate>{
    size_t operator()(WTF::Monostate) __NOEXCEPT{
        return 42;
    }
};

template<typename ... _Types>
struct hash<WTF::Variant<_Types...>>{
    size_t operator()(WTF::Variant<_Types...> const &v) __NOEXCEPT {
        return std::hash<ptrdiff_t>()(v.index()) ^ WTF::visit(WTF::__hash_visitor(), v);
    }
};

} // namespace std

using WTF::Monostate;
using WTF::Variant;

#endif // !COMPILER(CLANG) || WTF_CPP_STD_VER >= 14

#if COMPILER(MSVC)
#pragma warning(pop)
#endif