NOT FOR LANDING: Thread the needle through all webmodules.

third_party/WebKit/Source/wtf/Variant.h

+// 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.
+
+#ifndef WTF_VARIANT_H
+#define WTF_VARIANT_H
+
+#include <limits.h>
+#include <stddef.h>
+#include <wtf/Compiler.h>
+#include <wtf/StdLibExtras.h>
+#include <functional>
+#include <new>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable : 4245)
+#pragma warning(disable : 4521)
+#pragma warning(disable : 4522)
+#pragma warning(disable : 4814)
+#endif
+
+namespace std {
+
+template <class T>
+using add_const_t = typename std::add_const<T>::type;
+
+template <class T>
+using add_pointer_t = typename std::add_pointer<T>::type;
+
+template <class T>
+using add_volatile_t = typename std::add_volatile<T>::type;
+}
+
+namespace WTF {
+
+#define __THROW_EXCEPTION(__exception) \
+  do {                                 \
+    (void)__exception;                 \
+    CRASH();                           \
+  } while (0);
+#define __NOEXCEPT
+#define __NOEXCEPT_(...)
+
+struct __variant_in_place_private {
+  template <typename>
+  struct __type_holder;
+
+  template <size_t>
+  struct __value_holder;
+};
+
+struct variant_in_place_tag {
+  variant_in_place_tag() = delete;
+};
+
+using variant_in_place_t =
+    variant_in_place_tag (&)(__variant_in_place_private&);
+
+template <class _Type>
+using variant_in_place_type_t =
+    variant_in_place_tag (&)(__variant_in_place_private::__type_holder<_Type>&);
+
+template <size_t _Index>
+using variant_in_place_index_t = variant_in_place_tag (&)(
+    __variant_in_place_private::__value_holder<_Index>&);
+
+variant_in_place_tag variant_in_place(__variant_in_place_private&);
+
+template <class _Type>
+variant_in_place_tag variant_in_place(
+    __variant_in_place_private::__type_holder<_Type>&) {
+  __THROW_EXCEPTION(__variant_in_place_private());
+}
+
+template <size_t _Index>
+variant_in_place_tag variant_in_place(
+    __variant_in_place_private::__value_holder<_Index>&) {
+  __THROW_EXCEPTION(__variant_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>
+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) {
+    return 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(variant_in_place_index_t<0>, _Args&&... __args)
+      : __val(std::forward<_Args>(__args)...) {}
+
+  _Type& __get(variant_in_place_index_t<0>) {
+    return __variant_storage<_Type>::__get(__val);
+  }
+  /*constexpr*/ _Type&& __get_rref(variant_in_place_index_t<0>) {
+    return __variant_storage<_Type>::__get_rref(__val);
+  }
+  constexpr const _Type& __get(variant_in_place_index_t<0>) const {
+    return __variant_storage<_Type>::__get(__val);
+  }
+  constexpr const _Type&& __get_rref(variant_in_place_index_t<0>) const {
+    return __variant_storage<_Type>::__get_rref(__val);
+  }
+  void __destroy(variant_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(variant_in_place_index_t<0>, _Args&&... __args)
+      : __val(&std::forward<_Args>(__args)...) {}
+
+  _Type& __get(variant_in_place_index_t<0>) {
+    return __variant_storage<_Type&>::__get(__val);
+  }
+  constexpr _Type& __get(variant_in_place_index_t<0>) const {
+    return __variant_storage<_Type&>::__get(__val);
+  }
+
+  _Type& __get_rref(variant_in_place_index_t<0>) {
+    return __variant_storage<_Type&>::__get_rref(__val);
+  }
+  constexpr _Type& __get_rref(variant_in_place_index_t<0>) const {
+    return __variant_storage<_Type&>::__get_rref(__val);
+  }
+
+  void __destroy(variant_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(variant_in_place_index_t<0>, _Arg&& __arg) : __val(&__arg) {}
+
+  _Type&& __get(variant_in_place_index_t<0>) {
+    return __variant_storage<_Type&&>::__get(__val);
+  }
+  constexpr _Type&& __get(variant_in_place_index_t<0>) const {
+    return __variant_storage<_Type&&>::__get(__val);
+  }
+  _Type&& __get_rref(variant_in_place_index_t<0>) {
+    return __variant_storage<_Type&&>::__get_rref(__val);
+  }
+  constexpr _Type&& __get_rref(variant_in_place_index_t<0>) const {
+    return __variant_storage<_Type&&>::__get_rref(__val);
+  }
+  void __destroy(variant_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(variant_in_place_index_t<0>, _Args&&... __args)
+      : __head(variant_in_place<0>, std::forward<_Args>(__args)...) {}
+  template <size_t _Index, typename... _Args>
+  constexpr __variant_data(variant_in_place_index_t<_Index>, _Args&&... __args)
+      : __rest(variant_in_place<_Index - 1>, std::forward<_Args>(__args)...) {}
+
+  _Head& __get(variant_in_place_index_t<0>) {
+    return __head.__get(variant_in_place<0>);
+  }
+
+  /*constexpr*/ _Head&& __get_rref(variant_in_place_index_t<0>) {
+    return __head.__get_rref(variant_in_place<0>);
+  }
+
+  constexpr const _Head& __get(variant_in_place_index_t<0>) const {
+    return __head.__get(variant_in_place<0>);
+  }
+
+  constexpr const _Head&& __get_rref(variant_in_place_index_t<0>) const {
+    return __head.__get_rref(variant_in_place<0>);
+  }
+
+  template <size_t _Index>
+  typename __indexed_type<_Index - 1, _Rest...>::__type& __get(
+      variant_in_place_index_t<_Index>) {
+    return __rest.__get(variant_in_place<_Index - 1>);
+  }
+
+  template <size_t _Index>
+  /*constexpr*/ typename __indexed_type<_Index - 1, _Rest...>::__type&&
+  __get_rref(variant_in_place_index_t<_Index>) {
+    return __rest.__get_rref(variant_in_place<_Index - 1>);
+  }
+
+  template <size_t _Index>
+  constexpr const typename __indexed_type<_Index - 1, _Rest...>::__type& __get(
+      variant_in_place_index_t<_Index>) const {
+    return __rest.__get(variant_in_place<_Index - 1>);
+  }
+
+  template <size_t _Index>
+  constexpr const typename __indexed_type<_Index - 1, _Rest...>::__type&&
+  __get_rref(variant_in_place_index_t<_Index>) const {
+    return __rest.__get_rref(variant_in_place<_Index - 1>);
+  }
+
+  void __destroy(variant_in_place_index_t<0>) {
+    __head.__destroy(variant_in_place<0>);
+  }
+  template <size_t _Index>
+  void __destroy(variant_in_place_index_t<_Index>) {
+    __rest.__destroy(variant_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(variant_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 _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(variant_in_place<_Index>,
+                          std::move(__source.__get(variant_in_place<_Index>)));
+  }
+  static void __destroy_func(_Storage* __obj) {
+    __obj->__destroy(variant_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(variant_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(variant_in_place<0>,
+                                   std::forward<_Args>(__args)...);
+    __destroy_self();
+    __emplace_construct<_Index>(std::move(__local.__get(variant_in_place<0>)));
+    __index = _Index;
+    __local.__destroy(variant_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(variant_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(variant_in_place_type_t<_Type>, _Args&&... __args)
+      : __storage(variant_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(variant_in_place_index_t<_Index>,
+                             _Args&&... __args)
+      : __storage(variant_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(variant_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(variant_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(variant_in_place<_Index>);
+  }
+  static constexpr __type const& get(Variant<_Types...> const& __v) {
+    return __v.__storage.__get(variant_in_place<_Index>);
+  }
+  static constexpr __type&& get(Variant<_Types...>&& __v) {
+    return __v.__storage.__get_rref(variant_in_place<_Index>);
+  }
+  static constexpr const __type&& get(Variant<_Types...> const&& __v) {
+    return __v.__storage.__get_rref(variant_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;
+
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
+
+#endif