From 9aafd5ce068da6f87c2f3ac8c9cf0721976f2bbc Mon Sep 17 00:00:00 2001
From: Tyge Løvset <tylo@norceresearch.no>
Date: Thu, 7 Jul 2022 10:47:14 +0200
Subject: Added emhash by ktprime to external benchmarks. Very fast iteration
 and lookups.

---
 benchmarks/external/parallel_hashmap/phmap_base.h | 5171 ---------------------
 1 file changed, 5171 deletions(-)
 delete mode 100644 benchmarks/external/parallel_hashmap/phmap_base.h

(limited to 'benchmarks/external/parallel_hashmap/phmap_base.h')

diff --git a/benchmarks/external/parallel_hashmap/phmap_base.h b/benchmarks/external/parallel_hashmap/phmap_base.h
deleted file mode 100644
index d0c6f3ce..00000000
--- a/benchmarks/external/parallel_hashmap/phmap_base.h
+++ /dev/null
@@ -1,5171 +0,0 @@
-#if !defined(phmap_base_h_guard_)
-#define phmap_base_h_guard_
-
-// ---------------------------------------------------------------------------
-// Copyright (c) 2019, Gregory Popovitch - greg7mdp@gmail.com
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// Includes work from abseil-cpp (https://github.com/abseil/abseil-cpp)
-// with modifications.
-// 
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-// ---------------------------------------------------------------------------
-
-#include <algorithm>
-#include <cassert>
-#include <cstddef>
-#include <initializer_list>
-#include <iterator>
-#include <string>
-#include <type_traits>
-#include <utility>
-#include <functional>
-#include <tuple>
-#include <utility>
-#include <memory>
-#include <mutex> // for std::lock
-
-#include "phmap_config.h"
-
-#ifdef PHMAP_HAVE_SHARED_MUTEX
-    #include <shared_mutex>  // after "phmap_config.h"
-#endif
-
-#ifdef _MSC_VER
-    #pragma warning(push)
-    #pragma warning(disable : 4514) // unreferenced inline function has been removed
-    #pragma warning(disable : 4582) // constructor is not implicitly called
-    #pragma warning(disable : 4625) // copy constructor was implicitly defined as deleted
-    #pragma warning(disable : 4626) // assignment operator was implicitly defined as deleted
-    #pragma warning(disable : 4710) // function not inlined
-    #pragma warning(disable : 4711) //  selected for automatic inline expansion
-    #pragma warning(disable : 4820) // '6' bytes padding added after data member
-#endif  // _MSC_VER
-
-namespace phmap {
-
-template <class T> using Allocator = typename std::allocator<T>;
-
-template<class T1, class T2> using Pair = typename std::pair<T1, T2>;
-
-template <class T>
-struct EqualTo
-{
-    inline bool operator()(const T& a, const T& b) const
-    {
-        return std::equal_to<T>()(a, b);
-    }
-};
-
-template <class T>
-struct Less
-{
-    inline bool operator()(const T& a, const T& b) const
-    {
-        return std::less<T>()(a, b);
-    }
-};
-
-namespace type_traits_internal {
-
-template <typename... Ts>
-struct VoidTImpl {
-  using type = void;
-};
-
-// This trick to retrieve a default alignment is necessary for our
-// implementation of aligned_storage_t to be consistent with any implementation
-// of std::aligned_storage.
-// ---------------------------------------------------------------------------
-template <size_t Len, typename T = std::aligned_storage<Len>>
-struct default_alignment_of_aligned_storage;
-
-template <size_t Len, size_t Align>
-struct default_alignment_of_aligned_storage<Len,
-                                            std::aligned_storage<Len, Align>> {
-  static constexpr size_t value = Align;
-};
-
-// NOTE: The `is_detected` family of templates here differ from the library
-// fundamentals specification in that for library fundamentals, `Op<Args...>` is
-// evaluated as soon as the type `is_detected<Op, Args...>` undergoes
-// substitution, regardless of whether or not the `::value` is accessed. That
-// is inconsistent with all other standard traits and prevents lazy evaluation
-// in larger contexts (such as if the `is_detected` check is a trailing argument
-// of a `conjunction`. This implementation opts to instead be lazy in the same
-// way that the standard traits are (this "defect" of the detection idiom
-// specifications has been reported).
-// ---------------------------------------------------------------------------
-
-template <class Enabler, template <class...> class Op, class... Args>
-struct is_detected_impl {
-  using type = std::false_type;
-};
-
-template <template <class...> class Op, class... Args>
-struct is_detected_impl<typename VoidTImpl<Op<Args...>>::type, Op, Args...> {
-  using type = std::true_type;
-};
-
-template <template <class...> class Op, class... Args>
-struct is_detected : is_detected_impl<void, Op, Args...>::type {};
-
-template <class Enabler, class To, template <class...> class Op, class... Args>
-struct is_detected_convertible_impl {
-  using type = std::false_type;
-};
-
-template <class To, template <class...> class Op, class... Args>
-struct is_detected_convertible_impl<
-    typename std::enable_if<std::is_convertible<Op<Args...>, To>::value>::type,
-    To, Op, Args...> {
-  using type = std::true_type;
-};
-
-template <class To, template <class...> class Op, class... Args>
-struct is_detected_convertible
-    : is_detected_convertible_impl<void, To, Op, Args...>::type {};
-
-template <typename T>
-using IsCopyAssignableImpl =
-    decltype(std::declval<T&>() = std::declval<const T&>());
-
-template <typename T>
-using IsMoveAssignableImpl = decltype(std::declval<T&>() = std::declval<T&&>());
-
-}  // namespace type_traits_internal
-
-template <typename T>
-struct is_copy_assignable : type_traits_internal::is_detected<
-                                type_traits_internal::IsCopyAssignableImpl, T> {
-};
-
-template <typename T>
-struct is_move_assignable : type_traits_internal::is_detected<
-                                type_traits_internal::IsMoveAssignableImpl, T> {
-};
-
-// ---------------------------------------------------------------------------
-// void_t()
-//
-// Ignores the type of any its arguments and returns `void`. In general, this
-// metafunction allows you to create a general case that maps to `void` while
-// allowing specializations that map to specific types.
-//
-// This metafunction is designed to be a drop-in replacement for the C++17
-// `std::void_t` metafunction.
-//
-// NOTE: `phmap::void_t` does not use the standard-specified implementation so
-// that it can remain compatible with gcc < 5.1. This can introduce slightly
-// different behavior, such as when ordering partial specializations.
-// ---------------------------------------------------------------------------
-template <typename... Ts>
-using void_t = typename type_traits_internal::VoidTImpl<Ts...>::type;
-
-// ---------------------------------------------------------------------------
-// conjunction
-//
-// Performs a compile-time logical AND operation on the passed types (which
-// must have  `::value` members convertible to `bool`. Short-circuits if it
-// encounters any `false` members (and does not compare the `::value` members
-// of any remaining arguments).
-//
-// This metafunction is designed to be a drop-in replacement for the C++17
-// `std::conjunction` metafunction.
-// ---------------------------------------------------------------------------
-template <typename... Ts>
-struct conjunction;
-
-template <typename T, typename... Ts>
-struct conjunction<T, Ts...>
-    : std::conditional<T::value, conjunction<Ts...>, T>::type {};
-
-template <typename T>
-struct conjunction<T> : T {};
-
-template <>
-struct conjunction<> : std::true_type {};
-
-// ---------------------------------------------------------------------------
-// disjunction
-//
-// Performs a compile-time logical OR operation on the passed types (which
-// must have  `::value` members convertible to `bool`. Short-circuits if it
-// encounters any `true` members (and does not compare the `::value` members
-// of any remaining arguments).
-//
-// This metafunction is designed to be a drop-in replacement for the C++17
-// `std::disjunction` metafunction.
-// ---------------------------------------------------------------------------
-template <typename... Ts>
-struct disjunction;
-
-template <typename T, typename... Ts>
-struct disjunction<T, Ts...> :
-      std::conditional<T::value, T, disjunction<Ts...>>::type {};
-
-template <typename T>
-struct disjunction<T> : T {};
-
-template <>
-struct disjunction<> : std::false_type {};
-
-template <typename T>
-struct negation : std::integral_constant<bool, !T::value> {};
-
-template <typename T>
-struct is_trivially_destructible
-    : std::integral_constant<bool, __has_trivial_destructor(T) &&
-      std::is_destructible<T>::value> {};
-
-template <typename T>
-struct is_trivially_default_constructible
-    : std::integral_constant<bool, __has_trivial_constructor(T) &&
-                                   std::is_default_constructible<T>::value &&
-      is_trivially_destructible<T>::value> {};
-
-template <typename T>
-struct is_trivially_copy_constructible
-    : std::integral_constant<bool, __has_trivial_copy(T) &&
-                                   std::is_copy_constructible<T>::value &&
-      is_trivially_destructible<T>::value> {};
-
-template <typename T>
-struct is_trivially_copy_assignable
-    : std::integral_constant<
-          bool, __has_trivial_assign(typename std::remove_reference<T>::type) &&
-      phmap::is_copy_assignable<T>::value> {};
-
-// -----------------------------------------------------------------------------
-// C++14 "_t" trait aliases
-// -----------------------------------------------------------------------------
-
-template <typename T>
-using remove_cv_t = typename std::remove_cv<T>::type;
-
-template <typename T>
-using remove_const_t = typename std::remove_const<T>::type;
-
-template <typename T>
-using remove_volatile_t = typename std::remove_volatile<T>::type;
-
-template <typename T>
-using add_cv_t = typename std::add_cv<T>::type;
-
-template <typename T>
-using add_const_t = typename std::add_const<T>::type;
-
-template <typename T>
-using add_volatile_t = typename std::add_volatile<T>::type;
-
-template <typename T>
-using remove_reference_t = typename std::remove_reference<T>::type;
-
-template <typename T>
-using add_lvalue_reference_t = typename std::add_lvalue_reference<T>::type;
-
-template <typename T>
-using add_rvalue_reference_t = typename std::add_rvalue_reference<T>::type;
-
-template <typename T>
-using remove_pointer_t = typename std::remove_pointer<T>::type;
-
-template <typename T>
-using add_pointer_t = typename std::add_pointer<T>::type;
-
-template <typename T>
-using make_signed_t = typename std::make_signed<T>::type;
-
-template <typename T>
-using make_unsigned_t = typename std::make_unsigned<T>::type;
-
-template <typename T>
-using remove_extent_t = typename std::remove_extent<T>::type;
-
-template <typename T>
-using remove_all_extents_t = typename std::remove_all_extents<T>::type;
-
-template <size_t Len, size_t Align = type_traits_internal::
-                          default_alignment_of_aligned_storage<Len>::value>
-using aligned_storage_t = typename std::aligned_storage<Len, Align>::type;
-
-template <typename T>
-using decay_t = typename std::decay<T>::type;
-
-template <bool B, typename T = void>
-using enable_if_t = typename std::enable_if<B, T>::type;
-
-template <bool B, typename T, typename F>
-using conditional_t = typename std::conditional<B, T, F>::type;
-
-
-template <typename... T>
-using common_type_t = typename std::common_type<T...>::type;
-
-template <typename T>
-using underlying_type_t = typename std::underlying_type<T>::type;
-
-template< class F, class... ArgTypes>
-#if PHMAP_HAVE_CC17
-    using invoke_result = typename std::invoke_result<F, ArgTypes...>;
-#else
-    using invoke_result = typename std::result_of<F(ArgTypes...)>::type;
-#endif
-
-namespace type_traits_internal {
-
-// ----------------------------------------------------------------------
-// In MSVC we can't probe std::hash or stdext::hash because it triggers a
-// static_assert instead of failing substitution. Libc++ prior to 4.0
-// also used a static_assert.
-// ----------------------------------------------------------------------
-#if defined(_MSC_VER) || (defined(_LIBCPP_VERSION) && \
-                          _LIBCPP_VERSION < 4000 && _LIBCPP_STD_VER > 11)
-    #define PHMAP_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_ 0
-#else
-    #define PHMAP_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_ 1
-#endif
-
-#if !PHMAP_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
-    template <typename Key, typename = size_t>
-    struct IsHashable : std::true_type {};
-#else   // PHMAP_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
-    template <typename Key, typename = void>
-    struct IsHashable : std::false_type {};
-
-    template <typename Key>
-    struct IsHashable<Key,
-        phmap::enable_if_t<std::is_convertible<
-            decltype(std::declval<std::hash<Key>&>()(std::declval<Key const&>())),
-            std::size_t>::value>> : std::true_type {};
-#endif
-
-struct AssertHashEnabledHelper 
-{
-private:
-    static void Sink(...) {}
-    struct NAT {};
-
-    template <class Key>
-    static auto GetReturnType(int)
-        -> decltype(std::declval<std::hash<Key>>()(std::declval<Key const&>()));
-    template <class Key>
-    static NAT GetReturnType(...);
-
-    template <class Key>
-    static std::nullptr_t DoIt() {
-        static_assert(IsHashable<Key>::value,
-                      "std::hash<Key> does not provide a call operator");
-        static_assert(
-            std::is_default_constructible<std::hash<Key>>::value,
-            "std::hash<Key> must be default constructible when it is enabled");
-        static_assert(
-            std::is_copy_constructible<std::hash<Key>>::value,
-            "std::hash<Key> must be copy constructible when it is enabled");
-        static_assert(phmap::is_copy_assignable<std::hash<Key>>::value,
-                      "std::hash<Key> must be copy assignable when it is enabled");
-        // is_destructible is unchecked as it's implied by each of the
-        // is_constructible checks.
-        using ReturnType = decltype(GetReturnType<Key>(0));
-        static_assert(std::is_same<ReturnType, NAT>::value ||
-                      std::is_same<ReturnType, size_t>::value,
-                      "std::hash<Key> must return size_t");
-        return nullptr;
-    }
-
-    template <class... Ts>
-    friend void AssertHashEnabled();
-};
-
-template <class... Ts>
-inline void AssertHashEnabled
-() 
-{
-    using Helper = AssertHashEnabledHelper;
-    Helper::Sink(Helper::DoIt<Ts>()...);
-}
-
-}  // namespace type_traits_internal
-
-}  // namespace phmap
-
-
-// -----------------------------------------------------------------------------
-//          hash_policy_traits
-// -----------------------------------------------------------------------------
-namespace phmap {
-namespace priv {
-
-// Defines how slots are initialized/destroyed/moved.
-template <class Policy, class = void>
-struct hash_policy_traits 
-{
-private:
-    struct ReturnKey 
-    {
-        // We return `Key` here.
-        // When Key=T&, we forward the lvalue reference.
-        // When Key=T, we return by value to avoid a dangling reference.
-        // eg, for string_hash_map.
-        template <class Key, class... Args>
-        Key operator()(Key&& k, const Args&...) const {
-            return std::forward<Key>(k);
-        }
-    };
-
-    template <class P = Policy, class = void>
-    struct ConstantIteratorsImpl : std::false_type {};
-
-    template <class P>
-    struct ConstantIteratorsImpl<P, phmap::void_t<typename P::constant_iterators>>
-        : P::constant_iterators {};
-
-public:
-    // The actual object stored in the hash table.
-    using slot_type  = typename Policy::slot_type;
-
-    // The type of the keys stored in the hashtable.
-    using key_type   = typename Policy::key_type;
-
-    // The argument type for insertions into the hashtable. This is different
-    // from value_type for increased performance. See initializer_list constructor
-    // and insert() member functions for more details.
-    using init_type  = typename Policy::init_type;
-
-    using reference  = decltype(Policy::element(std::declval<slot_type*>()));
-    using pointer    = typename std::remove_reference<reference>::type*;
-    using value_type = typename std::remove_reference<reference>::type;
-
-    // Policies can set this variable to tell raw_hash_set that all iterators
-    // should be constant, even `iterator`. This is useful for set-like
-    // containers.
-    // Defaults to false if not provided by the policy.
-    using constant_iterators = ConstantIteratorsImpl<>;
-
-    // PRECONDITION: `slot` is UNINITIALIZED
-    // POSTCONDITION: `slot` is INITIALIZED
-    template <class Alloc, class... Args>
-    static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
-        Policy::construct(alloc, slot, std::forward<Args>(args)...);
-    }
-
-    // PRECONDITION: `slot` is INITIALIZED
-    // POSTCONDITION: `slot` is UNINITIALIZED
-    template <class Alloc>
-    static void destroy(Alloc* alloc, slot_type* slot) {
-        Policy::destroy(alloc, slot);
-    }
-
-    // Transfers the `old_slot` to `new_slot`. Any memory allocated by the
-    // allocator inside `old_slot` to `new_slot` can be transferred.
-    //
-    // OPTIONAL: defaults to:
-    //
-    //     clone(new_slot, std::move(*old_slot));
-    //     destroy(old_slot);
-    //
-    // PRECONDITION: `new_slot` is UNINITIALIZED and `old_slot` is INITIALIZED
-    // POSTCONDITION: `new_slot` is INITIALIZED and `old_slot` is
-    //                UNINITIALIZED
-    template <class Alloc>
-    static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
-        transfer_impl(alloc, new_slot, old_slot, 0);
-    }
-
-    // PRECONDITION: `slot` is INITIALIZED
-    // POSTCONDITION: `slot` is INITIALIZED
-    template <class P = Policy>
-    static auto element(slot_type* slot) -> decltype(P::element(slot)) {
-        return P::element(slot);
-    }
-
-    // Returns the amount of memory owned by `slot`, exclusive of `sizeof(*slot)`.
-    //
-    // If `slot` is nullptr, returns the constant amount of memory owned by any
-    // full slot or -1 if slots own variable amounts of memory.
-    //
-    // PRECONDITION: `slot` is INITIALIZED or nullptr
-    template <class P = Policy>
-    static size_t space_used(const slot_type* slot) {
-        return P::space_used(slot);
-    }
-
-    // Provides generalized access to the key for elements, both for elements in
-    // the table and for elements that have not yet been inserted (or even
-    // constructed).  We would like an API that allows us to say: `key(args...)`
-    // but we cannot do that for all cases, so we use this more general API that
-    // can be used for many things, including the following:
-    //
-    //   - Given an element in a table, get its key.
-    //   - Given an element initializer, get its key.
-    //   - Given `emplace()` arguments, get the element key.
-    //
-    // Implementations of this must adhere to a very strict technical
-    // specification around aliasing and consuming arguments:
-    //
-    // Let `value_type` be the result type of `element()` without ref- and
-    // cv-qualifiers. The first argument is a functor, the rest are constructor
-    // arguments for `value_type`. Returns `std::forward<F>(f)(k, xs...)`, where
-    // `k` is the element key, and `xs...` are the new constructor arguments for
-    // `value_type`. It's allowed for `k` to alias `xs...`, and for both to alias
-    // `ts...`. The key won't be touched once `xs...` are used to construct an
-    // element; `ts...` won't be touched at all, which allows `apply()` to consume
-    // any rvalues among them.
-    //
-    // If `value_type` is constructible from `Ts&&...`, `Policy::apply()` must not
-    // trigger a hard compile error unless it originates from `f`. In other words,
-    // `Policy::apply()` must be SFINAE-friendly. If `value_type` is not
-    // constructible from `Ts&&...`, either SFINAE or a hard compile error is OK.
-    //
-    // If `Ts...` is `[cv] value_type[&]` or `[cv] init_type[&]`,
-    // `Policy::apply()` must work. A compile error is not allowed, SFINAE or not.
-    template <class F, class... Ts, class P = Policy>
-    static auto apply(F&& f, Ts&&... ts)
-        -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
-        return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
-    }
-
-    // Returns the "key" portion of the slot.
-    // Used for node handle manipulation.
-    template <class P = Policy>
-    static auto key(slot_type* slot)
-        -> decltype(P::apply(ReturnKey(), element(slot))) {
-        return P::apply(ReturnKey(), element(slot));
-    }
-
-    // Returns the "value" (as opposed to the "key") portion of the element. Used
-    // by maps to implement `operator[]`, `at()` and `insert_or_assign()`.
-    template <class T, class P = Policy>
-    static auto value(T* elem) -> decltype(P::value(elem)) {
-        return P::value(elem);
-    }
-
-private:
-
-    // Use auto -> decltype as an enabler.
-    template <class Alloc, class P = Policy>
-    static auto transfer_impl(Alloc* alloc, slot_type* new_slot,
-                              slot_type* old_slot, int)
-        -> decltype((void)P::transfer(alloc, new_slot, old_slot)) {
-        P::transfer(alloc, new_slot, old_slot);
-    }
-
-    template <class Alloc>
-    static void transfer_impl(Alloc* alloc, slot_type* new_slot,
-                              slot_type* old_slot, char) {
-        construct(alloc, new_slot, std::move(element(old_slot)));
-        destroy(alloc, old_slot);
-    }
-};
-
-}  // namespace priv
-}  // namespace phmap
-
-// -----------------------------------------------------------------------------
-// file utility.h
-// -----------------------------------------------------------------------------
-
-// --------- identity.h
-namespace phmap {
-namespace internal {
-
-template <typename T>
-struct identity {
-    typedef T type;
-};
-
-template <typename T>
-using identity_t = typename identity<T>::type;
-
-}  // namespace internal
-}  // namespace phmap
-
-
-// --------- inline_variable.h
-
-#ifdef __cpp_inline_variables
-
-#if defined(__clang__)
-    #define PHMAP_INTERNAL_EXTERN_DECL(type, name) \
-      extern const ::phmap::internal::identity_t<type> name;
-#else  // Otherwise, just define the macro to do nothing.
-    #define PHMAP_INTERNAL_EXTERN_DECL(type, name)
-#endif  // defined(__clang__)
-
-// See above comment at top of file for details.
-#define PHMAP_INTERNAL_INLINE_CONSTEXPR(type, name, init) \
-  PHMAP_INTERNAL_EXTERN_DECL(type, name)                  \
-  inline constexpr ::phmap::internal::identity_t<type> name = init
-
-#else
-
-// See above comment at top of file for details.
-//
-// Note:
-//   identity_t is used here so that the const and name are in the
-//   appropriate place for pointer types, reference types, function pointer
-//   types, etc..
-#define PHMAP_INTERNAL_INLINE_CONSTEXPR(var_type, name, init)                  \
-  template <class /*PhmapInternalDummy*/ = void>                               \
-  struct PhmapInternalInlineVariableHolder##name {                             \
-    static constexpr ::phmap::internal::identity_t<var_type> kInstance = init; \
-  };                                                                          \
-                                                                              \
-  template <class PhmapInternalDummy>                                          \
-  constexpr ::phmap::internal::identity_t<var_type>                            \
-      PhmapInternalInlineVariableHolder##name<PhmapInternalDummy>::kInstance;   \
-                                                                              \
-  static constexpr const ::phmap::internal::identity_t<var_type>&              \
-      name = /* NOLINT */                                                     \
-      PhmapInternalInlineVariableHolder##name<>::kInstance;                    \
-  static_assert(sizeof(void (*)(decltype(name))) != 0,                        \
-                "Silence unused variable warnings.")
-
-#endif  // __cpp_inline_variables
-
-// ----------- throw_delegate
-
-namespace phmap {
-namespace base_internal {
-
-namespace {
-template <typename T>
-#ifdef PHMAP_HAVE_EXCEPTIONS
-[[noreturn]] void Throw(const T& error) {
-    throw error;
-}
-#else
-[[noreturn]] void Throw(const T&) {
-    std::abort();
-}
-#endif
-}  // namespace
-
-static inline void ThrowStdLogicError(const std::string& what_arg) {
-  Throw(std::logic_error(what_arg));
-}
-static inline void ThrowStdLogicError(const char* what_arg) {
-  Throw(std::logic_error(what_arg));
-}
-static inline void ThrowStdInvalidArgument(const std::string& what_arg) {
-  Throw(std::invalid_argument(what_arg));
-}
-static inline void ThrowStdInvalidArgument(const char* what_arg) {
-  Throw(std::invalid_argument(what_arg));
-}
-
-static inline void ThrowStdDomainError(const std::string& what_arg) {
-  Throw(std::domain_error(what_arg));
-}
-static inline void ThrowStdDomainError(const char* what_arg) {
-  Throw(std::domain_error(what_arg));
-}
-
-static inline void ThrowStdLengthError(const std::string& what_arg) {
-  Throw(std::length_error(what_arg));
-}
-static inline void ThrowStdLengthError(const char* what_arg) {
-  Throw(std::length_error(what_arg));
-}
-
-static inline void ThrowStdOutOfRange(const std::string& what_arg) {
-  Throw(std::out_of_range(what_arg));
-}
-static inline void ThrowStdOutOfRange(const char* what_arg) {
-  Throw(std::out_of_range(what_arg));
-}
-
-static inline void ThrowStdRuntimeError(const std::string& what_arg) {
-  Throw(std::runtime_error(what_arg));
-}
-static inline void ThrowStdRuntimeError(const char* what_arg) {
-  Throw(std::runtime_error(what_arg));
-}
-
-static inline void ThrowStdRangeError(const std::string& what_arg) {
-  Throw(std::range_error(what_arg));
-}
-static inline void ThrowStdRangeError(const char* what_arg) {
-  Throw(std::range_error(what_arg));
-}
-
-static inline void ThrowStdOverflowError(const std::string& what_arg) {
-  Throw(std::overflow_error(what_arg));
-}
-static inline void ThrowStdOverflowError(const char* what_arg) {
-  Throw(std::overflow_error(what_arg));
-}
-
-static inline void ThrowStdUnderflowError(const std::string& what_arg) {
-  Throw(std::underflow_error(what_arg));
-}
-static inline void ThrowStdUnderflowError(const char* what_arg) {
-  Throw(std::underflow_error(what_arg));
-}
-
-static inline void ThrowStdBadFunctionCall() { Throw(std::bad_function_call()); }
-
-static inline void ThrowStdBadAlloc() { Throw(std::bad_alloc()); }
-
-}  // namespace base_internal
-}  // namespace phmap
-
-// ----------- invoke.h
-
-namespace phmap {
-namespace base_internal {
-
-template <typename Derived>
-struct StrippedAccept 
-{
-    template <typename... Args>
-    struct Accept : Derived::template AcceptImpl<typename std::remove_cv<
-                                                     typename std::remove_reference<Args>::type>::type...> {};
-};
-
-// (t1.*f)(t2, ..., tN) when f is a pointer to a member function of a class T
-// and t1 is an object of type T or a reference to an object of type T or a
-// reference to an object of a type derived from T.
-struct MemFunAndRef : StrippedAccept<MemFunAndRef> 
-{
-    template <typename... Args>
-    struct AcceptImpl : std::false_type {};
-
-    template <typename R, typename C, typename... Params, typename Obj,
-              typename... Args>
-    struct AcceptImpl<R (C::*)(Params...), Obj, Args...>
-        : std::is_base_of<C, Obj> {};
-
-    template <typename R, typename C, typename... Params, typename Obj,
-              typename... Args>
-    struct AcceptImpl<R (C::*)(Params...) const, Obj, Args...>
-        : std::is_base_of<C, Obj> {};
-
-    template <typename MemFun, typename Obj, typename... Args>
-    static decltype((std::declval<Obj>().*
-                     std::declval<MemFun>())(std::declval<Args>()...))
-    Invoke(MemFun&& mem_fun, Obj&& obj, Args&&... args) {
-        return (std::forward<Obj>(obj).*
-                std::forward<MemFun>(mem_fun))(std::forward<Args>(args)...);
-    }
-};
-
-// ((*t1).*f)(t2, ..., tN) when f is a pointer to a member function of a
-// class T and t1 is not one of the types described in the previous item.
-struct MemFunAndPtr : StrippedAccept<MemFunAndPtr> 
-{
-    template <typename... Args>
-    struct AcceptImpl : std::false_type {};
-
-    template <typename R, typename C, typename... Params, typename Ptr,
-              typename... Args>
-    struct AcceptImpl<R (C::*)(Params...), Ptr, Args...>
-        : std::integral_constant<bool, !std::is_base_of<C, Ptr>::value> {};
-
-    template <typename R, typename C, typename... Params, typename Ptr,
-              typename... Args>
-    struct AcceptImpl<R (C::*)(Params...) const, Ptr, Args...>
-        : std::integral_constant<bool, !std::is_base_of<C, Ptr>::value> {};
-
-    template <typename MemFun, typename Ptr, typename... Args>
-    static decltype(((*std::declval<Ptr>()).*
-                     std::declval<MemFun>())(std::declval<Args>()...))
-    Invoke(MemFun&& mem_fun, Ptr&& ptr, Args&&... args) {
-        return ((*std::forward<Ptr>(ptr)).*
-                std::forward<MemFun>(mem_fun))(std::forward<Args>(args)...);
-    }
-};
-
-// t1.*f when N == 1 and f is a pointer to member data of a class T and t1 is
-// an object of type T or a reference to an object of type T or a reference
-// to an object of a type derived from T.
-struct DataMemAndRef : StrippedAccept<DataMemAndRef> 
-{
-    template <typename... Args>
-    struct AcceptImpl : std::false_type {};
-
-    template <typename R, typename C, typename Obj>
-    struct AcceptImpl<R C::*, Obj> : std::is_base_of<C, Obj> {};
-
-    template <typename DataMem, typename Ref>
-    static decltype(std::declval<Ref>().*std::declval<DataMem>()) Invoke(
-        DataMem&& data_mem, Ref&& ref) {
-        return std::forward<Ref>(ref).*std::forward<DataMem>(data_mem);
-    }
-};
-
-// (*t1).*f when N == 1 and f is a pointer to member data of a class T and t1
-// is not one of the types described in the previous item.
-struct DataMemAndPtr : StrippedAccept<DataMemAndPtr> 
-{
-    template <typename... Args>
-    struct AcceptImpl : std::false_type {};
-
-    template <typename R, typename C, typename Ptr>
-    struct AcceptImpl<R C::*, Ptr>
-        : std::integral_constant<bool, !std::is_base_of<C, Ptr>::value> {};
-
-    template <typename DataMem, typename Ptr>
-    static decltype((*std::declval<Ptr>()).*std::declval<DataMem>()) Invoke(
-        DataMem&& data_mem, Ptr&& ptr) {
-        return (*std::forward<Ptr>(ptr)).*std::forward<DataMem>(data_mem);
-    }
-};
-
-// f(t1, t2, ..., tN) in all other cases.
-struct Callable
-{
-    // Callable doesn't have Accept because it's the last clause that gets picked
-    // when none of the previous clauses are applicable.
-    template <typename F, typename... Args>
-    static decltype(std::declval<F>()(std::declval<Args>()...)) Invoke(
-        F&& f, Args&&... args) {
-        return std::forward<F>(f)(std::forward<Args>(args)...);
-    }
-};
-
-// Resolves to the first matching clause.
-template <typename... Args>
-struct Invoker 
-{
-    typedef typename std::conditional<
-        MemFunAndRef::Accept<Args...>::value, MemFunAndRef,
-        typename std::conditional<
-            MemFunAndPtr::Accept<Args...>::value, MemFunAndPtr,
-            typename std::conditional<
-                DataMemAndRef::Accept<Args...>::value, DataMemAndRef,
-                typename std::conditional<DataMemAndPtr::Accept<Args...>::value,
-                                          DataMemAndPtr, Callable>::type>::type>::
-        type>::type type;
-};
-
-// The result type of Invoke<F, Args...>.
-template <typename F, typename... Args>
-using InvokeT = decltype(Invoker<F, Args...>::type::Invoke(
-    std::declval<F>(), std::declval<Args>()...));
-
-// Invoke(f, args...) is an implementation of INVOKE(f, args...) from section
-// [func.require] of the C++ standard.
-template <typename F, typename... Args>
-InvokeT<F, Args...> Invoke(F&& f, Args&&... args) {
-  return Invoker<F, Args...>::type::Invoke(std::forward<F>(f),
-                                           std::forward<Args>(args)...);
-}
-}  // namespace base_internal
-}  // namespace phmap
-
-
-// ----------- utility.h
-
-namespace phmap {
-
-// integer_sequence
-//
-// Class template representing a compile-time integer sequence. An instantiation
-// of `integer_sequence<T, Ints...>` has a sequence of integers encoded in its
-// type through its template arguments (which is a common need when
-// working with C++11 variadic templates). `phmap::integer_sequence` is designed
-// to be a drop-in replacement for C++14's `std::integer_sequence`.
-//
-// Example:
-//
-//   template< class T, T... Ints >
-//   void user_function(integer_sequence<T, Ints...>);
-//
-//   int main()
-//   {
-//     // user_function's `T` will be deduced to `int` and `Ints...`
-//     // will be deduced to `0, 1, 2, 3, 4`.
-//     user_function(make_integer_sequence<int, 5>());
-//   }
-template <typename T, T... Ints>
-struct integer_sequence 
-{
-    using value_type = T;
-    static constexpr size_t size() noexcept { return sizeof...(Ints); }
-};
-
-// index_sequence
-//
-// A helper template for an `integer_sequence` of `size_t`,
-// `phmap::index_sequence` is designed to be a drop-in replacement for C++14's
-// `std::index_sequence`.
-template <size_t... Ints>
-using index_sequence = integer_sequence<size_t, Ints...>;
-
-namespace utility_internal {
-
-template <typename Seq, size_t SeqSize, size_t Rem>
-struct Extend;
-
-// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency.
-template <typename T, T... Ints, size_t SeqSize>
-struct Extend<integer_sequence<T, Ints...>, SeqSize, 0> {
-  using type = integer_sequence<T, Ints..., (Ints + SeqSize)...>;
-};
-
-template <typename T, T... Ints, size_t SeqSize>
-struct Extend<integer_sequence<T, Ints...>, SeqSize, 1> {
-  using type = integer_sequence<T, Ints..., (Ints + SeqSize)..., 2 * SeqSize>;
-};
-
-// Recursion helper for 'make_integer_sequence<T, N>'.
-// 'Gen<T, N>::type' is an alias for 'integer_sequence<T, 0, 1, ... N-1>'.
-template <typename T, size_t N>
-struct Gen {
-  using type =
-      typename Extend<typename Gen<T, N / 2>::type, N / 2, N % 2>::type;
-};
-
-template <typename T>
-struct Gen<T, 0> {
-  using type = integer_sequence<T>;
-};
-
-}  // namespace utility_internal
-
-// Compile-time sequences of integers
-
-// make_integer_sequence
-//
-// This template alias is equivalent to
-// `integer_sequence<int, 0, 1, ..., N-1>`, and is designed to be a drop-in
-// replacement for C++14's `std::make_integer_sequence`.
-template <typename T, T N>
-using make_integer_sequence = typename utility_internal::Gen<T, N>::type;
-
-// make_index_sequence
-//
-// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`,
-// and is designed to be a drop-in replacement for C++14's
-// `std::make_index_sequence`.
-template <size_t N>
-using make_index_sequence = make_integer_sequence<size_t, N>;
-
-// index_sequence_for
-//
-// Converts a typename pack into an index sequence of the same length, and
-// is designed to be a drop-in replacement for C++14's
-// `std::index_sequence_for()`
-template <typename... Ts>
-using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
-
-// Tag types
-
-#ifdef PHMAP_HAVE_STD_OPTIONAL
-
-using std::in_place_t;
-using std::in_place;
-
-#else  // PHMAP_HAVE_STD_OPTIONAL
-
-// in_place_t
-//
-// Tag type used to specify in-place construction, such as with
-// `phmap::optional`, designed to be a drop-in replacement for C++17's
-// `std::in_place_t`.
-struct in_place_t {};
-
-PHMAP_INTERNAL_INLINE_CONSTEXPR(in_place_t, in_place, {});
-
-#endif  // PHMAP_HAVE_STD_OPTIONAL
-
-#if defined(PHMAP_HAVE_STD_ANY) || defined(PHMAP_HAVE_STD_VARIANT)
-using std::in_place_type_t;
-#else
-
-// in_place_type_t
-//
-// Tag type used for in-place construction when the type to construct needs to
-// be specified, such as with `phmap::any`, designed to be a drop-in replacement
-// for C++17's `std::in_place_type_t`.
-template <typename T>
-struct in_place_type_t {};
-#endif  // PHMAP_HAVE_STD_ANY || PHMAP_HAVE_STD_VARIANT
-
-#ifdef PHMAP_HAVE_STD_VARIANT
-using std::in_place_index_t;
-#else
-
-// in_place_index_t
-//
-// Tag type used for in-place construction when the type to construct needs to
-// be specified, such as with `phmap::any`, designed to be a drop-in replacement
-// for C++17's `std::in_place_index_t`.
-template <size_t I>
-struct in_place_index_t {};
-#endif  // PHMAP_HAVE_STD_VARIANT
-
-// Constexpr move and forward
-
-// move()
-//
-// A constexpr version of `std::move()`, designed to be a drop-in replacement
-// for C++14's `std::move()`.
-template <typename T>
-constexpr phmap::remove_reference_t<T>&& move(T&& t) noexcept {
-  return static_cast<phmap::remove_reference_t<T>&&>(t);
-}
-
-// forward()
-//
-// A constexpr version of `std::forward()`, designed to be a drop-in replacement
-// for C++14's `std::forward()`.
-template <typename T>
-constexpr T&& forward(
-    phmap::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
-  return static_cast<T&&>(t);
-}
-
-namespace utility_internal {
-// Helper method for expanding tuple into a called method.
-template <typename Functor, typename Tuple, std::size_t... Indexes>
-auto apply_helper(Functor&& functor, Tuple&& t, index_sequence<Indexes...>)
-    -> decltype(phmap::base_internal::Invoke(
-        phmap::forward<Functor>(functor),
-        std::get<Indexes>(phmap::forward<Tuple>(t))...)) {
-  return phmap::base_internal::Invoke(
-      phmap::forward<Functor>(functor),
-      std::get<Indexes>(phmap::forward<Tuple>(t))...);
-}
-
-}  // namespace utility_internal
-
-// apply
-//
-// Invokes a Callable using elements of a tuple as its arguments.
-// Each element of the tuple corresponds to an argument of the call (in order).
-// Both the Callable argument and the tuple argument are perfect-forwarded.
-// For member-function Callables, the first tuple element acts as the `this`
-// pointer. `phmap::apply` is designed to be a drop-in replacement for C++17's
-// `std::apply`. Unlike C++17's `std::apply`, this is not currently `constexpr`.
-//
-// Example:
-//
-//   class Foo {
-//    public:
-//     void Bar(int);
-//   };
-//   void user_function1(int, std::string);
-//   void user_function2(std::unique_ptr<Foo>);
-//   auto user_lambda = [](int, int) {};
-//
-//   int main()
-//   {
-//       std::tuple<int, std::string> tuple1(42, "bar");
-//       // Invokes the first user function on int, std::string.
-//       phmap::apply(&user_function1, tuple1);
-//
-//       std::tuple<std::unique_ptr<Foo>> tuple2(phmap::make_unique<Foo>());
-//       // Invokes the user function that takes ownership of the unique
-//       // pointer.
-//       phmap::apply(&user_function2, std::move(tuple2));
-//
-//       auto foo = phmap::make_unique<Foo>();
-//       std::tuple<Foo*, int> tuple3(foo.get(), 42);
-//       // Invokes the method Bar on foo with one argument, 42.
-//       phmap::apply(&Foo::Bar, tuple3);
-//
-//       std::tuple<int, int> tuple4(8, 9);
-//       // Invokes a lambda.
-//       phmap::apply(user_lambda, tuple4);
-//   }
-template <typename Functor, typename Tuple>
-auto apply(Functor&& functor, Tuple&& t)
-    -> decltype(utility_internal::apply_helper(
-        phmap::forward<Functor>(functor), phmap::forward<Tuple>(t),
-        phmap::make_index_sequence<std::tuple_size<
-            typename std::remove_reference<Tuple>::type>::value>{})) {
-  return utility_internal::apply_helper(
-      phmap::forward<Functor>(functor), phmap::forward<Tuple>(t),
-      phmap::make_index_sequence<std::tuple_size<
-          typename std::remove_reference<Tuple>::type>::value>{});
-}
-
-#ifdef _MSC_VER
-    #pragma warning(push)
-    #pragma warning(disable : 4365) // '=': conversion from 'T' to 'T', signed/unsigned mismatch
-#endif  // _MSC_VER
-
-// exchange
-//
-// Replaces the value of `obj` with `new_value` and returns the old value of
-// `obj`.  `phmap::exchange` is designed to be a drop-in replacement for C++14's
-// `std::exchange`.
-//
-// Example:
-//
-//   Foo& operator=(Foo&& other) {
-//     ptr1_ = phmap::exchange(other.ptr1_, nullptr);
-//     int1_ = phmap::exchange(other.int1_, -1);
-//     return *this;
-//   }
-template <typename T, typename U = T>
-T exchange(T& obj, U&& new_value)
-{
-    T old_value = phmap::move(obj);
-    obj = phmap::forward<U>(new_value);
-    return old_value;
-}
-
-#ifdef _MSC_VER
-    #pragma warning(pop)
-#endif  // _MSC_VER
-
-
-}  // namespace phmap
-
-// -----------------------------------------------------------------------------
-//          memory.h
-// -----------------------------------------------------------------------------
-
-namespace phmap {
-
-template <typename T>
-std::unique_ptr<T> WrapUnique(T* ptr) 
-{
-    static_assert(!std::is_array<T>::value, "array types are unsupported");
-    static_assert(std::is_object<T>::value, "non-object types are unsupported");
-    return std::unique_ptr<T>(ptr);
-}
-
-namespace memory_internal {
-
-// Traits to select proper overload and return type for `phmap::make_unique<>`.
-template <typename T>
-struct MakeUniqueResult {
-    using scalar = std::unique_ptr<T>;
-};
-template <typename T>
-struct MakeUniqueResult<T[]> {
-    using array = std::unique_ptr<T[]>;
-};
-template <typename T, size_t N>
-struct MakeUniqueResult<T[N]> {
-    using invalid = void;
-};
-
-}  // namespace memory_internal
-
-#if (__cplusplus > 201103L || defined(_MSC_VER)) && \
-    !(defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 8) 
-    using std::make_unique;
-#else
-
-    template <typename T, typename... Args>
-    typename memory_internal::MakeUniqueResult<T>::scalar make_unique(
-        Args&&... args) {
-        return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
-    }
-    
-    template <typename T>
-    typename memory_internal::MakeUniqueResult<T>::array make_unique(size_t n) {
-        return std::unique_ptr<T>(new typename phmap::remove_extent_t<T>[n]());
-    }
-    
-    template <typename T, typename... Args>
-    typename memory_internal::MakeUniqueResult<T>::invalid make_unique(
-        Args&&... /* args */) = delete;
-#endif
-
-template <typename T>
-auto RawPtr(T&& ptr) -> decltype(std::addressof(*ptr))
-{
-    // ptr is a forwarding reference to support Ts with non-const operators.
-    return (ptr != nullptr) ? std::addressof(*ptr) : nullptr;
-}
-
-inline std::nullptr_t RawPtr(std::nullptr_t) { return nullptr; }
-
-template <typename T, typename D>
-std::shared_ptr<T> ShareUniquePtr(std::unique_ptr<T, D>&& ptr) {
-    return ptr ? std::shared_ptr<T>(std::move(ptr)) : std::shared_ptr<T>();
-}
-
-template <typename T>
-std::weak_ptr<T> WeakenPtr(const std::shared_ptr<T>& ptr) {
-    return std::weak_ptr<T>(ptr);
-}
-
-namespace memory_internal {
-
-// ExtractOr<E, O, D>::type evaluates to E<O> if possible. Otherwise, D.
-template <template <typename> class Extract, typename Obj, typename Default,
-          typename>
-struct ExtractOr {
-    using type = Default;
-};
-
-template <template <typename> class Extract, typename Obj, typename Default>
-struct ExtractOr<Extract, Obj, Default, void_t<Extract<Obj>>> {
-    using type = Extract<Obj>;
-};
-
-template <template <typename> class Extract, typename Obj, typename Default>
-using ExtractOrT = typename ExtractOr<Extract, Obj, Default, void>::type;
-
-// Extractors for the features of allocators.
-template <typename T>
-using GetPointer = typename T::pointer;
-
-template <typename T>
-using GetConstPointer = typename T::const_pointer;
-
-template <typename T>
-using GetVoidPointer = typename T::void_pointer;
-
-template <typename T>
-using GetConstVoidPointer = typename T::const_void_pointer;
-
-template <typename T>
-using GetDifferenceType = typename T::difference_type;
-
-template <typename T>
-using GetSizeType = typename T::size_type;
-
-template <typename T>
-using GetPropagateOnContainerCopyAssignment =
-    typename T::propagate_on_container_copy_assignment;
-
-template <typename T>
-using GetPropagateOnContainerMoveAssignment =
-    typename T::propagate_on_container_move_assignment;
-
-template <typename T>
-using GetPropagateOnContainerSwap = typename T::propagate_on_container_swap;
-
-template <typename T>
-using GetIsAlwaysEqual = typename T::is_always_equal;
-
-template <typename T>
-struct GetFirstArg;
-
-template <template <typename...> class Class, typename T, typename... Args>
-struct GetFirstArg<Class<T, Args...>> {
-  using type = T;
-};
-
-template <typename Ptr, typename = void>
-struct ElementType {
-  using type = typename GetFirstArg<Ptr>::type;
-};
-
-template <typename T>
-struct ElementType<T, void_t<typename T::element_type>> {
-  using type = typename T::element_type;
-};
-
-template <typename T, typename U>
-struct RebindFirstArg;
-
-template <template <typename...> class Class, typename T, typename... Args,
-          typename U>
-struct RebindFirstArg<Class<T, Args...>, U> {
-  using type = Class<U, Args...>;
-};
-
-template <typename T, typename U, typename = void>
-struct RebindPtr {
-  using type = typename RebindFirstArg<T, U>::type;
-};
-
-template <typename T, typename U>
-struct RebindPtr<T, U, void_t<typename T::template rebind<U>>> {
-  using type = typename T::template rebind<U>;
-};
-
-template <typename T, typename U>
-constexpr bool HasRebindAlloc(...) {
-  return false;
-}
-
-template <typename T, typename U>
-constexpr bool HasRebindAlloc(typename std::allocator_traits<T>::template rebind_alloc<U>*) {
-  return true;
-}
-
-template <typename T, typename U, bool = HasRebindAlloc<T, U>(nullptr)>
-struct RebindAlloc {
-  using type = typename RebindFirstArg<T, U>::type;
-};
-
-template <typename A, typename U>
-struct RebindAlloc<A, U, true> {
-    using type = typename std::allocator_traits<A>::template rebind_alloc<U>;
-};
-
-
-}  // namespace memory_internal
-
-template <typename Ptr>
-struct pointer_traits 
-{
-    using pointer = Ptr;
-
-    // element_type:
-    // Ptr::element_type if present. Otherwise T if Ptr is a template
-    // instantiation Template<T, Args...>
-    using element_type = typename memory_internal::ElementType<Ptr>::type;
-
-    // difference_type:
-    // Ptr::difference_type if present, otherwise std::ptrdiff_t
-    using difference_type =
-        memory_internal::ExtractOrT<memory_internal::GetDifferenceType, Ptr,
-                                    std::ptrdiff_t>;
-
-    // rebind:
-    // Ptr::rebind<U> if exists, otherwise Template<U, Args...> if Ptr is a
-    // template instantiation Template<T, Args...>
-    template <typename U>
-    using rebind = typename memory_internal::RebindPtr<Ptr, U>::type;
-
-    // pointer_to:
-    // Calls Ptr::pointer_to(r)
-    static pointer pointer_to(element_type& r) {  // NOLINT(runtime/references)
-        return Ptr::pointer_to(r);
-    }
-};
-
-// Specialization for T*.
-template <typename T>
-struct pointer_traits<T*> 
-{
-    using pointer = T*;
-    using element_type = T;
-    using difference_type = std::ptrdiff_t;
-
-    template <typename U>
-    using rebind = U*;
-
-    // pointer_to:
-    // Calls std::addressof(r)
-    static pointer pointer_to(
-        element_type& r) noexcept {  // NOLINT(runtime/references)
-        return std::addressof(r);
-    }
-};
-
-// -----------------------------------------------------------------------------
-// Class Template: allocator_traits
-// -----------------------------------------------------------------------------
-//
-// A C++11 compatible implementation of C++17's std::allocator_traits.
-//
-template <typename Alloc>
-struct allocator_traits 
-{
-    using allocator_type = Alloc;
-
-    // value_type:
-    // Alloc::value_type
-    using value_type = typename Alloc::value_type;
-
-    // pointer:
-    // Alloc::pointer if present, otherwise value_type*
-    using pointer = memory_internal::ExtractOrT<memory_internal::GetPointer,
-                                                Alloc, value_type*>;
-
-    // const_pointer:
-    // Alloc::const_pointer if present, otherwise
-    // phmap::pointer_traits<pointer>::rebind<const value_type>
-    using const_pointer =
-        memory_internal::ExtractOrT<memory_internal::GetConstPointer, Alloc,
-                                    typename phmap::pointer_traits<pointer>::
-                                    template rebind<const value_type>>;
-
-    // void_pointer:
-    // Alloc::void_pointer if present, otherwise
-    // phmap::pointer_traits<pointer>::rebind<void>
-    using void_pointer = memory_internal::ExtractOrT<
-        memory_internal::GetVoidPointer, Alloc,
-        typename phmap::pointer_traits<pointer>::template rebind<void>>;
-
-    // const_void_pointer:
-    // Alloc::const_void_pointer if present, otherwise
-    // phmap::pointer_traits<pointer>::rebind<const void>
-    using const_void_pointer = memory_internal::ExtractOrT<
-        memory_internal::GetConstVoidPointer, Alloc,
-        typename phmap::pointer_traits<pointer>::template rebind<const void>>;
-
-    // difference_type:
-    // Alloc::difference_type if present, otherwise
-    // phmap::pointer_traits<pointer>::difference_type
-    using difference_type = memory_internal::ExtractOrT<
-        memory_internal::GetDifferenceType, Alloc,
-        typename phmap::pointer_traits<pointer>::difference_type>;
-
-    // size_type:
-    // Alloc::size_type if present, otherwise
-    // std::make_unsigned<difference_type>::type
-    using size_type = memory_internal::ExtractOrT<
-        memory_internal::GetSizeType, Alloc,
-        typename std::make_unsigned<difference_type>::type>;
-
-    // propagate_on_container_copy_assignment:
-    // Alloc::propagate_on_container_copy_assignment if present, otherwise
-    // std::false_type
-    using propagate_on_container_copy_assignment = memory_internal::ExtractOrT<
-        memory_internal::GetPropagateOnContainerCopyAssignment, Alloc,
-        std::false_type>;
-
-    // propagate_on_container_move_assignment:
-    // Alloc::propagate_on_container_move_assignment if present, otherwise
-    // std::false_type
-    using propagate_on_container_move_assignment = memory_internal::ExtractOrT<
-        memory_internal::GetPropagateOnContainerMoveAssignment, Alloc,
-        std::false_type>;
-
-    // propagate_on_container_swap:
-    // Alloc::propagate_on_container_swap if present, otherwise std::false_type
-    using propagate_on_container_swap =
-        memory_internal::ExtractOrT<memory_internal::GetPropagateOnContainerSwap,
-                                    Alloc, std::false_type>;
-
-    // is_always_equal:
-    // Alloc::is_always_equal if present, otherwise std::is_empty<Alloc>::type
-    using is_always_equal =
-        memory_internal::ExtractOrT<memory_internal::GetIsAlwaysEqual, Alloc,
-                                    typename std::is_empty<Alloc>::type>;
-
-    // rebind_alloc:
-    // Alloc::rebind<T>::other if present, otherwise Alloc<T, Args> if this Alloc
-    // is Alloc<U, Args>
-    template <typename T>
-    using rebind_alloc = typename memory_internal::RebindAlloc<Alloc, T>::type;
-
-    // rebind_traits:
-    // phmap::allocator_traits<rebind_alloc<T>>
-    template <typename T>
-    using rebind_traits = phmap::allocator_traits<rebind_alloc<T>>;
-
-    // allocate(Alloc& a, size_type n):
-    // Calls a.allocate(n)
-    static pointer allocate(Alloc& a,  // NOLINT(runtime/references)
-                            size_type n) {
-        return a.allocate(n);
-    }
-
-    // allocate(Alloc& a, size_type n, const_void_pointer hint):
-    // Calls a.allocate(n, hint) if possible.
-    // If not possible, calls a.allocate(n)
-    static pointer allocate(Alloc& a, size_type n,  // NOLINT(runtime/references)
-                            const_void_pointer hint) {
-        return allocate_impl(0, a, n, hint);
-    }
-
-    // deallocate(Alloc& a, pointer p, size_type n):
-    // Calls a.deallocate(p, n)
-    static void deallocate(Alloc& a, pointer p,  // NOLINT(runtime/references)
-                           size_type n) {
-        a.deallocate(p, n);
-    }
-
-    // construct(Alloc& a, T* p, Args&&... args):
-    // Calls a.construct(p, std::forward<Args>(args)...) if possible.
-    // If not possible, calls
-    //   ::new (static_cast<void*>(p)) T(std::forward<Args>(args)...)
-    template <typename T, typename... Args>
-    static void construct(Alloc& a, T* p,  // NOLINT(runtime/references)
-                          Args&&... args) {
-        construct_impl(0, a, p, std::forward<Args>(args)...);
-    }
-
-    // destroy(Alloc& a, T* p):
-    // Calls a.destroy(p) if possible. If not possible, calls p->~T().
-    template <typename T>
-    static void destroy(Alloc& a, T* p) {  // NOLINT(runtime/references)
-        destroy_impl(0, a, p);
-    }
-
-    // max_size(const Alloc& a):
-    // Returns a.max_size() if possible. If not possible, returns
-    //   std::numeric_limits<size_type>::max() / sizeof(value_type)
-    static size_type max_size(const Alloc& a) { return max_size_impl(0, a); }
-
-    // select_on_container_copy_construction(const Alloc& a):
-    // Returns a.select_on_container_copy_construction() if possible.
-    // If not possible, returns a.
-    static Alloc select_on_container_copy_construction(const Alloc& a) {
-        return select_on_container_copy_construction_impl(0, a);
-    }
-
-private:
-    template <typename A>
-    static auto allocate_impl(int, A& a,  // NOLINT(runtime/references)
-                              size_type n, const_void_pointer hint)
-        -> decltype(a.allocate(n, hint)) {
-        return a.allocate(n, hint);
-    }
-    static pointer allocate_impl(char, Alloc& a,  // NOLINT(runtime/references)
-                                 size_type n, const_void_pointer) {
-        return a.allocate(n);
-    }
-
-    template <typename A, typename... Args>
-    static auto construct_impl(int, A& a,  // NOLINT(runtime/references)
-                               Args&&... args)
-        -> decltype(std::allocator_traits<A>::construct(a, std::forward<Args>(args)...)) {
-        std::allocator_traits<A>::construct(a, std::forward<Args>(args)...);
-    }
-
-    template <typename T, typename... Args>
-    static void construct_impl(char, Alloc&, T* p, Args&&... args) {
-        ::new (static_cast<void*>(p)) T(std::forward<Args>(args)...);
-    }
-
-    template <typename A, typename T>
-    static auto destroy_impl(int, A& a,  // NOLINT(runtime/references)
-                             T* p) -> decltype(std::allocator_traits<A>::destroy(a, p)) {
-        std::allocator_traits<A>::destroy(a, p);
-    }
-    template <typename T>
-    static void destroy_impl(char, Alloc&, T* p) {
-        p->~T();
-    }
-
-    template <typename A>
-    static auto max_size_impl(int, const A& a) -> decltype(a.max_size()) {
-        return a.max_size();
-    }
-    static size_type max_size_impl(char, const Alloc&) {
-        return (std::numeric_limits<size_type>::max)() / sizeof(value_type);
-    }
-
-    template <typename A>
-    static auto select_on_container_copy_construction_impl(int, const A& a)
-        -> decltype(a.select_on_container_copy_construction()) {
-        return a.select_on_container_copy_construction();
-    }
-    static Alloc select_on_container_copy_construction_impl(char,
-                                                            const Alloc& a) {
-        return a;
-    }
-};
-
-namespace memory_internal {
-
-// This template alias transforms Alloc::is_nothrow into a metafunction with
-// Alloc as a parameter so it can be used with ExtractOrT<>.
-template <typename Alloc>
-using GetIsNothrow = typename Alloc::is_nothrow;
-
-}  // namespace memory_internal
-
-// PHMAP_ALLOCATOR_NOTHROW is a build time configuration macro for user to
-// specify whether the default allocation function can throw or never throws.
-// If the allocation function never throws, user should define it to a non-zero
-// value (e.g. via `-DPHMAP_ALLOCATOR_NOTHROW`).
-// If the allocation function can throw, user should leave it undefined or
-// define it to zero.
-//
-// allocator_is_nothrow<Alloc> is a traits class that derives from
-// Alloc::is_nothrow if present, otherwise std::false_type. It's specialized
-// for Alloc = std::allocator<T> for any type T according to the state of
-// PHMAP_ALLOCATOR_NOTHROW.
-//
-// default_allocator_is_nothrow is a class that derives from std::true_type
-// when the default allocator (global operator new) never throws, and
-// std::false_type when it can throw. It is a convenience shorthand for writing
-// allocator_is_nothrow<std::allocator<T>> (T can be any type).
-// NOTE: allocator_is_nothrow<std::allocator<T>> is guaranteed to derive from
-// the same type for all T, because users should specialize neither
-// allocator_is_nothrow nor std::allocator.
-template <typename Alloc>
-struct allocator_is_nothrow
-    : memory_internal::ExtractOrT<memory_internal::GetIsNothrow, Alloc,
-                                  std::false_type> {};
-
-#if defined(PHMAP_ALLOCATOR_NOTHROW) && PHMAP_ALLOCATOR_NOTHROW
-    template <typename T>
-    struct allocator_is_nothrow<std::allocator<T>> : std::true_type {};
-    struct default_allocator_is_nothrow : std::true_type {};
-#else
-    struct default_allocator_is_nothrow : std::false_type {};
-#endif
-
-namespace memory_internal {
-template <typename Allocator, typename Iterator, typename... Args>
-void ConstructRange(Allocator& alloc, Iterator first, Iterator last,
-                    const Args&... args) 
-{
-    for (Iterator cur = first; cur != last; ++cur) {
-        PHMAP_INTERNAL_TRY {
-            std::allocator_traits<Allocator>::construct(alloc, std::addressof(*cur),
-                                                        args...);
-        }
-        PHMAP_INTERNAL_CATCH_ANY {
-            while (cur != first) {
-                --cur;
-                std::allocator_traits<Allocator>::destroy(alloc, std::addressof(*cur));
-            }
-            PHMAP_INTERNAL_RETHROW;
-        }
-    }
-}
-
-template <typename Allocator, typename Iterator, typename InputIterator>
-void CopyRange(Allocator& alloc, Iterator destination, InputIterator first,
-               InputIterator last) 
-{
-    for (Iterator cur = destination; first != last;
-         static_cast<void>(++cur), static_cast<void>(++first)) {
-        PHMAP_INTERNAL_TRY {
-            std::allocator_traits<Allocator>::construct(alloc, std::addressof(*cur),
-                                                        *first);
-        }
-        PHMAP_INTERNAL_CATCH_ANY {
-            while (cur != destination) {
-                --cur;
-                std::allocator_traits<Allocator>::destroy(alloc, std::addressof(*cur));
-            }
-            PHMAP_INTERNAL_RETHROW;
-        }
-    }
-}
-}  // namespace memory_internal
-}  // namespace phmap
-
-
-// -----------------------------------------------------------------------------
-//          optional.h
-// -----------------------------------------------------------------------------
-#ifdef PHMAP_HAVE_STD_OPTIONAL
-
-#include <optional>  // IWYU pragma: export
-
-namespace phmap {
-using std::bad_optional_access;
-using std::optional;
-using std::make_optional;
-using std::nullopt_t;
-using std::nullopt;
-}  // namespace phmap
-
-#else
-
-#if defined(__clang__)
-    #if __has_feature(cxx_inheriting_constructors)
-        #define PHMAP_OPTIONAL_USE_INHERITING_CONSTRUCTORS 1
-    #endif
-#elif (defined(__GNUC__) &&                                       \
-       (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 8)) || \
-    (__cpp_inheriting_constructors >= 200802) ||                  \
-    (defined(_MSC_VER) && _MSC_VER >= 1910)
-
-    #define PHMAP_OPTIONAL_USE_INHERITING_CONSTRUCTORS 1
-#endif
-
-namespace phmap {
-
-class bad_optional_access : public std::exception 
-{
-public:
-    bad_optional_access() = default;
-    ~bad_optional_access() override;
-    const char* what() const noexcept override;
-};
-
-template <typename T>
-class optional;
-
-// --------------------------------
-struct nullopt_t 
-{
-    struct init_t {};
-    static init_t init;
-
-    explicit constexpr nullopt_t(init_t& /*unused*/) {}
-};
-
-constexpr nullopt_t nullopt(nullopt_t::init);
-
-namespace optional_internal {
-
-// throw delegator
-[[noreturn]] void throw_bad_optional_access();
-
-
-struct empty_struct {};
-
-// This class stores the data in optional<T>.
-// It is specialized based on whether T is trivially destructible.
-// This is the specialization for non trivially destructible type.
-template <typename T, bool unused = std::is_trivially_destructible<T>::value>
-class optional_data_dtor_base 
-{
-    struct dummy_type {
-        static_assert(sizeof(T) % sizeof(empty_struct) == 0, "");
-        // Use an array to avoid GCC 6 placement-new warning.
-        empty_struct data[sizeof(T) / sizeof(empty_struct)];
-    };
-
-protected:
-    // Whether there is data or not.
-    bool engaged_;
-    // Data storage
-    union {
-        dummy_type dummy_;
-        T data_;
-    };
-
-    void destruct() noexcept {
-        if (engaged_) {
-            data_.~T();
-            engaged_ = false;
-        }
-    }
-
-    // dummy_ must be initialized for constexpr constructor.
-    constexpr optional_data_dtor_base() noexcept : engaged_(false), dummy_{{}} {}
-
-    template <typename... Args>
-    constexpr explicit optional_data_dtor_base(in_place_t, Args&&... args)
-        : engaged_(true), data_(phmap::forward<Args>(args)...) {}
-
-    ~optional_data_dtor_base() { destruct(); }
-};
-
-// Specialization for trivially destructible type.
-template <typename T>
-class optional_data_dtor_base<T, true> 
-{
-    struct dummy_type {
-        static_assert(sizeof(T) % sizeof(empty_struct) == 0, "");
-        // Use array to avoid GCC 6 placement-new warning.
-        empty_struct data[sizeof(T) / sizeof(empty_struct)];
-    };
-
-protected:
-    // Whether there is data or not.
-    bool engaged_;
-    // Data storage
-    union {
-        dummy_type dummy_;
-        T data_;
-    };
-    void destruct() noexcept { engaged_ = false; }
-
-    // dummy_ must be initialized for constexpr constructor.
-    constexpr optional_data_dtor_base() noexcept : engaged_(false), dummy_{{}} {}
-
-    template <typename... Args>
-    constexpr explicit optional_data_dtor_base(in_place_t, Args&&... args)
-        : engaged_(true), data_(phmap::forward<Args>(args)...) {}
-};
-
-template <typename T>
-class optional_data_base : public optional_data_dtor_base<T> 
-{
-protected:
-    using base = optional_data_dtor_base<T>;
-#if PHMAP_OPTIONAL_USE_INHERITING_CONSTRUCTORS
-    using base::base;
-#else
-    optional_data_base() = default;
-
-    template <typename... Args>
-    constexpr explicit optional_data_base(in_place_t t, Args&&... args)
-        : base(t, phmap::forward<Args>(args)...) {}
-#endif
-
-    template <typename... Args>
-    void construct(Args&&... args) {
-        // Use dummy_'s address to work around casting cv-qualified T* to void*.
-        ::new (static_cast<void*>(&this->dummy_)) T(std::forward<Args>(args)...);
-        this->engaged_ = true;
-    }
-
-    template <typename U>
-    void assign(U&& u) {
-        if (this->engaged_) {
-            this->data_ = std::forward<U>(u);
-        } else {
-            construct(std::forward<U>(u));
-        }
-    }
-};
-
-// TODO: Add another class using
-// std::is_trivially_move_constructible trait when available to match
-// http://cplusplus.github.io/LWG/lwg-defects.html#2900, for types that
-// have trivial move but nontrivial copy.
-// Also, we should be checking is_trivially_copyable here, which is not
-// supported now, so we use is_trivially_* traits instead.
-template <typename T,
-          bool unused = phmap::is_trivially_copy_constructible<T>::value&&
-              phmap::is_trivially_copy_assignable<typename std::remove_cv<
-                  T>::type>::value&& std::is_trivially_destructible<T>::value>
-class optional_data;
-
-// Trivially copyable types
-template <typename T>
-class optional_data<T, true> : public optional_data_base<T> 
-{
-protected:
-#if PHMAP_OPTIONAL_USE_INHERITING_CONSTRUCTORS
-    using optional_data_base<T>::optional_data_base;
-#else
-    optional_data() = default;
-
-    template <typename... Args>
-    constexpr explicit optional_data(in_place_t t, Args&&... args)
-        : optional_data_base<T>(t, phmap::forward<Args>(args)...) {}
-#endif
-};
-
-template <typename T>
-class optional_data<T, false> : public optional_data_base<T> 
-{
-protected:
-#if PHMAP_OPTIONAL_USE_INHERITING_CONSTRUCTORS
-    using optional_data_base<T>::optional_data_base;
-#else
-    template <typename... Args>
-    constexpr explicit optional_data(in_place_t t, Args&&... args)
-        : optional_data_base<T>(t, phmap::forward<Args>(args)...) {}
-#endif
-
-    optional_data() = default;
-
-    optional_data(const optional_data& rhs) : optional_data_base<T>() {
-        if (rhs.engaged_) {
-            this->construct(rhs.data_);
-        }
-    }
-
-    optional_data(optional_data&& rhs) noexcept(
-        phmap::default_allocator_is_nothrow::value ||
-        std::is_nothrow_move_constructible<T>::value)
-    : optional_data_base<T>() {
-        if (rhs.engaged_) {
-            this->construct(std::move(rhs.data_));
-        }
-    }
-
-    optional_data& operator=(const optional_data& rhs) {
-        if (rhs.engaged_) {
-            this->assign(rhs.data_);
-        } else {
-            this->destruct();
-        }
-        return *this;
-    }
-
-    optional_data& operator=(optional_data&& rhs) noexcept(
-        std::is_nothrow_move_assignable<T>::value&&
-        std::is_nothrow_move_constructible<T>::value) {
-        if (rhs.engaged_) {
-            this->assign(std::move(rhs.data_));
-        } else {
-            this->destruct();
-        }
-        return *this;
-    }
-};
-
-// Ordered by level of restriction, from low to high.
-// Copyable implies movable.
-enum class copy_traits { copyable = 0, movable = 1, non_movable = 2 };
-
-// Base class for enabling/disabling copy/move constructor.
-template <copy_traits>
-class optional_ctor_base;
-
-template <>
-class optional_ctor_base<copy_traits::copyable> 
-{
-public:
-    constexpr optional_ctor_base() = default;
-    optional_ctor_base(const optional_ctor_base&) = default;
-    optional_ctor_base(optional_ctor_base&&) = default;
-    optional_ctor_base& operator=(const optional_ctor_base&) = default;
-    optional_ctor_base& operator=(optional_ctor_base&&) = default;
-};
-
-template <>
-class optional_ctor_base<copy_traits::movable> 
-{
-public:
-    constexpr optional_ctor_base() = default;
-    optional_ctor_base(const optional_ctor_base&) = delete;
-    optional_ctor_base(optional_ctor_base&&) = default;
-    optional_ctor_base& operator=(const optional_ctor_base&) = default;
-    optional_ctor_base& operator=(optional_ctor_base&&) = default;
-};
-
-template <>
-class optional_ctor_base<copy_traits::non_movable> 
-{
-public:
-    constexpr optional_ctor_base() = default;
-    optional_ctor_base(const optional_ctor_base&) = delete;
-    optional_ctor_base(optional_ctor_base&&) = delete;
-    optional_ctor_base& operator=(const optional_ctor_base&) = default;
-    optional_ctor_base& operator=(optional_ctor_base&&) = default;
-};
-
-// Base class for enabling/disabling copy/move assignment.
-template <copy_traits>
-class optional_assign_base;
-
-template <>
-class optional_assign_base<copy_traits::copyable> 
-{
-public:
-    constexpr optional_assign_base() = default;
-    optional_assign_base(const optional_assign_base&) = default;
-    optional_assign_base(optional_assign_base&&) = default;
-    optional_assign_base& operator=(const optional_assign_base&) = default;
-    optional_assign_base& operator=(optional_assign_base&&) = default;
-};
-
-template <>
-class optional_assign_base<copy_traits::movable> 
-{
-public:
-    constexpr optional_assign_base() = default;
-    optional_assign_base(const optional_assign_base&) = default;
-    optional_assign_base(optional_assign_base&&) = default;
-    optional_assign_base& operator=(const optional_assign_base&) = delete;
-    optional_assign_base& operator=(optional_assign_base&&) = default;
-};
-
-template <>
-class optional_assign_base<copy_traits::non_movable> 
-{
-public:
-    constexpr optional_assign_base() = default;
-    optional_assign_base(const optional_assign_base&) = default;
-    optional_assign_base(optional_assign_base&&) = default;
-    optional_assign_base& operator=(const optional_assign_base&) = delete;
-    optional_assign_base& operator=(optional_assign_base&&) = delete;
-};
-
-template <typename T>
-constexpr copy_traits get_ctor_copy_traits() 
-{
-    return std::is_copy_constructible<T>::value
-        ? copy_traits::copyable
-        : std::is_move_constructible<T>::value ? copy_traits::movable
-        : copy_traits::non_movable;
-}
-
-template <typename T>
-constexpr copy_traits get_assign_copy_traits() 
-{
-    return phmap::is_copy_assignable<T>::value &&
-                 std::is_copy_constructible<T>::value
-             ? copy_traits::copyable
-             : phmap::is_move_assignable<T>::value &&
-                       std::is_move_constructible<T>::value
-                   ? copy_traits::movable
-                   : copy_traits::non_movable;
-}
-
-// Whether T is constructible or convertible from optional<U>.
-template <typename T, typename U>
-struct is_constructible_convertible_from_optional
-    : std::integral_constant<
-          bool, std::is_constructible<T, optional<U>&>::value ||
-                    std::is_constructible<T, optional<U>&&>::value ||
-                    std::is_constructible<T, const optional<U>&>::value ||
-                    std::is_constructible<T, const optional<U>&&>::value ||
-                    std::is_convertible<optional<U>&, T>::value ||
-                    std::is_convertible<optional<U>&&, T>::value ||
-                    std::is_convertible<const optional<U>&, T>::value ||
-                    std::is_convertible<const optional<U>&&, T>::value> {};
-
-// Whether T is constructible or convertible or assignable from optional<U>.
-template <typename T, typename U>
-struct is_constructible_convertible_assignable_from_optional
-    : std::integral_constant<
-          bool, is_constructible_convertible_from_optional<T, U>::value ||
-                    std::is_assignable<T&, optional<U>&>::value ||
-                    std::is_assignable<T&, optional<U>&&>::value ||
-                    std::is_assignable<T&, const optional<U>&>::value ||
-                    std::is_assignable<T&, const optional<U>&&>::value> {};
-
-// Helper function used by [optional.relops], [optional.comp_with_t],
-// for checking whether an expression is convertible to bool.
-bool convertible_to_bool(bool);
-
-// Base class for std::hash<phmap::optional<T>>:
-// If std::hash<std::remove_const_t<T>> is enabled, it provides operator() to
-// compute the hash; Otherwise, it is disabled.
-// Reference N4659 23.14.15 [unord.hash].
-template <typename T, typename = size_t>
-struct optional_hash_base 
-{
-    optional_hash_base() = delete;
-    optional_hash_base(const optional_hash_base&) = delete;
-    optional_hash_base(optional_hash_base&&) = delete;
-    optional_hash_base& operator=(const optional_hash_base&) = delete;
-    optional_hash_base& operator=(optional_hash_base&&) = delete;
-};
-
-template <typename T>
-struct optional_hash_base<T, decltype(std::hash<phmap::remove_const_t<T> >()(
-                                 std::declval<phmap::remove_const_t<T> >()))> 
-{
-    using argument_type = phmap::optional<T>;
-    using result_type = size_t;
-    size_t operator()(const phmap::optional<T>& opt) const {
-        phmap::type_traits_internal::AssertHashEnabled<phmap::remove_const_t<T>>();
-        if (opt) {
-            return std::hash<phmap::remove_const_t<T> >()(*opt);
-        } else {
-            return static_cast<size_t>(0x297814aaad196e6dULL);
-        }
-    }
-};
-
-}  // namespace optional_internal
-
-
-// -----------------------------------------------------------------------------
-// phmap::optional class definition
-// -----------------------------------------------------------------------------
-
-template <typename T>
-class optional : private optional_internal::optional_data<T>,
-                 private optional_internal::optional_ctor_base<
-                     optional_internal::get_ctor_copy_traits<T>()>,
-                 private optional_internal::optional_assign_base<
-                     optional_internal::get_assign_copy_traits<T>()> 
-{
-    using data_base = optional_internal::optional_data<T>;
-
-public:
-    typedef T value_type;
-
-    // Constructors
-
-    // Constructs an `optional` holding an empty value, NOT a default constructed
-    // `T`.
-    constexpr optional() noexcept {}
-
-    // Constructs an `optional` initialized with `nullopt` to hold an empty value.
-    constexpr optional(nullopt_t) noexcept {}  // NOLINT(runtime/explicit)
-
-    // Copy constructor, standard semantics
-    optional(const optional& src) = default;
-
-    // Move constructor, standard semantics
-    optional(optional&& src) = default;
-
-    // Constructs a non-empty `optional` direct-initialized value of type `T` from
-    // the arguments `std::forward<Args>(args)...`  within the `optional`.
-    // (The `in_place_t` is a tag used to indicate that the contained object
-    // should be constructed in-place.)
-    template <typename InPlaceT, typename... Args,
-              phmap::enable_if_t<phmap::conjunction<
-                                    std::is_same<InPlaceT, in_place_t>,
-                                    std::is_constructible<T, Args&&...> >::value>* = nullptr>
-        constexpr explicit optional(InPlaceT, Args&&... args)
-        : data_base(in_place_t(), phmap::forward<Args>(args)...) {}
-
-    // Constructs a non-empty `optional` direct-initialized value of type `T` from
-    // the arguments of an initializer_list and `std::forward<Args>(args)...`.
-    // (The `in_place_t` is a tag used to indicate that the contained object
-    // should be constructed in-place.)
-    template <typename U, typename... Args,
-              typename = typename std::enable_if<std::is_constructible<
-                                                     T, std::initializer_list<U>&, Args&&...>::value>::type>
-        constexpr explicit optional(in_place_t, std::initializer_list<U> il,
-                                    Args&&... args)
-        : data_base(in_place_t(), il, phmap::forward<Args>(args)...) {
-    }
-
-    // Value constructor (implicit)
-    template <
-        typename U = T,
-        typename std::enable_if<
-            phmap::conjunction<phmap::negation<std::is_same<
-                                                 in_place_t, typename std::decay<U>::type> >,
-                              phmap::negation<std::is_same<
-                                                 optional<T>, typename std::decay<U>::type> >,
-                              std::is_convertible<U&&, T>,
-                              std::is_constructible<T, U&&> >::value,
-            bool>::type = false>
-        constexpr optional(U&& v) : data_base(in_place_t(), phmap::forward<U>(v)) {}
-
-    // Value constructor (explicit)
-    template <
-        typename U = T,
-        typename std::enable_if<
-            phmap::conjunction<phmap::negation<std::is_same<
-                                                 in_place_t, typename std::decay<U>::type>>,
-                              phmap::negation<std::is_same<
-                                                 optional<T>, typename std::decay<U>::type>>,
-                              phmap::negation<std::is_convertible<U&&, T>>,
-                              std::is_constructible<T, U&&>>::value,
-            bool>::type = false>
-        explicit constexpr optional(U&& v)
-        : data_base(in_place_t(), phmap::forward<U>(v)) {}
-
-    // Converting copy constructor (implicit)
-    template <typename U,
-              typename std::enable_if<
-                  phmap::conjunction<
-                      phmap::negation<std::is_same<T, U> >,
-                      std::is_constructible<T, const U&>,
-                      phmap::negation<
-                          optional_internal::
-                          is_constructible_convertible_from_optional<T, U> >,
-                      std::is_convertible<const U&, T> >::value,
-                  bool>::type = false>
-    optional(const optional<U>& rhs) {
-        if (rhs) {
-            this->construct(*rhs);
-        }
-    }
-
-    // Converting copy constructor (explicit)
-    template <typename U,
-              typename std::enable_if<
-                  phmap::conjunction<
-                      phmap::negation<std::is_same<T, U>>,
-                      std::is_constructible<T, const U&>,
-                      phmap::negation<
-                          optional_internal::
-                          is_constructible_convertible_from_optional<T, U>>,
-                      phmap::negation<std::is_convertible<const U&, T>>>::value,
-                  bool>::type = false>
-        explicit optional(const optional<U>& rhs) {
-        if (rhs) {
-            this->construct(*rhs);
-        }
-    }
-
-    // Converting move constructor (implicit)
-    template <typename U,
-              typename std::enable_if<
-                  phmap::conjunction<
-                      phmap::negation<std::is_same<T, U> >,
-                      std::is_constructible<T, U&&>,
-                      phmap::negation<
-                          optional_internal::
-                          is_constructible_convertible_from_optional<T, U> >,
-                      std::is_convertible<U&&, T> >::value,
-                  bool>::type = false>
-        optional(optional<U>&& rhs) {
-        if (rhs) {
-            this->construct(std::move(*rhs));
-        }
-    }
-
-    // Converting move constructor (explicit)
-    template <
-        typename U,
-        typename std::enable_if<
-            phmap::conjunction<
-                phmap::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>,
-                phmap::negation<
-                    optional_internal::is_constructible_convertible_from_optional<
-                        T, U>>,
-                phmap::negation<std::is_convertible<U&&, T>>>::value,
-            bool>::type = false>
-        explicit optional(optional<U>&& rhs) {
-        if (rhs) {
-            this->construct(std::move(*rhs));
-        }
-    }
-
-    // Destructor. Trivial if `T` is trivially destructible.
-    ~optional() = default;
-
-    // Assignment Operators
-
-    // Assignment from `nullopt`
-    //
-    // Example:
-    //
-    //   struct S { int value; };
-    //   optional<S> opt = phmap::nullopt;  // Could also use opt = { };
-    optional& operator=(nullopt_t) noexcept {
-        this->destruct();
-        return *this;
-    }
-
-    // Copy assignment operator, standard semantics
-    optional& operator=(const optional& src) = default;
-
-    // Move assignment operator, standard semantics
-    optional& operator=(optional&& src) = default;
-
-    // Value assignment operators
-    template <
-        typename U = T,
-        typename = typename std::enable_if<phmap::conjunction<
-                                               phmap::negation<
-                                                   std::is_same<optional<T>, typename std::decay<U>::type>>,
-                                               phmap::negation<
-                                                   phmap::conjunction<std::is_scalar<T>,
-                                                                     std::is_same<T, typename std::decay<U>::type>>>,
-                                               std::is_constructible<T, U>, std::is_assignable<T&, U>>::value>::type>
-        optional& operator=(U&& v) {
-        this->assign(std::forward<U>(v));
-        return *this;
-    }
-
-    template <
-        typename U,
-        typename = typename std::enable_if<phmap::conjunction<
-                                               phmap::negation<std::is_same<T, U>>,
-                                               std::is_constructible<T, const U&>, std::is_assignable<T&, const U&>,
-                                               phmap::negation<
-                                                   optional_internal::
-                                                   is_constructible_convertible_assignable_from_optional<
-                                                       T, U>>>::value>::type>
-        optional& operator=(const optional<U>& rhs) {
-        if (rhs) {
-            this->assign(*rhs);
-        } else {
-            this->destruct();
-        }
-        return *this;
-    }
-
-    template <typename U,
-              typename = typename std::enable_if<phmap::conjunction<
-                                                     phmap::negation<std::is_same<T, U>>, std::is_constructible<T, U>,
-                                                     std::is_assignable<T&, U>,
-                                                     phmap::negation<
-                                                         optional_internal::
-                                                         is_constructible_convertible_assignable_from_optional<
-                                                             T, U>>>::value>::type>
-        optional& operator=(optional<U>&& rhs) {
-        if (rhs) {
-            this->assign(std::move(*rhs));
-        } else {
-            this->destruct();
-        }
-        return *this;
-    }
-
-    // Modifiers
-
-    // optional::reset()
-    //
-    // Destroys the inner `T` value of an `phmap::optional` if one is present.
-    PHMAP_ATTRIBUTE_REINITIALIZES void reset() noexcept { this->destruct(); }
-
-    // optional::emplace()
-    //
-    // (Re)constructs the underlying `T` in-place with the given forwarded
-    // arguments.
-    //
-    // Example:
-    //
-    //   optional<Foo> opt;
-    //   opt.emplace(arg1,arg2,arg3);  // Constructs Foo(arg1,arg2,arg3)
-    //
-    // If the optional is non-empty, and the `args` refer to subobjects of the
-    // current object, then behaviour is undefined, because the current object
-    // will be destructed before the new object is constructed with `args`.
-    template <typename... Args,
-              typename = typename std::enable_if<
-                  std::is_constructible<T, Args&&...>::value>::type>
-        T& emplace(Args&&... args) {
-        this->destruct();
-        this->construct(std::forward<Args>(args)...);
-        return reference();
-    }
-
-    // Emplace reconstruction overload for an initializer list and the given
-    // forwarded arguments.
-    //
-    // Example:
-    //
-    //   struct Foo {
-    //     Foo(std::initializer_list<int>);
-    //   };
-    //
-    //   optional<Foo> opt;
-    //   opt.emplace({1,2,3});  // Constructs Foo({1,2,3})
-    template <typename U, typename... Args,
-              typename = typename std::enable_if<std::is_constructible<
-                                                     T, std::initializer_list<U>&, Args&&...>::value>::type>
-        T& emplace(std::initializer_list<U> il, Args&&... args) {
-        this->destruct();
-        this->construct(il, std::forward<Args>(args)...);
-        return reference();
-    }
-
-    // Swaps
-
-    // Swap, standard semantics
-    void swap(optional& rhs) noexcept(
-        std::is_nothrow_move_constructible<T>::value&&
-        std::is_trivial<T>::value) {
-        if (*this) {
-            if (rhs) {
-                using std::swap;
-                swap(**this, *rhs);
-            } else {
-                rhs.construct(std::move(**this));
-                this->destruct();
-            }
-        } else {
-            if (rhs) {
-                this->construct(std::move(*rhs));
-                rhs.destruct();
-            } else {
-                // No effect (swap(disengaged, disengaged)).
-            }
-        }
-    }
-
-    // Observers
-
-    // optional::operator->()
-    //
-    // Accesses the underlying `T` value's member `m` of an `optional`. If the
-    // `optional` is empty, behavior is undefined.
-    //
-    // If you need myOpt->foo in constexpr, use (*myOpt).foo instead.
-    const T* operator->() const {
-        assert(this->engaged_);
-        return std::addressof(this->data_);
-    }
-    T* operator->() {
-        assert(this->engaged_);
-        return std::addressof(this->data_);
-    }
-
-    // optional::operator*()
-    //
-    // Accesses the underlying `T` value of an `optional`. If the `optional` is
-    // empty, behavior is undefined.
-    constexpr const T& operator*() const & { return reference(); }
-    T& operator*() & {
-        assert(this->engaged_);
-        return reference();
-    }
-    constexpr const T&& operator*() const && {
-        return phmap::move(reference());
-    }
-    T&& operator*() && {
-        assert(this->engaged_);
-        return std::move(reference());
-    }
-
-    // optional::operator bool()
-    //
-    // Returns false if and only if the `optional` is empty.
-    //
-    //   if (opt) {
-    //     // do something with opt.value();
-    //   } else {
-    //     // opt is empty.
-    //   }
-    //
-    constexpr explicit operator bool() const noexcept { return this->engaged_; }
-
-    // optional::has_value()
-    //
-    // Determines whether the `optional` contains a value. Returns `false` if and
-    // only if `*this` is empty.
-    constexpr bool has_value() const noexcept { return this->engaged_; }
-
-// Suppress bogus warning on MSVC: MSVC complains call to reference() after
-// throw_bad_optional_access() is unreachable.
-#ifdef _MSC_VER
-    #pragma warning(push)
-    #pragma warning(disable : 4702)
-#endif  // _MSC_VER
-    // optional::value()
-    //
-    // Returns a reference to an `optional`s underlying value. The constness
-    // and lvalue/rvalue-ness of the `optional` is preserved to the view of
-    // the `T` sub-object. Throws `phmap::bad_optional_access` when the `optional`
-    // is empty.
-    constexpr const T& value() const & {
-        return static_cast<bool>(*this)
-            ? reference()
-            : (optional_internal::throw_bad_optional_access(), reference());
-    }
-    T& value() & {
-        return static_cast<bool>(*this)
-            ? reference()
-            : (optional_internal::throw_bad_optional_access(), reference());
-    }
-    T&& value() && {  // NOLINT(build/c++11)
-        return std::move(
-            static_cast<bool>(*this)
-            ? reference()
-            : (optional_internal::throw_bad_optional_access(), reference()));
-    }
-    constexpr const T&& value() const && {  // NOLINT(build/c++11)
-        return phmap::move(
-            static_cast<bool>(*this)
-            ? reference()
-            : (optional_internal::throw_bad_optional_access(), reference()));
-    }
-#ifdef _MSC_VER
-    #pragma warning(pop)
-#endif  // _MSC_VER
-
-    // optional::value_or()
-    //
-    // Returns either the value of `T` or a passed default `v` if the `optional`
-    // is empty.
-    template <typename U>
-    constexpr T value_or(U&& v) const& {
-        static_assert(std::is_copy_constructible<value_type>::value,
-                      "optional<T>::value_or: T must by copy constructible");
-        static_assert(std::is_convertible<U&&, value_type>::value,
-                      "optional<T>::value_or: U must be convertible to T");
-        return static_cast<bool>(*this)
-            ? **this
-            : static_cast<T>(phmap::forward<U>(v));
-    }
-    template <typename U>
-    T value_or(U&& v) && {  // NOLINT(build/c++11)
-        static_assert(std::is_move_constructible<value_type>::value,
-                      "optional<T>::value_or: T must by move constructible");
-        static_assert(std::is_convertible<U&&, value_type>::value,
-                      "optional<T>::value_or: U must be convertible to T");
-        return static_cast<bool>(*this) ? std::move(**this)
-            : static_cast<T>(std::forward<U>(v));
-    }
-
-private:
-    // Private accessors for internal storage viewed as reference to T.
-    constexpr const T& reference() const { return this->data_; }
-    T& reference() { return this->data_; }
-
-    // T constraint checks.  You can't have an optional of nullopt_t, in_place_t
-    // or a reference.
-    static_assert(
-        !std::is_same<nullopt_t, typename std::remove_cv<T>::type>::value,
-        "optional<nullopt_t> is not allowed.");
-    static_assert(
-        !std::is_same<in_place_t, typename std::remove_cv<T>::type>::value,
-        "optional<in_place_t> is not allowed.");
-    static_assert(!std::is_reference<T>::value,
-                  "optional<reference> is not allowed.");
-};
-
-// Non-member functions
-
-// swap()
-//
-// Performs a swap between two `phmap::optional` objects, using standard
-// semantics.
-//
-// NOTE: we assume `is_swappable()` is always `true`. A compile error will
-// result if this is not the case.
-template <typename T,
-          typename std::enable_if<std::is_move_constructible<T>::value,
-                                  bool>::type = false>
-void swap(optional<T>& a, optional<T>& b) noexcept(noexcept(a.swap(b))) {
-    a.swap(b);
-}
-
-// make_optional()
-//
-// Creates a non-empty `optional<T>` where the type of `T` is deduced. An
-// `phmap::optional` can also be explicitly instantiated with
-// `make_optional<T>(v)`.
-//
-// Note: `make_optional()` constructions may be declared `constexpr` for
-// trivially copyable types `T`. Non-trivial types require copy elision
-// support in C++17 for `make_optional` to support `constexpr` on such
-// non-trivial types.
-//
-// Example:
-//
-//   constexpr phmap::optional<int> opt = phmap::make_optional(1);
-//   static_assert(opt.value() == 1, "");
-template <typename T>
-constexpr optional<typename std::decay<T>::type> make_optional(T&& v) {
-    return optional<typename std::decay<T>::type>(phmap::forward<T>(v));
-}
-
-template <typename T, typename... Args>
-constexpr optional<T> make_optional(Args&&... args) {
-    return optional<T>(in_place_t(), phmap::forward<Args>(args)...);
-}
-
-template <typename T, typename U, typename... Args>
-constexpr optional<T> make_optional(std::initializer_list<U> il,
-                                    Args&&... args) {
-    return optional<T>(in_place_t(), il,
-                       phmap::forward<Args>(args)...);
-}
-
-// Relational operators [optional.relops]
-
-// Empty optionals are considered equal to each other and less than non-empty
-// optionals. Supports relations between optional<T> and optional<U>, between
-// optional<T> and U, and between optional<T> and nullopt.
-//
-// Note: We're careful to support T having non-bool relationals.
-
-// Requires: The expression, e.g. "*x == *y" shall be well-formed and its result
-// shall be convertible to bool.
-// The C++17 (N4606) "Returns:" statements are translated into
-// code in an obvious way here, and the original text retained as function docs.
-// Returns: If bool(x) != bool(y), false; otherwise if bool(x) == false, true;
-// otherwise *x == *y.
-template <typename T, typename U>
-constexpr auto operator==(const optional<T>& x, const optional<U>& y)
-    -> decltype(optional_internal::convertible_to_bool(*x == *y)) {
-    return static_cast<bool>(x) != static_cast<bool>(y)
-             ? false
-             : static_cast<bool>(x) == false ? true
-                                             : static_cast<bool>(*x == *y);
-}
-
-// Returns: If bool(x) != bool(y), true; otherwise, if bool(x) == false, false;
-// otherwise *x != *y.
-template <typename T, typename U>
-constexpr auto operator!=(const optional<T>& x, const optional<U>& y)
-    -> decltype(optional_internal::convertible_to_bool(*x != *y)) {
-    return static_cast<bool>(x) != static_cast<bool>(y)
-             ? true
-             : static_cast<bool>(x) == false ? false
-                                             : static_cast<bool>(*x != *y);
-}
-// Returns: If !y, false; otherwise, if !x, true; otherwise *x < *y.
-template <typename T, typename U>
-constexpr auto operator<(const optional<T>& x, const optional<U>& y)
-    -> decltype(optional_internal::convertible_to_bool(*x < *y)) {
-    return !y ? false : !x ? true : static_cast<bool>(*x < *y);
-}
-// Returns: If !x, false; otherwise, if !y, true; otherwise *x > *y.
-template <typename T, typename U>
-constexpr auto operator>(const optional<T>& x, const optional<U>& y)
-    -> decltype(optional_internal::convertible_to_bool(*x > *y)) {
-    return !x ? false : !y ? true : static_cast<bool>(*x > *y);
-}
-// Returns: If !x, true; otherwise, if !y, false; otherwise *x <= *y.
-template <typename T, typename U>
-constexpr auto operator<=(const optional<T>& x, const optional<U>& y)
-    -> decltype(optional_internal::convertible_to_bool(*x <= *y)) {
-    return !x ? true : !y ? false : static_cast<bool>(*x <= *y);
-}
-// Returns: If !y, true; otherwise, if !x, false; otherwise *x >= *y.
-template <typename T, typename U>
-constexpr auto operator>=(const optional<T>& x, const optional<U>& y)
-    -> decltype(optional_internal::convertible_to_bool(*x >= *y)) {
-    return !y ? true : !x ? false : static_cast<bool>(*x >= *y);
-}
-
-// Comparison with nullopt [optional.nullops]
-// The C++17 (N4606) "Returns:" statements are used directly here.
-template <typename T>
-constexpr bool operator==(const optional<T>& x, nullopt_t) noexcept {
-    return !x;
-}
-template <typename T>
-constexpr bool operator==(nullopt_t, const optional<T>& x) noexcept {
-    return !x;
-}
-template <typename T>
-constexpr bool operator!=(const optional<T>& x, nullopt_t) noexcept {
-    return static_cast<bool>(x);
-}
-template <typename T>
-constexpr bool operator!=(nullopt_t, const optional<T>& x) noexcept {
-    return static_cast<bool>(x);
-}
-template <typename T>
-constexpr bool operator<(const optional<T>&, nullopt_t) noexcept {
-    return false;
-}
-template <typename T>
-constexpr bool operator<(nullopt_t, const optional<T>& x) noexcept {
-    return static_cast<bool>(x);
-}
-template <typename T>
-constexpr bool operator<=(const optional<T>& x, nullopt_t) noexcept {
-    return !x;
-}
-template <typename T>
-constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept {
-    return true;
-}
-template <typename T>
-constexpr bool operator>(const optional<T>& x, nullopt_t) noexcept {
-    return static_cast<bool>(x);
-}
-template <typename T>
-constexpr bool operator>(nullopt_t, const optional<T>&) noexcept {
-    return false;
-}
-template <typename T>
-constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept {
-    return true;
-}
-template <typename T>
-constexpr bool operator>=(nullopt_t, const optional<T>& x) noexcept {
-    return !x;
-}
-
-// Comparison with T [optional.comp_with_t]
-
-// Requires: The expression, e.g. "*x == v" shall be well-formed and its result
-// shall be convertible to bool.
-// The C++17 (N4606) "Equivalent to:" statements are used directly here.
-template <typename T, typename U>
-constexpr auto operator==(const optional<T>& x, const U& v)
-    -> decltype(optional_internal::convertible_to_bool(*x == v)) {
-    return static_cast<bool>(x) ? static_cast<bool>(*x == v) : false;
-}
-template <typename T, typename U>
-constexpr auto operator==(const U& v, const optional<T>& x)
-    -> decltype(optional_internal::convertible_to_bool(v == *x)) {
-    return static_cast<bool>(x) ? static_cast<bool>(v == *x) : false;
-}
-template <typename T, typename U>
-constexpr auto operator!=(const optional<T>& x, const U& v)
-    -> decltype(optional_internal::convertible_to_bool(*x != v)) {
-    return static_cast<bool>(x) ? static_cast<bool>(*x != v) : true;
-}
-template <typename T, typename U>
-constexpr auto operator!=(const U& v, const optional<T>& x)
-    -> decltype(optional_internal::convertible_to_bool(v != *x)) {
-    return static_cast<bool>(x) ? static_cast<bool>(v != *x) : true;
-}
-template <typename T, typename U>
-constexpr auto operator<(const optional<T>& x, const U& v)
-    -> decltype(optional_internal::convertible_to_bool(*x < v)) {
-    return static_cast<bool>(x) ? static_cast<bool>(*x < v) : true;
-}
-template <typename T, typename U>
-constexpr auto operator<(const U& v, const optional<T>& x)
-    -> decltype(optional_internal::convertible_to_bool(v < *x)) {
-    return static_cast<bool>(x) ? static_cast<bool>(v < *x) : false;
-}
-template <typename T, typename U>
-constexpr auto operator<=(const optional<T>& x, const U& v)
-    -> decltype(optional_internal::convertible_to_bool(*x <= v)) {
-    return static_cast<bool>(x) ? static_cast<bool>(*x <= v) : true;
-}
-template <typename T, typename U>
-constexpr auto operator<=(const U& v, const optional<T>& x)
-    -> decltype(optional_internal::convertible_to_bool(v <= *x)) {
-    return static_cast<bool>(x) ? static_cast<bool>(v <= *x) : false;
-}
-template <typename T, typename U>
-constexpr auto operator>(const optional<T>& x, const U& v)
-    -> decltype(optional_internal::convertible_to_bool(*x > v)) {
-    return static_cast<bool>(x) ? static_cast<bool>(*x > v) : false;
-}
-template <typename T, typename U>
-constexpr auto operator>(const U& v, const optional<T>& x)
-    -> decltype(optional_internal::convertible_to_bool(v > *x)) {
-    return static_cast<bool>(x) ? static_cast<bool>(v > *x) : true;
-}
-template <typename T, typename U>
-constexpr auto operator>=(const optional<T>& x, const U& v)
-    -> decltype(optional_internal::convertible_to_bool(*x >= v)) {
-    return static_cast<bool>(x) ? static_cast<bool>(*x >= v) : false;
-}
-template <typename T, typename U>
-constexpr auto operator>=(const U& v, const optional<T>& x)
-    -> decltype(optional_internal::convertible_to_bool(v >= *x)) {
-    return static_cast<bool>(x) ? static_cast<bool>(v >= *x) : true;
-}
-
-}  // namespace phmap
-
-namespace std {
-
-// std::hash specialization for phmap::optional.
-template <typename T>
-struct hash<phmap::optional<T> >
-    : phmap::optional_internal::optional_hash_base<T> {};
-
-}  // namespace std
-
-#endif
-
-// -----------------------------------------------------------------------------
-//          common.h
-// -----------------------------------------------------------------------------
-namespace phmap {
-namespace priv {
-
-template <class, class = void>
-struct IsTransparent : std::false_type {};
-template <class T>
-struct IsTransparent<T, phmap::void_t<typename T::is_transparent>>
-    : std::true_type {};
-
-template <bool is_transparent>
-struct KeyArg 
-{
-    // Transparent. Forward `K`.
-    template <typename K, typename key_type>
-    using type = K;
-};
-
-template <>
-struct KeyArg<false> 
-{
-    // Not transparent. Always use `key_type`.
-    template <typename K, typename key_type>
-    using type = key_type;
-};
-
-#ifdef _MSC_VER
-    #pragma warning(push)  
-    //  warning C4820: '6' bytes padding added after data member
-    #pragma warning(disable : 4820)
-#endif
-
-// The node_handle concept from C++17.
-// We specialize node_handle for sets and maps. node_handle_base holds the
-// common API of both.
-// -----------------------------------------------------------------------
-template <typename PolicyTraits, typename Alloc>
-class node_handle_base 
-{
-protected:
-    using slot_type = typename PolicyTraits::slot_type;
-
-public:
-    using allocator_type = Alloc;
-
-    constexpr node_handle_base() {}
-
-    node_handle_base(node_handle_base&& other) noexcept {
-        *this = std::move(other);
-    }
-
-    ~node_handle_base() { destroy(); }
-
-    node_handle_base& operator=(node_handle_base&& other) noexcept {
-        destroy();
-        if (!other.empty()) {
-            alloc_ = other.alloc_;
-            PolicyTraits::transfer(alloc(), slot(), other.slot());
-            other.reset();
-        }
-        return *this;
-    }
-
-    bool empty() const noexcept { return !alloc_; }
-    explicit operator bool() const noexcept { return !empty(); }
-    allocator_type get_allocator() const { return *alloc_; }
-
-protected:
-    friend struct CommonAccess;
-
-    struct transfer_tag_t {};
-    node_handle_base(transfer_tag_t, const allocator_type& a, slot_type* s)
-        : alloc_(a) {
-        PolicyTraits::transfer(alloc(), slot(), s);
-    }
-    
-    struct move_tag_t {};
-    node_handle_base(move_tag_t, const allocator_type& a, slot_type* s)
-        : alloc_(a) {
-        PolicyTraits::construct(alloc(), slot(), s);
-    }
-
-    node_handle_base(const allocator_type& a, slot_type* s) : alloc_(a) {
-        PolicyTraits::transfer(alloc(), slot(), s);
-    }
-
-    //node_handle_base(const node_handle_base&) = delete;
-    //node_handle_base& operator=(const node_handle_base&) = delete;
-
-    void destroy() {
-        if (!empty()) {
-            PolicyTraits::destroy(alloc(), slot());
-            reset();
-        }
-    }
-
-    void reset() {
-        assert(alloc_.has_value());
-        alloc_ = phmap::nullopt;
-    }
-
-    slot_type* slot() const {
-        assert(!empty());
-        return reinterpret_cast<slot_type*>(std::addressof(slot_space_));
-    }
-
-    allocator_type* alloc() { return std::addressof(*alloc_); }
-
-private:
-    phmap::optional<allocator_type> alloc_;
-    mutable phmap::aligned_storage_t<sizeof(slot_type), alignof(slot_type)> slot_space_;
-};
-
-#ifdef _MSC_VER
-     #pragma warning(pop)  
-#endif
-
-// For sets.
-// ---------
-template <typename Policy, typename PolicyTraits, typename Alloc,
-          typename = void>
-class node_handle : public node_handle_base<PolicyTraits, Alloc> 
-{
-    using Base = node_handle_base<PolicyTraits, Alloc>;
-
-public:
-    using value_type = typename PolicyTraits::value_type;
-
-    constexpr node_handle() {}
-
-    value_type& value() const { return PolicyTraits::element(this->slot()); }
-
-    value_type& key() const { return PolicyTraits::element(this->slot()); }
-
-private:
-    friend struct CommonAccess;
-
-    using Base::Base;
-};
-
-// For maps.
-// ---------
-template <typename Policy, typename PolicyTraits, typename Alloc>
-class node_handle<Policy, PolicyTraits, Alloc,
-                  phmap::void_t<typename Policy::mapped_type>>
-    : public node_handle_base<PolicyTraits, Alloc> 
-{
-    using Base = node_handle_base<PolicyTraits, Alloc>;
-
-public:
-    using key_type = typename Policy::key_type;
-    using mapped_type = typename Policy::mapped_type;
-
-    constexpr node_handle() {}
-
-    auto key() const -> decltype(PolicyTraits::key(this->slot())) {
-        return PolicyTraits::key(this->slot());
-    }
-
-    mapped_type& mapped() const {
-        return PolicyTraits::value(&PolicyTraits::element(this->slot()));
-    }
-
-private:
-    friend struct CommonAccess;
-
-    using Base::Base;
-};
-
-// Provide access to non-public node-handle functions.
-struct CommonAccess 
-{
-    template <typename Node>
-    static auto GetSlot(const Node& node) -> decltype(node.slot()) {
-        return node.slot();
-    }
-
-    template <typename Node>
-    static void Destroy(Node* node) {
-        node->destroy();
-    }
-
-    template <typename Node>
-    static void Reset(Node* node) {
-        node->reset();
-    }
-
-    template <typename T, typename... Args>
-    static T Make(Args&&... args) {
-        return T(std::forward<Args>(args)...);
-    }
-
-    template <typename T, typename... Args>
-    static T Transfer(Args&&... args) {
-        return T(typename T::transfer_tag_t{}, std::forward<Args>(args)...);
-    }
-
-    template <typename T, typename... Args>
-    static T Move(Args&&... args) {
-        return T(typename T::move_tag_t{}, std::forward<Args>(args)...);
-    }
-};
-
-// Implement the insert_return_type<> concept of C++17.
-template <class Iterator, class NodeType>
-struct InsertReturnType 
-{
-    Iterator position;
-    bool inserted;
-    NodeType node;
-};
-
-}  // namespace priv
-}  // namespace phmap
-
-
-#ifdef ADDRESS_SANITIZER
-    #include <sanitizer/asan_interface.h>
-#endif
-
-// ---------------------------------------------------------------------------
-//  span.h
-// ---------------------------------------------------------------------------
-
-namespace phmap {
-
-template <typename T>
-class Span;
-
-namespace span_internal {
-// A constexpr min function
-constexpr size_t Min(size_t a, size_t b) noexcept { return a < b ? a : b; }
-
-// Wrappers for access to container data pointers.
-template <typename C>
-constexpr auto GetDataImpl(C& c, char) noexcept  // NOLINT(runtime/references)
-    -> decltype(c.data()) {
-  return c.data();
-}
-
-// Before C++17, std::string::data returns a const char* in all cases.
-inline char* GetDataImpl(std::string& s,  // NOLINT(runtime/references)
-                         int) noexcept {
-  return &s[0];
-}
-
-template <typename C>
-constexpr auto GetData(C& c) noexcept  // NOLINT(runtime/references)
-    -> decltype(GetDataImpl(c, 0)) {
-  return GetDataImpl(c, 0);
-}
-
-// Detection idioms for size() and data().
-template <typename C>
-using HasSize =
-    std::is_integral<phmap::decay_t<decltype(std::declval<C&>().size())>>;
-
-// We want to enable conversion from vector<T*> to Span<const T* const> but
-// disable conversion from vector<Derived> to Span<Base>. Here we use
-// the fact that U** is convertible to Q* const* if and only if Q is the same
-// type or a more cv-qualified version of U.  We also decay the result type of
-// data() to avoid problems with classes which have a member function data()
-// which returns a reference.
-template <typename T, typename C>
-using HasData =
-    std::is_convertible<phmap::decay_t<decltype(GetData(std::declval<C&>()))>*,
-                        T* const*>;
-
-// Extracts value type from a Container
-template <typename C>
-struct ElementType {
-  using type = typename phmap::remove_reference_t<C>::value_type;
-};
-
-template <typename T, size_t N>
-struct ElementType<T (&)[N]> {
-  using type = T;
-};
-
-template <typename C>
-using ElementT = typename ElementType<C>::type;
-
-template <typename T>
-using EnableIfMutable =
-    typename std::enable_if<!std::is_const<T>::value, int>::type;
-
-template <typename T>
-bool EqualImpl(Span<T> a, Span<T> b) {
-  static_assert(std::is_const<T>::value, "");
-  return std::equal(a.begin(), a.end(), b.begin(), b.end());
-}
-
-template <typename T>
-bool LessThanImpl(Span<T> a, Span<T> b) {
-  static_assert(std::is_const<T>::value, "");
-  return std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end());
-}
-
-// The `IsConvertible` classes here are needed because of the
-// `std::is_convertible` bug in libcxx when compiled with GCC. This build
-// configuration is used by Android NDK toolchain. Reference link:
-// https://bugs.llvm.org/show_bug.cgi?id=27538.
-template <typename From, typename To>
-struct IsConvertibleHelper {
-  static std::true_type testval(To);
-  static std::false_type testval(...);
-
-  using type = decltype(testval(std::declval<From>()));
-};
-
-template <typename From, typename To>
-struct IsConvertible : IsConvertibleHelper<From, To>::type {};
-
-// TODO(zhangxy): replace `IsConvertible` with `std::is_convertible` once the
-// older version of libcxx is not supported.
-template <typename From, typename To>
-using EnableIfConvertibleToSpanConst =
-    typename std::enable_if<IsConvertible<From, Span<const To>>::value>::type;
-}  // namespace span_internal
-
-//------------------------------------------------------------------------------
-// Span
-//------------------------------------------------------------------------------
-//
-// A `Span` is an "array view" type for holding a view of a contiguous data
-// array; the `Span` object does not and cannot own such data itself. A span
-// provides an easy way to provide overloads for anything operating on
-// contiguous sequences without needing to manage pointers and array lengths
-// manually.
-
-// A span is conceptually a pointer (ptr) and a length (size) into an already
-// existing array of contiguous memory; the array it represents references the
-// elements "ptr[0] .. ptr[size-1]". Passing a properly-constructed `Span`
-// instead of raw pointers avoids many issues related to index out of bounds
-// errors.
-//
-// Spans may also be constructed from containers holding contiguous sequences.
-// Such containers must supply `data()` and `size() const` methods (e.g
-// `std::vector<T>`, `phmap::InlinedVector<T, N>`). All implicit conversions to
-// `phmap::Span` from such containers will create spans of type `const T`;
-// spans which can mutate their values (of type `T`) must use explicit
-// constructors.
-//
-// A `Span<T>` is somewhat analogous to an `phmap::string_view`, but for an array
-// of elements of type `T`. A user of `Span` must ensure that the data being
-// pointed to outlives the `Span` itself.
-//
-// You can construct a `Span<T>` in several ways:
-//
-//   * Explicitly from a reference to a container type
-//   * Explicitly from a pointer and size
-//   * Implicitly from a container type (but only for spans of type `const T`)
-//   * Using the `MakeSpan()` or `MakeConstSpan()` factory functions.
-//
-// Examples:
-//
-//   // Construct a Span explicitly from a container:
-//   std::vector<int> v = {1, 2, 3, 4, 5};
-//   auto span = phmap::Span<const int>(v);
-//
-//   // Construct a Span explicitly from a C-style array:
-//   int a[5] =  {1, 2, 3, 4, 5};
-//   auto span = phmap::Span<const int>(a);
-//
-//   // Construct a Span implicitly from a container
-//   void MyRoutine(phmap::Span<const int> a) {
-//     ...
-//   }
-//   std::vector v = {1,2,3,4,5};
-//   MyRoutine(v)                     // convert to Span<const T>
-//
-// Note that `Span` objects, in addition to requiring that the memory they
-// point to remains alive, must also ensure that such memory does not get
-// reallocated. Therefore, to avoid undefined behavior, containers with
-// associated span views should not invoke operations that may reallocate memory
-// (such as resizing) or invalidate iterators into the container.
-//
-// One common use for a `Span` is when passing arguments to a routine that can
-// accept a variety of array types (e.g. a `std::vector`, `phmap::InlinedVector`,
-// a C-style array, etc.). Instead of creating overloads for each case, you
-// can simply specify a `Span` as the argument to such a routine.
-//
-// Example:
-//
-//   void MyRoutine(phmap::Span<const int> a) {
-//     ...
-//   }
-//
-//   std::vector v = {1,2,3,4,5};
-//   MyRoutine(v);
-//
-//   phmap::InlinedVector<int, 4> my_inline_vector;
-//   MyRoutine(my_inline_vector);
-//
-//   // Explicit constructor from pointer,size
-//   int* my_array = new int[10];
-//   MyRoutine(phmap::Span<const int>(my_array, 10));
-template <typename T>
-class Span 
-{
-private:
-    // Used to determine whether a Span can be constructed from a container of
-    // type C.
-    template <typename C>
-    using EnableIfConvertibleFrom =
-        typename std::enable_if<span_internal::HasData<T, C>::value &&
-                                span_internal::HasSize<C>::value>::type;
-
-    // Used to SFINAE-enable a function when the slice elements are const.
-    template <typename U>
-    using EnableIfConstView =
-        typename std::enable_if<std::is_const<T>::value, U>::type;
-
-    // Used to SFINAE-enable a function when the slice elements are mutable.
-    template <typename U>
-    using EnableIfMutableView =
-        typename std::enable_if<!std::is_const<T>::value, U>::type;
-
-public:
-    using value_type = phmap::remove_cv_t<T>;
-    using pointer = T*;
-    using const_pointer = const T*;
-    using reference = T&;
-    using const_reference = const T&;
-    using iterator = pointer;
-    using const_iterator = const_pointer;
-    using reverse_iterator = std::reverse_iterator<iterator>;
-    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-    using size_type = size_t;
-    using difference_type = ptrdiff_t;
-
-    static const size_type npos = ~(size_type(0));
-
-    constexpr Span() noexcept : Span(nullptr, 0) {}
-    constexpr Span(pointer array, size_type lgth) noexcept
-        : ptr_(array), len_(lgth) {}
-
-    // Implicit conversion constructors
-    template <size_t N>
-    constexpr Span(T (&a)[N]) noexcept  // NOLINT(runtime/explicit)
-        : Span(a, N) {}
-
-    // Explicit reference constructor for a mutable `Span<T>` type. Can be
-    // replaced with MakeSpan() to infer the type parameter.
-    template <typename V, typename = EnableIfConvertibleFrom<V>,
-              typename = EnableIfMutableView<V>>
-        explicit Span(V& v) noexcept  // NOLINT(runtime/references)
-        : Span(span_internal::GetData(v), v.size()) {}
-
-    // Implicit reference constructor for a read-only `Span<const T>` type
-    template <typename V, typename = EnableIfConvertibleFrom<V>,
-              typename = EnableIfConstView<V>>
-        constexpr Span(const V& v) noexcept  // NOLINT(runtime/explicit)
-        : Span(span_internal::GetData(v), v.size()) {}
-
-    // Implicit constructor from an initializer list, making it possible to pass a
-    // brace-enclosed initializer list to a function expecting a `Span`. Such
-    // spans constructed from an initializer list must be of type `Span<const T>`.
-    //
-    //   void Process(phmap::Span<const int> x);
-    //   Process({1, 2, 3});
-    //
-    // Note that as always the array referenced by the span must outlive the span.
-    // Since an initializer list constructor acts as if it is fed a temporary
-    // array (cf. C++ standard [dcl.init.list]/5), it's safe to use this
-    // constructor only when the `std::initializer_list` itself outlives the span.
-    // In order to meet this requirement it's sufficient to ensure that neither
-    // the span nor a copy of it is used outside of the expression in which it's
-    // created:
-    //
-    //   // Assume that this function uses the array directly, not retaining any
-    //   // copy of the span or pointer to any of its elements.
-    //   void Process(phmap::Span<const int> ints);
-    //
-    //   // Okay: the std::initializer_list<int> will reference a temporary array
-    //   // that isn't destroyed until after the call to Process returns.
-    //   Process({ 17, 19 });
-    //
-    //   // Not okay: the storage used by the std::initializer_list<int> is not
-    //   // allowed to be referenced after the first line.
-    //   phmap::Span<const int> ints = { 17, 19 };
-    //   Process(ints);
-    //
-    //   // Not okay for the same reason as above: even when the elements of the
-    //   // initializer list expression are not temporaries the underlying array
-    //   // is, so the initializer list must still outlive the span.
-    //   const int foo = 17;
-    //   phmap::Span<const int> ints = { foo };
-    //   Process(ints);
-    //
-    template <typename LazyT = T,
-              typename = EnableIfConstView<LazyT>>
-        Span(
-            std::initializer_list<value_type> v) noexcept  // NOLINT(runtime/explicit)
-        : Span(v.begin(), v.size()) {}
-
-    // Accessors
-
-    // Span::data()
-    //
-    // Returns a pointer to the span's underlying array of data (which is held
-    // outside the span).
-    constexpr pointer data() const noexcept { return ptr_; }
-
-    // Span::size()
-    //
-    // Returns the size of this span.
-    constexpr size_type size() const noexcept { return len_; }
-
-    // Span::length()
-    //
-    // Returns the length (size) of this span.
-    constexpr size_type length() const noexcept { return size(); }
-
-    // Span::empty()
-    //
-    // Returns a boolean indicating whether or not this span is considered empty.
-    constexpr bool empty() const noexcept { return size() == 0; }
-
-    // Span::operator[]
-    //
-    // Returns a reference to the i'th element of this span.
-    constexpr reference operator[](size_type i) const noexcept {
-        // MSVC 2015 accepts this as constexpr, but not ptr_[i]
-        return *(data() + i);
-    }
-
-    // Span::at()
-    //
-    // Returns a reference to the i'th element of this span.
-    constexpr reference at(size_type i) const {
-        return PHMAP_PREDICT_TRUE(i < size())  //
-            ? *(data() + i)
-            : (base_internal::ThrowStdOutOfRange(
-                   "Span::at failed bounds check"),
-               *(data() + i));
-    }
-
-    // Span::front()
-    //
-    // Returns a reference to the first element of this span.
-    constexpr reference front() const noexcept {
-        return PHMAP_ASSERT(size() > 0), *data();
-    }
-
-    // Span::back()
-    //
-    // Returns a reference to the last element of this span.
-    constexpr reference back() const noexcept {
-        return PHMAP_ASSERT(size() > 0), *(data() + size() - 1);
-    }
-
-    // Span::begin()
-    //
-    // Returns an iterator to the first element of this span.
-    constexpr iterator begin() const noexcept { return data(); }
-
-    // Span::cbegin()
-    //
-    // Returns a const iterator to the first element of this span.
-    constexpr const_iterator cbegin() const noexcept { return begin(); }
-
-    // Span::end()
-    //
-    // Returns an iterator to the last element of this span.
-    constexpr iterator end() const noexcept { return data() + size(); }
-
-    // Span::cend()
-    //
-    // Returns a const iterator to the last element of this span.
-    constexpr const_iterator cend() const noexcept { return end(); }
-
-    // Span::rbegin()
-    //
-    // Returns a reverse iterator starting at the last element of this span.
-    constexpr reverse_iterator rbegin() const noexcept {
-        return reverse_iterator(end());
-    }
-
-    // Span::crbegin()
-    //
-    // Returns a reverse const iterator starting at the last element of this span.
-    constexpr const_reverse_iterator crbegin() const noexcept { return rbegin(); }
-
-    // Span::rend()
-    //
-    // Returns a reverse iterator starting at the first element of this span.
-    constexpr reverse_iterator rend() const noexcept {
-        return reverse_iterator(begin());
-    }
-
-    // Span::crend()
-    //
-    // Returns a reverse iterator starting at the first element of this span.
-    constexpr const_reverse_iterator crend() const noexcept { return rend(); }
-
-    // Span mutations
-
-    // Span::remove_prefix()
-    //
-    // Removes the first `n` elements from the span.
-    void remove_prefix(size_type n) noexcept {
-        assert(size() >= n);
-        ptr_ += n;
-        len_ -= n;
-    }
-
-    // Span::remove_suffix()
-    //
-    // Removes the last `n` elements from the span.
-    void remove_suffix(size_type n) noexcept {
-        assert(size() >= n);
-        len_ -= n;
-    }
-
-    // Span::subspan()
-    //
-    // Returns a `Span` starting at element `pos` and of length `len`. Both `pos`
-    // and `len` are of type `size_type` and thus non-negative. Parameter `pos`
-    // must be <= size(). Any `len` value that points past the end of the span
-    // will be trimmed to at most size() - `pos`. A default `len` value of `npos`
-    // ensures the returned subspan continues until the end of the span.
-    //
-    // Examples:
-    //
-    //   std::vector<int> vec = {10, 11, 12, 13};
-    //   phmap::MakeSpan(vec).subspan(1, 2);  // {11, 12}
-    //   phmap::MakeSpan(vec).subspan(2, 8);  // {12, 13}
-    //   phmap::MakeSpan(vec).subspan(1);     // {11, 12, 13}
-    //   phmap::MakeSpan(vec).subspan(4);     // {}
-    //   phmap::MakeSpan(vec).subspan(5);     // throws std::out_of_range
-    constexpr Span subspan(size_type pos = 0, size_type len = npos) const {
-        return (pos <= size())
-            ? Span(data() + pos, span_internal::Min(size() - pos, len))
-            : (base_internal::ThrowStdOutOfRange("pos > size()"), Span());
-    }
-
-    // Span::first()
-    //
-    // Returns a `Span` containing first `len` elements. Parameter `len` is of
-    // type `size_type` and thus non-negative. `len` value must be <= size().
-    //
-    // Examples:
-    //
-    //   std::vector<int> vec = {10, 11, 12, 13};
-    //   phmap::MakeSpan(vec).first(1);  // {10}
-    //   phmap::MakeSpan(vec).first(3);  // {10, 11, 12}
-    //   phmap::MakeSpan(vec).first(5);  // throws std::out_of_range
-    constexpr Span first(size_type len) const {
-        return (len <= size())
-            ? Span(data(), len)
-            : (base_internal::ThrowStdOutOfRange("len > size()"), Span());
-    }
-
-    // Span::last()
-    //
-    // Returns a `Span` containing last `len` elements. Parameter `len` is of
-    // type `size_type` and thus non-negative. `len` value must be <= size().
-    //
-    // Examples:
-    //
-    //   std::vector<int> vec = {10, 11, 12, 13};
-    //   phmap::MakeSpan(vec).last(1);  // {13}
-    //   phmap::MakeSpan(vec).last(3);  // {11, 12, 13}
-    //   phmap::MakeSpan(vec).last(5);  // throws std::out_of_range
-    constexpr Span last(size_type len) const {
-        return (len <= size())
-            ? Span(size() - len + data(), len)
-            : (base_internal::ThrowStdOutOfRange("len > size()"), Span());
-    }
-
-    // Support for phmap::Hash.
-    template <typename H>
-    friend H AbslHashValue(H h, Span v) {
-        return H::combine(H::combine_contiguous(std::move(h), v.data(), v.size()),
-                          v.size());
-    }
-
-private:
-    pointer ptr_;
-    size_type len_;
-};
-
-template <typename T>
-const typename Span<T>::size_type Span<T>::npos;
-
-// Span relationals
-
-// Equality is compared element-by-element, while ordering is lexicographical.
-// We provide three overloads for each operator to cover any combination on the
-// left or right hand side of mutable Span<T>, read-only Span<const T>, and
-// convertible-to-read-only Span<T>.
-// TODO(zhangxy): Due to MSVC overload resolution bug with partial ordering
-// template functions, 5 overloads per operator is needed as a workaround. We
-// should update them to 3 overloads per operator using non-deduced context like
-// string_view, i.e.
-// - (Span<T>, Span<T>)
-// - (Span<T>, non_deduced<Span<const T>>)
-// - (non_deduced<Span<const T>>, Span<T>)
-
-// operator==
-template <typename T>
-bool operator==(Span<T> a, Span<T> b) {
-  return span_internal::EqualImpl<const T>(a, b);
-}
-
-template <typename T>
-bool operator==(Span<const T> a, Span<T> b) {
-  return span_internal::EqualImpl<const T>(a, b);
-}
-
-template <typename T>
-bool operator==(Span<T> a, Span<const T> b) {
-  return span_internal::EqualImpl<const T>(a, b);
-}
-
-template <typename T, typename U,
-          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
-bool operator==(const U& a, Span<T> b) {
-  return span_internal::EqualImpl<const T>(a, b);
-}
-
-template <typename T, typename U,
-          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
-bool operator==(Span<T> a, const U& b) {
-  return span_internal::EqualImpl<const T>(a, b);
-}
-
-// operator!=
-template <typename T>
-bool operator!=(Span<T> a, Span<T> b) {
-  return !(a == b);
-}
-
-template <typename T>
-bool operator!=(Span<const T> a, Span<T> b) {
-  return !(a == b);
-}
-
-template <typename T>
-bool operator!=(Span<T> a, Span<const T> b) {
-  return !(a == b);
-}
-
-template <typename T, typename U,
-          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
-bool operator!=(const U& a, Span<T> b) {
-  return !(a == b);
-}
-
-template <typename T, typename U,
-          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
-bool operator!=(Span<T> a, const U& b) {
-  return !(a == b);
-}
-
-// operator<
-template <typename T>
-bool operator<(Span<T> a, Span<T> b) {
-  return span_internal::LessThanImpl<const T>(a, b);
-}
-
-template <typename T>
-bool operator<(Span<const T> a, Span<T> b) {
-  return span_internal::LessThanImpl<const T>(a, b);
-}
-
-template <typename T>
-bool operator<(Span<T> a, Span<const T> b) {
-  return span_internal::LessThanImpl<const T>(a, b);
-}
-
-template <typename T, typename U,
-          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
-bool operator<(const U& a, Span<T> b) {
-  return span_internal::LessThanImpl<const T>(a, b);
-}
-
-template <typename T, typename U,
-          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
-bool operator<(Span<T> a, const U& b) {
-  return span_internal::LessThanImpl<const T>(a, b);
-}
-
-// operator>
-template <typename T>
-bool operator>(Span<T> a, Span<T> b) {
-  return b < a;
-}
-
-template <typename T>
-bool operator>(Span<const T> a, Span<T> b) {
-  return b < a;
-}
-
-template <typename T>
-bool operator>(Span<T> a, Span<const T> b) {
-  return b < a;
-}
-
-template <typename T, typename U,
-          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
-bool operator>(const U& a, Span<T> b) {
-  return b < a;
-}
-
-template <typename T, typename U,
-          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
-bool operator>(Span<T> a, const U& b) {
-  return b < a;
-}
-
-// operator<=
-template <typename T>
-bool operator<=(Span<T> a, Span<T> b) {
-  return !(b < a);
-}
-
-template <typename T>
-bool operator<=(Span<const T> a, Span<T> b) {
-  return !(b < a);
-}
-
-template <typename T>
-bool operator<=(Span<T> a, Span<const T> b) {
-  return !(b < a);
-}
-
-template <typename T, typename U,
-          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
-bool operator<=(const U& a, Span<T> b) {
-  return !(b < a);
-}
-
-template <typename T, typename U,
-          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
-bool operator<=(Span<T> a, const U& b) {
-  return !(b < a);
-}
-
-// operator>=
-template <typename T>
-bool operator>=(Span<T> a, Span<T> b) {
-  return !(a < b);
-}
-
-template <typename T>
-bool operator>=(Span<const T> a, Span<T> b) {
-  return !(a < b);
-}
-
-template <typename T>
-bool operator>=(Span<T> a, Span<const T> b) {
-  return !(a < b);
-}
-
-template <typename T, typename U,
-          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
-bool operator>=(const U& a, Span<T> b) {
-  return !(a < b);
-}
-
-template <typename T, typename U,
-          typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
-bool operator>=(Span<T> a, const U& b) {
-  return !(a < b);
-}
-
-// MakeSpan()
-//
-// Constructs a mutable `Span<T>`, deducing `T` automatically from either a
-// container or pointer+size.
-//
-// Because a read-only `Span<const T>` is implicitly constructed from container
-// types regardless of whether the container itself is a const container,
-// constructing mutable spans of type `Span<T>` from containers requires
-// explicit constructors. The container-accepting version of `MakeSpan()`
-// deduces the type of `T` by the constness of the pointer received from the
-// container's `data()` member. Similarly, the pointer-accepting version returns
-// a `Span<const T>` if `T` is `const`, and a `Span<T>` otherwise.
-//
-// Examples:
-//
-//   void MyRoutine(phmap::Span<MyComplicatedType> a) {
-//     ...
-//   };
-//   // my_vector is a container of non-const types
-//   std::vector<MyComplicatedType> my_vector;
-//
-//   // Constructing a Span implicitly attempts to create a Span of type
-//   // `Span<const T>`
-//   MyRoutine(my_vector);                // error, type mismatch
-//
-//   // Explicitly constructing the Span is verbose
-//   MyRoutine(phmap::Span<MyComplicatedType>(my_vector));
-//
-//   // Use MakeSpan() to make an phmap::Span<T>
-//   MyRoutine(phmap::MakeSpan(my_vector));
-//
-//   // Construct a span from an array ptr+size
-//   phmap::Span<T> my_span() {
-//     return phmap::MakeSpan(&array[0], num_elements_);
-//   }
-//
-template <int&... ExplicitArgumentBarrier, typename T>
-constexpr Span<T> MakeSpan(T* ptr, size_t size) noexcept {
-  return Span<T>(ptr, size);
-}
-
-template <int&... ExplicitArgumentBarrier, typename T>
-Span<T> MakeSpan(T* begin, T* end) noexcept {
-  return PHMAP_ASSERT(begin <= end), Span<T>(begin, end - begin);
-}
-
-template <int&... ExplicitArgumentBarrier, typename C>
-constexpr auto MakeSpan(C& c) noexcept  // NOLINT(runtime/references)
-    -> decltype(phmap::MakeSpan(span_internal::GetData(c), c.size())) {
-  return MakeSpan(span_internal::GetData(c), c.size());
-}
-
-template <int&... ExplicitArgumentBarrier, typename T, size_t N>
-constexpr Span<T> MakeSpan(T (&array)[N]) noexcept {
-  return Span<T>(array, N);
-}
-
-// MakeConstSpan()
-//
-// Constructs a `Span<const T>` as with `MakeSpan`, deducing `T` automatically,
-// but always returning a `Span<const T>`.
-//
-// Examples:
-//
-//   void ProcessInts(phmap::Span<const int> some_ints);
-//
-//   // Call with a pointer and size.
-//   int array[3] = { 0, 0, 0 };
-//   ProcessInts(phmap::MakeConstSpan(&array[0], 3));
-//
-//   // Call with a [begin, end) pair.
-//   ProcessInts(phmap::MakeConstSpan(&array[0], &array[3]));
-//
-//   // Call directly with an array.
-//   ProcessInts(phmap::MakeConstSpan(array));
-//
-//   // Call with a contiguous container.
-//   std::vector<int> some_ints = ...;
-//   ProcessInts(phmap::MakeConstSpan(some_ints));
-//   ProcessInts(phmap::MakeConstSpan(std::vector<int>{ 0, 0, 0 }));
-//
-template <int&... ExplicitArgumentBarrier, typename T>
-constexpr Span<const T> MakeConstSpan(T* ptr, size_t size) noexcept {
-  return Span<const T>(ptr, size);
-}
-
-template <int&... ExplicitArgumentBarrier, typename T>
-Span<const T> MakeConstSpan(T* begin, T* end) noexcept {
-  return PHMAP_ASSERT(begin <= end), Span<const T>(begin, end - begin);
-}
-
-template <int&... ExplicitArgumentBarrier, typename C>
-constexpr auto MakeConstSpan(const C& c) noexcept -> decltype(MakeSpan(c)) {
-  return MakeSpan(c);
-}
-
-template <int&... ExplicitArgumentBarrier, typename T, size_t N>
-constexpr Span<const T> MakeConstSpan(const T (&array)[N]) noexcept {
-  return Span<const T>(array, N);
-}
-}  // namespace phmap
-
-// ---------------------------------------------------------------------------
-//  layout.h
-// ---------------------------------------------------------------------------
-#if defined(__GXX_RTTI)
-    #define PHMAP_INTERNAL_HAS_CXA_DEMANGLE
-#endif
-
-#ifdef PHMAP_INTERNAL_HAS_CXA_DEMANGLE
-    #include <cxxabi.h>
-#endif
-
-namespace phmap {
-namespace priv {
-
-// A type wrapper that instructs `Layout` to use the specific alignment for the
-// array. `Layout<..., Aligned<T, N>, ...>` has exactly the same API
-// and behavior as `Layout<..., T, ...>` except that the first element of the
-// array of `T` is aligned to `N` (the rest of the elements follow without
-// padding).
-//
-// Requires: `N >= alignof(T)` and `N` is a power of 2.
-template <class T, size_t N>
-struct Aligned;
-
-namespace internal_layout {
-
-template <class T>
-struct NotAligned {};
-
-template <class T, size_t N>
-struct NotAligned<const Aligned<T, N>> {
-  static_assert(sizeof(T) == 0, "Aligned<T, N> cannot be const-qualified");
-};
-
-template <size_t>
-using IntToSize = size_t;
-
-template <class>
-using TypeToSize = size_t;
-
-template <class T>
-struct Type : NotAligned<T> {
-    using type = T;
-};
-
-template <class T, size_t N>
-struct Type<Aligned<T, N>> {
-    using type = T;
-};
-
-template <class T>
-struct SizeOf : NotAligned<T>, std::integral_constant<size_t, sizeof(T)> {};
-
-template <class T, size_t N>
-struct SizeOf<Aligned<T, N>> : std::integral_constant<size_t, sizeof(T)> {};
-
-// Note: workaround for https://gcc.gnu.org/PR88115
-template <class T>
-struct AlignOf : NotAligned<T> {
-    static constexpr size_t value = alignof(T);
-};
-
-template <class T, size_t N>
-struct AlignOf<Aligned<T, N>> {
-    static_assert(N % alignof(T) == 0,
-                  "Custom alignment can't be lower than the type's alignment");
-    static constexpr size_t value = N;
-};
-
-// Does `Ts...` contain `T`?
-template <class T, class... Ts>
-using Contains = phmap::disjunction<std::is_same<T, Ts>...>;
-
-template <class From, class To>
-using CopyConst =
-    typename std::conditional<std::is_const<From>::value, const To, To>::type;
-
-// Note: We're not qualifying this with phmap:: because it doesn't compile under
-// MSVC.
-template <class T>
-using SliceType = Span<T>;
-
-// This namespace contains no types. It prevents functions defined in it from
-// being found by ADL.
-namespace adl_barrier {
-
-template <class Needle, class... Ts>
-constexpr size_t Find(Needle, Needle, Ts...) {
-    static_assert(!Contains<Needle, Ts...>(), "Duplicate element type");
-    return 0;
-}
-
-template <class Needle, class T, class... Ts>
-constexpr size_t Find(Needle, T, Ts...) {
-  return adl_barrier::Find(Needle(), Ts()...) + 1;
-}
-
-constexpr bool IsPow2(size_t n) { return !(n & (n - 1)); }
-
-// Returns `q * m` for the smallest `q` such that `q * m >= n`.
-// Requires: `m` is a power of two. It's enforced by IsLegalElementType below.
-constexpr size_t Align(size_t n, size_t m) { return (n + m - 1) & ~(m - 1); }
-
-constexpr size_t Min(size_t a, size_t b) { return b < a ? b : a; }
-
-constexpr size_t Max(size_t a) { return a; }
-
-template <class... Ts>
-constexpr size_t Max(size_t a, size_t b, Ts... rest) {
-    return adl_barrier::Max(b < a ? a : b, rest...);
-}
-
-}  // namespace adl_barrier
-
-template <bool C>
-using EnableIf = typename std::enable_if<C, int>::type;
-
-// Can `T` be a template argument of `Layout`?
-// ---------------------------------------------------------------------------
-template <class T>
-using IsLegalElementType = std::integral_constant<
-    bool, !std::is_reference<T>::value && !std::is_volatile<T>::value &&
-              !std::is_reference<typename Type<T>::type>::value &&
-              !std::is_volatile<typename Type<T>::type>::value &&
-              adl_barrier::IsPow2(AlignOf<T>::value)>;
-
-template <class Elements, class SizeSeq, class OffsetSeq>
-class LayoutImpl;
-
-// ---------------------------------------------------------------------------
-// Public base class of `Layout` and the result type of `Layout::Partial()`.
-//
-// `Elements...` contains all template arguments of `Layout` that created this
-// instance.
-//
-// `SizeSeq...` is `[0, NumSizes)` where `NumSizes` is the number of arguments
-// passed to `Layout::Partial()` or `Layout::Layout()`.
-//
-// `OffsetSeq...` is `[0, NumOffsets)` where `NumOffsets` is
-// `Min(sizeof...(Elements), NumSizes + 1)` (the number of arrays for which we
-// can compute offsets).
-// ---------------------------------------------------------------------------
-template <class... Elements, size_t... SizeSeq, size_t... OffsetSeq>
-class LayoutImpl<std::tuple<Elements...>, phmap::index_sequence<SizeSeq...>,
-                 phmap::index_sequence<OffsetSeq...>> 
-{
-private:
-    static_assert(sizeof...(Elements) > 0, "At least one field is required");
-    static_assert(phmap::conjunction<IsLegalElementType<Elements>...>::value,
-                  "Invalid element type (see IsLegalElementType)");
-
-    enum {
-        NumTypes = sizeof...(Elements),
-        NumSizes = sizeof...(SizeSeq),
-        NumOffsets = sizeof...(OffsetSeq),
-    };
-
-    // These are guaranteed by `Layout`.
-    static_assert(NumOffsets == adl_barrier::Min(NumTypes, NumSizes + 1),
-                  "Internal error");
-    static_assert(NumTypes > 0, "Internal error");
-
-    // Returns the index of `T` in `Elements...`. Results in a compilation error
-    // if `Elements...` doesn't contain exactly one instance of `T`.
-    template <class T>
-        static constexpr size_t ElementIndex() {
-        static_assert(Contains<Type<T>, Type<typename Type<Elements>::type>...>(),
-                      "Type not found");
-        return adl_barrier::Find(Type<T>(),
-                                 Type<typename Type<Elements>::type>()...);
-    }
-
-    template <size_t N>
-        using ElementAlignment =
-        AlignOf<typename std::tuple_element<N, std::tuple<Elements...>>::type>;
-
-public:
-    // Element types of all arrays packed in a tuple.
-    using ElementTypes = std::tuple<typename Type<Elements>::type...>;
-
-    // Element type of the Nth array.
-    template <size_t N>
-        using ElementType = typename std::tuple_element<N, ElementTypes>::type;
-
-    constexpr explicit LayoutImpl(IntToSize<SizeSeq>... sizes)
-        : size_{sizes...} {}
-
-    // Alignment of the layout, equal to the strictest alignment of all elements.
-    // All pointers passed to the methods of layout must be aligned to this value.
-    static constexpr size_t Alignment() {
-        return adl_barrier::Max(AlignOf<Elements>::value...);
-    }
-
-    // Offset in bytes of the Nth array.
-    //
-    //   // int[3], 4 bytes of padding, double[4].
-    //   Layout<int, double> x(3, 4);
-    //   assert(x.Offset<0>() == 0);   // The ints starts from 0.
-    //   assert(x.Offset<1>() == 16);  // The doubles starts from 16.
-    //
-    // Requires: `N <= NumSizes && N < sizeof...(Ts)`.
-    template <size_t N, EnableIf<N == 0> = 0>
-        constexpr size_t Offset() const {
-        return 0;
-    }
-
-    template <size_t N, EnableIf<N != 0> = 0>
-        constexpr size_t Offset() const {
-        static_assert(N < NumOffsets, "Index out of bounds");
-        return adl_barrier::Align(
-            Offset<N - 1>() + SizeOf<ElementType<N - 1>>() * size_[N - 1],
-            ElementAlignment<N>::value);
-    }
-
-    // Offset in bytes of the array with the specified element type. There must
-    // be exactly one such array and its zero-based index must be at most
-    // `NumSizes`.
-    //
-    //   // int[3], 4 bytes of padding, double[4].
-    //   Layout<int, double> x(3, 4);
-    //   assert(x.Offset<int>() == 0);      // The ints starts from 0.
-    //   assert(x.Offset<double>() == 16);  // The doubles starts from 16.
-    template <class T>
-        constexpr size_t Offset() const {
-        return Offset<ElementIndex<T>()>();
-    }
-
-    // Offsets in bytes of all arrays for which the offsets are known.
-    constexpr std::array<size_t, NumOffsets> Offsets() const {
-        return {{Offset<OffsetSeq>()...}};
-    }
-
-    // The number of elements in the Nth array. This is the Nth argument of
-    // `Layout::Partial()` or `Layout::Layout()` (zero-based).
-    //
-    //   // int[3], 4 bytes of padding, double[4].
-    //   Layout<int, double> x(3, 4);
-    //   assert(x.Size<0>() == 3);
-    //   assert(x.Size<1>() == 4);
-    //
-    // Requires: `N < NumSizes`.
-    template <size_t N>
-        constexpr size_t Size() const {
-        static_assert(N < NumSizes, "Index out of bounds");
-        return size_[N];
-    }
-
-    // The number of elements in the array with the specified element type.
-    // There must be exactly one such array and its zero-based index must be
-    // at most `NumSizes`.
-    //
-    //   // int[3], 4 bytes of padding, double[4].
-    //   Layout<int, double> x(3, 4);
-    //   assert(x.Size<int>() == 3);
-    //   assert(x.Size<double>() == 4);
-    template <class T>
-        constexpr size_t Size() const {
-        return Size<ElementIndex<T>()>();
-    }
-
-    // The number of elements of all arrays for which they are known.
-    constexpr std::array<size_t, NumSizes> Sizes() const {
-        return {{Size<SizeSeq>()...}};
-    }
-
-    // Pointer to the beginning of the Nth array.
-    //
-    // `Char` must be `[const] [signed|unsigned] char`.
-    //
-    //   // int[3], 4 bytes of padding, double[4].
-    //   Layout<int, double> x(3, 4);
-    //   unsigned char* p = new unsigned char[x.AllocSize()];
-    //   int* ints = x.Pointer<0>(p);
-    //   double* doubles = x.Pointer<1>(p);
-    //
-    // Requires: `N <= NumSizes && N < sizeof...(Ts)`.
-    // Requires: `p` is aligned to `Alignment()`.
-    template <size_t N, class Char>
-        CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
-        using C = typename std::remove_const<Char>::type;
-        static_assert(
-            std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
-            std::is_same<C, signed char>(),
-            "The argument must be a pointer to [const] [signed|unsigned] char");
-        constexpr size_t alignment = Alignment();
-        (void)alignment;
-        assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
-        return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
-    }
-
-    // Pointer to the beginning of the array with the specified element type.
-    // There must be exactly one such array and its zero-based index must be at
-    // most `NumSizes`.
-    //
-    // `Char` must be `[const] [signed|unsigned] char`.
-    //
-    //   // int[3], 4 bytes of padding, double[4].
-    //   Layout<int, double> x(3, 4);
-    //   unsigned char* p = new unsigned char[x.AllocSize()];
-    //   int* ints = x.Pointer<int>(p);
-    //   double* doubles = x.Pointer<double>(p);
-    //
-    // Requires: `p` is aligned to `Alignment()`.
-    template <class T, class Char>
-        CopyConst<Char, T>* Pointer(Char* p) const {
-        return Pointer<ElementIndex<T>()>(p);
-    }
-
-    // Pointers to all arrays for which pointers are known.
-    //
-    // `Char` must be `[const] [signed|unsigned] char`.
-    //
-    //   // int[3], 4 bytes of padding, double[4].
-    //   Layout<int, double> x(3, 4);
-    //   unsigned char* p = new unsigned char[x.AllocSize()];
-    //
-    //   int* ints;
-    //   double* doubles;
-    //   std::tie(ints, doubles) = x.Pointers(p);
-    //
-    // Requires: `p` is aligned to `Alignment()`.
-    //
-    // Note: We're not using ElementType alias here because it does not compile
-    // under MSVC.
-    template <class Char>
-        std::tuple<CopyConst<
-                       Char, typename std::tuple_element<OffsetSeq, ElementTypes>::type>*...>
-        Pointers(Char* p) const {
-        return std::tuple<CopyConst<Char, ElementType<OffsetSeq>>*...>(
-            Pointer<OffsetSeq>(p)...);
-    }
-
-    // The Nth array.
-    //
-    // `Char` must be `[const] [signed|unsigned] char`.
-    //
-    //   // int[3], 4 bytes of padding, double[4].
-    //   Layout<int, double> x(3, 4);
-    //   unsigned char* p = new unsigned char[x.AllocSize()];
-    //   Span<int> ints = x.Slice<0>(p);
-    //   Span<double> doubles = x.Slice<1>(p);
-    //
-    // Requires: `N < NumSizes`.
-    // Requires: `p` is aligned to `Alignment()`.
-    template <size_t N, class Char>
-        SliceType<CopyConst<Char, ElementType<N>>> Slice(Char* p) const {
-        return SliceType<CopyConst<Char, ElementType<N>>>(Pointer<N>(p), Size<N>());
-    }
-
-    // The array with the specified element type. There must be exactly one
-    // such array and its zero-based index must be less than `NumSizes`.
-    //
-    // `Char` must be `[const] [signed|unsigned] char`.
-    //
-    //   // int[3], 4 bytes of padding, double[4].
-    //   Layout<int, double> x(3, 4);
-    //   unsigned char* p = new unsigned char[x.AllocSize()];
-    //   Span<int> ints = x.Slice<int>(p);
-    //   Span<double> doubles = x.Slice<double>(p);
-    //
-    // Requires: `p` is aligned to `Alignment()`.
-    template <class T, class Char>
-        SliceType<CopyConst<Char, T>> Slice(Char* p) const {
-        return Slice<ElementIndex<T>()>(p);
-    }
-
-    // All arrays with known sizes.
-    //
-    // `Char` must be `[const] [signed|unsigned] char`.
-    //
-    //   // int[3], 4 bytes of padding, double[4].
-    //   Layout<int, double> x(3, 4);
-    //   unsigned char* p = new unsigned char[x.AllocSize()];
-    //
-    //   Span<int> ints;
-    //   Span<double> doubles;
-    //   std::tie(ints, doubles) = x.Slices(p);
-    //
-    // Requires: `p` is aligned to `Alignment()`.
-    //
-    // Note: We're not using ElementType alias here because it does not compile
-    // under MSVC.
-    template <class Char>
-        std::tuple<SliceType<CopyConst<
-                                 Char, typename std::tuple_element<SizeSeq, ElementTypes>::type>>...>
-        Slices(Char* p) const {
-        // Workaround for https://gcc.gnu.org/bugzilla/show_bug.cgi?id=63875 (fixed
-        // in 6.1).
-        (void)p;
-        return std::tuple<SliceType<CopyConst<Char, ElementType<SizeSeq>>>...>(
-            Slice<SizeSeq>(p)...);
-    }
-
-    // The size of the allocation that fits all arrays.
-    //
-    //   // int[3], 4 bytes of padding, double[4].
-    //   Layout<int, double> x(3, 4);
-    //   unsigned char* p = new unsigned char[x.AllocSize()];  // 48 bytes
-    //
-    // Requires: `NumSizes == sizeof...(Ts)`.
-    constexpr size_t AllocSize() const {
-        static_assert(NumTypes == NumSizes, "You must specify sizes of all fields");
-        return Offset<NumTypes - 1>() +
-            SizeOf<ElementType<NumTypes - 1>>() * size_[NumTypes - 1];
-    }
-
-    // If built with --config=asan, poisons padding bytes (if any) in the
-    // allocation. The pointer must point to a memory block at least
-    // `AllocSize()` bytes in length.
-    //
-    // `Char` must be `[const] [signed|unsigned] char`.
-    //
-    // Requires: `p` is aligned to `Alignment()`.
-    template <class Char, size_t N = NumOffsets - 1, EnableIf<N == 0> = 0>
-        void PoisonPadding(const Char* p) const {
-        Pointer<0>(p);  // verify the requirements on `Char` and `p`
-    }
-
-    template <class Char, size_t N = NumOffsets - 1, EnableIf<N != 0> = 0>
-        void PoisonPadding(const Char* p) const {
-        static_assert(N < NumOffsets, "Index out of bounds");
-        (void)p;
-#ifdef ADDRESS_SANITIZER
-        PoisonPadding<Char, N - 1>(p);
-        // The `if` is an optimization. It doesn't affect the observable behaviour.
-        if (ElementAlignment<N - 1>::value % ElementAlignment<N>::value) {
-            size_t start =
-                Offset<N - 1>() + SizeOf<ElementType<N - 1>>() * size_[N - 1];
-            ASAN_POISON_MEMORY_REGION(p + start, Offset<N>() - start);
-        }
-#endif
-    }
-
-private:
-    // Arguments of `Layout::Partial()` or `Layout::Layout()`.
-    size_t size_[NumSizes > 0 ? NumSizes : 1];
-};
-
-template <size_t NumSizes, class... Ts>
-using LayoutType = LayoutImpl<
-    std::tuple<Ts...>, phmap::make_index_sequence<NumSizes>,
-    phmap::make_index_sequence<adl_barrier::Min(sizeof...(Ts), NumSizes + 1)>>;
-
-}  // namespace internal_layout
-
-// ---------------------------------------------------------------------------
-// Descriptor of arrays of various types and sizes laid out in memory one after
-// another. See the top of the file for documentation.
-//
-// Check out the public API of internal_layout::LayoutImpl above. The type is
-// internal to the library but its methods are public, and they are inherited
-// by `Layout`.
-// ---------------------------------------------------------------------------
-template <class... Ts>
-class Layout : public internal_layout::LayoutType<sizeof...(Ts), Ts...> 
-{
-public:
-    static_assert(sizeof...(Ts) > 0, "At least one field is required");
-    static_assert(
-        phmap::conjunction<internal_layout::IsLegalElementType<Ts>...>::value,
-        "Invalid element type (see IsLegalElementType)");
-
-    template <size_t NumSizes>
-    using PartialType = internal_layout::LayoutType<NumSizes, Ts...>;
-
-    template <class... Sizes>
-    static constexpr PartialType<sizeof...(Sizes)> Partial(Sizes&&... sizes) {
-        static_assert(sizeof...(Sizes) <= sizeof...(Ts), "");
-        return PartialType<sizeof...(Sizes)>(phmap::forward<Sizes>(sizes)...);
-    }
-
-    // Creates a layout with the sizes of all arrays specified. If you know
-    // only the sizes of the first N arrays (where N can be zero), you can use
-    // `Partial()` defined above. The constructor is essentially equivalent to
-    // calling `Partial()` and passing in all array sizes; the constructor is
-    // provided as a convenient abbreviation.
-    //
-    // Note: The sizes of the arrays must be specified in number of elements,
-    // not in bytes.
-    constexpr explicit Layout(internal_layout::TypeToSize<Ts>... sizes)
-        : internal_layout::LayoutType<sizeof...(Ts), Ts...>(sizes...) {}
-};
-
-}  // namespace priv
-}  // namespace phmap
-
-// ---------------------------------------------------------------------------
-//  compressed_tuple.h
-// ---------------------------------------------------------------------------
-
-#ifdef _MSC_VER
-    // We need to mark these classes with this declspec to ensure that
-    // CompressedTuple happens.
-    #define PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC __declspec(empty_bases)
-#else  // _MSC_VER
-    #define PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC
-#endif  // _MSC_VER
-
-namespace phmap {
-namespace priv {
-
-template <typename... Ts>
-class CompressedTuple;
-
-namespace internal_compressed_tuple {
-
-template <typename D, size_t I>
-struct Elem;
-template <typename... B, size_t I>
-struct Elem<CompressedTuple<B...>, I>
-    : std::tuple_element<I, std::tuple<B...>> {};
-template <typename D, size_t I>
-using ElemT = typename Elem<D, I>::type;
-
-// ---------------------------------------------------------------------------
-// Use the __is_final intrinsic if available. Where it's not available, classes
-// declared with the 'final' specifier cannot be used as CompressedTuple
-// elements.
-// TODO(sbenza): Replace this with std::is_final in C++14.
-// ---------------------------------------------------------------------------
-template <typename T>
-constexpr bool IsFinal() {
-#if defined(__clang__) || defined(__GNUC__)
-    return __is_final(T);
-#else
-    return false;
-#endif
-}
-
-template <typename T>
-constexpr bool ShouldUseBase() {
-#ifdef __INTEL_COMPILER
-    // avoid crash in Intel compiler
-    // assertion failed at: "shared/cfe/edgcpfe/lower_init.c", line 7013
-    return false; 
-#else
-    return std::is_class<T>::value && std::is_empty<T>::value && !IsFinal<T>();
-#endif
-}
-
-// The storage class provides two specializations:
-//  - For empty classes, it stores T as a base class.
-//  - For everything else, it stores T as a member.
-// ------------------------------------------------
-template <typename D, size_t I, bool = ShouldUseBase<ElemT<D, I>>()>
-struct Storage 
-{
-    using T = ElemT<D, I>;
-    T value;
-    constexpr Storage() = default;
-    explicit constexpr Storage(T&& v) : value(phmap::forward<T>(v)) {}
-    constexpr const T& get() const& { return value; }
-    T& get() & { return value; }
-    constexpr const T&& get() const&& { return phmap::move(*this).value; }
-    T&& get() && { return std::move(*this).value; }
-};
-
-template <typename D, size_t I>
-struct PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC Storage<D, I, true>
-    : ElemT<D, I> 
-{
-    using T = internal_compressed_tuple::ElemT<D, I>;
-    constexpr Storage() = default;
-    explicit constexpr Storage(T&& v) : T(phmap::forward<T>(v)) {}
-    constexpr const T& get() const& { return *this; }
-    T& get() & { return *this; }
-    constexpr const T&& get() const&& { return phmap::move(*this); }
-    T&& get() && { return std::move(*this); }
-};
-
-template <typename D, typename I>
-struct PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl;
-
-template <typename... Ts, size_t... I>
-struct PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC
-    CompressedTupleImpl<CompressedTuple<Ts...>, phmap::index_sequence<I...>>
-    // We use the dummy identity function through std::integral_constant to
-    // convince MSVC of accepting and expanding I in that context. Without it
-    // you would get:
-    //   error C3548: 'I': parameter pack cannot be used in this context
-    : Storage<CompressedTuple<Ts...>,
-              std::integral_constant<size_t, I>::value>... 
-{
-    constexpr CompressedTupleImpl() = default;
-    explicit constexpr CompressedTupleImpl(Ts&&... args)
-        : Storage<CompressedTuple<Ts...>, I>(phmap::forward<Ts>(args))... {}
-};
-
-}  // namespace internal_compressed_tuple
-
-// ---------------------------------------------------------------------------
-// Helper class to perform the Empty Base Class Optimization.
-// Ts can contain classes and non-classes, empty or not. For the ones that
-// are empty classes, we perform the CompressedTuple. If all types in Ts are
-// empty classes, then CompressedTuple<Ts...> is itself an empty class.
-//
-// To access the members, use member .get<N>() function.
-//
-// Eg:
-//   phmap::priv::CompressedTuple<int, T1, T2, T3> value(7, t1, t2,
-//                                                                    t3);
-//   assert(value.get<0>() == 7);
-//   T1& t1 = value.get<1>();
-//   const T2& t2 = value.get<2>();
-//   ...
-//
-// https://en.cppreference.com/w/cpp/language/ebo
-// ---------------------------------------------------------------------------
-template <typename... Ts>
-class PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple
-    : private internal_compressed_tuple::CompressedTupleImpl<
-          CompressedTuple<Ts...>, phmap::index_sequence_for<Ts...>> 
-{
-private:
-    template <int I>
-        using ElemT = internal_compressed_tuple::ElemT<CompressedTuple, I>;
-
-public:
-    constexpr CompressedTuple() = default;
-    explicit constexpr CompressedTuple(Ts... base)
-        : CompressedTuple::CompressedTupleImpl(phmap::forward<Ts>(base)...) {}
-
-    template <int I>
-        ElemT<I>& get() & {
-        return internal_compressed_tuple::Storage<CompressedTuple, I>::get();
-    }
-
-    template <int I>
-        constexpr const ElemT<I>& get() const& {
-        return internal_compressed_tuple::Storage<CompressedTuple, I>::get();
-    }
-
-    template <int I>
-        ElemT<I>&& get() && {
-        return std::move(*this)
-            .internal_compressed_tuple::template Storage<CompressedTuple, I>::get();
-    }
-
-    template <int I>
-        constexpr const ElemT<I>&& get() const&& {
-        return phmap::move(*this)
-            .internal_compressed_tuple::template Storage<CompressedTuple, I>::get();
-    }
-};
-
-// Explicit specialization for a zero-element tuple
-// (needed to avoid ambiguous overloads for the default constructor).
-// ---------------------------------------------------------------------------
-template <>
-class PHMAP_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple<> {};
-
-}  // namespace priv
-}  // namespace phmap
-
-
-namespace phmap {
-namespace priv {
-
-#ifdef _MSC_VER
-    #pragma warning(push)  
-    // warning warning C4324: structure was padded due to alignment specifier
-    #pragma warning(disable : 4324)
-#endif
-
-
-// ----------------------------------------------------------------------------
-// Allocates at least n bytes aligned to the specified alignment.
-// Alignment must be a power of 2. It must be positive.
-//
-// Note that many allocators don't honor alignment requirements above certain
-// threshold (usually either alignof(std::max_align_t) or alignof(void*)).
-// Allocate() doesn't apply alignment corrections. If the underlying allocator
-// returns insufficiently alignment pointer, that's what you are going to get.
-// ----------------------------------------------------------------------------
-template <size_t Alignment, class Alloc>
-void* Allocate(Alloc* alloc, size_t n) {
-  static_assert(Alignment > 0, "");
-  assert(n && "n must be positive");
-  struct alignas(Alignment) M {};
-  using A = typename phmap::allocator_traits<Alloc>::template rebind_alloc<M>;
-  using AT = typename phmap::allocator_traits<Alloc>::template rebind_traits<M>;
-  A mem_alloc(*alloc);
-  void* p = AT::allocate(mem_alloc, (n + sizeof(M) - 1) / sizeof(M));
-  assert(reinterpret_cast<uintptr_t>(p) % Alignment == 0 &&
-         "allocator does not respect alignment");
-  return p;
-}
-
-// ----------------------------------------------------------------------------
-// The pointer must have been previously obtained by calling
-// Allocate<Alignment>(alloc, n).
-// ----------------------------------------------------------------------------
-template <size_t Alignment, class Alloc>
-void Deallocate(Alloc* alloc, void* p, size_t n) {
-  static_assert(Alignment > 0, "");
-  assert(n && "n must be positive");
-  struct alignas(Alignment) M {};
-  using A = typename phmap::allocator_traits<Alloc>::template rebind_alloc<M>;
-  using AT = typename phmap::allocator_traits<Alloc>::template rebind_traits<M>;
-  A mem_alloc(*alloc);
-  AT::deallocate(mem_alloc, static_cast<M*>(p),
-                 (n + sizeof(M) - 1) / sizeof(M));
-}
-
-#ifdef _MSC_VER
-     #pragma warning(pop)  
-#endif
-
-// Helper functions for asan and msan.
-// ----------------------------------------------------------------------------
-inline void SanitizerPoisonMemoryRegion(const void* m, size_t s) {
-#ifdef ADDRESS_SANITIZER
-    ASAN_POISON_MEMORY_REGION(m, s);
-#endif
-#ifdef MEMORY_SANITIZER
-    __msan_poison(m, s);
-#endif
-    (void)m;
-    (void)s;
-}
-
-inline void SanitizerUnpoisonMemoryRegion(const void* m, size_t s) {
-#ifdef ADDRESS_SANITIZER
-    ASAN_UNPOISON_MEMORY_REGION(m, s);
-#endif
-#ifdef MEMORY_SANITIZER
-    __msan_unpoison(m, s);
-#endif
-    (void)m;
-    (void)s;
-}
-
-template <typename T>
-inline void SanitizerPoisonObject(const T* object) {
-    SanitizerPoisonMemoryRegion(object, sizeof(T));
-}
-
-template <typename T>
-inline void SanitizerUnpoisonObject(const T* object) {
-    SanitizerUnpoisonMemoryRegion(object, sizeof(T));
-}
-
-}  // namespace priv
-}  // namespace phmap
-
-
-// ---------------------------------------------------------------------------
-//  thread_annotations.h
-// ---------------------------------------------------------------------------
-
-#if defined(__clang__)
-    #define PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(x)   __attribute__((x))
-#else
-    #define PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(x)   // no-op
-#endif
-
-#define PHMAP_GUARDED_BY(x) PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x))
-#define PHMAP_PT_GUARDED_BY(x) PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_by(x))
-
-#define PHMAP_ACQUIRED_AFTER(...) \
-  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(__VA_ARGS__))
-
-#define PHMAP_ACQUIRED_BEFORE(...) \
-  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(__VA_ARGS__))
-
-#define PHMAP_EXCLUSIVE_LOCKS_REQUIRED(...) \
-  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(__VA_ARGS__))
-
-#define PHMAP_SHARED_LOCKS_REQUIRED(...) \
-  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(shared_locks_required(__VA_ARGS__))
-
-#define PHMAP_LOCKS_EXCLUDED(...) \
-  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__))
-
-#define PHMAP_LOCK_RETURNED(x) \
-  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x))
-
-#define PHMAP_LOCKABLE \
-  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(lockable)
-
-#define PHMAP_SCOPED_LOCKABLE \
-  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable)
-
-#define PHMAP_EXCLUSIVE_LOCK_FUNCTION(...) \
-  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_lock_function(__VA_ARGS__))
-
-#define PHMAP_SHARED_LOCK_FUNCTION(...) \
-  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(shared_lock_function(__VA_ARGS__))
-
-#define PHMAP_UNLOCK_FUNCTION(...) \
-  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(unlock_function(__VA_ARGS__))
-
-#define PHMAP_EXCLUSIVE_TRYLOCK_FUNCTION(...) \
-  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_trylock_function(__VA_ARGS__))
-
-#define PHMAP_SHARED_TRYLOCK_FUNCTION(...) \
-  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(shared_trylock_function(__VA_ARGS__))
-
-#define PHMAP_ASSERT_EXCLUSIVE_LOCK(...) \
-  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(assert_exclusive_lock(__VA_ARGS__))
-
-#define PHMAP_ASSERT_SHARED_LOCK(...) \
-  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(assert_shared_lock(__VA_ARGS__))
-
-#define PHMAP_NO_THREAD_SAFETY_ANALYSIS \
-  PHMAP_THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis)
-
-//------------------------------------------------------------------------------
-// Tool-Supplied Annotations
-//------------------------------------------------------------------------------
-
-// TS_UNCHECKED should be placed around lock expressions that are not valid
-// C++ syntax, but which are present for documentation purposes.  These
-// annotations will be ignored by the analysis.
-#define PHMAP_TS_UNCHECKED(x) ""
-
-// TS_FIXME is used to mark lock expressions that are not valid C++ syntax.
-// It is used by automated tools to mark and disable invalid expressions.
-// The annotation should either be fixed, or changed to TS_UNCHECKED.
-#define PHMAP_TS_FIXME(x) ""
-
-// Like NO_THREAD_SAFETY_ANALYSIS, this turns off checking within the body of
-// a particular function.  However, this attribute is used to mark functions
-// that are incorrect and need to be fixed.  It is used by automated tools to
-// avoid breaking the build when the analysis is updated.
-// Code owners are expected to eventually fix the routine.
-#define PHMAP_NO_THREAD_SAFETY_ANALYSIS_FIXME  PHMAP_NO_THREAD_SAFETY_ANALYSIS
-
-// Similar to NO_THREAD_SAFETY_ANALYSIS_FIXME, this macro marks a GUARDED_BY
-// annotation that needs to be fixed, because it is producing thread safety
-// warning.  It disables the GUARDED_BY.
-#define PHMAP_GUARDED_BY_FIXME(x)
-
-// Disables warnings for a single read operation.  This can be used to avoid
-// warnings when it is known that the read is not actually involved in a race,
-// but the compiler cannot confirm that.
-#define PHMAP_TS_UNCHECKED_READ(x) thread_safety_analysis::ts_unchecked_read(x)
-
-
-namespace phmap {
-namespace thread_safety_analysis {
-
-// Takes a reference to a guarded data member, and returns an unguarded
-// reference.
-template <typename T>
-inline const T& ts_unchecked_read(const T& v) PHMAP_NO_THREAD_SAFETY_ANALYSIS {
-    return v;
-}
-
-template <typename T>
-inline T& ts_unchecked_read(T& v) PHMAP_NO_THREAD_SAFETY_ANALYSIS {
-    return v;
-}
-
-}  // namespace thread_safety_analysis
-
-namespace priv {
-
-namespace memory_internal {
-
-// ----------------------------------------------------------------------------
-// If Pair is a standard-layout type, OffsetOf<Pair>::kFirst and
-// OffsetOf<Pair>::kSecond are equivalent to offsetof(Pair, first) and
-// offsetof(Pair, second) respectively. Otherwise they are -1.
-//
-// The purpose of OffsetOf is to avoid calling offsetof() on non-standard-layout
-// type, which is non-portable.
-// ----------------------------------------------------------------------------
-template <class Pair, class = std::true_type>
-struct OffsetOf {
-    static constexpr size_t kFirst = (size_t)-1;
-  static constexpr size_t kSecond = (size_t)-1;
-};
-
-template <class Pair>
-struct OffsetOf<Pair, typename std::is_standard_layout<Pair>::type> 
-{
-    static constexpr size_t kFirst = offsetof(Pair, first);
-    static constexpr size_t kSecond = offsetof(Pair, second);
-};
-
-// ----------------------------------------------------------------------------
-template <class K, class V>
-struct IsLayoutCompatible 
-{
-private:
-    struct Pair {
-        K first;
-        V second;
-    };
-
-    // Is P layout-compatible with Pair?
-    template <class P>
-    static constexpr bool LayoutCompatible() {
-        return std::is_standard_layout<P>() && sizeof(P) == sizeof(Pair) &&
-            alignof(P) == alignof(Pair) &&
-            memory_internal::OffsetOf<P>::kFirst ==
-            memory_internal::OffsetOf<Pair>::kFirst &&
-            memory_internal::OffsetOf<P>::kSecond ==
-            memory_internal::OffsetOf<Pair>::kSecond;
-    }
-
-public:
-    // Whether pair<const K, V> and pair<K, V> are layout-compatible. If they are,
-    // then it is safe to store them in a union and read from either.
-    static constexpr bool value = std::is_standard_layout<K>() &&
-        std::is_standard_layout<Pair>() &&
-        memory_internal::OffsetOf<Pair>::kFirst == 0 &&
-        LayoutCompatible<std::pair<K, V>>() &&
-        LayoutCompatible<std::pair<const K, V>>();
-};
-
-}  // namespace memory_internal
-
-// ----------------------------------------------------------------------------
-// The internal storage type for key-value containers like flat_hash_map.
-//
-// It is convenient for the value_type of a flat_hash_map<K, V> to be
-// pair<const K, V>; the "const K" prevents accidental modification of the key
-// when dealing with the reference returned from find() and similar methods.
-// However, this creates other problems; we want to be able to emplace(K, V)
-// efficiently with move operations, and similarly be able to move a
-// pair<K, V> in insert().
-//
-// The solution is this union, which aliases the const and non-const versions
-// of the pair. This also allows flat_hash_map<const K, V> to work, even though
-// that has the same efficiency issues with move in emplace() and insert() -
-// but people do it anyway.
-//
-// If kMutableKeys is false, only the value member can be accessed.
-//
-// If kMutableKeys is true, key can be accessed through all slots while value
-// and mutable_value must be accessed only via INITIALIZED slots. Slots are
-// created and destroyed via mutable_value so that the key can be moved later.
-//
-// Accessing one of the union fields while the other is active is safe as
-// long as they are layout-compatible, which is guaranteed by the definition of
-// kMutableKeys. For C++11, the relevant section of the standard is
-// https://timsong-cpp.github.io/cppwp/n3337/class.mem#19 (9.2.19)
-// ----------------------------------------------------------------------------
-template <class K, class V>
-union map_slot_type 
-{
-    map_slot_type() {}
-    ~map_slot_type() = delete;
-    map_slot_type(const map_slot_type&) = delete;
-    map_slot_type& operator=(const map_slot_type&) = delete;
-
-    using value_type = std::pair<const K, V>;
-    using mutable_value_type = std::pair<K, V>;
-
-    value_type value;
-    mutable_value_type mutable_value;
-    K key;
-};
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-template <class K, class V>
-struct map_slot_policy 
-{
-    using slot_type = map_slot_type<K, V>;
-    using value_type = std::pair<const K, V>;
-    using mutable_value_type = std::pair<K, V>;
-
-private:
-    static void emplace(slot_type* slot) {
-        // The construction of union doesn't do anything at runtime but it allows us
-        // to access its members without violating aliasing rules.
-        new (slot) slot_type;
-    }
-    // If pair<const K, V> and pair<K, V> are layout-compatible, we can accept one
-    // or the other via slot_type. We are also free to access the key via
-    // slot_type::key in this case.
-    using kMutableKeys = memory_internal::IsLayoutCompatible<K, V>;
-
-public:
-    static value_type& element(slot_type* slot) { return slot->value; }
-    static const value_type& element(const slot_type* slot) {
-        return slot->value;
-    }
-
-    static const K& key(const slot_type* slot) {
-        return kMutableKeys::value ? slot->key : slot->value.first;
-    }
-
-    template <class Allocator, class... Args>
-    static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
-        emplace(slot);
-        if (kMutableKeys::value) {
-            phmap::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
-                                                         std::forward<Args>(args)...);
-        } else {
-            phmap::allocator_traits<Allocator>::construct(*alloc, &slot->value,
-                                                         std::forward<Args>(args)...);
-        }
-    }
-
-    // Construct this slot by moving from another slot.
-    template <class Allocator>
-    static void construct(Allocator* alloc, slot_type* slot, slot_type* other) {
-        emplace(slot);
-        if (kMutableKeys::value) {
-            phmap::allocator_traits<Allocator>::construct(
-                *alloc, &slot->mutable_value, std::move(other->mutable_value));
-        } else {
-            phmap::allocator_traits<Allocator>::construct(*alloc, &slot->value,
-                                                         std::move(other->value));
-        }
-    }
-
-    template <class Allocator>
-    static void destroy(Allocator* alloc, slot_type* slot) {
-        if (kMutableKeys::value) {
-            phmap::allocator_traits<Allocator>::destroy(*alloc, &slot->mutable_value);
-        } else {
-            phmap::allocator_traits<Allocator>::destroy(*alloc, &slot->value);
-        }
-    }
-
-    template <class Allocator>
-    static void transfer(Allocator* alloc, slot_type* new_slot,
-                         slot_type* old_slot) {
-        emplace(new_slot);
-        if (kMutableKeys::value) {
-            phmap::allocator_traits<Allocator>::construct(
-                *alloc, &new_slot->mutable_value, std::move(old_slot->mutable_value));
-        } else {
-            phmap::allocator_traits<Allocator>::construct(*alloc, &new_slot->value,
-                                                         std::move(old_slot->value));
-        }
-        destroy(alloc, old_slot);
-    }
-
-    template <class Allocator>
-    static void swap(Allocator* alloc, slot_type* a, slot_type* b) {
-        if (kMutableKeys::value) {
-            using std::swap;
-            swap(a->mutable_value, b->mutable_value);
-        } else {
-            value_type tmp = std::move(a->value);
-            phmap::allocator_traits<Allocator>::destroy(*alloc, &a->value);
-            phmap::allocator_traits<Allocator>::construct(*alloc, &a->value,
-                                                         std::move(b->value));
-            phmap::allocator_traits<Allocator>::destroy(*alloc, &b->value);
-            phmap::allocator_traits<Allocator>::construct(*alloc, &b->value,
-                                                         std::move(tmp));
-        }
-    }
-
-    template <class Allocator>
-    static void move(Allocator* alloc, slot_type* src, slot_type* dest) {
-        if (kMutableKeys::value) {
-            dest->mutable_value = std::move(src->mutable_value);
-        } else {
-            phmap::allocator_traits<Allocator>::destroy(*alloc, &dest->value);
-            phmap::allocator_traits<Allocator>::construct(*alloc, &dest->value,
-                                                          std::move(src->value));
-        }
-    }
-
-    template <class Allocator>
-    static void move(Allocator* alloc, slot_type* first, slot_type* last,
-                     slot_type* result) {
-        for (slot_type *src = first, *dest = result; src != last; ++src, ++dest)
-            move(alloc, src, dest);
-    }
-};
-
-}  // namespace priv
-}  // phmap
-
-
-namespace phmap {
-
-#ifdef BOOST_THREAD_LOCK_OPTIONS_HPP
-    using defer_lock_t  = boost::defer_lock_t;
-    using try_to_lock_t = boost::try_to_lock_t;
-    using adopt_lock_t  = boost::adopt_lock_t;
-#else
-    struct adopt_lock_t  { explicit adopt_lock_t() = default; };
-    struct defer_lock_t  { explicit defer_lock_t() = default; };
-    struct try_to_lock_t { explicit try_to_lock_t() = default; };
-#endif
-
-// -----------------------------------------------------------------------------
-// NullMutex
-// -----------------------------------------------------------------------------
-// A class that implements the Mutex interface, but does nothing. This is to be 
-// used as a default template parameters for classes who provide optional 
-// internal locking (like phmap::parallel_flat_hash_map).
-// -----------------------------------------------------------------------------
-class NullMutex {
-public:
-    NullMutex() {}
-    ~NullMutex() {}
-    void lock() {}
-    void unlock() {}
-    bool try_lock() { return true; }
-    void lock_shared() {}
-    void unlock_shared() {}
-    bool try_lock_shared() { return true; }
-};
-
-// ------------------------ lockable object used internally -------------------------
-template <class MutexType>
-class LockableBaseImpl 
-{
-public:
-    // ----------------------------------------------------
-    struct DoNothing
-    {
-        using mutex_type = MutexType;  
-        DoNothing() noexcept {}
-        explicit DoNothing(mutex_type& ) noexcept {}
-        explicit DoNothing(mutex_type& , mutex_type&) noexcept {}
-        DoNothing(mutex_type&, phmap::adopt_lock_t) noexcept {}
-        DoNothing(mutex_type&, phmap::defer_lock_t) noexcept {}
-        DoNothing(mutex_type&, phmap::try_to_lock_t) {}
-        template<class T> explicit DoNothing(T&&) {}
-        DoNothing& operator=(const DoNothing&) { return *this; }
-        DoNothing& operator=(DoNothing&&) { return *this; }
-        void swap(DoNothing &) {}
-        bool owns_lock() const noexcept { return true; }
-    };
-
-    // ----------------------------------------------------
-    class WriteLock
-    {
-    public:
-        using mutex_type = MutexType;
-
-        WriteLock() :  m_(nullptr), locked_(false)  {}
-
-        explicit WriteLock(mutex_type &m) : m_(&m) { 
-            m_->lock(); 
-            locked_ = true; 
-        }
-
-        WriteLock(mutex_type& m, adopt_lock_t) noexcept :
-            m_(&m), locked_(true) 
-        {}
-
-        WriteLock(mutex_type& m, defer_lock_t) noexcept :
-            m_(&m), locked_(false) 
-        {}
-
-        WriteLock(mutex_type& m, try_to_lock_t)  :
-            m_(&m), locked_(false) { 
-            m_->try_lock(); 
-        }
-
-        WriteLock(WriteLock &&o) :
-            m_(std::move(o.m_)), locked_(std::move(o.locked_)) {
-            o.locked_ = false;
-            o.m_      = nullptr;
-        }
-
-        WriteLock& operator=(WriteLock&& other) {
-            WriteLock temp(std::move(other));
-            swap(temp);
-            return *this;
-        }
-
-        ~WriteLock() {
-            if (locked_) 
-                m_->unlock(); 
-        }
-
-        void lock() { 
-            if (!locked_) { 
-                m_->lock(); 
-                locked_ = true; 
-            }
-        }
-
-        void unlock() { 
-            if (locked_) {
-                m_->unlock(); 
-                locked_ = false;
-            }
-        } 
-
-        bool try_lock() { 
-            if (locked_)
-                return true;
-            locked_ = m_->try_lock(); 
-            return locked_;
-        }
-        
-        bool owns_lock() const noexcept { return locked_; }
-
-        void swap(WriteLock &o) noexcept { 
-            std::swap(m_, o.m_);
-            std::swap(locked_, o.locked_);
-        }
-
-        mutex_type *mutex() const noexcept { return m_; }
-
-    private:
-        mutex_type *m_;
-        bool        locked_;
-    };
-
-    // ----------------------------------------------------
-    class ReadLock
-    {
-    public:
-        using mutex_type = MutexType;
-
-        ReadLock() :  m_(nullptr), locked_(false)  {}
-
-        explicit ReadLock(mutex_type &m) : m_(&m) { 
-            m_->lock_shared(); 
-            locked_ = true; 
-        }
-
-        ReadLock(mutex_type& m, adopt_lock_t) noexcept :
-            m_(&m), locked_(true) 
-        {}
-
-        ReadLock(mutex_type& m, defer_lock_t) noexcept :
-            m_(&m), locked_(false) 
-        {}
-
-        ReadLock(mutex_type& m, try_to_lock_t)  :
-            m_(&m), locked_(false) { 
-            m_->try_lock_shared(); 
-        }
-
-        ReadLock(ReadLock &&o) :
-            m_(std::move(o.m_)), locked_(std::move(o.locked_)) {
-            o.locked_ = false;
-            o.m_      = nullptr;
-        }
-
-        ReadLock& operator=(ReadLock&& other) {
-            ReadLock temp(std::move(other));
-            swap(temp);
-            return *this;
-        }
-
-        ~ReadLock() {
-            if (locked_) 
-                m_->unlock_shared(); 
-        }
-
-        void lock() { 
-            if (!locked_) { 
-                m_->lock_shared(); 
-                locked_ = true; 
-            }
-        }
-
-        void unlock() { 
-            if (locked_) {
-                m_->unlock_shared(); 
-                locked_ = false;
-            }
-        } 
-
-        bool try_lock() { 
-            if (locked_)
-                return true;
-            locked_ = m_->try_lock_shared(); 
-            return locked_;
-        }
-        
-        bool owns_lock() const noexcept { return locked_; }
-
-        void swap(ReadLock &o) noexcept { 
-            std::swap(m_, o.m_);
-            std::swap(locked_, o.locked_);
-        }
-
-        mutex_type *mutex() const noexcept { return m_; }
-
-    private:
-        mutex_type *m_;
-        bool        locked_;
-    };
-
-    // ----------------------------------------------------
-    class WriteLocks
-    {
-    public:
-        using mutex_type = MutexType;  
-
-        explicit WriteLocks(mutex_type& m1, mutex_type& m2) : 
-            _m1(m1), _m2(m2)
-        { 
-            std::lock(m1, m2); 
-        }
-
-        WriteLocks(adopt_lock_t, mutex_type& m1, mutex_type& m2) :
-            _m1(m1), _m2(m2)
-        { // adopt means we already own the mutexes
-        }
-
-        ~WriteLocks()
-        {
-            _m1.unlock();
-            _m2.unlock();
-        }
-
-        WriteLocks(WriteLocks const&) = delete;
-        WriteLocks& operator=(WriteLocks const&) = delete;
-    private:
-        mutex_type& _m1;
-        mutex_type& _m2;
-    };
-
-    // ----------------------------------------------------
-    class ReadLocks
-    {
-    public:
-        using mutex_type = MutexType;  
-
-        explicit ReadLocks(mutex_type& m1, mutex_type& m2) : 
-            _m1(m1), _m2(m2)
-        { 
-            _m1.lock_shared(); 
-            _m2.lock_shared(); 
-        }
-
-        ReadLocks(adopt_lock_t, mutex_type& m1, mutex_type& m2) :
-            _m1(m1), _m2(m2)
-        { // adopt means we already own the mutexes
-        }
-
-        ~ReadLocks()
-        {
-            _m1.unlock_shared();
-            _m2.unlock_shared();
-        }
-
-        ReadLocks(ReadLocks const&) = delete;
-        ReadLocks& operator=(ReadLocks const&) = delete;
-    private:
-        mutex_type& _m1;
-        mutex_type& _m2;
-    };
-};
-
-// ------------------------ holds a mutex ------------------------------------
-// Default implementation for Lockable, should work fine for std::mutex 
-// -----------------------------------
-// use as:
-//    using Lockable = phmap::LockableImpl<mutex_type>;
-//    Lockable m;
-//  
-//    Lockable::UpgradeLock read_lock(m); // take a upgradable lock
-//
-//    {
-//        Lockable::UpgradeToUnique unique_lock(read_lock);
-//        // now locked for write
-//    }
-//
-// ---------------------------------------------------------------------------
-//         Generic mutex support (always write locks)
-// --------------------------------------------------------------------------
-template <class Mtx_>
-class LockableImpl : public Mtx_
-{
-public:
-    using mutex_type      = Mtx_;
-    using Base            = LockableBaseImpl<Mtx_>;
-    using SharedLock      = typename Base::WriteLock;
-    using UpgradeLock     = typename Base::WriteLock;
-    using UniqueLock      = typename Base::WriteLock;
-    using SharedLocks     = typename Base::WriteLocks;
-    using UniqueLocks     = typename Base::WriteLocks;
-    using UpgradeToUnique = typename Base::DoNothing;        // we already have unique ownership
-};
-
-// ---------------------------------------------------------------------------
-//          Null mutex (no-op) - when we don't want internal synchronization
-// ---------------------------------------------------------------------------
-template <>
-class  LockableImpl<phmap::NullMutex>: public phmap::NullMutex
-{
-public:
-    using mutex_type      = phmap::NullMutex;
-    using Base            = LockableBaseImpl<phmap::NullMutex>;
-    using SharedLock      = typename Base::DoNothing; 
-    using UpgradeLock     = typename Base::DoNothing; 
-    using UniqueLock      = typename Base::DoNothing; 
-    using UpgradeToUnique = typename Base::DoNothing; 
-    using SharedLocks     = typename Base::DoNothing;
-    using UniqueLocks     = typename Base::DoNothing;
-};
-
-// --------------------------------------------------------------------------
-//         Abseil Mutex support (read and write lock support)
-// --------------------------------------------------------------------------
-#ifdef ABSL_SYNCHRONIZATION_MUTEX_H_
-    
-    struct AbslMutex : protected absl::Mutex
-    {
-        void lock()            { this->Lock(); }
-        void unlock()          { this->Unlock(); }
-        void try_lock()        { this->TryLock(); }
-        void lock_shared()     { this->ReaderLock(); }
-        void unlock_shared()   { this->ReaderUnlock(); }
-        void try_lock_shared() { this->ReaderTryLock(); }
-    };
-    
-    template <>
-    class  LockableImpl<absl::Mutex> : public AbslMutex
-    {
-    public:
-        using mutex_type      = phmap::AbslMutex;
-        using Base            = LockableBaseImpl<phmap::AbslMutex>;
-        using SharedLock      = typename Base::ReadLock;
-        using UpgradeLock     = typename Base::WriteLock;
-        using UniqueLock      = typename Base::WriteLock;
-        using SharedLocks     = typename Base::ReadLocks;
-        using UniqueLocks     = typename Base::WriteLocks;
-        using UpgradeToUnique = typename Base::DoNothing; // we already have unique ownership
-    };
-
-#endif
-
-// --------------------------------------------------------------------------
-//         Boost shared_mutex support (read and write lock support)
-// --------------------------------------------------------------------------
-#ifdef BOOST_THREAD_SHARED_MUTEX_HPP
-
-#if 1
-    // ---------------------------------------------------------------------------
-    template <>
-    class  LockableImpl<boost::shared_mutex> : public boost::shared_mutex
-    {
-    public:
-        using mutex_type      = boost::shared_mutex;
-        using Base            = LockableBaseImpl<boost::shared_mutex>;
-        using SharedLock      = boost::shared_lock<mutex_type>;
-        using UpgradeLock     = boost::unique_lock<mutex_type>; // assume can't upgrade
-        using UniqueLock      = boost::unique_lock<mutex_type>;
-        using SharedLocks     = typename Base::ReadLocks;
-        using UniqueLocks     = typename Base::WriteLocks;
-        using UpgradeToUnique = typename Base::DoNothing;  // we already have unique ownership
-    };
-#else
-    // ---------------------------------------------------------------------------
-    template <>
-    class  LockableImpl<boost::upgrade_mutex> : public boost::upgrade_mutex
-    {
-    public:
-        using mutex_type      = boost::upgrade_mutex;
-        using SharedLock      = boost::shared_lock<mutex_type>;
-        using UpgradeLock     = boost::upgrade_lock<mutex_type>;
-        using UniqueLock      = boost::unique_lock<mutex_type>;
-        using SharedLocks     = typename Base::ReadLocks;
-        using UniqueLocks     = typename Base::WriteLocks;
-        using UpgradeToUnique = boost::upgrade_to_unique_lock<mutex_type>;
-    };
-#endif
-
-#endif // BOOST_THREAD_SHARED_MUTEX_HPP
-
-// --------------------------------------------------------------------------
-//         std::shared_mutex support (read and write lock support)
-// --------------------------------------------------------------------------
-#ifdef PHMAP_HAVE_SHARED_MUTEX
-
-    // ---------------------------------------------------------------------------
-    template <>
-    class  LockableImpl<std::shared_mutex> : public std::shared_mutex
-    {
-    public:
-        using mutex_type      = std::shared_mutex;
-        using Base            = LockableBaseImpl<std::shared_mutex>;
-        using SharedLock      = std::shared_lock<mutex_type>;
-        using UpgradeLock     = std::unique_lock<mutex_type>; // assume can't upgrade
-        using UniqueLock      = std::unique_lock<mutex_type>;
-        using SharedLocks     = typename Base::ReadLocks;
-        using UniqueLocks     = typename Base::WriteLocks;
-        using UpgradeToUnique = typename Base::DoNothing;  // we already have unique ownership
-    };
-#endif // PHMAP_HAVE_SHARED_MUTEX
-
-
-}  // phmap
-
-#ifdef _MSC_VER
-     #pragma warning(pop)  
-#endif
-
-
-#endif // phmap_base_h_guard_
-- 
cgit v1.2.3