From 1bf1084f2b10c3b47fd1a588d85d21ed0eb41d0c Mon Sep 17 00:00:00 2001
From: Lorry Tar Creator <lorry-tar-importer@lorry>
Date: Tue, 27 Jun 2017 06:07:23 +0000
Subject: webkitgtk-2.16.5

---
 Source/WTF/wtf/Variant.h | 2079 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 2079 insertions(+)
 create mode 100644 Source/WTF/wtf/Variant.h

(limited to 'Source/WTF/wtf/Variant.h')

diff --git a/Source/WTF/wtf/Variant.h b/Source/WTF/wtf/Variant.h
new file mode 100644
index 000000000..6d4a7399c
--- /dev/null
+++ b/Source/WTF/wtf/Variant.h
@@ -0,0 +1,2079 @@
+// 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())
+            ? &__throw_bad_variant_access<typename __indexed_type<_Index,_Types...>::__type const&>("Bad Variant index in get")
+            : &__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())
+            ? &__throw_bad_variant_access<typename __indexed_type<_Index,_Types...>::__type&>("Bad Variant index in get")
+            : &__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:&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:&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:
+        &__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:
+        &__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
-- 
cgit v1.2.1