chore(3p/abseil_cpp): unvendor abseil_cpp r/3786

we weren't actually using these sources anymore, okay?

Change-Id: If701571d9716de308d3512e1eb22c35db0877a66
Reviewed-on: https://cl.tvl.fyi/c/depot/+/5248
Tested-by: BuildkiteCI
Reviewed-by: grfn <grfn@gws.fyi>
Autosubmit: tazjin <tazjin@tvl.su>

12 files changed, 0 insertions, 4251 deletions

diff --git a/third_party/abseil_cpp/absl/hash/BUILD.bazel b/third_party/abseil_cpp/absl/hash/BUILD.bazel
deleted file mode 100644
index 5b1e2d01fd3c..000000000000
--- a/third_party/abseil_cpp/absl/hash/BUILD.bazel
+++ /dev/null
@@ -1,122 +0,0 @@
-#
-# Copyright 2019 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.
-#
-
-load("@rules_cc//cc:defs.bzl", "cc_library", "cc_test")
-load(
-    "//absl:copts/configure_copts.bzl",
-    "ABSL_DEFAULT_COPTS",
-    "ABSL_DEFAULT_LINKOPTS",
-    "ABSL_TEST_COPTS",
-)
-
-package(default_visibility = ["//visibility:public"])
-
-licenses(["notice"])
-
-cc_library(
-    name = "hash",
-    srcs = [
-        "internal/hash.cc",
-        "internal/hash.h",
-    ],
-    hdrs = ["hash.h"],
-    copts = ABSL_DEFAULT_COPTS,
-    linkopts = ABSL_DEFAULT_LINKOPTS,
-    deps = [
-        ":city",
-        "//absl/base:core_headers",
-        "//absl/base:endian",
-        "//absl/container:fixed_array",
-        "//absl/meta:type_traits",
-        "//absl/numeric:int128",
-        "//absl/strings",
-        "//absl/types:optional",
-        "//absl/types:variant",
-        "//absl/utility",
-    ],
-)
-
-cc_library(
-    name = "hash_testing",
-    testonly = 1,
-    hdrs = ["hash_testing.h"],
-    linkopts = ABSL_DEFAULT_LINKOPTS,
-    deps = [
-        ":spy_hash_state",
-        "//absl/meta:type_traits",
-        "//absl/strings",
-        "//absl/types:variant",
-        "@com_google_googletest//:gtest",
-    ],
-)
-
-cc_test(
-    name = "hash_test",
-    srcs = ["hash_test.cc"],
-    copts = ABSL_TEST_COPTS,
-    linkopts = ABSL_DEFAULT_LINKOPTS,
-    deps = [
-        ":hash",
-        ":hash_testing",
-        ":spy_hash_state",
-        "//absl/base:core_headers",
-        "//absl/container:flat_hash_set",
-        "//absl/meta:type_traits",
-        "//absl/numeric:int128",
-        "//absl/strings:cord_test_helpers",
-        "@com_google_googletest//:gtest_main",
-    ],
-)
-
-cc_library(
-    name = "spy_hash_state",
-    testonly = 1,
-    hdrs = ["internal/spy_hash_state.h"],
-    copts = ABSL_DEFAULT_COPTS,
-    linkopts = ABSL_DEFAULT_LINKOPTS,
-    visibility = ["//visibility:private"],
-    deps = [
-        ":hash",
-        "//absl/strings",
-        "//absl/strings:str_format",
-    ],
-)
-
-cc_library(
-    name = "city",
-    srcs = ["internal/city.cc"],
-    hdrs = [
-        "internal/city.h",
-    ],
-    copts = ABSL_DEFAULT_COPTS,
-    linkopts = ABSL_DEFAULT_LINKOPTS,
-    deps = [
-        "//absl/base:config",
-        "//absl/base:core_headers",
-        "//absl/base:endian",
-    ],
-)
-
-cc_test(
-    name = "city_test",
-    srcs = ["internal/city_test.cc"],
-    copts = ABSL_TEST_COPTS,
-    linkopts = ABSL_DEFAULT_LINKOPTS,
-    deps = [
-        ":city",
-        "@com_google_googletest//:gtest_main",
-    ],
-)
diff --git a/third_party/abseil_cpp/absl/hash/CMakeLists.txt b/third_party/abseil_cpp/absl/hash/CMakeLists.txt
deleted file mode 100644
index 61365e9bb5a1..000000000000
--- a/third_party/abseil_cpp/absl/hash/CMakeLists.txt
+++ /dev/null
@@ -1,116 +0,0 @@
-#
-# 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.
-#
-
-absl_cc_library(
-  NAME
-    hash
-  HDRS
-    "hash.h"
-  SRCS
-    "internal/hash.cc"
-    "internal/hash.h"
-  COPTS
-    ${ABSL_DEFAULT_COPTS}
-  DEPS
-    absl::core_headers
-    absl::endian
-    absl::fixed_array
-    absl::meta
-    absl::int128
-    absl::strings
-    absl::optional
-    absl::variant
-    absl::utility
-    absl::city
-  PUBLIC
-)
-
-absl_cc_library(
-  NAME
-    hash_testing
-  HDRS
-    "hash_testing.h"
-  COPTS
-    ${ABSL_TEST_COPTS}
-  DEPS
-    absl::spy_hash_state
-    absl::meta
-    absl::strings
-    absl::variant
-    gmock
-  TESTONLY
-)
-
-absl_cc_test(
-  NAME
-    hash_test
-  SRCS
-    "hash_test.cc"
-  COPTS
-    ${ABSL_TEST_COPTS}
-  DEPS
-    absl::cord_test_helpers
-    absl::hash
-    absl::hash_testing
-    absl::core_headers
-    absl::flat_hash_set
-    absl::spy_hash_state
-    absl::meta
-    absl::int128
-    gmock_main
-)
-
-absl_cc_library(
-  NAME
-    spy_hash_state
-  HDRS
-    "internal/spy_hash_state.h"
-  COPTS
-    ${ABSL_DEFAULT_COPTS}
-  DEPS
-    absl::hash
-    absl::strings
-    absl::str_format
-  TESTONLY
-)
-
-absl_cc_library(
-  NAME
-    city
-  HDRS
-    "internal/city.h"
-  SRCS
-    "internal/city.cc"
-  COPTS
-    ${ABSL_DEFAULT_COPTS}
-  DEPS
-    absl::config
-    absl::core_headers
-    absl::endian
-)
-
-absl_cc_test(
-  NAME
-    city_test
-  SRCS
-    "internal/city_test.cc"
-  COPTS
-    ${ABSL_TEST_COPTS}
-  DEPS
-    absl::city
-    gmock_main
-)
-
diff --git a/third_party/abseil_cpp/absl/hash/hash.h b/third_party/abseil_cpp/absl/hash/hash.h
deleted file mode 100644
index 5de132cac8ac..000000000000
--- a/third_party/abseil_cpp/absl/hash/hash.h
+++ /dev/null
@@ -1,325 +0,0 @@
-// 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.
-//
-// -----------------------------------------------------------------------------
-// File: hash.h
-// -----------------------------------------------------------------------------
-//
-// This header file defines the Abseil `hash` library and the Abseil hashing
-// framework. This framework consists of the following:
-//
-//   * The `absl::Hash` functor, which is used to invoke the hasher within the
-//     Abseil hashing framework. `absl::Hash<T>` supports most basic types and
-//     a number of Abseil types out of the box.
-//   * `AbslHashValue`, an extension point that allows you to extend types to
-//     support Abseil hashing without requiring you to define a hashing
-//     algorithm.
-//   * `HashState`, a type-erased class which implements the manipulation of the
-//     hash state (H) itself, contains member functions `combine()` and
-//     `combine_contiguous()`, which you can use to contribute to an existing
-//     hash state when hashing your types.
-//
-// Unlike `std::hash` or other hashing frameworks, the Abseil hashing framework
-// provides most of its utility by abstracting away the hash algorithm (and its
-// implementation) entirely. Instead, a type invokes the Abseil hashing
-// framework by simply combining its state with the state of known, hashable
-// types. Hashing of that combined state is separately done by `absl::Hash`.
-//
-// One should assume that a hash algorithm is chosen randomly at the start of
-// each process.  E.g., `absl::Hash<int>{}(9)` in one process and
-// `absl::Hash<int>{}(9)` in another process are likely to differ.
-//
-// `absl::Hash` is intended to strongly mix input bits with a target of passing
-// an [Avalanche Test](https://en.wikipedia.org/wiki/Avalanche_effect).
-//
-// Example:
-//
-//   // Suppose we have a class `Circle` for which we want to add hashing:
-//   class Circle {
-//    public:
-//     ...
-//    private:
-//     std::pair<int, int> center_;
-//     int radius_;
-//   };
-//
-//   // To add hashing support to `Circle`, we simply need to add a free
-//   // (non-member) function `AbslHashValue()`, and return the combined hash
-//   // state of the existing hash state and the class state. You can add such a
-//   // free function using a friend declaration within the body of the class:
-//   class Circle {
-//    public:
-//     ...
-//     template <typename H>
-//     friend H AbslHashValue(H h, const Circle& c) {
-//       return H::combine(std::move(h), c.center_, c.radius_);
-//     }
-//     ...
-//   };
-//
-// For more information, see Adding Type Support to `absl::Hash` below.
-//
-#ifndef ABSL_HASH_HASH_H_
-#define ABSL_HASH_HASH_H_
-
-#include "absl/hash/internal/hash.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// -----------------------------------------------------------------------------
-// `absl::Hash`
-// -----------------------------------------------------------------------------
-//
-// `absl::Hash<T>` is a convenient general-purpose hash functor for any type `T`
-// satisfying any of the following conditions (in order):
-//
-//  * T is an arithmetic or pointer type
-//  * T defines an overload for `AbslHashValue(H, const T&)` for an arbitrary
-//    hash state `H`.
-//  - T defines a specialization of `std::hash<T>`
-//
-// `absl::Hash` intrinsically supports the following types:
-//
-//   * All integral types (including bool)
-//   * All enum types
-//   * All floating-point types (although hashing them is discouraged)
-//   * All pointer types, including nullptr_t
-//   * std::pair<T1, T2>, if T1 and T2 are hashable
-//   * std::tuple<Ts...>, if all the Ts... are hashable
-//   * std::unique_ptr and std::shared_ptr
-//   * All string-like types including:
-//     * absl::Cord
-//     * std::string
-//     * std::string_view (as well as any instance of std::basic_string that
-//       uses char and std::char_traits)
-//  * All the standard sequence containers (provided the elements are hashable)
-//  * All the standard ordered associative containers (provided the elements are
-//    hashable)
-//  * absl types such as the following:
-//    * absl::string_view
-//    * absl::InlinedVector
-//    * absl::FixedArray
-//    * absl::uint128
-//    * absl::Time, absl::Duration, and absl::TimeZone
-//
-// Note: the list above is not meant to be exhaustive. Additional type support
-// may be added, in which case the above list will be updated.
-//
-// -----------------------------------------------------------------------------
-// absl::Hash Invocation Evaluation
-// -----------------------------------------------------------------------------
-//
-// When invoked, `absl::Hash<T>` searches for supplied hash functions in the
-// following order:
-//
-//   * Natively supported types out of the box (see above)
-//   * Types for which an `AbslHashValue()` overload is provided (such as
-//     user-defined types). See "Adding Type Support to `absl::Hash`" below.
-//   * Types which define a `std::hash<T>` specialization
-//
-// The fallback to legacy hash functions exists mainly for backwards
-// compatibility. If you have a choice, prefer defining an `AbslHashValue`
-// overload instead of specializing any legacy hash functors.
-//
-// -----------------------------------------------------------------------------
-// The Hash State Concept, and using `HashState` for Type Erasure
-// -----------------------------------------------------------------------------
-//
-// The `absl::Hash` framework relies on the Concept of a "hash state." Such a
-// hash state is used in several places:
-//
-// * Within existing implementations of `absl::Hash<T>` to store the hashed
-//   state of an object. Note that it is up to the implementation how it stores
-//   such state. A hash table, for example, may mix the state to produce an
-//   integer value; a testing framework may simply hold a vector of that state.
-// * Within implementations of `AbslHashValue()` used to extend user-defined
-//   types. (See "Adding Type Support to absl::Hash" below.)
-// * Inside a `HashState`, providing type erasure for the concept of a hash
-//   state, which you can use to extend the `absl::Hash` framework for types
-//   that are otherwise difficult to extend using `AbslHashValue()`. (See the
-//   `HashState` class below.)
-//
-// The "hash state" concept contains two member functions for mixing hash state:
-//
-// * `H::combine(state, values...)`
-//
-//   Combines an arbitrary number of values into a hash state, returning the
-//   updated state. Note that the existing hash state is move-only and must be
-//   passed by value.
-//
-//   Each of the value types T must be hashable by H.
-//
-//   NOTE:
-//
-//     state = H::combine(std::move(state), value1, value2, value3);
-//
-//   must be guaranteed to produce the same hash expansion as
-//
-//     state = H::combine(std::move(state), value1);
-//     state = H::combine(std::move(state), value2);
-//     state = H::combine(std::move(state), value3);
-//
-// * `H::combine_contiguous(state, data, size)`
-//
-//    Combines a contiguous array of `size` elements into a hash state,
-//    returning the updated state. Note that the existing hash state is
-//    move-only and must be passed by value.
-//
-//    NOTE:
-//
-//      state = H::combine_contiguous(std::move(state), data, size);
-//
-//    need NOT be guaranteed to produce the same hash expansion as a loop
-//    (it may perform internal optimizations). If you need this guarantee, use a
-//    loop instead.
-//
-// -----------------------------------------------------------------------------
-// Adding Type Support to `absl::Hash`
-// -----------------------------------------------------------------------------
-//
-// To add support for your user-defined type, add a proper `AbslHashValue()`
-// overload as a free (non-member) function. The overload will take an
-// existing hash state and should combine that state with state from the type.
-//
-// Example:
-//
-//   template <typename H>
-//   H AbslHashValue(H state, const MyType& v) {
-//     return H::combine(std::move(state), v.field1, ..., v.fieldN);
-//   }
-//
-// where `(field1, ..., fieldN)` are the members you would use on your
-// `operator==` to define equality.
-//
-// Notice that `AbslHashValue` is not a class member, but an ordinary function.
-// An `AbslHashValue` overload for a type should only be declared in the same
-// file and namespace as said type. The proper `AbslHashValue` implementation
-// for a given type will be discovered via ADL.
-//
-// Note: unlike `std::hash', `absl::Hash` should never be specialized. It must
-// only be extended by adding `AbslHashValue()` overloads.
-//
-template <typename T>
-using Hash = absl::hash_internal::Hash<T>;
-
-// HashState
-//
-// A type erased version of the hash state concept, for use in user-defined
-// `AbslHashValue` implementations that can't use templates (such as PImpl
-// classes, virtual functions, etc.). The type erasure adds overhead so it
-// should be avoided unless necessary.
-//
-// Note: This wrapper will only erase calls to:
-//     combine_contiguous(H, const unsigned char*, size_t)
-//
-// All other calls will be handled internally and will not invoke overloads
-// provided by the wrapped class.
-//
-// Users of this class should still define a template `AbslHashValue` function,
-// but can use `absl::HashState::Create(&state)` to erase the type of the hash
-// state and dispatch to their private hashing logic.
-//
-// This state can be used like any other hash state. In particular, you can call
-// `HashState::combine()` and `HashState::combine_contiguous()` on it.
-//
-// Example:
-//
-//   class Interface {
-//    public:
-//     template <typename H>
-//     friend H AbslHashValue(H state, const Interface& value) {
-//       state = H::combine(std::move(state), std::type_index(typeid(*this)));
-//       value.HashValue(absl::HashState::Create(&state));
-//       return state;
-//     }
-//    private:
-//     virtual void HashValue(absl::HashState state) const = 0;
-//   };
-//
-//   class Impl : Interface {
-//    private:
-//     void HashValue(absl::HashState state) const override {
-//       absl::HashState::combine(std::move(state), v1_, v2_);
-//     }
-//     int v1_;
-//     std::string v2_;
-//   };
-class HashState : public hash_internal::HashStateBase<HashState> {
- public:
-  // HashState::Create()
-  //
-  // Create a new `HashState` instance that wraps `state`. All calls to
-  // `combine()` and `combine_contiguous()` on the new instance will be
-  // redirected to the original `state` object. The `state` object must outlive
-  // the `HashState` instance.
-  template <typename T>
-  static HashState Create(T* state) {
-    HashState s;
-    s.Init(state);
-    return s;
-  }
-
-  HashState(const HashState&) = delete;
-  HashState& operator=(const HashState&) = delete;
-  HashState(HashState&&) = default;
-  HashState& operator=(HashState&&) = default;
-
-  // HashState::combine()
-  //
-  // Combines an arbitrary number of values into a hash state, returning the
-  // updated state.
-  using HashState::HashStateBase::combine;
-
-  // HashState::combine_contiguous()
-  //
-  // Combines a contiguous array of `size` elements into a hash state, returning
-  // the updated state.
-  static HashState combine_contiguous(HashState hash_state,
-                                      const unsigned char* first, size_t size) {
-    hash_state.combine_contiguous_(hash_state.state_, first, size);
-    return hash_state;
-  }
-  using HashState::HashStateBase::combine_contiguous;
-
- private:
-  HashState() = default;
-
-  template <typename T>
-  static void CombineContiguousImpl(void* p, const unsigned char* first,
-                                    size_t size) {
-    T& state = *static_cast<T*>(p);
-    state = T::combine_contiguous(std::move(state), first, size);
-  }
-
-  template <typename T>
-  void Init(T* state) {
-    state_ = state;
-    combine_contiguous_ = &CombineContiguousImpl<T>;
-  }
-
-  // Do not erase an already erased state.
-  void Init(HashState* state) {
-    state_ = state->state_;
-    combine_contiguous_ = state->combine_contiguous_;
-  }
-
-  void* state_;
-  void (*combine_contiguous_)(void*, const unsigned char*, size_t);
-};
-
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_HASH_HASH_H_
diff --git a/third_party/abseil_cpp/absl/hash/hash_test.cc b/third_party/abseil_cpp/absl/hash/hash_test.cc
deleted file mode 100644
index 1d2e6cf0df44..000000000000
--- a/third_party/abseil_cpp/absl/hash/hash_test.cc
+++ /dev/null
@@ -1,976 +0,0 @@
-// 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 "absl/hash/hash.h"
-
-#include <array>
-#include <bitset>
-#include <cstring>
-#include <deque>
-#include <forward_list>
-#include <functional>
-#include <iterator>
-#include <limits>
-#include <list>
-#include <map>
-#include <memory>
-#include <numeric>
-#include <random>
-#include <set>
-#include <string>
-#include <tuple>
-#include <type_traits>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "absl/container/flat_hash_set.h"
-#include "absl/hash/hash_testing.h"
-#include "absl/hash/internal/spy_hash_state.h"
-#include "absl/meta/type_traits.h"
-#include "absl/numeric/int128.h"
-#include "absl/strings/cord_test_helpers.h"
-
-namespace {
-
-using absl::Hash;
-using absl::hash_internal::SpyHashState;
-
-template <typename T>
-class HashValueIntTest : public testing::Test {
-};
-TYPED_TEST_SUITE_P(HashValueIntTest);
-
-template <typename T>
-SpyHashState SpyHash(const T& value) {
-  return SpyHashState::combine(SpyHashState(), value);
-}
-
-// Helper trait to verify if T is hashable. We use absl::Hash's poison status to
-// detect it.
-template <typename T>
-using is_hashable = std::is_default_constructible<absl::Hash<T>>;
-
-TYPED_TEST_P(HashValueIntTest, BasicUsage) {
-  EXPECT_TRUE((is_hashable<TypeParam>::value));
-
-  TypeParam n = 42;
-  EXPECT_EQ(SpyHash(n), SpyHash(TypeParam{42}));
-  EXPECT_NE(SpyHash(n), SpyHash(TypeParam{0}));
-  EXPECT_NE(SpyHash(std::numeric_limits<TypeParam>::max()),
-            SpyHash(std::numeric_limits<TypeParam>::min()));
-}
-
-TYPED_TEST_P(HashValueIntTest, FastPath) {
-  // Test the fast-path to make sure the values are the same.
-  TypeParam n = 42;
-  EXPECT_EQ(absl::Hash<TypeParam>{}(n),
-            absl::Hash<std::tuple<TypeParam>>{}(std::tuple<TypeParam>(n)));
-}
-
-REGISTER_TYPED_TEST_CASE_P(HashValueIntTest, BasicUsage, FastPath);
-using IntTypes = testing::Types<unsigned char, char, int, int32_t, int64_t,
-                                uint32_t, uint64_t, size_t>;
-INSTANTIATE_TYPED_TEST_CASE_P(My, HashValueIntTest, IntTypes);
-
-enum LegacyEnum { kValue1, kValue2, kValue3 };
-
-enum class EnumClass { kValue4, kValue5, kValue6 };
-
-TEST(HashValueTest, EnumAndBool) {
-  EXPECT_TRUE((is_hashable<LegacyEnum>::value));
-  EXPECT_TRUE((is_hashable<EnumClass>::value));
-  EXPECT_TRUE((is_hashable<bool>::value));
-
-  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(std::make_tuple(
-      LegacyEnum::kValue1, LegacyEnum::kValue2, LegacyEnum::kValue3)));
-  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(std::make_tuple(
-      EnumClass::kValue4, EnumClass::kValue5, EnumClass::kValue6)));
-  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
-      std::make_tuple(true, false)));
-}
-
-TEST(HashValueTest, FloatingPoint) {
-  EXPECT_TRUE((is_hashable<float>::value));
-  EXPECT_TRUE((is_hashable<double>::value));
-  EXPECT_TRUE((is_hashable<long double>::value));
-
-  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
-      std::make_tuple(42.f, 0.f, -0.f, std::numeric_limits<float>::infinity(),
-                      -std::numeric_limits<float>::infinity())));
-
-  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
-      std::make_tuple(42., 0., -0., std::numeric_limits<double>::infinity(),
-                      -std::numeric_limits<double>::infinity())));
-
-  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(std::make_tuple(
-      // Add some values with small exponent to test that NORMAL values also
-      // append their category.
-      .5L, 1.L, 2.L, 4.L, 42.L, 0.L, -0.L,
-      17 * static_cast<long double>(std::numeric_limits<double>::max()),
-      std::numeric_limits<long double>::infinity(),
-      -std::numeric_limits<long double>::infinity())));
-}
-
-TEST(HashValueTest, Pointer) {
-  EXPECT_TRUE((is_hashable<int*>::value));
-
-  int i;
-  int* ptr = &i;
-  int* n = nullptr;
-
-  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
-      std::make_tuple(&i, ptr, nullptr, ptr + 1, n)));
-}
-
-TEST(HashValueTest, PointerAlignment) {
-  // We want to make sure that pointer alignment will not cause bits to be
-  // stuck.
-
-  constexpr size_t kTotalSize = 1 << 20;
-  std::unique_ptr<char[]> data(new char[kTotalSize]);
-  constexpr size_t kLog2NumValues = 5;
-  constexpr size_t kNumValues = 1 << kLog2NumValues;
-
-  for (size_t align = 1; align < kTotalSize / kNumValues;
-       align < 8 ? align += 1 : align < 1024 ? align += 8 : align += 32) {
-    SCOPED_TRACE(align);
-    ASSERT_LE(align * kNumValues, kTotalSize);
-
-    size_t bits_or = 0;
-    size_t bits_and = ~size_t{};
-
-    for (size_t i = 0; i < kNumValues; ++i) {
-      size_t hash = absl::Hash<void*>()(data.get() + i * align);
-      bits_or |= hash;
-      bits_and &= hash;
-    }
-
-    // Limit the scope to the bits we would be using for Swisstable.
-    constexpr size_t kMask = (1 << (kLog2NumValues + 7)) - 1;
-    size_t stuck_bits = (~bits_or | bits_and) & kMask;
-    EXPECT_EQ(stuck_bits, 0) << "0x" << std::hex << stuck_bits;
-  }
-}
-
-TEST(HashValueTest, PairAndTuple) {
-  EXPECT_TRUE((is_hashable<std::pair<int, int>>::value));
-  EXPECT_TRUE((is_hashable<std::pair<const int&, const int&>>::value));
-  EXPECT_TRUE((is_hashable<std::tuple<int&, int&>>::value));
-  EXPECT_TRUE((is_hashable<std::tuple<int&&, int&&>>::value));
-
-  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(std::make_tuple(
-      std::make_pair(0, 42), std::make_pair(0, 42), std::make_pair(42, 0),
-      std::make_pair(0, 0), std::make_pair(42, 42), std::make_pair(1, 42))));
-
-  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
-      std::make_tuple(std::make_tuple(0, 0, 0), std::make_tuple(0, 0, 42),
-                      std::make_tuple(0, 23, 0), std::make_tuple(17, 0, 0),
-                      std::make_tuple(42, 0, 0), std::make_tuple(3, 9, 9),
-                      std::make_tuple(0, 0, -42))));
-
-  // Test that tuples of lvalue references work (so we need a few lvalues):
-  int a = 0, b = 1, c = 17, d = 23;
-  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(std::make_tuple(
-      std::tie(a, a), std::tie(a, b), std::tie(b, c), std::tie(c, d))));
-
-  // Test that tuples of rvalue references work:
-  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(std::make_tuple(
-      std::forward_as_tuple(0, 0, 0), std::forward_as_tuple(0, 0, 42),
-      std::forward_as_tuple(0, 23, 0), std::forward_as_tuple(17, 0, 0),
-      std::forward_as_tuple(42, 0, 0), std::forward_as_tuple(3, 9, 9),
-      std::forward_as_tuple(0, 0, -42))));
-}
-
-TEST(HashValueTest, CombineContiguousWorks) {
-  std::vector<std::tuple<int>> v1 = {std::make_tuple(1), std::make_tuple(3)};
-  std::vector<std::tuple<int>> v2 = {std::make_tuple(1), std::make_tuple(2)};
-
-  auto vh1 = SpyHash(v1);
-  auto vh2 = SpyHash(v2);
-  EXPECT_NE(vh1, vh2);
-}
-
-struct DummyDeleter {
-  template <typename T>
-  void operator() (T* ptr) {}
-};
-
-struct SmartPointerEq {
-  template <typename T, typename U>
-  bool operator()(const T& t, const U& u) const {
-    return GetPtr(t) == GetPtr(u);
-  }
-
-  template <typename T>
-  static auto GetPtr(const T& t) -> decltype(&*t) {
-    return t ? &*t : nullptr;
-  }
-
-  static std::nullptr_t GetPtr(std::nullptr_t) { return nullptr; }
-};
-
-TEST(HashValueTest, SmartPointers) {
-  EXPECT_TRUE((is_hashable<std::unique_ptr<int>>::value));
-  EXPECT_TRUE((is_hashable<std::unique_ptr<int, DummyDeleter>>::value));
-  EXPECT_TRUE((is_hashable<std::shared_ptr<int>>::value));
-
-  int i, j;
-  std::unique_ptr<int, DummyDeleter> unique1(&i);
-  std::unique_ptr<int, DummyDeleter> unique2(&i);
-  std::unique_ptr<int, DummyDeleter> unique_other(&j);
-  std::unique_ptr<int, DummyDeleter> unique_null;
-
-  std::shared_ptr<int> shared1(&i, DummyDeleter());
-  std::shared_ptr<int> shared2(&i, DummyDeleter());
-  std::shared_ptr<int> shared_other(&j, DummyDeleter());
-  std::shared_ptr<int> shared_null;
-
-  // Sanity check of the Eq function.
-  ASSERT_TRUE(SmartPointerEq{}(unique1, shared1));
-  ASSERT_FALSE(SmartPointerEq{}(unique1, shared_other));
-  ASSERT_TRUE(SmartPointerEq{}(unique_null, nullptr));
-  ASSERT_FALSE(SmartPointerEq{}(shared2, nullptr));
-
-  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
-      std::forward_as_tuple(&i, nullptr,                    //
-                            unique1, unique2, unique_null,  //
-                            absl::make_unique<int>(),       //
-                            shared1, shared2, shared_null,  //
-                            std::make_shared<int>()),
-      SmartPointerEq{}));
-}
-
-TEST(HashValueTest, FunctionPointer) {
-  using Func = int (*)();
-  EXPECT_TRUE(is_hashable<Func>::value);
-
-  Func p1 = [] { return 2; }, p2 = [] { return 1; };
-  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
-      std::make_tuple(p1, p2, nullptr)));
-}
-
-struct WrapInTuple {
-  template <typename T>
-  std::tuple<int, T, size_t> operator()(const T& t) const {
-    return std::make_tuple(7, t, 0xdeadbeef);
-  }
-};
-
-absl::Cord FlatCord(absl::string_view sv) {
-  absl::Cord c(sv);
-  c.Flatten();
-  return c;
-}
-
-absl::Cord FragmentedCord(absl::string_view sv) {
-  if (sv.size() < 2) {
-    return absl::Cord(sv);
-  }
-  size_t halfway = sv.size() / 2;
-  std::vector<absl::string_view> parts = {sv.substr(0, halfway),
-                                          sv.substr(halfway)};
-  return absl::MakeFragmentedCord(parts);
-}
-
-TEST(HashValueTest, Strings) {
-  EXPECT_TRUE((is_hashable<std::string>::value));
-
-  const std::string small = "foo";
-  const std::string dup = "foofoo";
-  const std::string large = std::string(2048, 'x');  // multiple of chunk size
-  const std::string huge = std::string(5000, 'a');   // not a multiple
-
-  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(std::make_tuple(  //
-      std::string(), absl::string_view(), absl::Cord(),                     //
-      std::string(""), absl::string_view(""), absl::Cord(""),               //
-      std::string(small), absl::string_view(small), absl::Cord(small),      //
-      std::string(dup), absl::string_view(dup), absl::Cord(dup),            //
-      std::string(large), absl::string_view(large), absl::Cord(large),      //
-      std::string(huge), absl::string_view(huge), FlatCord(huge),           //
-      FragmentedCord(huge))));
-
-  // Also check that nested types maintain the same hash.
-  const WrapInTuple t{};
-  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(std::make_tuple(  //
-      t(std::string()), t(absl::string_view()), t(absl::Cord()),            //
-      t(std::string("")), t(absl::string_view("")), t(absl::Cord("")),      //
-      t(std::string(small)), t(absl::string_view(small)),                   //
-          t(absl::Cord(small)),                                             //
-      t(std::string(dup)), t(absl::string_view(dup)), t(absl::Cord(dup)),   //
-      t(std::string(large)), t(absl::string_view(large)),                   //
-          t(absl::Cord(large)),                                             //
-      t(std::string(huge)), t(absl::string_view(huge)),                     //
-          t(FlatCord(huge)), t(FragmentedCord(huge)))));
-
-  // Make sure that hashing a `const char*` does not use its string-value.
-  EXPECT_NE(SpyHash(static_cast<const char*>("ABC")),
-            SpyHash(absl::string_view("ABC")));
-}
-
-TEST(HashValueTest, WString) {
-  EXPECT_TRUE((is_hashable<std::wstring>::value));
-
-  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(std::make_tuple(
-      std::wstring(), std::wstring(L"ABC"), std::wstring(L"ABC"),
-      std::wstring(L"Some other different string"),
-      std::wstring(L"Iñtërnâtiônàlizætiøn"))));
-}
-
-TEST(HashValueTest, U16String) {
-  EXPECT_TRUE((is_hashable<std::u16string>::value));
-
-  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(std::make_tuple(
-      std::u16string(), std::u16string(u"ABC"), std::u16string(u"ABC"),
-      std::u16string(u"Some other different string"),
-      std::u16string(u"Iñtërnâtiônàlizætiøn"))));
-}
-
-TEST(HashValueTest, U32String) {
-  EXPECT_TRUE((is_hashable<std::u32string>::value));
-
-  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(std::make_tuple(
-      std::u32string(), std::u32string(U"ABC"), std::u32string(U"ABC"),
-      std::u32string(U"Some other different string"),
-      std::u32string(U"Iñtërnâtiônàlizætiøn"))));
-}
-
-TEST(HashValueTest, StdArray) {
-  EXPECT_TRUE((is_hashable<std::array<int, 3>>::value));
-
-  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
-      std::make_tuple(std::array<int, 3>{}, std::array<int, 3>{{0, 23, 42}})));
-}
-
-TEST(HashValueTest, StdBitset) {
-  EXPECT_TRUE((is_hashable<std::bitset<257>>::value));
-
-  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
-      {std::bitset<2>("00"), std::bitset<2>("01"), std::bitset<2>("10"),
-       std::bitset<2>("11")}));
-  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
-      {std::bitset<5>("10101"), std::bitset<5>("10001"), std::bitset<5>()}));
-
-  constexpr int kNumBits = 256;
-  std::array<std::string, 6> bit_strings;
-  bit_strings.fill(std::string(kNumBits, '1'));
-  bit_strings[1][0] = '0';
-  bit_strings[2][1] = '0';
-  bit_strings[3][kNumBits / 3] = '0';
-  bit_strings[4][kNumBits - 2] = '0';
-  bit_strings[5][kNumBits - 1] = '0';
-  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
-      {std::bitset<kNumBits>(bit_strings[0].c_str()),
-       std::bitset<kNumBits>(bit_strings[1].c_str()),
-       std::bitset<kNumBits>(bit_strings[2].c_str()),
-       std::bitset<kNumBits>(bit_strings[3].c_str()),
-       std::bitset<kNumBits>(bit_strings[4].c_str()),
-       std::bitset<kNumBits>(bit_strings[5].c_str())}));
-}  // namespace
-
-template <typename T>
-class HashValueSequenceTest : public testing::Test {
-};
-TYPED_TEST_SUITE_P(HashValueSequenceTest);
-
-TYPED_TEST_P(HashValueSequenceTest, BasicUsage) {
-  EXPECT_TRUE((is_hashable<TypeParam>::value));
-
-  using ValueType = typename TypeParam::value_type;
-  auto a = static_cast<ValueType>(0);
-  auto b = static_cast<ValueType>(23);
-  auto c = static_cast<ValueType>(42);
-
-  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
-      std::make_tuple(TypeParam(), TypeParam{}, TypeParam{a, b, c},
-                      TypeParam{a, b}, TypeParam{b, c})));
-}
-
-REGISTER_TYPED_TEST_CASE_P(HashValueSequenceTest, BasicUsage);
-using IntSequenceTypes =
-    testing::Types<std::deque<int>, std::forward_list<int>, std::list<int>,
-                   std::vector<int>, std::vector<bool>, std::set<int>,
-                   std::multiset<int>>;
-INSTANTIATE_TYPED_TEST_CASE_P(My, HashValueSequenceTest, IntSequenceTypes);
-
-// Private type that only supports AbslHashValue to make sure our chosen hash
-// implementation is recursive within absl::Hash.
-// It uses std::abs() on the value to provide different bitwise representations
-// of the same logical value.
-struct Private {
-  int i;
-  template <typename H>
-  friend H AbslHashValue(H h, Private p) {
-    return H::combine(std::move(h), std::abs(p.i));
-  }
-
-  friend bool operator==(Private a, Private b) {
-    return std::abs(a.i) == std::abs(b.i);
-  }
-
-  friend std::ostream& operator<<(std::ostream& o, Private p) {
-    return o << p.i;
-  }
-};
-
-// Test helper for combine_piecewise_buffer.  It holds a string_view to the
-// buffer-to-be-hashed.  Its AbslHashValue specialization will split up its
-// contents at the character offsets requested.
-class PiecewiseHashTester {
- public:
-  // Create a hash view of a buffer to be hashed contiguously.
-  explicit PiecewiseHashTester(absl::string_view buf)
-      : buf_(buf), piecewise_(false), split_locations_() {}
-
-  // Create a hash view of a buffer to be hashed piecewise, with breaks at the
-  // given locations.
-  PiecewiseHashTester(absl::string_view buf, std::set<size_t> split_locations)
-      : buf_(buf),
-        piecewise_(true),
-        split_locations_(std::move(split_locations)) {}
-
-  template <typename H>
-  friend H AbslHashValue(H h, const PiecewiseHashTester& p) {
-    if (!p.piecewise_) {
-      return H::combine_contiguous(std::move(h), p.buf_.data(), p.buf_.size());
-    }
-    absl::hash_internal::PiecewiseCombiner combiner;
-    if (p.split_locations_.empty()) {
-      h = combiner.add_buffer(std::move(h), p.buf_.data(), p.buf_.size());
-      return combiner.finalize(std::move(h));
-    }
-    size_t begin = 0;
-    for (size_t next : p.split_locations_) {
-      absl::string_view chunk = p.buf_.substr(begin, next - begin);
-      h = combiner.add_buffer(std::move(h), chunk.data(), chunk.size());
-      begin = next;
-    }
-    absl::string_view last_chunk = p.buf_.substr(begin);
-    if (!last_chunk.empty()) {
-      h = combiner.add_buffer(std::move(h), last_chunk.data(),
-                              last_chunk.size());
-    }
-    return combiner.finalize(std::move(h));
-  }
-
- private:
-  absl::string_view buf_;
-  bool piecewise_;
-  std::set<size_t> split_locations_;
-};
-
-// Dummy object that hashes as two distinct contiguous buffers, "foo" followed
-// by "bar"
-struct DummyFooBar {
-  template <typename H>
-  friend H AbslHashValue(H h, const DummyFooBar&) {
-    const char* foo = "foo";
-    const char* bar = "bar";
-    h = H::combine_contiguous(std::move(h), foo, 3);
-    h = H::combine_contiguous(std::move(h), bar, 3);
-    return h;
-  }
-};
-
-TEST(HashValueTest, CombinePiecewiseBuffer) {
-  absl::Hash<PiecewiseHashTester> hash;
-
-  // Check that hashing an empty buffer through the piecewise API works.
-  EXPECT_EQ(hash(PiecewiseHashTester("")), hash(PiecewiseHashTester("", {})));
-
-  // Similarly, small buffers should give consistent results
-  EXPECT_EQ(hash(PiecewiseHashTester("foobar")),
-            hash(PiecewiseHashTester("foobar", {})));
-  EXPECT_EQ(hash(PiecewiseHashTester("foobar")),
-            hash(PiecewiseHashTester("foobar", {3})));
-
-  // But hashing "foobar" in pieces gives a different answer than hashing "foo"
-  // contiguously, then "bar" contiguously.
-  EXPECT_NE(hash(PiecewiseHashTester("foobar", {3})),
-            absl::Hash<DummyFooBar>()(DummyFooBar{}));
-
-  // Test hashing a large buffer incrementally, broken up in several different
-  // ways.  Arrange for breaks on and near the stride boundaries to look for
-  // off-by-one errors in the implementation.
-  //
-  // This test is run on a buffer that is a multiple of the stride size, and one
-  // that isn't.
-  for (size_t big_buffer_size : {1024 * 2 + 512, 1024 * 3}) {
-    SCOPED_TRACE(big_buffer_size);
-    std::string big_buffer;
-    for (int i = 0; i < big_buffer_size; ++i) {
-      // Arbitrary string
-      big_buffer.push_back(32 + (i * (i / 3)) % 64);
-    }
-    auto big_buffer_hash = hash(PiecewiseHashTester(big_buffer));
-
-    const int possible_breaks = 9;
-    size_t breaks[possible_breaks] = {1,    512,  1023, 1024, 1025,
-                                      1536, 2047, 2048, 2049};
-    for (unsigned test_mask = 0; test_mask < (1u << possible_breaks);
-         ++test_mask) {
-      SCOPED_TRACE(test_mask);
-      std::set<size_t> break_locations;
-      for (int j = 0; j < possible_breaks; ++j) {
-        if (test_mask & (1u << j)) {
-          break_locations.insert(breaks[j]);
-        }
-      }
-      EXPECT_EQ(
-          hash(PiecewiseHashTester(big_buffer, std::move(break_locations))),
-          big_buffer_hash);
-    }
-  }
-}
-
-TEST(HashValueTest, PrivateSanity) {
-  // Sanity check that Private is working as the tests below expect it to work.
-  EXPECT_TRUE(is_hashable<Private>::value);
-  EXPECT_NE(SpyHash(Private{0}), SpyHash(Private{1}));
-  EXPECT_EQ(SpyHash(Private{1}), SpyHash(Private{1}));
-}
-
-TEST(HashValueTest, Optional) {
-  EXPECT_TRUE(is_hashable<absl::optional<Private>>::value);
-
-  using O = absl::optional<Private>;
-  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
-      std::make_tuple(O{}, O{{1}}, O{{-1}}, O{{10}})));
-}
-
-TEST(HashValueTest, Variant) {
-  using V = absl::variant<Private, std::string>;
-  EXPECT_TRUE(is_hashable<V>::value);
-
-  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(std::make_tuple(
-      V(Private{1}), V(Private{-1}), V(Private{2}), V("ABC"), V("BCD"))));
-
-#if ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
-  struct S {};
-  EXPECT_FALSE(is_hashable<absl::variant<S>>::value);
-#endif
-}
-
-TEST(HashValueTest, Maps) {
-  EXPECT_TRUE((is_hashable<std::map<int, std::string>>::value));
-
-  using M = std::map<int, std::string>;
-  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(std::make_tuple(
-      M{}, M{{0, "foo"}}, M{{1, "foo"}}, M{{0, "bar"}}, M{{1, "bar"}},
-      M{{0, "foo"}, {42, "bar"}}, M{{1, "foo"}, {42, "bar"}},
-      M{{1, "foo"}, {43, "bar"}}, M{{1, "foo"}, {43, "baz"}})));
-
-  using MM = std::multimap<int, std::string>;
-  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(std::make_tuple(
-      MM{}, MM{{0, "foo"}}, MM{{1, "foo"}}, MM{{0, "bar"}}, MM{{1, "bar"}},
-      MM{{0, "foo"}, {0, "bar"}}, MM{{0, "bar"}, {0, "foo"}},
-      MM{{0, "foo"}, {42, "bar"}}, MM{{1, "foo"}, {42, "bar"}},
-      MM{{1, "foo"}, {1, "foo"}, {43, "bar"}}, MM{{1, "foo"}, {43, "baz"}})));
-}
-
-TEST(HashValueTest, ReferenceWrapper) {
-  EXPECT_TRUE(is_hashable<std::reference_wrapper<Private>>::value);
-
-  Private p1{1}, p10{10};
-  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(std::make_tuple(
-      p1, p10, std::ref(p1), std::ref(p10), std::cref(p1), std::cref(p10))));
-
-  EXPECT_TRUE(is_hashable<std::reference_wrapper<int>>::value);
-  int one = 1, ten = 10;
-  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(std::make_tuple(
-      one, ten, std::ref(one), std::ref(ten), std::cref(one), std::cref(ten))));
-
-  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
-      std::make_tuple(std::tuple<std::reference_wrapper<int>>(std::ref(one)),
-                      std::tuple<std::reference_wrapper<int>>(std::ref(ten)),
-                      std::tuple<int>(one), std::tuple<int>(ten))));
-}
-
-template <typename T, typename = void>
-struct IsHashCallable : std::false_type {};
-
-template <typename T>
-struct IsHashCallable<T, absl::void_t<decltype(std::declval<absl::Hash<T>>()(
-                            std::declval<const T&>()))>> : std::true_type {};
-
-template <typename T, typename = void>
-struct IsAggregateInitializable : std::false_type {};
-
-template <typename T>
-struct IsAggregateInitializable<T, absl::void_t<decltype(T{})>>
-    : std::true_type {};
-
-TEST(IsHashableTest, ValidHash) {
-  EXPECT_TRUE((is_hashable<int>::value));
-  EXPECT_TRUE(std::is_default_constructible<absl::Hash<int>>::value);
-  EXPECT_TRUE(std::is_copy_constructible<absl::Hash<int>>::value);
-  EXPECT_TRUE(std::is_move_constructible<absl::Hash<int>>::value);
-  EXPECT_TRUE(absl::is_copy_assignable<absl::Hash<int>>::value);
-  EXPECT_TRUE(absl::is_move_assignable<absl::Hash<int>>::value);
-  EXPECT_TRUE(IsHashCallable<int>::value);
-  EXPECT_TRUE(IsAggregateInitializable<absl::Hash<int>>::value);
-}
-
-#if ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
-TEST(IsHashableTest, PoisonHash) {
-  struct X {};
-  EXPECT_FALSE((is_hashable<X>::value));
-  EXPECT_FALSE(std::is_default_constructible<absl::Hash<X>>::value);
-  EXPECT_FALSE(std::is_copy_constructible<absl::Hash<X>>::value);
-  EXPECT_FALSE(std::is_move_constructible<absl::Hash<X>>::value);
-  EXPECT_FALSE(absl::is_copy_assignable<absl::Hash<X>>::value);
-  EXPECT_FALSE(absl::is_move_assignable<absl::Hash<X>>::value);
-  EXPECT_FALSE(IsHashCallable<X>::value);
-#if !defined(__GNUC__) || __GNUC__ < 9
-  // This doesn't compile on GCC 9.
-  EXPECT_FALSE(IsAggregateInitializable<absl::Hash<X>>::value);
-#endif
-}
-#endif  // ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
-
-// Hashable types
-//
-// These types exist simply to exercise various AbslHashValue behaviors, so
-// they are named by what their AbslHashValue overload does.
-struct NoOp {
-  template <typename HashCode>
-  friend HashCode AbslHashValue(HashCode h, NoOp n) {
-    return h;
-  }
-};
-
-struct EmptyCombine {
-  template <typename HashCode>
-  friend HashCode AbslHashValue(HashCode h, EmptyCombine e) {
-    return HashCode::combine(std::move(h));
-  }
-};
-
-template <typename Int>
-struct CombineIterative {
-  template <typename HashCode>
-  friend HashCode AbslHashValue(HashCode h, CombineIterative c) {
-    for (int i = 0; i < 5; ++i) {
-      h = HashCode::combine(std::move(h), Int(i));
-    }
-    return h;
-  }
-};
-
-template <typename Int>
-struct CombineVariadic {
-  template <typename HashCode>
-  friend HashCode AbslHashValue(HashCode h, CombineVariadic c) {
-    return HashCode::combine(std::move(h), Int(0), Int(1), Int(2), Int(3),
-                             Int(4));
-  }
-};
-enum class InvokeTag {
-  kUniquelyRepresented,
-  kHashValue,
-#if ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_
-  kLegacyHash,
-#endif  // ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_
-  kStdHash,
-  kNone
-};
-
-template <InvokeTag T>
-using InvokeTagConstant = std::integral_constant<InvokeTag, T>;
-
-template <InvokeTag... Tags>
-struct MinTag;
-
-template <InvokeTag a, InvokeTag b, InvokeTag... Tags>
-struct MinTag<a, b, Tags...> : MinTag<(a < b ? a : b), Tags...> {};
-
-template <InvokeTag a>
-struct MinTag<a> : InvokeTagConstant<a> {};
-
-template <InvokeTag... Tags>
-struct CustomHashType {
-  explicit CustomHashType(size_t val) : value(val) {}
-  size_t value;
-};
-
-template <InvokeTag allowed, InvokeTag... tags>
-struct EnableIfContained
-    : std::enable_if<absl::disjunction<
-          std::integral_constant<bool, allowed == tags>...>::value> {};
-
-template <
-    typename H, InvokeTag... Tags,
-    typename = typename EnableIfContained<InvokeTag::kHashValue, Tags...>::type>
-H AbslHashValue(H state, CustomHashType<Tags...> t) {
-  static_assert(MinTag<Tags...>::value == InvokeTag::kHashValue, "");
-  return H::combine(std::move(state),
-                    t.value + static_cast<int>(InvokeTag::kHashValue));
-}
-
-}  // namespace
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace hash_internal {
-template <InvokeTag... Tags>
-struct is_uniquely_represented<
-    CustomHashType<Tags...>,
-    typename EnableIfContained<InvokeTag::kUniquelyRepresented, Tags...>::type>
-    : std::true_type {};
-}  // namespace hash_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#if ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_
-namespace ABSL_INTERNAL_LEGACY_HASH_NAMESPACE {
-template <InvokeTag... Tags>
-struct hash<CustomHashType<Tags...>> {
-  template <InvokeTag... TagsIn, typename = typename EnableIfContained<
-                                     InvokeTag::kLegacyHash, TagsIn...>::type>
-  size_t operator()(CustomHashType<TagsIn...> t) const {
-    static_assert(MinTag<Tags...>::value == InvokeTag::kLegacyHash, "");
-    return t.value + static_cast<int>(InvokeTag::kLegacyHash);
-  }
-};
-}  // namespace ABSL_INTERNAL_LEGACY_HASH_NAMESPACE
-#endif  // ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_
-
-namespace std {
-template <InvokeTag... Tags>  // NOLINT
-struct hash<CustomHashType<Tags...>> {
-  template <InvokeTag... TagsIn, typename = typename EnableIfContained<
-                                     InvokeTag::kStdHash, TagsIn...>::type>
-  size_t operator()(CustomHashType<TagsIn...> t) const {
-    static_assert(MinTag<Tags...>::value == InvokeTag::kStdHash, "");
-    return t.value + static_cast<int>(InvokeTag::kStdHash);
-  }
-};
-}  // namespace std
-
-namespace {
-
-template <typename... T>
-void TestCustomHashType(InvokeTagConstant<InvokeTag::kNone>, T...) {
-  using type = CustomHashType<T::value...>;
-  SCOPED_TRACE(testing::PrintToString(std::vector<InvokeTag>{T::value...}));
-  EXPECT_TRUE(is_hashable<type>());
-  EXPECT_TRUE(is_hashable<const type>());
-  EXPECT_TRUE(is_hashable<const type&>());
-
-  const size_t offset = static_cast<int>(std::min({T::value...}));
-  EXPECT_EQ(SpyHash(type(7)), SpyHash(size_t{7 + offset}));
-}
-
-void TestCustomHashType(InvokeTagConstant<InvokeTag::kNone>) {
-#if ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
-  // is_hashable is false if we don't support any of the hooks.
-  using type = CustomHashType<>;
-  EXPECT_FALSE(is_hashable<type>());
-  EXPECT_FALSE(is_hashable<const type>());
-  EXPECT_FALSE(is_hashable<const type&>());
-#endif  // ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
-}
-
-template <InvokeTag Tag, typename... T>
-void TestCustomHashType(InvokeTagConstant<Tag> tag, T... t) {
-  constexpr auto next = static_cast<InvokeTag>(static_cast<int>(Tag) + 1);
-  TestCustomHashType(InvokeTagConstant<next>(), tag, t...);
-  TestCustomHashType(InvokeTagConstant<next>(), t...);
-}
-
-TEST(HashTest, CustomHashType) {
-  TestCustomHashType(InvokeTagConstant<InvokeTag{}>());
-}
-
-TEST(HashTest, NoOpsAreEquivalent) {
-  EXPECT_EQ(Hash<NoOp>()({}), Hash<NoOp>()({}));
-  EXPECT_EQ(Hash<NoOp>()({}), Hash<EmptyCombine>()({}));
-}
-
-template <typename T>
-class HashIntTest : public testing::Test {
-};
-TYPED_TEST_SUITE_P(HashIntTest);
-
-TYPED_TEST_P(HashIntTest, BasicUsage) {
-  EXPECT_NE(Hash<NoOp>()({}), Hash<TypeParam>()(0));
-  EXPECT_NE(Hash<NoOp>()({}),
-            Hash<TypeParam>()(std::numeric_limits<TypeParam>::max()));
-  if (std::numeric_limits<TypeParam>::min() != 0) {
-    EXPECT_NE(Hash<NoOp>()({}),
-              Hash<TypeParam>()(std::numeric_limits<TypeParam>::min()));
-  }
-
-  EXPECT_EQ(Hash<CombineIterative<TypeParam>>()({}),
-            Hash<CombineVariadic<TypeParam>>()({}));
-}
-
-REGISTER_TYPED_TEST_CASE_P(HashIntTest, BasicUsage);
-using IntTypes = testing::Types<unsigned char, char, int, int32_t, int64_t,
-                                uint32_t, uint64_t, size_t>;
-INSTANTIATE_TYPED_TEST_CASE_P(My, HashIntTest, IntTypes);
-
-struct StructWithPadding {
-  char c;
-  int i;
-
-  template <typename H>
-  friend H AbslHashValue(H hash_state, const StructWithPadding& s) {
-    return H::combine(std::move(hash_state), s.c, s.i);
-  }
-};
-
-static_assert(sizeof(StructWithPadding) > sizeof(char) + sizeof(int),
-              "StructWithPadding doesn't have padding");
-static_assert(std::is_standard_layout<StructWithPadding>::value, "");
-
-// This check has to be disabled because libstdc++ doesn't support it.
-// static_assert(std::is_trivially_constructible<StructWithPadding>::value, "");
-
-template <typename T>
-struct ArraySlice {
-  T* begin;
-  T* end;
-
-  template <typename H>
-  friend H AbslHashValue(H hash_state, const ArraySlice& slice) {
-    for (auto t = slice.begin; t != slice.end; ++t) {
-      hash_state = H::combine(std::move(hash_state), *t);
-    }
-    return hash_state;
-  }
-};
-
-TEST(HashTest, HashNonUniquelyRepresentedType) {
-  // Create equal StructWithPadding objects that are known to have non-equal
-  // padding bytes.
-  static const size_t kNumStructs = 10;
-  unsigned char buffer1[kNumStructs * sizeof(StructWithPadding)];
-  std::memset(buffer1, 0, sizeof(buffer1));
-  auto* s1 = reinterpret_cast<StructWithPadding*>(buffer1);
-
-  unsigned char buffer2[kNumStructs * sizeof(StructWithPadding)];
-  std::memset(buffer2, 255, sizeof(buffer2));
-  auto* s2 = reinterpret_cast<StructWithPadding*>(buffer2);
-  for (int i = 0; i < kNumStructs; ++i) {
-    SCOPED_TRACE(i);
-    s1[i].c = s2[i].c = '0' + i;
-    s1[i].i = s2[i].i = i;
-    ASSERT_FALSE(memcmp(buffer1 + i * sizeof(StructWithPadding),
-                        buffer2 + i * sizeof(StructWithPadding),
-                        sizeof(StructWithPadding)) == 0)
-        << "Bug in test code: objects do not have unequal"
-        << " object representations";
-  }
-
-  EXPECT_EQ(Hash<StructWithPadding>()(s1[0]), Hash<StructWithPadding>()(s2[0]));
-  EXPECT_EQ(Hash<ArraySlice<StructWithPadding>>()({s1, s1 + kNumStructs}),
-            Hash<ArraySlice<StructWithPadding>>()({s2, s2 + kNumStructs}));
-}
-
-TEST(HashTest, StandardHashContainerUsage) {
-  std::unordered_map<int, std::string, Hash<int>> map = {{0, "foo"},
-                                                         {42, "bar"}};
-
-  EXPECT_NE(map.find(0), map.end());
-  EXPECT_EQ(map.find(1), map.end());
-  EXPECT_NE(map.find(0u), map.end());
-}
-
-struct ConvertibleFromNoOp {
-  ConvertibleFromNoOp(NoOp) {}  // NOLINT(runtime/explicit)
-
-  template <typename H>
-  friend H AbslHashValue(H hash_state, ConvertibleFromNoOp) {
-    return H::combine(std::move(hash_state), 1);
-  }
-};
-
-TEST(HashTest, HeterogeneousCall) {
-  EXPECT_NE(Hash<ConvertibleFromNoOp>()(NoOp()),
-            Hash<NoOp>()(NoOp()));
-}
-
-TEST(IsUniquelyRepresentedTest, SanityTest) {
-  using absl::hash_internal::is_uniquely_represented;
-
-  EXPECT_TRUE(is_uniquely_represented<unsigned char>::value);
-  EXPECT_TRUE(is_uniquely_represented<int>::value);
-  EXPECT_FALSE(is_uniquely_represented<bool>::value);
-  EXPECT_FALSE(is_uniquely_represented<int*>::value);
-}
-
-struct IntAndString {
-  int i;
-  std::string s;
-
-  template <typename H>
-  friend H AbslHashValue(H hash_state, IntAndString int_and_string) {
-    return H::combine(std::move(hash_state), int_and_string.s,
-                      int_and_string.i);
-  }
-};
-
-TEST(HashTest, SmallValueOn64ByteBoundary) {
-  Hash<IntAndString>()(IntAndString{0, std::string(63, '0')});
-}
-
-struct TypeErased {
-  size_t n;
-
-  template <typename H>
-  friend H AbslHashValue(H hash_state, const TypeErased& v) {
-    v.HashValue(absl::HashState::Create(&hash_state));
-    return hash_state;
-  }
-
-  void HashValue(absl::HashState state) const {
-    absl::HashState::combine(std::move(state), n);
-  }
-};
-
-TEST(HashTest, TypeErased) {
-  EXPECT_TRUE((is_hashable<TypeErased>::value));
-  EXPECT_TRUE((is_hashable<std::pair<TypeErased, int>>::value));
-
-  EXPECT_EQ(SpyHash(TypeErased{7}), SpyHash(size_t{7}));
-  EXPECT_NE(SpyHash(TypeErased{7}), SpyHash(size_t{13}));
-
-  EXPECT_EQ(SpyHash(std::make_pair(TypeErased{7}, 17)),
-            SpyHash(std::make_pair(size_t{7}, 17)));
-}
-
-struct ValueWithBoolConversion {
-  operator bool() const { return false; }
-  int i;
-};
-
-}  // namespace
-namespace std {
-template <>
-struct hash<ValueWithBoolConversion> {
-  size_t operator()(ValueWithBoolConversion v) { return v.i; }
-};
-}  // namespace std
-
-namespace {
-
-TEST(HashTest, DoesNotUseImplicitConversionsToBool) {
-  EXPECT_NE(absl::Hash<ValueWithBoolConversion>()(ValueWithBoolConversion{0}),
-            absl::Hash<ValueWithBoolConversion>()(ValueWithBoolConversion{1}));
-}
-
-}  // namespace
diff --git a/third_party/abseil_cpp/absl/hash/hash_testing.h b/third_party/abseil_cpp/absl/hash/hash_testing.h
deleted file mode 100644
index 1e1c5741491e..000000000000
--- a/third_party/abseil_cpp/absl/hash/hash_testing.h
+++ /dev/null
@@ -1,378 +0,0 @@
-// 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.
-
-#ifndef ABSL_HASH_HASH_TESTING_H_
-#define ABSL_HASH_HASH_TESTING_H_
-
-#include <initializer_list>
-#include <tuple>
-#include <type_traits>
-#include <vector>
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "absl/hash/internal/spy_hash_state.h"
-#include "absl/meta/type_traits.h"
-#include "absl/strings/str_cat.h"
-#include "absl/types/variant.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// Run the absl::Hash algorithm over all the elements passed in and verify that
-// their hash expansion is congruent with their `==` operator.
-//
-// It is used in conjunction with EXPECT_TRUE. Failures will output information
-// on what requirement failed and on which objects.
-//
-// Users should pass a collection of types as either an initializer list or a
-// container of cases.
-//
-//   EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
-//       {v1, v2, ..., vN}));
-//
-//   std::vector<MyType> cases;
-//   // Fill cases...
-//   EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(cases));
-//
-// Users can pass a variety of types for testing heterogeneous lookup with
-// `std::make_tuple`:
-//
-//   EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
-//       std::make_tuple(v1, v2, ..., vN)));
-//
-//
-// Ideally, the values passed should provide enough coverage of the `==`
-// operator and the AbslHashValue implementations.
-// For dynamically sized types, the empty state should usually be included in
-// the values.
-//
-// The function accepts an optional comparator function, in case that `==` is
-// not enough for the values provided.
-//
-// Usage:
-//
-//   EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly(
-//       std::make_tuple(v1, v2, ..., vN), MyCustomEq{}));
-//
-// It checks the following requirements:
-//   1. The expansion for a value is deterministic.
-//   2. For any two objects `a` and `b` in the sequence, if `a == b` evaluates
-//      to true, then their hash expansion must be equal.
-//   3. If `a == b` evaluates to false their hash expansion must be unequal.
-//   4. If `a == b` evaluates to false neither hash expansion can be a
-//      suffix of the other.
-//   5. AbslHashValue overloads should not be called by the user. They are only
-//      meant to be called by the framework. Users should call H::combine() and
-//      H::combine_contiguous().
-//   6. No moved-from instance of the hash state is used in the implementation
-//      of AbslHashValue.
-//
-// The values do not have to have the same type. This can be useful for
-// equivalent types that support heterogeneous lookup.
-//
-// A possible reason for breaking (2) is combining state in the hash expansion
-// that was not used in `==`.
-// For example:
-//
-// struct Bad2 {
-//   int a, b;
-//   template <typename H>
-//   friend H AbslHashValue(H state, Bad2 x) {
-//     // Uses a and b.
-//     return H::combine(std::move(state), x.a, x.b);
-//   }
-//   friend bool operator==(Bad2 x, Bad2 y) {
-//     // Only uses a.
-//     return x.a == y.a;
-//   }
-// };
-//
-// As for (3), breaking this usually means that there is state being passed to
-// the `==` operator that is not used in the hash expansion.
-// For example:
-//
-// struct Bad3 {
-//   int a, b;
-//   template <typename H>
-//   friend H AbslHashValue(H state, Bad3 x) {
-//     // Only uses a.
-//     return H::combine(std::move(state), x.a);
-//   }
-//   friend bool operator==(Bad3 x, Bad3 y) {
-//     // Uses a and b.
-//     return x.a == y.a && x.b == y.b;
-//   }
-// };
-//
-// Finally, a common way to break 4 is by combining dynamic ranges without
-// combining the size of the range.
-// For example:
-//
-// struct Bad4 {
-//   int *p, size;
-//   template <typename H>
-//   friend H AbslHashValue(H state, Bad4 x) {
-//     return H::combine_contiguous(std::move(state), x.p, x.p + x.size);
-//   }
-//   friend bool operator==(Bad4 x, Bad4 y) {
-//    // Compare two ranges for equality. C++14 code can instead use std::equal.
-//     return absl::equal(x.p, x.p + x.size, y.p, y.p + y.size);
-//   }
-// };
-//
-// An easy solution to this is to combine the size after combining the range,
-// like so:
-// template <typename H>
-// friend H AbslHashValue(H state, Bad4 x) {
-//   return H::combine(
-//       H::combine_contiguous(std::move(state), x.p, x.p + x.size), x.size);
-// }
-//
-template <int&... ExplicitBarrier, typename Container>
-ABSL_MUST_USE_RESULT testing::AssertionResult
-VerifyTypeImplementsAbslHashCorrectly(const Container& values);
-
-template <int&... ExplicitBarrier, typename Container, typename Eq>
-ABSL_MUST_USE_RESULT testing::AssertionResult
-VerifyTypeImplementsAbslHashCorrectly(const Container& values, Eq equals);
-
-template <int&..., typename T>
-ABSL_MUST_USE_RESULT testing::AssertionResult
-VerifyTypeImplementsAbslHashCorrectly(std::initializer_list<T> values);
-
-template <int&..., typename T, typename Eq>
-ABSL_MUST_USE_RESULT testing::AssertionResult
-VerifyTypeImplementsAbslHashCorrectly(std::initializer_list<T> values,
-                                      Eq equals);
-
-namespace hash_internal {
-
-struct PrintVisitor {
-  size_t index;
-  template <typename T>
-  std::string operator()(const T* value) const {
-    return absl::StrCat("#", index, "(", testing::PrintToString(*value), ")");
-  }
-};
-
-template <typename Eq>
-struct EqVisitor {
-  Eq eq;
-  template <typename T, typename U>
-  bool operator()(const T* t, const U* u) const {
-    return eq(*t, *u);
-  }
-};
-
-struct ExpandVisitor {
-  template <typename T>
-  SpyHashState operator()(const T* value) const {
-    return SpyHashState::combine(SpyHashState(), *value);
-  }
-};
-
-template <typename Container, typename Eq>
-ABSL_MUST_USE_RESULT testing::AssertionResult
-VerifyTypeImplementsAbslHashCorrectly(const Container& values, Eq equals) {
-  using V = typename Container::value_type;
-
-  struct Info {
-    const V& value;
-    size_t index;
-    std::string ToString() const {
-      return absl::visit(PrintVisitor{index}, value);
-    }
-    SpyHashState expand() const { return absl::visit(ExpandVisitor{}, value); }
-  };
-
-  using EqClass = std::vector<Info>;
-  std::vector<EqClass> classes;
-
-  // Gather the values in equivalence classes.
-  size_t i = 0;
-  for (const auto& value : values) {
-    EqClass* c = nullptr;
-    for (auto& eqclass : classes) {
-      if (absl::visit(EqVisitor<Eq>{equals}, value, eqclass[0].value)) {
-        c = &eqclass;
-        break;
-      }
-    }
-    if (c == nullptr) {
-      classes.emplace_back();
-      c = &classes.back();
-    }
-    c->push_back({value, i});
-    ++i;
-
-    // Verify potential errors captured by SpyHashState.
-    if (auto error = c->back().expand().error()) {
-      return testing::AssertionFailure() << *error;
-    }
-  }
-
-  if (classes.size() < 2) {
-    return testing::AssertionFailure()
-           << "At least two equivalence classes are expected.";
-  }
-
-  // We assume that equality is correctly implemented.
-  // Now we verify that AbslHashValue is also correctly implemented.
-
-  for (const auto& c : classes) {
-    // All elements of the equivalence class must have the same hash
-    // expansion.
-    const SpyHashState expected = c[0].expand();
-    for (const Info& v : c) {
-      if (v.expand() != v.expand()) {
-        return testing::AssertionFailure()
-               << "Hash expansion for " << v.ToString()
-               << " is non-deterministic.";
-      }
-      if (v.expand() != expected) {
-        return testing::AssertionFailure()
-               << "Values " << c[0].ToString() << " and " << v.ToString()
-               << " evaluate as equal but have an unequal hash expansion.";
-      }
-    }
-
-    // Elements from other classes must have different hash expansion.
-    for (const auto& c2 : classes) {
-      if (&c == &c2) continue;
-      const SpyHashState c2_hash = c2[0].expand();
-      switch (SpyHashState::Compare(expected, c2_hash)) {
-        case SpyHashState::CompareResult::kEqual:
-          return testing::AssertionFailure()
-                 << "Values " << c[0].ToString() << " and " << c2[0].ToString()
-                 << " evaluate as unequal but have an equal hash expansion.";
-        case SpyHashState::CompareResult::kBSuffixA:
-          return testing::AssertionFailure()
-                 << "Hash expansion of " << c2[0].ToString()
-                 << " is a suffix of the hash expansion of " << c[0].ToString()
-                 << ".";
-        case SpyHashState::CompareResult::kASuffixB:
-          return testing::AssertionFailure()
-                 << "Hash expansion of " << c[0].ToString()
-                 << " is a suffix of the hash expansion of " << c2[0].ToString()
-                 << ".";
-        case SpyHashState::CompareResult::kUnequal:
-          break;
-      }
-    }
-  }
-  return testing::AssertionSuccess();
-}
-
-template <typename... T>
-struct TypeSet {
-  template <typename U, bool = disjunction<std::is_same<T, U>...>::value>
-  struct Insert {
-    using type = TypeSet<U, T...>;
-  };
-  template <typename U>
-  struct Insert<U, true> {
-    using type = TypeSet;
-  };
-
-  template <template <typename...> class C>
-  using apply = C<T...>;
-};
-
-template <typename... T>
-struct MakeTypeSet : TypeSet<> {};
-template <typename T, typename... Ts>
-struct MakeTypeSet<T, Ts...> : MakeTypeSet<Ts...>::template Insert<T>::type {};
-
-template <typename... T>
-using VariantForTypes = typename MakeTypeSet<
-    const typename std::decay<T>::type*...>::template apply<absl::variant>;
-
-template <typename Container>
-struct ContainerAsVector {
-  using V = absl::variant<const typename Container::value_type*>;
-  using Out = std::vector<V>;
-
-  static Out Do(const Container& values) {
-    Out out;
-    for (const auto& v : values) out.push_back(&v);
-    return out;
-  }
-};
-
-template <typename... T>
-struct ContainerAsVector<std::tuple<T...>> {
-  using V = VariantForTypes<T...>;
-  using Out = std::vector<V>;
-
-  template <size_t... I>
-  static Out DoImpl(const std::tuple<T...>& tuple, absl::index_sequence<I...>) {
-    return Out{&std::get<I>(tuple)...};
-  }
-
-  static Out Do(const std::tuple<T...>& values) {
-    return DoImpl(values, absl::index_sequence_for<T...>());
-  }
-};
-
-template <>
-struct ContainerAsVector<std::tuple<>> {
-  static std::vector<VariantForTypes<int>> Do(std::tuple<>) { return {}; }
-};
-
-struct DefaultEquals {
-  template <typename T, typename U>
-  bool operator()(const T& t, const U& u) const {
-    return t == u;
-  }
-};
-
-}  // namespace hash_internal
-
-template <int&..., typename Container>
-ABSL_MUST_USE_RESULT testing::AssertionResult
-VerifyTypeImplementsAbslHashCorrectly(const Container& values) {
-  return hash_internal::VerifyTypeImplementsAbslHashCorrectly(
-      hash_internal::ContainerAsVector<Container>::Do(values),
-      hash_internal::DefaultEquals{});
-}
-
-template <int&..., typename Container, typename Eq>
-ABSL_MUST_USE_RESULT testing::AssertionResult
-VerifyTypeImplementsAbslHashCorrectly(const Container& values, Eq equals) {
-  return hash_internal::VerifyTypeImplementsAbslHashCorrectly(
-      hash_internal::ContainerAsVector<Container>::Do(values), equals);
-}
-
-template <int&..., typename T>
-ABSL_MUST_USE_RESULT testing::AssertionResult
-VerifyTypeImplementsAbslHashCorrectly(std::initializer_list<T> values) {
-  return hash_internal::VerifyTypeImplementsAbslHashCorrectly(
-      hash_internal::ContainerAsVector<std::initializer_list<T>>::Do(values),
-      hash_internal::DefaultEquals{});
-}
-
-template <int&..., typename T, typename Eq>
-ABSL_MUST_USE_RESULT testing::AssertionResult
-VerifyTypeImplementsAbslHashCorrectly(std::initializer_list<T> values,
-                                      Eq equals) {
-  return hash_internal::VerifyTypeImplementsAbslHashCorrectly(
-      hash_internal::ContainerAsVector<std::initializer_list<T>>::Do(values),
-      equals);
-}
-
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_HASH_HASH_TESTING_H_
diff --git a/third_party/abseil_cpp/absl/hash/internal/city.cc b/third_party/abseil_cpp/absl/hash/internal/city.cc
deleted file mode 100644
index 5460134e5762..000000000000
--- a/third_party/abseil_cpp/absl/hash/internal/city.cc
+++ /dev/null
@@ -1,349 +0,0 @@
-// 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.
-//
-// This file provides CityHash64() and related functions.
-//
-// It's probably possible to create even faster hash functions by
-// writing a program that systematically explores some of the space of
-// possible hash functions, by using SIMD instructions, or by
-// compromising on hash quality.
-
-#include "absl/hash/internal/city.h"
-
-#include <string.h>  // for memcpy and memset
-#include <algorithm>
-
-#include "absl/base/config.h"
-#include "absl/base/internal/endian.h"
-#include "absl/base/internal/unaligned_access.h"
-#include "absl/base/optimization.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace hash_internal {
-
-#ifdef ABSL_IS_BIG_ENDIAN
-#define uint32_in_expected_order(x) (absl::gbswap_32(x))
-#define uint64_in_expected_order(x) (absl::gbswap_64(x))
-#else
-#define uint32_in_expected_order(x) (x)
-#define uint64_in_expected_order(x) (x)
-#endif
-
-static uint64_t Fetch64(const char *p) {
-  return uint64_in_expected_order(ABSL_INTERNAL_UNALIGNED_LOAD64(p));
-}
-
-static uint32_t Fetch32(const char *p) {
-  return uint32_in_expected_order(ABSL_INTERNAL_UNALIGNED_LOAD32(p));
-}
-
-// Some primes between 2^63 and 2^64 for various uses.
-static const uint64_t k0 = 0xc3a5c85c97cb3127ULL;
-static const uint64_t k1 = 0xb492b66fbe98f273ULL;
-static const uint64_t k2 = 0x9ae16a3b2f90404fULL;
-
-// Magic numbers for 32-bit hashing.  Copied from Murmur3.
-static const uint32_t c1 = 0xcc9e2d51;
-static const uint32_t c2 = 0x1b873593;
-
-// A 32-bit to 32-bit integer hash copied from Murmur3.
-static uint32_t fmix(uint32_t h) {
-  h ^= h >> 16;
-  h *= 0x85ebca6b;
-  h ^= h >> 13;
-  h *= 0xc2b2ae35;
-  h ^= h >> 16;
-  return h;
-}
-
-static uint32_t Rotate32(uint32_t val, int shift) {
-  // Avoid shifting by 32: doing so yields an undefined result.
-  return shift == 0 ? val : ((val >> shift) | (val << (32 - shift)));
-}
-
-#undef PERMUTE3
-#define PERMUTE3(a, b, c) \
-  do {                    \
-    std::swap(a, b);      \
-    std::swap(a, c);      \
-  } while (0)
-
-static uint32_t Mur(uint32_t a, uint32_t h) {
-  // Helper from Murmur3 for combining two 32-bit values.
-  a *= c1;
-  a = Rotate32(a, 17);
-  a *= c2;
-  h ^= a;
-  h = Rotate32(h, 19);
-  return h * 5 + 0xe6546b64;
-}
-
-static uint32_t Hash32Len13to24(const char *s, size_t len) {
-  uint32_t a = Fetch32(s - 4 + (len >> 1));
-  uint32_t b = Fetch32(s + 4);
-  uint32_t c = Fetch32(s + len - 8);
-  uint32_t d = Fetch32(s + (len >> 1));
-  uint32_t e = Fetch32(s);
-  uint32_t f = Fetch32(s + len - 4);
-  uint32_t h = len;
-
-  return fmix(Mur(f, Mur(e, Mur(d, Mur(c, Mur(b, Mur(a, h)))))));
-}
-
-static uint32_t Hash32Len0to4(const char *s, size_t len) {
-  uint32_t b = 0;
-  uint32_t c = 9;
-  for (size_t i = 0; i < len; i++) {
-    signed char v = s[i];
-    b = b * c1 + v;
-    c ^= b;
-  }
-  return fmix(Mur(b, Mur(len, c)));
-}
-
-static uint32_t Hash32Len5to12(const char *s, size_t len) {
-  uint32_t a = len, b = len * 5, c = 9, d = b;
-  a += Fetch32(s);
-  b += Fetch32(s + len - 4);
-  c += Fetch32(s + ((len >> 1) & 4));
-  return fmix(Mur(c, Mur(b, Mur(a, d))));
-}
-
-uint32_t CityHash32(const char *s, size_t len) {
-  if (len <= 24) {
-    return len <= 12
-               ? (len <= 4 ? Hash32Len0to4(s, len) : Hash32Len5to12(s, len))
-               : Hash32Len13to24(s, len);
-  }
-
-  // len > 24
-  uint32_t h = len, g = c1 * len, f = g;
-
-  uint32_t a0 = Rotate32(Fetch32(s + len - 4) * c1, 17) * c2;
-  uint32_t a1 = Rotate32(Fetch32(s + len - 8) * c1, 17) * c2;
-  uint32_t a2 = Rotate32(Fetch32(s + len - 16) * c1, 17) * c2;
-  uint32_t a3 = Rotate32(Fetch32(s + len - 12) * c1, 17) * c2;
-  uint32_t a4 = Rotate32(Fetch32(s + len - 20) * c1, 17) * c2;
-  h ^= a0;
-  h = Rotate32(h, 19);
-  h = h * 5 + 0xe6546b64;
-  h ^= a2;
-  h = Rotate32(h, 19);
-  h = h * 5 + 0xe6546b64;
-  g ^= a1;
-  g = Rotate32(g, 19);
-  g = g * 5 + 0xe6546b64;
-  g ^= a3;
-  g = Rotate32(g, 19);
-  g = g * 5 + 0xe6546b64;
-  f += a4;
-  f = Rotate32(f, 19);
-  f = f * 5 + 0xe6546b64;
-  size_t iters = (len - 1) / 20;
-  do {
-    uint32_t b0 = Rotate32(Fetch32(s) * c1, 17) * c2;
-    uint32_t b1 = Fetch32(s + 4);
-    uint32_t b2 = Rotate32(Fetch32(s + 8) * c1, 17) * c2;
-    uint32_t b3 = Rotate32(Fetch32(s + 12) * c1, 17) * c2;
-    uint32_t b4 = Fetch32(s + 16);
-    h ^= b0;
-    h = Rotate32(h, 18);
-    h = h * 5 + 0xe6546b64;
-    f += b1;
-    f = Rotate32(f, 19);
-    f = f * c1;
-    g += b2;
-    g = Rotate32(g, 18);
-    g = g * 5 + 0xe6546b64;
-    h ^= b3 + b1;
-    h = Rotate32(h, 19);
-    h = h * 5 + 0xe6546b64;
-    g ^= b4;
-    g = absl::gbswap_32(g) * 5;
-    h += b4 * 5;
-    h = absl::gbswap_32(h);
-    f += b0;
-    PERMUTE3(f, h, g);
-    s += 20;
-  } while (--iters != 0);
-  g = Rotate32(g, 11) * c1;
-  g = Rotate32(g, 17) * c1;
-  f = Rotate32(f, 11) * c1;
-  f = Rotate32(f, 17) * c1;
-  h = Rotate32(h + g, 19);
-  h = h * 5 + 0xe6546b64;
-  h = Rotate32(h, 17) * c1;
-  h = Rotate32(h + f, 19);
-  h = h * 5 + 0xe6546b64;
-  h = Rotate32(h, 17) * c1;
-  return h;
-}
-
-// Bitwise right rotate.  Normally this will compile to a single
-// instruction, especially if the shift is a manifest constant.
-static uint64_t Rotate(uint64_t val, int shift) {
-  // Avoid shifting by 64: doing so yields an undefined result.
-  return shift == 0 ? val : ((val >> shift) | (val << (64 - shift)));
-}
-
-static uint64_t ShiftMix(uint64_t val) { return val ^ (val >> 47); }
-
-static uint64_t HashLen16(uint64_t u, uint64_t v, uint64_t mul) {
-  // Murmur-inspired hashing.
-  uint64_t a = (u ^ v) * mul;
-  a ^= (a >> 47);
-  uint64_t b = (v ^ a) * mul;
-  b ^= (b >> 47);
-  b *= mul;
-  return b;
-}
-
-static uint64_t HashLen16(uint64_t u, uint64_t v) {
-  const uint64_t kMul = 0x9ddfea08eb382d69ULL;
-  return HashLen16(u, v, kMul);
-}
-
-static uint64_t HashLen0to16(const char *s, size_t len) {
-  if (len >= 8) {
-    uint64_t mul = k2 + len * 2;
-    uint64_t a = Fetch64(s) + k2;
-    uint64_t b = Fetch64(s + len - 8);
-    uint64_t c = Rotate(b, 37) * mul + a;
-    uint64_t d = (Rotate(a, 25) + b) * mul;
-    return HashLen16(c, d, mul);
-  }
-  if (len >= 4) {
-    uint64_t mul = k2 + len * 2;
-    uint64_t a = Fetch32(s);
-    return HashLen16(len + (a << 3), Fetch32(s + len - 4), mul);
-  }
-  if (len > 0) {
-    uint8_t a = s[0];
-    uint8_t b = s[len >> 1];
-    uint8_t c = s[len - 1];
-    uint32_t y = static_cast<uint32_t>(a) + (static_cast<uint32_t>(b) << 8);
-    uint32_t z = len + (static_cast<uint32_t>(c) << 2);
-    return ShiftMix(y * k2 ^ z * k0) * k2;
-  }
-  return k2;
-}
-
-// This probably works well for 16-byte strings as well, but it may be overkill
-// in that case.
-static uint64_t HashLen17to32(const char *s, size_t len) {
-  uint64_t mul = k2 + len * 2;
-  uint64_t a = Fetch64(s) * k1;
-  uint64_t b = Fetch64(s + 8);
-  uint64_t c = Fetch64(s + len - 8) * mul;
-  uint64_t d = Fetch64(s + len - 16) * k2;
-  return HashLen16(Rotate(a + b, 43) + Rotate(c, 30) + d,
-                   a + Rotate(b + k2, 18) + c, mul);
-}
-
-// Return a 16-byte hash for 48 bytes.  Quick and dirty.
-// Callers do best to use "random-looking" values for a and b.
-static std::pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
-    uint64_t w, uint64_t x, uint64_t y, uint64_t z, uint64_t a, uint64_t b) {
-  a += w;
-  b = Rotate(b + a + z, 21);
-  uint64_t c = a;
-  a += x;
-  a += y;
-  b += Rotate(a, 44);
-  return std::make_pair(a + z, b + c);
-}
-
-// Return a 16-byte hash for s[0] ... s[31], a, and b.  Quick and dirty.
-static std::pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(const char *s,
-                                                            uint64_t a,
-                                                            uint64_t b) {
-  return WeakHashLen32WithSeeds(Fetch64(s), Fetch64(s + 8), Fetch64(s + 16),
-                                Fetch64(s + 24), a, b);
-}
-
-// Return an 8-byte hash for 33 to 64 bytes.
-static uint64_t HashLen33to64(const char *s, size_t len) {
-  uint64_t mul = k2 + len * 2;
-  uint64_t a = Fetch64(s) * k2;
-  uint64_t b = Fetch64(s + 8);
-  uint64_t c = Fetch64(s + len - 24);
-  uint64_t d = Fetch64(s + len - 32);
-  uint64_t e = Fetch64(s + 16) * k2;
-  uint64_t f = Fetch64(s + 24) * 9;
-  uint64_t g = Fetch64(s + len - 8);
-  uint64_t h = Fetch64(s + len - 16) * mul;
-  uint64_t u = Rotate(a + g, 43) + (Rotate(b, 30) + c) * 9;
-  uint64_t v = ((a + g) ^ d) + f + 1;
-  uint64_t w = absl::gbswap_64((u + v) * mul) + h;
-  uint64_t x = Rotate(e + f, 42) + c;
-  uint64_t y = (absl::gbswap_64((v + w) * mul) + g) * mul;
-  uint64_t z = e + f + c;
-  a = absl::gbswap_64((x + z) * mul + y) + b;
-  b = ShiftMix((z + a) * mul + d + h) * mul;
-  return b + x;
-}
-
-uint64_t CityHash64(const char *s, size_t len) {
-  if (len <= 32) {
-    if (len <= 16) {
-      return HashLen0to16(s, len);
-    } else {
-      return HashLen17to32(s, len);
-    }
-  } else if (len <= 64) {
-    return HashLen33to64(s, len);
-  }
-
-  // For strings over 64 bytes we hash the end first, and then as we
-  // loop we keep 56 bytes of state: v, w, x, y, and z.
-  uint64_t x = Fetch64(s + len - 40);
-  uint64_t y = Fetch64(s + len - 16) + Fetch64(s + len - 56);
-  uint64_t z = HashLen16(Fetch64(s + len - 48) + len, Fetch64(s + len - 24));
-  std::pair<uint64_t, uint64_t> v =
-      WeakHashLen32WithSeeds(s + len - 64, len, z);
-  std::pair<uint64_t, uint64_t> w =
-      WeakHashLen32WithSeeds(s + len - 32, y + k1, x);
-  x = x * k1 + Fetch64(s);
-
-  // Decrease len to the nearest multiple of 64, and operate on 64-byte chunks.
-  len = (len - 1) & ~static_cast<size_t>(63);
-  do {
-    x = Rotate(x + y + v.first + Fetch64(s + 8), 37) * k1;
-    y = Rotate(y + v.second + Fetch64(s + 48), 42) * k1;
-    x ^= w.second;
-    y += v.first + Fetch64(s + 40);
-    z = Rotate(z + w.first, 33) * k1;
-    v = WeakHashLen32WithSeeds(s, v.second * k1, x + w.first);
-    w = WeakHashLen32WithSeeds(s + 32, z + w.second, y + Fetch64(s + 16));
-    std::swap(z, x);
-    s += 64;
-    len -= 64;
-  } while (len != 0);
-  return HashLen16(HashLen16(v.first, w.first) + ShiftMix(y) * k1 + z,
-                   HashLen16(v.second, w.second) + x);
-}
-
-uint64_t CityHash64WithSeed(const char *s, size_t len, uint64_t seed) {
-  return CityHash64WithSeeds(s, len, k2, seed);
-}
-
-uint64_t CityHash64WithSeeds(const char *s, size_t len, uint64_t seed0,
-                             uint64_t seed1) {
-  return HashLen16(CityHash64(s, len) - seed0, seed1);
-}
-
-}  // namespace hash_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
diff --git a/third_party/abseil_cpp/absl/hash/internal/city.h b/third_party/abseil_cpp/absl/hash/internal/city.h
deleted file mode 100644
index 393da0b95d9f..000000000000
--- a/third_party/abseil_cpp/absl/hash/internal/city.h
+++ /dev/null
@@ -1,78 +0,0 @@
-// 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.
-//
-// https://code.google.com/p/cityhash/
-//
-// This file provides a few functions for hashing strings.  All of them are
-// high-quality functions in the sense that they pass standard tests such
-// as Austin Appleby's SMHasher.  They are also fast.
-//
-// For 64-bit x86 code, on short strings, we don't know of anything faster than
-// CityHash64 that is of comparable quality.  We believe our nearest competitor
-// is Murmur3.  For 64-bit x86 code, CityHash64 is an excellent choice for hash
-// tables and most other hashing (excluding cryptography).
-//
-// For 32-bit x86 code, we don't know of anything faster than CityHash32 that
-// is of comparable quality.  We believe our nearest competitor is Murmur3A.
-// (On 64-bit CPUs, it is typically faster to use the other CityHash variants.)
-//
-// Functions in the CityHash family are not suitable for cryptography.
-//
-// Please see CityHash's README file for more details on our performance
-// measurements and so on.
-//
-// WARNING: This code has been only lightly tested on big-endian platforms!
-// It is known to work well on little-endian platforms that have a small penalty
-// for unaligned reads, such as current Intel and AMD moderate-to-high-end CPUs.
-// It should work on all 32-bit and 64-bit platforms that allow unaligned reads;
-// bug reports are welcome.
-//
-// By the way, for some hash functions, given strings a and b, the hash
-// of a+b is easily derived from the hashes of a and b.  This property
-// doesn't hold for any hash functions in this file.
-
-#ifndef ABSL_HASH_INTERNAL_CITY_H_
-#define ABSL_HASH_INTERNAL_CITY_H_
-
-#include <stdint.h>
-#include <stdlib.h>  // for size_t.
-
-#include <utility>
-
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace hash_internal {
-
-// Hash function for a byte array.
-uint64_t CityHash64(const char *s, size_t len);
-
-// Hash function for a byte array.  For convenience, a 64-bit seed is also
-// hashed into the result.
-uint64_t CityHash64WithSeed(const char *s, size_t len, uint64_t seed);
-
-// Hash function for a byte array.  For convenience, two seeds are also
-// hashed into the result.
-uint64_t CityHash64WithSeeds(const char *s, size_t len, uint64_t seed0,
-                             uint64_t seed1);
-
-// Hash function for a byte array.  Most useful in 32-bit binaries.
-uint32_t CityHash32(const char *s, size_t len);
-
-}  // namespace hash_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_HASH_INTERNAL_CITY_H_
diff --git a/third_party/abseil_cpp/absl/hash/internal/city_test.cc b/third_party/abseil_cpp/absl/hash/internal/city_test.cc
deleted file mode 100644
index 251d381d73e1..000000000000
--- a/third_party/abseil_cpp/absl/hash/internal/city_test.cc
+++ /dev/null
@@ -1,595 +0,0 @@
-// 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 "absl/hash/internal/city.h"
-
-#include <string.h>
-#include <cstdio>
-#include <iostream>
-#include "gtest/gtest.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace hash_internal {
-
-static const uint64_t k0 = 0xc3a5c85c97cb3127ULL;
-static const uint64_t kSeed0 = 1234567;
-static const uint64_t kSeed1 = k0;
-static const int kDataSize = 1 << 20;
-static const int kTestSize = 300;
-
-static char data[kDataSize];
-
-// Initialize data to pseudorandom values.
-void setup() {
-  uint64_t a = 9;
-  uint64_t b = 777;
-  for (int i = 0; i < kDataSize; i++) {
-    a += b;
-    b += a;
-    a = (a ^ (a >> 41)) * k0;
-    b = (b ^ (b >> 41)) * k0 + i;
-    uint8_t u = b >> 37;
-    memcpy(data + i, &u, 1);  // uint8_t -> char
-  }
-}
-
-#define C(x) 0x##x##ULL
-static const uint64_t testdata[kTestSize][4] = {
-    {C(9ae16a3b2f90404f), C(75106db890237a4a), C(3feac5f636039766),
-     C(dc56d17a)},
-    {C(541150e87f415e96), C(1aef0d24b3148a1a), C(bacc300e1e82345a),
-     C(99929334)},
-    {C(f3786a4b25827c1), C(34ee1a2bf767bd1c), C(2f15ca2ebfb631f2), C(4252edb7)},
-    {C(ef923a7a1af78eab), C(79163b1e1e9a9b18), C(df3b2aca6e1e4a30),
-     C(ebc34f3c)},
-    {C(11df592596f41d88), C(843ec0bce9042f9c), C(cce2ea1e08b1eb30),
-     C(26f2b463)},
-    {C(831f448bdc5600b3), C(62a24be3120a6919), C(1b44098a41e010da),
-     C(b042c047)},
-    {C(3eca803e70304894), C(d80de767e4a920a), C(a51cfbb292efd53d), C(e73bb0a8)},
-    {C(1b5a063fb4c7f9f1), C(318dbc24af66dee9), C(10ef7b32d5c719af),
-     C(91dfdd75)},
-    {C(a0f10149a0e538d6), C(69d008c20f87419f), C(41b36376185b3e9e),
-     C(c87f95de)},
-    {C(fb8d9c70660b910b), C(a45b0cc3476bff1b), C(b28d1996144f0207),
-     C(3f5538ef)},
-    {C(236827beae282a46), C(e43970221139c946), C(4f3ac6faa837a3aa),
-     C(70eb1a1f)},
-    {C(c385e435136ecf7c), C(d9d17368ff6c4a08), C(1b31eed4e5251a67),
-     C(cfd63b83)},
-    {C(e3f6828b6017086d), C(21b4d1900554b3b0), C(bef38be1809e24f1),
-     C(894a52ef)},
-    {C(851fff285561dca0), C(4d1277d73cdf416f), C(28ccffa61010ebe2),
-     C(9cde6a54)},
-    {C(61152a63595a96d9), C(d1a3a91ef3a7ba45), C(443b6bb4a493ad0c),
-     C(6c4898d5)},
-    {C(44473e03be306c88), C(30097761f872472a), C(9fd1b669bfad82d7),
-     C(13e1978e)},
-    {C(3ead5f21d344056), C(fb6420393cfb05c3), C(407932394cbbd303), C(51b4ba8)},
-    {C(6abbfde37ee03b5b), C(83febf188d2cc113), C(cda7b62d94d5b8ee),
-     C(b6b06e40)},
-    {C(943e7ed63b3c080), C(1ef207e9444ef7f8), C(ef4a9f9f8c6f9b4a), C(240a2f2)},
-    {C(d72ce05171ef8a1a), C(c6bd6bd869203894), C(c760e6396455d23a),
-     C(5dcefc30)},
-    {C(4182832b52d63735), C(337097e123eea414), C(b5a72ca0456df910),
-     C(7a48b105)},
-    {C(d6cdae892584a2cb), C(58de0fa4eca17dcd), C(43df30b8f5f1cb00),
-     C(fd55007b)},
-    {C(5c8e90bc267c5ee4), C(e9ae044075d992d9), C(f234cbfd1f0a1e59),
-     C(6b95894c)},
-    {C(bbd7f30ac310a6f3), C(b23b570d2666685f), C(fb13fb08c9814fe7),
-     C(3360e827)},
-    {C(36a097aa49519d97), C(8204380a73c4065), C(77c2004bdd9e276a), C(45177e0b)},
-    {C(dc78cb032c49217), C(112464083f83e03a), C(96ae53e28170c0f5), C(7c6fffe4)},
-    {C(441593e0da922dfe), C(936ef46061469b32), C(204a1921197ddd87),
-     C(bbc78da4)},
-    {C(2ba3883d71cc2133), C(72f2bbb32bed1a3c), C(27e1bd96d4843251),
-     C(c5c25d39)},
-    {C(f2b6d2adf8423600), C(7514e2f016a48722), C(43045743a50396ba),
-     C(b6e5d06e)},
-    {C(38fffe7f3680d63c), C(d513325255a7a6d1), C(31ed47790f6ca62f),
-     C(6178504e)},
-    {C(b7477bf0b9ce37c6), C(63b1c580a7fd02a4), C(f6433b9f10a5dac), C(bd4c3637)},
-    {C(55bdb0e71e3edebd), C(c7ab562bcf0568bc), C(43166332f9ee684f),
-     C(6e7ac474)},
-    {C(782fa1b08b475e7), C(fb7138951c61b23b), C(9829105e234fb11e), C(1fb4b518)},
-    {C(c5dc19b876d37a80), C(15ffcff666cfd710), C(e8c30c72003103e2),
-     C(31d13d6d)},
-    {C(5e1141711d2d6706), C(b537f6dee8de6933), C(3af0a1fbbe027c54),
-     C(26fa72e3)},
-    {C(782edf6da001234f), C(f48cbd5c66c48f3), C(808754d1e64e2a32), C(6a7433bf)},
-    {C(d26285842ff04d44), C(8f38d71341eacca9), C(5ca436f4db7a883c),
-     C(4e6df758)},
-    {C(c6ab830865a6bae6), C(6aa8e8dd4b98815c), C(efe3846713c371e5),
-     C(d57f63ea)},
-    {C(44b3a1929232892), C(61dca0e914fc217), C(a607cc142096b964), C(52ef73b3)},
-    {C(4b603d7932a8de4f), C(fae64c464b8a8f45), C(8fafab75661d602a), C(3cb36c3)},
-    {C(4ec0b54cf1566aff), C(30d2c7269b206bf4), C(77c22e82295e1061),
-     C(72c39bea)},
-    {C(ed8b7a4b34954ff7), C(56432de31f4ee757), C(85bd3abaa572b155),
-     C(a65aa25c)},
-    {C(5d28b43694176c26), C(714cc8bc12d060ae), C(3437726273a83fe6),
-     C(74740539)},
-    {C(6a1ef3639e1d202e), C(919bc1bd145ad928), C(30f3f7e48c28a773),
-     C(c3ae3c26)},
-    {C(159f4d9e0307b111), C(3e17914a5675a0c), C(af849bd425047b51), C(f29db8a2)},
-    {C(cc0a840725a7e25b), C(57c69454396e193a), C(976eaf7eee0b4540),
-     C(1ef4cbf4)},
-    {C(a2b27ee22f63c3f1), C(9ebde0ce1b3976b2), C(2fe6a92a257af308),
-     C(a9be6c41)},
-    {C(d8f2f234899bcab3), C(b10b037297c3a168), C(debea2c510ceda7f), C(fa31801)},
-    {C(584f28543864844f), C(d7cee9fc2d46f20d), C(a38dca5657387205),
-     C(8331c5d8)},
-    {C(a94be46dd9aa41af), C(a57e5b7723d3f9bd), C(34bf845a52fd2f), C(e9876db8)},
-    {C(9a87bea227491d20), C(a468657e2b9c43e7), C(af9ba60db8d89ef7),
-     C(27b0604e)},
-    {C(27688c24958d1a5c), C(e3b4a1c9429cf253), C(48a95811f70d64bc),
-     C(dcec07f2)},
-    {C(5d1d37790a1873ad), C(ed9cd4bcc5fa1090), C(ce51cde05d8cd96a),
-     C(cff0a82a)},
-    {C(1f03fd18b711eea9), C(566d89b1946d381a), C(6e96e83fc92563ab),
-     C(fec83621)},
-    {C(f0316f286cf527b6), C(f84c29538de1aa5a), C(7612ed3c923d4a71), C(743d8dc)},
-    {C(297008bcb3e3401d), C(61a8e407f82b0c69), C(a4a35bff0524fa0e),
-     C(64d41d26)},
-    {C(43c6252411ee3be), C(b4ca1b8077777168), C(2746dc3f7da1737f), C(acd90c81)},
-    {C(ce38a9a54fad6599), C(6d6f4a90b9e8755e), C(c3ecc79ff105de3f),
-     C(7c746a4b)},
-    {C(270a9305fef70cf), C(600193999d884f3a), C(f4d49eae09ed8a1), C(b1047e99)},
-    {C(e71be7c28e84d119), C(eb6ace59932736e6), C(70c4397807ba12c5),
-     C(d1fd1068)},
-    {C(b5b58c24b53aaa19), C(d2a6ab0773dd897f), C(ef762fe01ecb5b97),
-     C(56486077)},
-    {C(44dd59bd301995cf), C(3ccabd76493ada1a), C(540db4c87d55ef23),
-     C(6069be80)},
-    {C(b4d4789eb6f2630b), C(bf6973263ce8ef0e), C(d1c75c50844b9d3), C(2078359b)},
-    {C(12807833c463737c), C(58e927ea3b3776b4), C(72dd20ef1c2f8ad0),
-     C(9ea21004)},
-    {C(e88419922b87176f), C(bcf32f41a7ddbf6f), C(d6ebefd8085c1a0f),
-     C(9c9cfe88)},
-    {C(105191e0ec8f7f60), C(5918dbfcca971e79), C(6b285c8a944767b9),
-     C(b70a6ddd)},
-    {C(a5b88bf7399a9f07), C(fca3ddfd96461cc4), C(ebe738fdc0282fc6),
-     C(dea37298)},
-    {C(d08c3f5747d84f50), C(4e708b27d1b6f8ac), C(70f70fd734888606),
-     C(8f480819)},
-    {C(2f72d12a40044b4b), C(889689352fec53de), C(f03e6ad87eb2f36), C(30b3b16)},
-    {C(aa1f61fdc5c2e11e), C(c2c56cd11277ab27), C(a1e73069fdf1f94f),
-     C(f31bc4e8)},
-    {C(9489b36fe2246244), C(3355367033be74b8), C(5f57c2277cbce516),
-     C(419f953b)},
-    {C(358d7c0476a044cd), C(e0b7b47bcbd8854f), C(ffb42ec696705519),
-     C(20e9e76d)},
-    {C(b0c48df14275265a), C(9da4448975905efa), C(d716618e414ceb6d),
-     C(646f0ff8)},
-    {C(daa70bb300956588), C(410ea6883a240c6d), C(f5c8239fb5673eb3),
-     C(eeb7eca8)},
-    {C(4ec97a20b6c4c7c2), C(5913b1cd454f29fd), C(a9629f9daf06d685), C(8112bb9)},
-    {C(5c3323628435a2e8), C(1bea45ce9e72a6e3), C(904f0a7027ddb52e),
-     C(85a6d477)},
-    {C(c1ef26bea260abdb), C(6ee423f2137f9280), C(df2118b946ed0b43),
-     C(56f76c84)},
-    {C(6be7381b115d653a), C(ed046190758ea511), C(de6a45ffc3ed1159),
-     C(9af45d55)},
-    {C(ae3eece1711b2105), C(14fd3f4027f81a4a), C(abb7e45177d151db),
-     C(d1c33760)},
-    {C(376c28588b8fb389), C(6b045e84d8491ed2), C(4e857effb7d4e7dc),
-     C(c56bbf69)},
-    {C(58d943503bb6748f), C(419c6c8e88ac70f6), C(586760cbf3d3d368),
-     C(abecfb9b)},
-    {C(dfff5989f5cfd9a1), C(bcee2e7ea3a96f83), C(681c7874adb29017),
-     C(8de13255)},
-    {C(7fb19eb1a496e8f5), C(d49e5dfdb5c0833f), C(c0d5d7b2f7c48dc7),
-     C(a98ee299)},
-    {C(5dba5b0dadccdbaa), C(4ba8da8ded87fcdc), C(f693fdd25badf2f0),
-     C(3015f556)},
-    {C(688bef4b135a6829), C(8d31d82abcd54e8e), C(f95f8a30d55036d7),
-     C(5a430e29)},
-    {C(d8323be05433a412), C(8d48fa2b2b76141d), C(3d346f23978336a5),
-     C(2797add0)},
-    {C(3b5404278a55a7fc), C(23ca0b327c2d0a81), C(a6d65329571c892c),
-     C(27d55016)},
-    {C(2a96a3f96c5e9bbc), C(8caf8566e212dda8), C(904de559ca16e45e),
-     C(84945a82)},
-    {C(22bebfdcc26d18ff), C(4b4d8dcb10807ba1), C(40265eee30c6b896),
-     C(3ef7e224)},
-    {C(627a2249ec6bbcc2), C(c0578b462a46735a), C(4974b8ee1c2d4f1f),
-     C(35ed8dc8)},
-    {C(3abaf1667ba2f3e0), C(ee78476b5eeadc1), C(7e56ac0a6ca4f3f4), C(6a75e43d)},
-    {C(3931ac68c5f1b2c9), C(efe3892363ab0fb0), C(40b707268337cd36),
-     C(235d9805)},
-    {C(b98fb0606f416754), C(46a6e5547ba99c1e), C(c909d82112a8ed2), C(f7d69572)},
-    {C(7f7729a33e58fcc4), C(2e4bc1e7a023ead4), C(e707008ea7ca6222),
-     C(bacd0199)},
-    {C(42a0aa9ce82848b3), C(57232730e6bee175), C(f89bb3f370782031),
-     C(e428f50e)},
-    {C(6b2c6d38408a4889), C(de3ef6f68fb25885), C(20754f456c203361),
-     C(81eaaad3)},
-    {C(930380a3741e862a), C(348d28638dc71658), C(89dedcfd1654ea0d),
-     C(addbd3e3)},
-    {C(94808b5d2aa25f9a), C(cec72968128195e0), C(d9f4da2bdc1e130f),
-     C(e66dbca0)},
-    {C(b31abb08ae6e3d38), C(9eb9a95cbd9e8223), C(8019e79b7ee94ea9),
-     C(afe11fd5)},
-    {C(dccb5534a893ea1a), C(ce71c398708c6131), C(fe2396315457c164),
-     C(a71a406f)},
-    {C(6369163565814de6), C(8feb86fb38d08c2f), C(4976933485cc9a20),
-     C(9d90eaf5)},
-    {C(edee4ff253d9f9b3), C(96ef76fb279ef0ad), C(a4d204d179db2460),
-     C(6665db10)},
-    {C(941993df6e633214), C(929bc1beca5b72c6), C(141fc52b8d55572d),
-     C(9c977cbf)},
-    {C(859838293f64cd4c), C(484403b39d44ad79), C(bf674e64d64b9339),
-     C(ee83ddd4)},
-    {C(c19b5648e0d9f555), C(328e47b2b7562993), C(e756b92ba4bd6a51), C(26519cc)},
-    {C(f963b63b9006c248), C(9e9bf727ffaa00bc), C(c73bacc75b917e3a),
-     C(a485a53f)},
-    {C(6a8aa0852a8c1f3b), C(c8f1e5e206a21016), C(2aa554aed1ebb524),
-     C(f62bc412)},
-    {C(740428b4d45e5fb8), C(4c95a4ce922cb0a5), C(e99c3ba78feae796),
-     C(8975a436)},
-    {C(658b883b3a872b86), C(2f0e303f0f64827a), C(975337e23dc45e1), C(94ff7f41)},
-    {C(6df0a977da5d27d4), C(891dd0e7cb19508), C(fd65434a0b71e680), C(760aa031)},
-    {C(a900275464ae07ef), C(11f2cfda34beb4a3), C(9abf91e5a1c38e4), C(3bda76df)},
-    {C(810bc8aa0c40bcb0), C(448a019568d01441), C(f60ec52f60d3aeae),
-     C(498e2e65)},
-    {C(22036327deb59ed7), C(adc05ceb97026a02), C(48bff0654262672b),
-     C(d38deb48)},
-    {C(7d14dfa9772b00c8), C(595735efc7eeaed7), C(29872854f94c3507),
-     C(82b3fb6b)},
-    {C(2d777cddb912675d), C(278d7b10722a13f9), C(f5c02bfb7cc078af),
-     C(e500e25f)},
-    {C(f2ec98824e8aa613), C(5eb7e3fb53fe3bed), C(12c22860466e1dd4),
-     C(bd2bb07c)},
-    {C(5e763988e21f487f), C(24189de8065d8dc5), C(d1519d2403b62aa0),
-     C(3a2b431d)},
-    {C(48949dc327bb96ad), C(e1fd21636c5c50b4), C(3f6eb7f13a8712b4),
-     C(7322a83d)},
-    {C(b7c4209fb24a85c5), C(b35feb319c79ce10), C(f0d3de191833b922),
-     C(a645ca1c)},
-    {C(9c9e5be0943d4b05), C(b73dc69e45201cbb), C(aab17180bfe5083d),
-     C(8909a45a)},
-    {C(3898bca4dfd6638d), C(f911ff35efef0167), C(24bdf69e5091fc88),
-     C(bd30074c)},
-    {C(5b5d2557400e68e7), C(98d610033574cee), C(dfd08772ce385deb), C(c17cf001)},
-    {C(a927ed8b2bf09bb6), C(606e52f10ae94eca), C(71c2203feb35a9ee),
-     C(26ffd25a)},
-    {C(8d25746414aedf28), C(34b1629d28b33d3a), C(4d5394aea5f82d7b),
-     C(f1d8ce3c)},
-    {C(b5bbdb73458712f2), C(1ff887b3c2a35137), C(7f7231f702d0ace9),
-     C(3ee8fb17)},
-    {C(3d32a26e3ab9d254), C(fc4070574dc30d3a), C(f02629579c2b27c9),
-     C(a77acc2a)},
-    {C(9371d3c35fa5e9a5), C(42967cf4d01f30), C(652d1eeae704145c), C(f4556dee)},
-    {C(cbaa3cb8f64f54e0), C(76c3b48ee5c08417), C(9f7d24e87e61ce9), C(de287a64)},
-    {C(b2e23e8116c2ba9f), C(7e4d9c0060101151), C(3310da5e5028f367),
-     C(878e55b9)},
-    {C(8aa77f52d7868eb9), C(4d55bd587584e6e2), C(d2db37041f495f5), C(7648486)},
-    {C(858fea922c7fe0c3), C(cfe8326bf733bc6f), C(4e5e2018cf8f7dfc),
-     C(57ac0fb1)},
-    {C(46ef25fdec8392b1), C(e48d7b6d42a5cd35), C(56a6fe1c175299ca),
-     C(d01967ca)},
-    {C(8d078f726b2df464), C(b50ee71cdcabb299), C(f4af300106f9c7ba),
-     C(96ecdf74)},
-    {C(35ea86e6960ca950), C(34fe1fe234fc5c76), C(a00207a3dc2a72b7),
-     C(779f5506)},
-    {C(8aee9edbc15dd011), C(51f5839dc8462695), C(b2213e17c37dca2d),
-     C(3c94c2de)},
-    {C(c3e142ba98432dda), C(911d060cab126188), C(b753fbfa8365b844),
-     C(39f98faf)},
-    {C(123ba6b99c8cd8db), C(448e582672ee07c4), C(cebe379292db9e65),
-     C(7af31199)},
-    {C(ba87acef79d14f53), C(b3e0fcae63a11558), C(d5ac313a593a9f45),
-     C(e341a9d6)},
-    {C(bcd3957d5717dc3), C(2da746741b03a007), C(873816f4b1ece472), C(ca24aeeb)},
-    {C(61442ff55609168e), C(6447c5fc76e8c9cf), C(6a846de83ae15728),
-     C(b2252b57)},
-    {C(dbe4b1b2d174757f), C(506512da18712656), C(6857f3e0b8dd95f), C(72c81da1)},
-    {C(531e8e77b363161c), C(eece0b43e2dae030), C(8294b82c78f34ed1),
-     C(6b9fce95)},
-    {C(f71e9c926d711e2b), C(d77af2853a4ceaa1), C(9aa0d6d76a36fae7),
-     C(19399857)},
-    {C(cb20ac28f52df368), C(e6705ee7880996de), C(9b665cc3ec6972f2),
-     C(3c57a994)},
-    {C(e4a794b4acb94b55), C(89795358057b661b), C(9c4cdcec176d7a70),
-     C(c053e729)},
-    {C(cb942e91443e7208), C(e335de8125567c2a), C(d4d74d268b86df1f),
-     C(51cbbba7)},
-    {C(ecca7563c203f7ba), C(177ae2423ef34bb2), C(f60b7243400c5731),
-     C(1acde79a)},
-    {C(1652cb940177c8b5), C(8c4fe7d85d2a6d6d), C(f6216ad097e54e72),
-     C(2d160d13)},
-    {C(31fed0fc04c13ce8), C(3d5d03dbf7ff240a), C(727c5c9b51581203),
-     C(787f5801)},
-    {C(e7b668947590b9b3), C(baa41ad32938d3fa), C(abcbc8d4ca4b39e4),
-     C(c9629828)},
-    {C(1de2119923e8ef3c), C(6ab27c096cf2fe14), C(8c3658edca958891),
-     C(be139231)},
-    {C(1269df1e69e14fa7), C(992f9d58ac5041b7), C(e97fcf695a7cbbb4),
-     C(7df699ef)},
-    {C(820826d7aba567ff), C(1f73d28e036a52f3), C(41c4c5a73f3b0893),
-     C(8ce6b96d)},
-    {C(ffe0547e4923cef9), C(3534ed49b9da5b02), C(548a273700fba03d),
-     C(6f9ed99c)},
-    {C(72da8d1b11d8bc8b), C(ba94b56b91b681c6), C(4e8cc51bd9b0fc8c),
-     C(e0244796)},
-    {C(d62ab4e3f88fc797), C(ea86c7aeb6283ae4), C(b5b93e09a7fe465), C(4ccf7e75)},
-    {C(d0f06c28c7b36823), C(1008cb0874de4bb8), C(d6c7ff816c7a737b),
-     C(915cef86)},
-    {C(99b7042460d72ec6), C(2a53e5e2b8e795c2), C(53a78132d9e1b3e3),
-     C(5cb59482)},
-    {C(4f4dfcfc0ec2bae5), C(841233148268a1b8), C(9248a76ab8be0d3), C(6ca3f532)},
-    {C(fe86bf9d4422b9ae), C(ebce89c90641ef9c), C(1c84e2292c0b5659),
-     C(e24f3859)},
-    {C(a90d81060932dbb0), C(8acfaa88c5fbe92b), C(7c6f3447e90f7f3f),
-     C(adf5a9c7)},
-    {C(17938a1b0e7f5952), C(22cadd2f56f8a4be), C(84b0d1183d5ed7c1),
-     C(32264b75)},
-    {C(de9e0cb0e16f6e6d), C(238e6283aa4f6594), C(4fb9c914c2f0a13b),
-     C(a64b3376)},
-    {C(6d4b876d9b146d1a), C(aab2d64ce8f26739), C(d315f93600e83fe5), C(d33890e)},
-    {C(e698fa3f54e6ea22), C(bd28e20e7455358c), C(9ace161f6ea76e66),
-     C(926d4b63)},
-    {C(7bc0deed4fb349f7), C(1771aff25dc722fa), C(19ff0644d9681917),
-     C(d51ba539)},
-    {C(db4b15e88533f622), C(256d6d2419b41ce9), C(9d7c5378396765d5),
-     C(7f37636d)},
-    {C(922834735e86ecb2), C(363382685b88328e), C(e9c92960d7144630),
-     C(b98026c0)},
-    {C(30f1d72c812f1eb8), C(b567cd4a69cd8989), C(820b6c992a51f0bc),
-     C(b877767e)},
-    {C(168884267f3817e9), C(5b376e050f637645), C(1c18314abd34497a), C(aefae77)},
-    {C(82e78596ee3e56a7), C(25697d9c87f30d98), C(7600a8342834924d), C(f686911)},
-    {C(aa2d6cf22e3cc252), C(9b4dec4f5e179f16), C(76fb0fba1d99a99a),
-     C(3deadf12)},
-    {C(7bf5ffd7f69385c7), C(fc077b1d8bc82879), C(9c04e36f9ed83a24),
-     C(ccf02a4e)},
-    {C(e89c8ff9f9c6e34b), C(f54c0f669a49f6c4), C(fc3e46f5d846adef),
-     C(176c1722)},
-    {C(a18fbcdccd11e1f4), C(8248216751dfd65e), C(40c089f208d89d7c), C(26f82ad)},
-    {C(2d54f40cc4088b17), C(59d15633b0cd1399), C(a8cc04bb1bffd15b),
-     C(b5244f42)},
-    {C(69276946cb4e87c7), C(62bdbe6183be6fa9), C(3ba9773dac442a1a),
-     C(49a689e5)},
-    {C(668174a3f443df1d), C(407299392da1ce86), C(c2a3f7d7f2c5be28), C(59fcdd3)},
-    {C(5e29be847bd5046), C(b561c7f19c8f80c3), C(5e5abd5021ccaeaf), C(4f4b04e9)},
-    {C(cd0d79f2164da014), C(4c386bb5c5d6ca0c), C(8e771b03647c3b63),
-     C(8b00f891)},
-    {C(e0e6fc0b1628af1d), C(29be5fb4c27a2949), C(1c3f781a604d3630),
-     C(16e114f3)},
-    {C(2058927664adfd93), C(6e8f968c7963baa5), C(af3dced6fff7c394),
-     C(d6b6dadc)},
-    {C(dc107285fd8e1af7), C(a8641a0609321f3f), C(db06e89ffdc54466),
-     C(897e20ac)},
-    {C(fbba1afe2e3280f1), C(755a5f392f07fce), C(9e44a9a15402809a), C(f996e05d)},
-    {C(bfa10785ddc1011b), C(b6e1c4d2f670f7de), C(517d95604e4fcc1f),
-     C(c4306af6)},
-    {C(534cc35f0ee1eb4e), C(b703820f1f3b3dce), C(884aa164cf22363), C(6dcad433)},
-    {C(7ca6e3933995dac), C(fd118c77daa8188), C(3aceb7b5e7da6545), C(3c07374d)},
-    {C(f0d6044f6efd7598), C(e044d6ba4369856e), C(91968e4f8c8a1a4c),
-     C(f0f4602c)},
-    {C(3d69e52049879d61), C(76610636ea9f74fe), C(e9bf5602f89310c0),
-     C(3e1ea071)},
-    {C(79da242a16acae31), C(183c5f438e29d40), C(6d351710ae92f3de), C(67580f0c)},
-    {C(461c82656a74fb57), C(d84b491b275aa0f7), C(8f262cb29a6eb8b2),
-     C(4e109454)},
-    {C(53c1a66d0b13003), C(731f060e6fe797fc), C(daa56811791371e3), C(88a474a7)},
-    {C(d3a2efec0f047e9), C(1cabce58853e58ea), C(7a17b2eae3256be4), C(5b5bedd)},
-    {C(43c64d7484f7f9b2), C(5da002b64aafaeb7), C(b576c1e45800a716),
-     C(1aaddfa7)},
-    {C(a7dec6ad81cf7fa1), C(180c1ab708683063), C(95e0fd7008d67cff),
-     C(5be07fd8)},
-    {C(5408a1df99d4aff), C(b9565e588740f6bd), C(abf241813b08006e), C(cbca8606)},
-    {C(a8b27a6bcaeeed4b), C(aec1eeded6a87e39), C(9daf246d6fed8326),
-     C(bde64d01)},
-    {C(9a952a8246fdc269), C(d0dcfcac74ef278c), C(250f7139836f0f1f),
-     C(ee90cf33)},
-    {C(c930841d1d88684f), C(5eb66eb18b7f9672), C(e455d413008a2546),
-     C(4305c3ce)},
-    {C(94dc6971e3cf071a), C(994c7003b73b2b34), C(ea16e85978694e5), C(4b3a1d76)},
-    {C(7fc98006e25cac9), C(77fee0484cda86a7), C(376ec3d447060456), C(a8bb6d80)},
-    {C(bd781c4454103f6), C(612197322f49c931), C(b9cf17fd7e5462d5), C(1f9fa607)},
-    {C(da60e6b14479f9df), C(3bdccf69ece16792), C(18ebf45c4fecfdc9),
-     C(8d0e4ed2)},
-    {C(4ca56a348b6c4d3), C(60618537c3872514), C(2fbb9f0e65871b09), C(1bf31347)},
-    {C(ebd22d4b70946401), C(6863602bf7139017), C(c0b1ac4e11b00666),
-     C(1ae3fc5b)},
-    {C(3cc4693d6cbcb0c), C(501689ea1c70ffa), C(10a4353e9c89e364), C(459c3930)},
-    {C(38908e43f7ba5ef0), C(1ab035d4e7781e76), C(41d133e8c0a68ff7),
-     C(e00c4184)},
-    {C(34983ccc6aa40205), C(21802cad34e72bc4), C(1943e8fb3c17bb8), C(ffc7a781)},
-    {C(86215c45dcac9905), C(ea546afe851cae4b), C(d85b6457e489e374),
-     C(6a125480)},
-    {C(420fc255c38db175), C(d503cd0f3c1208d1), C(d4684e74c825a0bc),
-     C(88a1512b)},
-    {C(1d7a31f5bc8fe2f9), C(4763991092dcf836), C(ed695f55b97416f4),
-     C(549bbbe5)},
-    {C(94129a84c376a26e), C(c245e859dc231933), C(1b8f74fecf917453),
-     C(c133d38c)},
-    {C(1d3a9809dab05c8d), C(adddeb4f71c93e8), C(ef342eb36631edb), C(fcace348)},
-    {C(90fa3ccbd60848da), C(dfa6e0595b569e11), C(e585d067a1f5135d),
-     C(ed7b6f9a)},
-    {C(2dbb4fc71b554514), C(9650e04b86be0f82), C(60f2304fba9274d3),
-     C(6d907dda)},
-    {C(b98bf4274d18374a), C(1b669fd4c7f9a19a), C(b1f5972b88ba2b7a),
-     C(7a4d48d5)},
-    {C(d6781d0b5e18eb68), C(b992913cae09b533), C(58f6021caaee3a40),
-     C(e686f3db)},
-    {C(226651cf18f4884c), C(595052a874f0f51c), C(c9b75162b23bab42), C(cce7c55)},
-    {C(a734fb047d3162d6), C(e523170d240ba3a5), C(125a6972809730e8), C(f58b96b)},
-    {C(c6df6364a24f75a3), C(c294e2c84c4f5df8), C(a88df65c6a89313b),
-     C(1bbf6f60)},
-    {C(d8d1364c1fbcd10), C(2d7cc7f54832deaa), C(4e22c876a7c57625), C(ce5e0cc2)},
-    {C(aae06f9146db885f), C(3598736441e280d9), C(fba339b117083e55),
-     C(584cfd6f)},
-    {C(8955ef07631e3bcc), C(7d70965ea3926f83), C(39aed4134f8b2db6),
-     C(8f9bbc33)},
-    {C(ad611c609cfbe412), C(d3c00b18bf253877), C(90b2172e1f3d0bfd),
-     C(d7640d95)},
-    {C(d5339adc295d5d69), C(b633cc1dcb8b586a), C(ee84184cf5b1aeaf), C(3d12a2b)},
-    {C(40d0aeff521375a8), C(77ba1ad7ecebd506), C(547c6f1a7d9df427),
-     C(aaeafed0)},
-    {C(8b2d54ae1a3df769), C(11e7adaee3216679), C(3483781efc563e03),
-     C(95b9b814)},
-    {C(99c175819b4eae28), C(932e8ff9f7a40043), C(ec78dcab07ca9f7c),
-     C(45fbe66e)},
-    {C(2a418335779b82fc), C(af0295987849a76b), C(c12bc5ff0213f46e),
-     C(b4baa7a8)},
-    {C(3b1fc6a3d279e67d), C(70ea1e49c226396), C(25505adcf104697c), C(83e962fe)},
-    {C(d97eacdf10f1c3c9), C(b54f4654043a36e0), C(b128f6eb09d1234), C(aac3531c)},
-    {C(293a5c1c4e203cd4), C(6b3329f1c130cefe), C(f2e32f8ec76aac91),
-     C(2b1db7cc)},
-    {C(4290e018ffaedde7), C(a14948545418eb5e), C(72d851b202284636),
-     C(cf00cd31)},
-    {C(f919a59cbde8bf2f), C(a56d04203b2dc5a5), C(38b06753ac871e48),
-     C(7d3c43b8)},
-    {C(1d70a3f5521d7fa4), C(fb97b3fdc5891965), C(299d49bbbe3535af),
-     C(cbd5fac6)},
-    {C(6af98d7b656d0d7c), C(d2e99ae96d6b5c0c), C(f63bd1603ef80627),
-     C(76d0fec4)},
-    {C(395b7a8adb96ab75), C(582df7165b20f4a), C(e52bd30e9ff657f9), C(405e3402)},
-    {C(3822dd82c7df012f), C(b9029b40bd9f122b), C(fd25b988468266c4),
-     C(c732c481)},
-    {C(79f7efe4a80b951a), C(dd3a3fddfc6c9c41), C(ab4c812f9e27aa40),
-     C(a8d123c9)},
-    {C(ae6e59f5f055921a), C(e9d9b7bf68e82), C(5ce4e4a5b269cc59), C(1e80ad7d)},
-    {C(8959dbbf07387d36), C(b4658afce48ea35d), C(8f3f82437d8cb8d6),
-     C(52aeb863)},
-    {C(4739613234278a49), C(99ea5bcd340bf663), C(258640912e712b12),
-     C(ef7c0c18)},
-    {C(420e6c926bc54841), C(96dbbf6f4e7c75cd), C(d8d40fa70c3c67bb),
-     C(b6ad4b68)},
-    {C(c8601bab561bc1b7), C(72b26272a0ff869a), C(56fdfc986d6bc3c4),
-     C(c1e46b17)},
-    {C(b2d294931a0e20eb), C(284ffd9a0815bc38), C(1f8a103aac9bbe6), C(57b8df25)},
-    {C(7966f53c37b6c6d7), C(8e6abcfb3aa2b88f), C(7f2e5e0724e5f345),
-     C(e9fa36d6)},
-    {C(be9bb0abd03b7368), C(13bca93a3031be55), C(e864f4f52b55b472),
-     C(8f8daefc)},
-    {C(a08d128c5f1649be), C(a8166c3dbbe19aad), C(cb9f914f829ec62c), C(6e1bb7e)},
-    {C(7c386f0ffe0465ac), C(530419c9d843dbf3), C(7450e3a4f72b8d8c),
-     C(fd0076f0)},
-    {C(bb362094e7ef4f8), C(ff3c2a48966f9725), C(55152803acd4a7fe), C(899b17b6)},
-    {C(cd80dea24321eea4), C(52b4fdc8130c2b15), C(f3ea100b154bfb82),
-     C(e3e84e31)},
-    {C(d599a04125372c3a), C(313136c56a56f363), C(1e993c3677625832),
-     C(eef79b6b)},
-    {C(dbbf541e9dfda0a), C(1479fceb6db4f844), C(31ab576b59062534), C(868e3315)},
-    {C(c2ee3288be4fe2bf), C(c65d2f5ddf32b92), C(af6ecdf121ba5485), C(4639a426)},
-    {C(d86603ced1ed4730), C(f9de718aaada7709), C(db8b9755194c6535),
-     C(f3213646)},
-    {C(915263c671b28809), C(a815378e7ad762fd), C(abec6dc9b669f559),
-     C(17f148e9)},
-    {C(2b67cdd38c307a5e), C(cb1d45bb5c9fe1c), C(800baf2a02ec18ad), C(bfd94880)},
-    {C(2d107419073b9cd0), C(a96db0740cef8f54), C(ec41ee91b3ecdc1b),
-     C(bb1fa7f3)},
-    {C(f3e9487ec0e26dfc), C(1ab1f63224e837fa), C(119983bb5a8125d8), C(88816b1)},
-    {C(1160987c8fe86f7d), C(879e6db1481eb91b), C(d7dcb802bfe6885d),
-     C(5c2faeb3)},
-    {C(eab8112c560b967b), C(97f550b58e89dbae), C(846ed506d304051f),
-     C(51b5fc6f)},
-    {C(1addcf0386d35351), C(b5f436561f8f1484), C(85d38e22181c9bb1),
-     C(33d94752)},
-    {C(d445ba84bf803e09), C(1216c2497038f804), C(2293216ea2237207),
-     C(b0c92948)},
-    {C(37235a096a8be435), C(d9b73130493589c2), C(3b1024f59378d3be),
-     C(c7171590)},
-    {C(763ad6ea2fe1c99d), C(cf7af5368ac1e26b), C(4d5e451b3bb8d3d4),
-     C(240a67fb)},
-    {C(ea627fc84cd1b857), C(85e372494520071f), C(69ec61800845780b),
-     C(e1843cd5)},
-    {C(1f2ffd79f2cdc0c8), C(726a1bc31b337aaa), C(678b7f275ef96434),
-     C(fda1452b)},
-    {C(39a9e146ec4b3210), C(f63f75802a78b1ac), C(e2e22539c94741c3),
-     C(a2cad330)},
-    {C(74cba303e2dd9d6d), C(692699b83289fad1), C(dfb9aa7874678480),
-     C(53467e16)},
-    {C(4cbc2b73a43071e0), C(56c5db4c4ca4e0b7), C(1b275a162f46bd3d),
-     C(da14a8d0)},
-    {C(875638b9715d2221), C(d9ba0615c0c58740), C(616d4be2dfe825aa),
-     C(67333551)},
-    {C(fb686b2782994a8d), C(edee60693756bb48), C(e6bc3cae0ded2ef5),
-     C(a0ebd66e)},
-    {C(ab21d81a911e6723), C(4c31b07354852f59), C(835da384c9384744),
-     C(4b769593)},
-    {C(33d013cc0cd46ecf), C(3de726423aea122c), C(116af51117fe21a9),
-     C(6aa75624)},
-    {C(8ca92c7cd39fae5d), C(317e620e1bf20f1), C(4f0b33bf2194b97f), C(602a3f96)},
-    {C(fdde3b03f018f43e), C(38f932946c78660), C(c84084ce946851ee), C(cd183c4d)},
-    {C(9c8502050e9c9458), C(d6d2a1a69964beb9), C(1675766f480229b5),
-     C(960a4d07)},
-    {C(348176ca2fa2fdd2), C(3a89c514cc360c2d), C(9f90b8afb318d6d0),
-     C(9ae998c4)},
-    {C(4a3d3dfbbaea130b), C(4e221c920f61ed01), C(553fd6cd1304531f),
-     C(74e2179d)},
-    {C(b371f768cdf4edb9), C(bdef2ace6d2de0f0), C(e05b4100f7f1baec),
-     C(ee9bae25)},
-    {C(7a1d2e96934f61f), C(eb1760ae6af7d961), C(887eb0da063005df), C(b66edf10)},
-    {C(8be53d466d4728f2), C(86a5ac8e0d416640), C(984aa464cdb5c8bb),
-     C(d6209737)},
-    {C(829677eb03abf042), C(43cad004b6bc2c0), C(f2f224756803971a), C(b994a88)},
-    {C(754435bae3496fc), C(5707fc006f094dcf), C(8951c86ab19d8e40), C(a05d43c0)},
-    {C(fda9877ea8e3805f), C(31e868b6ffd521b7), C(b08c90681fb6a0fd),
-     C(c79f73a8)},
-    {C(2e36f523ca8f5eb5), C(8b22932f89b27513), C(331cd6ecbfadc1bb),
-     C(a490aff5)},
-    {C(21a378ef76828208), C(a5c13037fa841da2), C(506d22a53fbe9812),
-     C(dfad65b4)},
-    {C(ccdd5600054b16ca), C(f78846e84204cb7b), C(1f9faec82c24eac9), C(1d07dfb)},
-    {C(7854468f4e0cabd0), C(3a3f6b4f098d0692), C(ae2423ec7799d30d),
-     C(416df9a0)},
-    {C(7f88db5346d8f997), C(88eac9aacc653798), C(68a4d0295f8eefa1),
-     C(1f8fb9cc)},
-    {C(bb3fb5fb01d60fcf), C(1b7cc0847a215eb6), C(1246c994437990a1),
-     C(7abf48e3)},
-    {C(2e783e1761acd84d), C(39158042bac975a0), C(1cd21c5a8071188d),
-     C(dea4e3dd)},
-    {C(392058251cf22acc), C(944ec4475ead4620), C(b330a10b5cb94166),
-     C(c6064f22)},
-    {C(adf5c1e5d6419947), C(2a9747bc659d28aa), C(95c5b8cb1f5d62c), C(743bed9c)},
-    {C(6bc1db2c2bee5aba), C(e63b0ed635307398), C(7b2eca111f30dbbc),
-     C(fce254d5)},
-    {C(b00f898229efa508), C(83b7590ad7f6985c), C(2780e70a0592e41d),
-     C(e47ec9d1)},
-    {C(b56eb769ce0d9a8c), C(ce196117bfbcaf04), C(b26c3c3797d66165),
-     C(334a145c)},
-    {C(70c0637675b94150), C(259e1669305b0a15), C(46e1dd9fd387a58d),
-     C(adec1e3c)},
-    {C(74c0b8a6821faafe), C(abac39d7491370e7), C(faf0b2a48a4e6aed),
-     C(f6a9fbf8)},
-    {C(5fb5e48ac7b7fa4f), C(a96170f08f5acbc7), C(bbf5c63d4f52a1e5),
-     C(5398210c)},
-};
-
-void TestUnchanging(const uint64_t* expected, int offset, int len) {
-  EXPECT_EQ(expected[0], CityHash64(data + offset, len));
-  EXPECT_EQ(expected[3], CityHash32(data + offset, len));
-  EXPECT_EQ(expected[1], CityHash64WithSeed(data + offset, len, kSeed0));
-  EXPECT_EQ(expected[2],
-            CityHash64WithSeeds(data + offset, len, kSeed0, kSeed1));
-}
-
-TEST(CityHashTest, Unchanging) {
-  setup();
-  int i = 0;
-  for (; i < kTestSize - 1; i++) {
-    TestUnchanging(testdata[i], i * i, i);
-  }
-  TestUnchanging(testdata[i], 0, kDataSize);
-}
-
-}  // namespace hash_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
diff --git a/third_party/abseil_cpp/absl/hash/internal/hash.cc b/third_party/abseil_cpp/absl/hash/internal/hash.cc
deleted file mode 100644
index b44ecb3a6b66..000000000000
--- a/third_party/abseil_cpp/absl/hash/internal/hash.cc
+++ /dev/null
@@ -1,55 +0,0 @@
-// 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 "absl/hash/internal/hash.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace hash_internal {
-
-uint64_t CityHashState::CombineLargeContiguousImpl32(uint64_t state,
-                                                     const unsigned char* first,
-                                                     size_t len) {
-  while (len >= PiecewiseChunkSize()) {
-    state =
-        Mix(state, absl::hash_internal::CityHash32(reinterpret_cast<const char*>(first),
-                                         PiecewiseChunkSize()));
-    len -= PiecewiseChunkSize();
-    first += PiecewiseChunkSize();
-  }
-  // Handle the remainder.
-  return CombineContiguousImpl(state, first, len,
-                               std::integral_constant<int, 4>{});
-}
-
-uint64_t CityHashState::CombineLargeContiguousImpl64(uint64_t state,
-                                                     const unsigned char* first,
-                                                     size_t len) {
-  while (len >= PiecewiseChunkSize()) {
-    state =
-        Mix(state, absl::hash_internal::CityHash64(reinterpret_cast<const char*>(first),
-                                         PiecewiseChunkSize()));
-    len -= PiecewiseChunkSize();
-    first += PiecewiseChunkSize();
-  }
-  // Handle the remainder.
-  return CombineContiguousImpl(state, first, len,
-                               std::integral_constant<int, 8>{});
-}
-
-ABSL_CONST_INIT const void* const CityHashState::kSeed = &kSeed;
-
-}  // namespace hash_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
diff --git a/third_party/abseil_cpp/absl/hash/internal/hash.h b/third_party/abseil_cpp/absl/hash/internal/hash.h
deleted file mode 100644
index b0132da2069d..000000000000
--- a/third_party/abseil_cpp/absl/hash/internal/hash.h
+++ /dev/null
@@ -1,1003 +0,0 @@
-// 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.
-//
-// -----------------------------------------------------------------------------
-// File: hash.h
-// -----------------------------------------------------------------------------
-//
-#ifndef ABSL_HASH_INTERNAL_HASH_H_
-#define ABSL_HASH_INTERNAL_HASH_H_
-
-#include <algorithm>
-#include <array>
-#include <cmath>
-#include <cstring>
-#include <deque>
-#include <forward_list>
-#include <functional>
-#include <iterator>
-#include <limits>
-#include <list>
-#include <map>
-#include <memory>
-#include <set>
-#include <string>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include <vector>
-
-#include "absl/base/internal/endian.h"
-#include "absl/base/port.h"
-#include "absl/container/fixed_array.h"
-#include "absl/meta/type_traits.h"
-#include "absl/numeric/int128.h"
-#include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
-#include "absl/types/variant.h"
-#include "absl/utility/utility.h"
-#include "absl/hash/internal/city.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace hash_internal {
-
-// Internal detail: Large buffers are hashed in smaller chunks.  This function
-// returns the size of these chunks.
-constexpr size_t PiecewiseChunkSize() { return 1024; }
-
-// PiecewiseCombiner
-//
-// PiecewiseCombiner is an internal-only helper class for hashing a piecewise
-// buffer of `char` or `unsigned char` as though it were contiguous.  This class
-// provides two methods:
-//
-//   H add_buffer(state, data, size)
-//   H finalize(state)
-//
-// `add_buffer` can be called zero or more times, followed by a single call to
-// `finalize`.  This will produce the same hash expansion as concatenating each
-// buffer piece into a single contiguous buffer, and passing this to
-// `H::combine_contiguous`.
-//
-//  Example usage:
-//    PiecewiseCombiner combiner;
-//    for (const auto& piece : pieces) {
-//      state = combiner.add_buffer(std::move(state), piece.data, piece.size);
-//    }
-//    return combiner.finalize(std::move(state));
-class PiecewiseCombiner {
- public:
-  PiecewiseCombiner() : position_(0) {}
-  PiecewiseCombiner(const PiecewiseCombiner&) = delete;
-  PiecewiseCombiner& operator=(const PiecewiseCombiner&) = delete;
-
-  // PiecewiseCombiner::add_buffer()
-  //
-  // Appends the given range of bytes to the sequence to be hashed, which may
-  // modify the provided hash state.
-  template <typename H>
-  H add_buffer(H state, const unsigned char* data, size_t size);
-  template <typename H>
-  H add_buffer(H state, const char* data, size_t size) {
-    return add_buffer(std::move(state),
-                      reinterpret_cast<const unsigned char*>(data), size);
-  }
-
-  // PiecewiseCombiner::finalize()
-  //
-  // Finishes combining the hash sequence, which may may modify the provided
-  // hash state.
-  //
-  // Once finalize() is called, add_buffer() may no longer be called. The
-  // resulting hash state will be the same as if the pieces passed to
-  // add_buffer() were concatenated into a single flat buffer, and then provided
-  // to H::combine_contiguous().
-  template <typename H>
-  H finalize(H state);
-
- private:
-  unsigned char buf_[PiecewiseChunkSize()];
-  size_t position_;
-};
-
-// HashStateBase
-//
-// A hash state object represents an intermediate state in the computation
-// of an unspecified hash algorithm. `HashStateBase` provides a CRTP style
-// base class for hash state implementations. Developers adding type support
-// for `absl::Hash` should not rely on any parts of the state object other than
-// the following member functions:
-//
-//   * HashStateBase::combine()
-//   * HashStateBase::combine_contiguous()
-//
-// A derived hash state class of type `H` must provide a static member function
-// with a signature similar to the following:
-//
-//    `static H combine_contiguous(H state, const unsigned char*, size_t)`.
-//
-// `HashStateBase` will provide a complete implementation for a hash state
-// object in terms of this method.
-//
-// Example:
-//
-//   // Use CRTP to define your derived class.
-//   struct MyHashState : HashStateBase<MyHashState> {
-//       static H combine_contiguous(H state, const unsigned char*, size_t);
-//       using MyHashState::HashStateBase::combine;
-//       using MyHashState::HashStateBase::combine_contiguous;
-//   };
-template <typename H>
-class HashStateBase {
- public:
-  // HashStateBase::combine()
-  //
-  // Combines an arbitrary number of values into a hash state, returning the
-  // updated state.
-  //
-  // Each of the value types `T` must be separately hashable by the Abseil
-  // hashing framework.
-  //
-  // NOTE:
-  //
-  //   state = H::combine(std::move(state), value1, value2, value3);
-  //
-  // is guaranteed to produce the same hash expansion as:
-  //
-  //   state = H::combine(std::move(state), value1);
-  //   state = H::combine(std::move(state), value2);
-  //   state = H::combine(std::move(state), value3);
-  template <typename T, typename... Ts>
-  static H combine(H state, const T& value, const Ts&... values);
-  static H combine(H state) { return state; }
-
-  // HashStateBase::combine_contiguous()
-  //
-  // Combines a contiguous array of `size` elements into a hash state, returning
-  // the updated state.
-  //
-  // NOTE:
-  //
-  //   state = H::combine_contiguous(std::move(state), data, size);
-  //
-  // is NOT guaranteed to produce the same hash expansion as a for-loop (it may
-  // perform internal optimizations).  If you need this guarantee, use the
-  // for-loop instead.
-  template <typename T>
-  static H combine_contiguous(H state, const T* data, size_t size);
-
-  using AbslInternalPiecewiseCombiner = PiecewiseCombiner;
-};
-
-// is_uniquely_represented
-//
-// `is_uniquely_represented<T>` is a trait class that indicates whether `T`
-// is uniquely represented.
-//
-// A type is "uniquely represented" if two equal values of that type are
-// guaranteed to have the same bytes in their underlying storage. In other
-// words, if `a == b`, then `memcmp(&a, &b, sizeof(T))` is guaranteed to be
-// zero. This property cannot be detected automatically, so this trait is false
-// by default, but can be specialized by types that wish to assert that they are
-// uniquely represented. This makes them eligible for certain optimizations.
-//
-// If you have any doubt whatsoever, do not specialize this template.
-// The default is completely safe, and merely disables some optimizations
-// that will not matter for most types. Specializing this template,
-// on the other hand, can be very hazardous.
-//
-// To be uniquely represented, a type must not have multiple ways of
-// representing the same value; for example, float and double are not
-// uniquely represented, because they have distinct representations for
-// +0 and -0. Furthermore, the type's byte representation must consist
-// solely of user-controlled data, with no padding bits and no compiler-
-// controlled data such as vptrs or sanitizer metadata. This is usually
-// very difficult to guarantee, because in most cases the compiler can
-// insert data and padding bits at its own discretion.
-//
-// If you specialize this template for a type `T`, you must do so in the file
-// that defines that type (or in this file). If you define that specialization
-// anywhere else, `is_uniquely_represented<T>` could have different meanings
-// in different places.
-//
-// The Enable parameter is meaningless; it is provided as a convenience,
-// to support certain SFINAE techniques when defining specializations.
-template <typename T, typename Enable = void>
-struct is_uniquely_represented : std::false_type {};
-
-// is_uniquely_represented<unsigned char>
-//
-// unsigned char is a synonym for "byte", so it is guaranteed to be
-// uniquely represented.
-template <>
-struct is_uniquely_represented<unsigned char> : std::true_type {};
-
-// is_uniquely_represented for non-standard integral types
-//
-// Integral types other than bool should be uniquely represented on any
-// platform that this will plausibly be ported to.
-template <typename Integral>
-struct is_uniquely_represented<
-    Integral, typename std::enable_if<std::is_integral<Integral>::value>::type>
-    : std::true_type {};
-
-// is_uniquely_represented<bool>
-//
-//
-template <>
-struct is_uniquely_represented<bool> : std::false_type {};
-
-// hash_bytes()
-//
-// Convenience function that combines `hash_state` with the byte representation
-// of `value`.
-template <typename H, typename T>
-H hash_bytes(H hash_state, const T& value) {
-  const unsigned char* start = reinterpret_cast<const unsigned char*>(&value);
-  return H::combine_contiguous(std::move(hash_state), start, sizeof(value));
-}
-
-// -----------------------------------------------------------------------------
-// AbslHashValue for Basic Types
-// -----------------------------------------------------------------------------
-
-// Note: Default `AbslHashValue` implementations live in `hash_internal`. This
-// allows us to block lexical scope lookup when doing an unqualified call to
-// `AbslHashValue` below. User-defined implementations of `AbslHashValue` can
-// only be found via ADL.
-
-// AbslHashValue() for hashing bool values
-//
-// We use SFINAE to ensure that this overload only accepts bool, not types that
-// are convertible to bool.
-template <typename H, typename B>
-typename std::enable_if<std::is_same<B, bool>::value, H>::type AbslHashValue(
-    H hash_state, B value) {
-  return H::combine(std::move(hash_state),
-                    static_cast<unsigned char>(value ? 1 : 0));
-}
-
-// AbslHashValue() for hashing enum values
-template <typename H, typename Enum>
-typename std::enable_if<std::is_enum<Enum>::value, H>::type AbslHashValue(
-    H hash_state, Enum e) {
-  // In practice, we could almost certainly just invoke hash_bytes directly,
-  // but it's possible that a sanitizer might one day want to
-  // store data in the unused bits of an enum. To avoid that risk, we
-  // convert to the underlying type before hashing. Hopefully this will get
-  // optimized away; if not, we can reopen discussion with c-toolchain-team.
-  return H::combine(std::move(hash_state),
-                    static_cast<typename std::underlying_type<Enum>::type>(e));
-}
-// AbslHashValue() for hashing floating-point values
-template <typename H, typename Float>
-typename std::enable_if<std::is_same<Float, float>::value ||
-                            std::is_same<Float, double>::value,
-                        H>::type
-AbslHashValue(H hash_state, Float value) {
-  return hash_internal::hash_bytes(std::move(hash_state),
-                                   value == 0 ? 0 : value);
-}
-
-// Long double has the property that it might have extra unused bytes in it.
-// For example, in x86 sizeof(long double)==16 but it only really uses 80-bits
-// of it. This means we can't use hash_bytes on a long double and have to
-// convert it to something else first.
-template <typename H, typename LongDouble>
-typename std::enable_if<std::is_same<LongDouble, long double>::value, H>::type
-AbslHashValue(H hash_state, LongDouble value) {
-  const int category = std::fpclassify(value);
-  switch (category) {
-    case FP_INFINITE:
-      // Add the sign bit to differentiate between +Inf and -Inf
-      hash_state = H::combine(std::move(hash_state), std::signbit(value));
-      break;
-
-    case FP_NAN:
-    case FP_ZERO:
-    default:
-      // Category is enough for these.
-      break;
-
-    case FP_NORMAL:
-    case FP_SUBNORMAL:
-      // We can't convert `value` directly to double because this would have
-      // undefined behavior if the value is out of range.
-      // std::frexp gives us a value in the range (-1, -.5] or [.5, 1) that is
-      // guaranteed to be in range for `double`. The truncation is
-      // implementation defined, but that works as long as it is deterministic.
-      int exp;
-      auto mantissa = static_cast<double>(std::frexp(value, &exp));
-      hash_state = H::combine(std::move(hash_state), mantissa, exp);
-  }
-
-  return H::combine(std::move(hash_state), category);
-}
-
-// AbslHashValue() for hashing pointers
-template <typename H, typename T>
-H AbslHashValue(H hash_state, T* ptr) {
-  auto v = reinterpret_cast<uintptr_t>(ptr);
-  // Due to alignment, pointers tend to have low bits as zero, and the next few
-  // bits follow a pattern since they are also multiples of some base value.
-  // Mixing the pointer twice helps prevent stuck low bits for certain alignment
-  // values.
-  return H::combine(std::move(hash_state), v, v);
-}
-
-// AbslHashValue() for hashing nullptr_t
-template <typename H>
-H AbslHashValue(H hash_state, std::nullptr_t) {
-  return H::combine(std::move(hash_state), static_cast<void*>(nullptr));
-}
-
-// -----------------------------------------------------------------------------
-// AbslHashValue for Composite Types
-// -----------------------------------------------------------------------------
-
-// is_hashable()
-//
-// Trait class which returns true if T is hashable by the absl::Hash framework.
-// Used for the AbslHashValue implementations for composite types below.
-template <typename T>
-struct is_hashable;
-
-// AbslHashValue() for hashing pairs
-template <typename H, typename T1, typename T2>
-typename std::enable_if<is_hashable<T1>::value && is_hashable<T2>::value,
-                        H>::type
-AbslHashValue(H hash_state, const std::pair<T1, T2>& p) {
-  return H::combine(std::move(hash_state), p.first, p.second);
-}
-
-// hash_tuple()
-//
-// Helper function for hashing a tuple. The third argument should
-// be an index_sequence running from 0 to tuple_size<Tuple> - 1.
-template <typename H, typename Tuple, size_t... Is>
-H hash_tuple(H hash_state, const Tuple& t, absl::index_sequence<Is...>) {
-  return H::combine(std::move(hash_state), std::get<Is>(t)...);
-}
-
-// AbslHashValue for hashing tuples
-template <typename H, typename... Ts>
-#if defined(_MSC_VER)
-// This SFINAE gets MSVC confused under some conditions. Let's just disable it
-// for now.
-H
-#else  // _MSC_VER
-typename std::enable_if<absl::conjunction<is_hashable<Ts>...>::value, H>::type
-#endif  // _MSC_VER
-AbslHashValue(H hash_state, const std::tuple<Ts...>& t) {
-  return hash_internal::hash_tuple(std::move(hash_state), t,
-                                   absl::make_index_sequence<sizeof...(Ts)>());
-}
-
-// -----------------------------------------------------------------------------
-// AbslHashValue for Pointers
-// -----------------------------------------------------------------------------
-
-// AbslHashValue for hashing unique_ptr
-template <typename H, typename T, typename D>
-H AbslHashValue(H hash_state, const std::unique_ptr<T, D>& ptr) {
-  return H::combine(std::move(hash_state), ptr.get());
-}
-
-// AbslHashValue for hashing shared_ptr
-template <typename H, typename T>
-H AbslHashValue(H hash_state, const std::shared_ptr<T>& ptr) {
-  return H::combine(std::move(hash_state), ptr.get());
-}
-
-// -----------------------------------------------------------------------------
-// AbslHashValue for String-Like Types
-// -----------------------------------------------------------------------------
-
-// AbslHashValue for hashing strings
-//
-// All the string-like types supported here provide the same hash expansion for
-// the same character sequence. These types are:
-//
-//  - `absl::Cord`
-//  - `std::string` (and std::basic_string<char, std::char_traits<char>, A> for
-//      any allocator A)
-//  - `absl::string_view` and `std::string_view`
-//
-// For simplicity, we currently support only `char` strings. This support may
-// be broadened, if necessary, but with some caution - this overload would
-// misbehave in cases where the traits' `eq()` member isn't equivalent to `==`
-// on the underlying character type.
-template <typename H>
-H AbslHashValue(H hash_state, absl::string_view str) {
-  return H::combine(
-      H::combine_contiguous(std::move(hash_state), str.data(), str.size()),
-      str.size());
-}
-
-// Support std::wstring, std::u16string and std::u32string.
-template <typename Char, typename Alloc, typename H,
-          typename = absl::enable_if_t<std::is_same<Char, wchar_t>::value ||
-                                       std::is_same<Char, char16_t>::value ||
-                                       std::is_same<Char, char32_t>::value>>
-H AbslHashValue(
-    H hash_state,
-    const std::basic_string<Char, std::char_traits<Char>, Alloc>& str) {
-  return H::combine(
-      H::combine_contiguous(std::move(hash_state), str.data(), str.size()),
-      str.size());
-}
-
-// -----------------------------------------------------------------------------
-// AbslHashValue for Sequence Containers
-// -----------------------------------------------------------------------------
-
-// AbslHashValue for hashing std::array
-template <typename H, typename T, size_t N>
-typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
-    H hash_state, const std::array<T, N>& array) {
-  return H::combine_contiguous(std::move(hash_state), array.data(),
-                               array.size());
-}
-
-// AbslHashValue for hashing std::deque
-template <typename H, typename T, typename Allocator>
-typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
-    H hash_state, const std::deque<T, Allocator>& deque) {
-  // TODO(gromer): investigate a more efficient implementation taking
-  // advantage of the chunk structure.
-  for (const auto& t : deque) {
-    hash_state = H::combine(std::move(hash_state), t);
-  }
-  return H::combine(std::move(hash_state), deque.size());
-}
-
-// AbslHashValue for hashing std::forward_list
-template <typename H, typename T, typename Allocator>
-typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
-    H hash_state, const std::forward_list<T, Allocator>& list) {
-  size_t size = 0;
-  for (const T& t : list) {
-    hash_state = H::combine(std::move(hash_state), t);
-    ++size;
-  }
-  return H::combine(std::move(hash_state), size);
-}
-
-// AbslHashValue for hashing std::list
-template <typename H, typename T, typename Allocator>
-typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
-    H hash_state, const std::list<T, Allocator>& list) {
-  for (const auto& t : list) {
-    hash_state = H::combine(std::move(hash_state), t);
-  }
-  return H::combine(std::move(hash_state), list.size());
-}
-
-// AbslHashValue for hashing std::vector
-//
-// Do not use this for vector<bool>. It does not have a .data(), and a fallback
-// for std::hash<> is most likely faster.
-template <typename H, typename T, typename Allocator>
-typename std::enable_if<is_hashable<T>::value && !std::is_same<T, bool>::value,
-                        H>::type
-AbslHashValue(H hash_state, const std::vector<T, Allocator>& vector) {
-  return H::combine(H::combine_contiguous(std::move(hash_state), vector.data(),
-                                          vector.size()),
-                    vector.size());
-}
-
-// -----------------------------------------------------------------------------
-// AbslHashValue for Ordered Associative Containers
-// -----------------------------------------------------------------------------
-
-// AbslHashValue for hashing std::map
-template <typename H, typename Key, typename T, typename Compare,
-          typename Allocator>
-typename std::enable_if<is_hashable<Key>::value && is_hashable<T>::value,
-                        H>::type
-AbslHashValue(H hash_state, const std::map<Key, T, Compare, Allocator>& map) {
-  for (const auto& t : map) {
-    hash_state = H::combine(std::move(hash_state), t);
-  }
-  return H::combine(std::move(hash_state), map.size());
-}
-
-// AbslHashValue for hashing std::multimap
-template <typename H, typename Key, typename T, typename Compare,
-          typename Allocator>
-typename std::enable_if<is_hashable<Key>::value && is_hashable<T>::value,
-                        H>::type
-AbslHashValue(H hash_state,
-              const std::multimap<Key, T, Compare, Allocator>& map) {
-  for (const auto& t : map) {
-    hash_state = H::combine(std::move(hash_state), t);
-  }
-  return H::combine(std::move(hash_state), map.size());
-}
-
-// AbslHashValue for hashing std::set
-template <typename H, typename Key, typename Compare, typename Allocator>
-typename std::enable_if<is_hashable<Key>::value, H>::type AbslHashValue(
-    H hash_state, const std::set<Key, Compare, Allocator>& set) {
-  for (const auto& t : set) {
-    hash_state = H::combine(std::move(hash_state), t);
-  }
-  return H::combine(std::move(hash_state), set.size());
-}
-
-// AbslHashValue for hashing std::multiset
-template <typename H, typename Key, typename Compare, typename Allocator>
-typename std::enable_if<is_hashable<Key>::value, H>::type AbslHashValue(
-    H hash_state, const std::multiset<Key, Compare, Allocator>& set) {
-  for (const auto& t : set) {
-    hash_state = H::combine(std::move(hash_state), t);
-  }
-  return H::combine(std::move(hash_state), set.size());
-}
-
-// -----------------------------------------------------------------------------
-// AbslHashValue for Wrapper Types
-// -----------------------------------------------------------------------------
-
-// AbslHashValue for hashing std::reference_wrapper
-template <typename H, typename T>
-typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
-    H hash_state, std::reference_wrapper<T> opt) {
-  return H::combine(std::move(hash_state), opt.get());
-}
-
-// AbslHashValue for hashing absl::optional
-template <typename H, typename T>
-typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
-    H hash_state, const absl::optional<T>& opt) {
-  if (opt) hash_state = H::combine(std::move(hash_state), *opt);
-  return H::combine(std::move(hash_state), opt.has_value());
-}
-
-// VariantVisitor
-template <typename H>
-struct VariantVisitor {
-  H&& hash_state;
-  template <typename T>
-  H operator()(const T& t) const {
-    return H::combine(std::move(hash_state), t);
-  }
-};
-
-// AbslHashValue for hashing absl::variant
-template <typename H, typename... T>
-typename std::enable_if<conjunction<is_hashable<T>...>::value, H>::type
-AbslHashValue(H hash_state, const absl::variant<T...>& v) {
-  if (!v.valueless_by_exception()) {
-    hash_state = absl::visit(VariantVisitor<H>{std::move(hash_state)}, v);
-  }
-  return H::combine(std::move(hash_state), v.index());
-}
-
-// -----------------------------------------------------------------------------
-// AbslHashValue for Other Types
-// -----------------------------------------------------------------------------
-
-// AbslHashValue for hashing std::bitset is not defined, for the same reason as
-// for vector<bool> (see std::vector above): It does not expose the raw bytes,
-// and a fallback to std::hash<> is most likely faster.
-
-// -----------------------------------------------------------------------------
-
-// hash_range_or_bytes()
-//
-// Mixes all values in the range [data, data+size) into the hash state.
-// This overload accepts only uniquely-represented types, and hashes them by
-// hashing the entire range of bytes.
-template <typename H, typename T>
-typename std::enable_if<is_uniquely_represented<T>::value, H>::type
-hash_range_or_bytes(H hash_state, const T* data, size_t size) {
-  const auto* bytes = reinterpret_cast<const unsigned char*>(data);
-  return H::combine_contiguous(std::move(hash_state), bytes, sizeof(T) * size);
-}
-
-// hash_range_or_bytes()
-template <typename H, typename T>
-typename std::enable_if<!is_uniquely_represented<T>::value, H>::type
-hash_range_or_bytes(H hash_state, const T* data, size_t size) {
-  for (const auto end = data + size; data < end; ++data) {
-    hash_state = H::combine(std::move(hash_state), *data);
-  }
-  return hash_state;
-}
-
-#if defined(ABSL_INTERNAL_LEGACY_HASH_NAMESPACE) && \
-    ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
-#define ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_ 1
-#else
-#define ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_ 0
-#endif
-
-// HashSelect
-//
-// Type trait to select the appropriate hash implementation to use.
-// HashSelect::type<T> will give the proper hash implementation, to be invoked
-// as:
-//   HashSelect::type<T>::Invoke(state, value)
-// Also, HashSelect::type<T>::value is a boolean equal to `true` if there is a
-// valid `Invoke` function. Types that are not hashable will have a ::value of
-// `false`.
-struct HashSelect {
- private:
-  struct State : HashStateBase<State> {
-    static State combine_contiguous(State hash_state, const unsigned char*,
-                                    size_t);
-    using State::HashStateBase::combine_contiguous;
-  };
-
-  struct UniquelyRepresentedProbe {
-    template <typename H, typename T>
-    static auto Invoke(H state, const T& value)
-        -> absl::enable_if_t<is_uniquely_represented<T>::value, H> {
-      return hash_internal::hash_bytes(std::move(state), value);
-    }
-  };
-
-  struct HashValueProbe {
-    template <typename H, typename T>
-    static auto Invoke(H state, const T& value) -> absl::enable_if_t<
-        std::is_same<H,
-                     decltype(AbslHashValue(std::move(state), value))>::value,
-        H> {
-      return AbslHashValue(std::move(state), value);
-    }
-  };
-
-  struct LegacyHashProbe {
-#if ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_
-    template <typename H, typename T>
-    static auto Invoke(H state, const T& value) -> absl::enable_if_t<
-        std::is_convertible<
-            decltype(ABSL_INTERNAL_LEGACY_HASH_NAMESPACE::hash<T>()(value)),
-            size_t>::value,
-        H> {
-      return hash_internal::hash_bytes(
-          std::move(state),
-          ABSL_INTERNAL_LEGACY_HASH_NAMESPACE::hash<T>{}(value));
-    }
-#endif  // ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_
-  };
-
-  struct StdHashProbe {
-    template <typename H, typename T>
-    static auto Invoke(H state, const T& value)
-        -> absl::enable_if_t<type_traits_internal::IsHashable<T>::value, H> {
-      return hash_internal::hash_bytes(std::move(state), std::hash<T>{}(value));
-    }
-  };
-
-  template <typename Hash, typename T>
-  struct Probe : Hash {
-   private:
-    template <typename H, typename = decltype(H::Invoke(
-                              std::declval<State>(), std::declval<const T&>()))>
-    static std::true_type Test(int);
-    template <typename U>
-    static std::false_type Test(char);
-
-   public:
-    static constexpr bool value = decltype(Test<Hash>(0))::value;
-  };
-
- public:
-  // Probe each implementation in order.
-  // disjunction provides short circuiting wrt instantiation.
-  template <typename T>
-  using Apply = absl::disjunction<         //
-      Probe<UniquelyRepresentedProbe, T>,  //
-      Probe<HashValueProbe, T>,            //
-      Probe<LegacyHashProbe, T>,           //
-      Probe<StdHashProbe, T>,              //
-      std::false_type>;
-};
-
-template <typename T>
-struct is_hashable
-    : std::integral_constant<bool, HashSelect::template Apply<T>::value> {};
-
-// CityHashState
-class ABSL_DLL CityHashState
-    : public HashStateBase<CityHashState> {
-  // absl::uint128 is not an alias or a thin wrapper around the intrinsic.
-  // We use the intrinsic when available to improve performance.
-#ifdef ABSL_HAVE_INTRINSIC_INT128
-  using uint128 = __uint128_t;
-#else   // ABSL_HAVE_INTRINSIC_INT128
-  using uint128 = absl::uint128;
-#endif  // ABSL_HAVE_INTRINSIC_INT128
-
-  static constexpr uint64_t kMul =
-      sizeof(size_t) == 4 ? uint64_t{0xcc9e2d51}
-                          : uint64_t{0x9ddfea08eb382d69};
-
-  template <typename T>
-  using IntegralFastPath =
-      conjunction<std::is_integral<T>, is_uniquely_represented<T>>;
-
- public:
-  // Move only
-  CityHashState(CityHashState&&) = default;
-  CityHashState& operator=(CityHashState&&) = default;
-
-  // CityHashState::combine_contiguous()
-  //
-  // Fundamental base case for hash recursion: mixes the given range of bytes
-  // into the hash state.
-  static CityHashState combine_contiguous(CityHashState hash_state,
-                                          const unsigned char* first,
-                                          size_t size) {
-    return CityHashState(
-        CombineContiguousImpl(hash_state.state_, first, size,
-                              std::integral_constant<int, sizeof(size_t)>{}));
-  }
-  using CityHashState::HashStateBase::combine_contiguous;
-
-  // CityHashState::hash()
-  //
-  // For performance reasons in non-opt mode, we specialize this for
-  // integral types.
-  // Otherwise we would be instantiating and calling dozens of functions for
-  // something that is just one multiplication and a couple xor's.
-  // The result should be the same as running the whole algorithm, but faster.
-  template <typename T, absl::enable_if_t<IntegralFastPath<T>::value, int> = 0>
-  static size_t hash(T value) {
-    return static_cast<size_t>(Mix(Seed(), static_cast<uint64_t>(value)));
-  }
-
-  // Overload of CityHashState::hash()
-  template <typename T, absl::enable_if_t<!IntegralFastPath<T>::value, int> = 0>
-  static size_t hash(const T& value) {
-    return static_cast<size_t>(combine(CityHashState{}, value).state_);
-  }
-
- private:
-  // Invoked only once for a given argument; that plus the fact that this is
-  // move-only ensures that there is only one non-moved-from object.
-  CityHashState() : state_(Seed()) {}
-
-  // Workaround for MSVC bug.
-  // We make the type copyable to fix the calling convention, even though we
-  // never actually copy it. Keep it private to not affect the public API of the
-  // type.
-  CityHashState(const CityHashState&) = default;
-
-  explicit CityHashState(uint64_t state) : state_(state) {}
-
-  // Implementation of the base case for combine_contiguous where we actually
-  // mix the bytes into the state.
-  // Dispatch to different implementations of the combine_contiguous depending
-  // on the value of `sizeof(size_t)`.
-  static uint64_t CombineContiguousImpl(uint64_t state,
-                                        const unsigned char* first, size_t len,
-                                        std::integral_constant<int, 4>
-                                        /* sizeof_size_t */);
-  static uint64_t CombineContiguousImpl(uint64_t state,
-                                        const unsigned char* first, size_t len,
-                                        std::integral_constant<int, 8>
-                                        /* sizeof_size_t*/);
-
-  // Slow dispatch path for calls to CombineContiguousImpl with a size argument
-  // larger than PiecewiseChunkSize().  Has the same effect as calling
-  // CombineContiguousImpl() repeatedly with the chunk stride size.
-  static uint64_t CombineLargeContiguousImpl32(uint64_t state,
-                                               const unsigned char* first,
-                                               size_t len);
-  static uint64_t CombineLargeContiguousImpl64(uint64_t state,
-                                               const unsigned char* first,
-                                               size_t len);
-
-  // Reads 9 to 16 bytes from p.
-  // The first 8 bytes are in .first, the rest (zero padded) bytes are in
-  // .second.
-  static std::pair<uint64_t, uint64_t> Read9To16(const unsigned char* p,
-                                                 size_t len) {
-    uint64_t high = little_endian::Load64(p + len - 8);
-    return {little_endian::Load64(p), high >> (128 - len * 8)};
-  }
-
-  // Reads 4 to 8 bytes from p. Zero pads to fill uint64_t.
-  static uint64_t Read4To8(const unsigned char* p, size_t len) {
-    return (static_cast<uint64_t>(little_endian::Load32(p + len - 4))
-            << (len - 4) * 8) |
-           little_endian::Load32(p);
-  }
-
-  // Reads 1 to 3 bytes from p. Zero pads to fill uint32_t.
-  static uint32_t Read1To3(const unsigned char* p, size_t len) {
-    return static_cast<uint32_t>((p[0]) |                         //
-                                 (p[len / 2] << (len / 2 * 8)) |  //
-                                 (p[len - 1] << ((len - 1) * 8)));
-  }
-
-  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Mix(uint64_t state, uint64_t v) {
-    using MultType =
-        absl::conditional_t<sizeof(size_t) == 4, uint64_t, uint128>;
-    // We do the addition in 64-bit space to make sure the 128-bit
-    // multiplication is fast. If we were to do it as MultType the compiler has
-    // to assume that the high word is non-zero and needs to perform 2
-    // multiplications instead of one.
-    MultType m = state + v;
-    m *= kMul;
-    return static_cast<uint64_t>(m ^ (m >> (sizeof(m) * 8 / 2)));
-  }
-
-  // Seed()
-  //
-  // A non-deterministic seed.
-  //
-  // The current purpose of this seed is to generate non-deterministic results
-  // and prevent having users depend on the particular hash values.
-  // It is not meant as a security feature right now, but it leaves the door
-  // open to upgrade it to a true per-process random seed. A true random seed
-  // costs more and we don't need to pay for that right now.
-  //
-  // On platforms with ASLR, we take advantage of it to make a per-process
-  // random value.
-  // See https://en.wikipedia.org/wiki/Address_space_layout_randomization
-  //
-  // On other platforms this is still going to be non-deterministic but most
-  // probably per-build and not per-process.
-  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Seed() {
-#if (!defined(__clang__) || __clang_major__ > 11) && \
-    !defined(__apple_build_version__)
-    return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(&kSeed));
-#else
-    // Workaround the absence of
-    // https://github.com/llvm/llvm-project/commit/bc15bf66dcca76cc06fe71fca35b74dc4d521021.
-    return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(kSeed));
-#endif
-  }
-  static const void* const kSeed;
-
-  uint64_t state_;
-};
-
-// CityHashState::CombineContiguousImpl()
-inline uint64_t CityHashState::CombineContiguousImpl(
-    uint64_t state, const unsigned char* first, size_t len,
-    std::integral_constant<int, 4> /* sizeof_size_t */) {
-  // For large values we use CityHash, for small ones we just use a
-  // multiplicative hash.
-  uint64_t v;
-  if (len > 8) {
-    if (ABSL_PREDICT_FALSE(len > PiecewiseChunkSize())) {
-      return CombineLargeContiguousImpl32(state, first, len);
-    }
-    v = absl::hash_internal::CityHash32(reinterpret_cast<const char*>(first), len);
-  } else if (len >= 4) {
-    v = Read4To8(first, len);
-  } else if (len > 0) {
-    v = Read1To3(first, len);
-  } else {
-    // Empty ranges have no effect.
-    return state;
-  }
-  return Mix(state, v);
-}
-
-// Overload of CityHashState::CombineContiguousImpl()
-inline uint64_t CityHashState::CombineContiguousImpl(
-    uint64_t state, const unsigned char* first, size_t len,
-    std::integral_constant<int, 8> /* sizeof_size_t */) {
-  // For large values we use CityHash, for small ones we just use a
-  // multiplicative hash.
-  uint64_t v;
-  if (len > 16) {
-    if (ABSL_PREDICT_FALSE(len > PiecewiseChunkSize())) {
-      return CombineLargeContiguousImpl64(state, first, len);
-    }
-    v = absl::hash_internal::CityHash64(reinterpret_cast<const char*>(first), len);
-  } else if (len > 8) {
-    auto p = Read9To16(first, len);
-    state = Mix(state, p.first);
-    v = p.second;
-  } else if (len >= 4) {
-    v = Read4To8(first, len);
-  } else if (len > 0) {
-    v = Read1To3(first, len);
-  } else {
-    // Empty ranges have no effect.
-    return state;
-  }
-  return Mix(state, v);
-}
-
-struct AggregateBarrier {};
-
-// HashImpl
-
-// Add a private base class to make sure this type is not an aggregate.
-// Aggregates can be aggregate initialized even if the default constructor is
-// deleted.
-struct PoisonedHash : private AggregateBarrier {
-  PoisonedHash() = delete;
-  PoisonedHash(const PoisonedHash&) = delete;
-  PoisonedHash& operator=(const PoisonedHash&) = delete;
-};
-
-template <typename T>
-struct HashImpl {
-  size_t operator()(const T& value) const { return CityHashState::hash(value); }
-};
-
-template <typename T>
-struct Hash
-    : absl::conditional_t<is_hashable<T>::value, HashImpl<T>, PoisonedHash> {};
-
-template <typename H>
-template <typename T, typename... Ts>
-H HashStateBase<H>::combine(H state, const T& value, const Ts&... values) {
-  return H::combine(hash_internal::HashSelect::template Apply<T>::Invoke(
-                        std::move(state), value),
-                    values...);
-}
-
-// HashStateBase::combine_contiguous()
-template <typename H>
-template <typename T>
-H HashStateBase<H>::combine_contiguous(H state, const T* data, size_t size) {
-  return hash_internal::hash_range_or_bytes(std::move(state), data, size);
-}
-
-// HashStateBase::PiecewiseCombiner::add_buffer()
-template <typename H>
-H PiecewiseCombiner::add_buffer(H state, const unsigned char* data,
-                                size_t size) {
-  if (position_ + size < PiecewiseChunkSize()) {
-    // This partial chunk does not fill our existing buffer
-    memcpy(buf_ + position_, data, size);
-    position_ += size;
-    return state;
-  }
-
-  // If the buffer is partially filled we need to complete the buffer
-  // and hash it.
-  if (position_ != 0) {
-    const size_t bytes_needed = PiecewiseChunkSize() - position_;
-    memcpy(buf_ + position_, data, bytes_needed);
-    state = H::combine_contiguous(std::move(state), buf_, PiecewiseChunkSize());
-    data += bytes_needed;
-    size -= bytes_needed;
-  }
-
-  // Hash whatever chunks we can without copying
-  while (size >= PiecewiseChunkSize()) {
-    state = H::combine_contiguous(std::move(state), data, PiecewiseChunkSize());
-    data += PiecewiseChunkSize();
-    size -= PiecewiseChunkSize();
-  }
-  // Fill the buffer with the remainder
-  memcpy(buf_, data, size);
-  position_ = size;
-  return state;
-}
-
-// HashStateBase::PiecewiseCombiner::finalize()
-template <typename H>
-H PiecewiseCombiner::finalize(H state) {
-  // Hash the remainder left in the buffer, which may be empty
-  return H::combine_contiguous(std::move(state), buf_, position_);
-}
-
-}  // namespace hash_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_HASH_INTERNAL_HASH_H_
diff --git a/third_party/abseil_cpp/absl/hash/internal/print_hash_of.cc b/third_party/abseil_cpp/absl/hash/internal/print_hash_of.cc
deleted file mode 100644
index c392125a69fa..000000000000
--- a/third_party/abseil_cpp/absl/hash/internal/print_hash_of.cc
+++ /dev/null
@@ -1,23 +0,0 @@
-// 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 <cstdlib>
-
-#include "absl/hash/hash.h"
-
-// Prints the hash of argv[1].
-int main(int argc, char** argv) {
-  if (argc < 2) return 1;
-  printf("%zu\n", absl::Hash<int>{}(std::atoi(argv[1])));  // NOLINT
-}
diff --git a/third_party/abseil_cpp/absl/hash/internal/spy_hash_state.h b/third_party/abseil_cpp/absl/hash/internal/spy_hash_state.h
deleted file mode 100644
index c08312081180..000000000000
--- a/third_party/abseil_cpp/absl/hash/internal/spy_hash_state.h
+++ /dev/null
@@ -1,231 +0,0 @@
-// 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.
-
-#ifndef ABSL_HASH_INTERNAL_SPY_HASH_STATE_H_
-#define ABSL_HASH_INTERNAL_SPY_HASH_STATE_H_
-
-#include <ostream>
-#include <string>
-#include <vector>
-
-#include "absl/hash/hash.h"
-#include "absl/strings/match.h"
-#include "absl/strings/str_format.h"
-#include "absl/strings/str_join.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace hash_internal {
-
-// SpyHashState is an implementation of the HashState API that simply
-// accumulates all input bytes in an internal buffer. This makes it useful
-// for testing AbslHashValue overloads (so long as they are templated on the
-// HashState parameter), since it can report the exact hash representation
-// that the AbslHashValue overload produces.
-//
-// Sample usage:
-// EXPECT_EQ(SpyHashState::combine(SpyHashState(), foo),
-//           SpyHashState::combine(SpyHashState(), bar));
-template <typename T>
-class SpyHashStateImpl : public HashStateBase<SpyHashStateImpl<T>> {
- public:
-  SpyHashStateImpl() : error_(std::make_shared<absl::optional<std::string>>()) {
-    static_assert(std::is_void<T>::value, "");
-  }
-
-  // Move-only
-  SpyHashStateImpl(const SpyHashStateImpl&) = delete;
-  SpyHashStateImpl& operator=(const SpyHashStateImpl&) = delete;
-
-  SpyHashStateImpl(SpyHashStateImpl&& other) noexcept {
-    *this = std::move(other);
-  }
-
-  SpyHashStateImpl& operator=(SpyHashStateImpl&& other) noexcept {
-    hash_representation_ = std::move(other.hash_representation_);
-    error_ = other.error_;
-    moved_from_ = other.moved_from_;
-    other.moved_from_ = true;
-    return *this;
-  }
-
-  template <typename U>
-  SpyHashStateImpl(SpyHashStateImpl<U>&& other) {  // NOLINT
-    hash_representation_ = std::move(other.hash_representation_);
-    error_ = other.error_;
-    moved_from_ = other.moved_from_;
-    other.moved_from_ = true;
-  }
-
-  template <typename A, typename... Args>
-  static SpyHashStateImpl combine(SpyHashStateImpl s, const A& a,
-                                  const Args&... args) {
-    // Pass an instance of SpyHashStateImpl<A> when trying to combine `A`. This
-    // allows us to test that the user only uses this instance for combine calls
-    // and does not call AbslHashValue directly.
-    // See AbslHashValue implementation at the bottom.
-    s = SpyHashStateImpl<A>::HashStateBase::combine(std::move(s), a);
-    return SpyHashStateImpl::combine(std::move(s), args...);
-  }
-  static SpyHashStateImpl combine(SpyHashStateImpl s) {
-    if (direct_absl_hash_value_error_) {
-      *s.error_ = "AbslHashValue should not be invoked directly.";
-    } else if (s.moved_from_) {
-      *s.error_ = "Used moved-from instance of the hash state object.";
-    }
-    return s;
-  }
-
-  static void SetDirectAbslHashValueError() {
-    direct_absl_hash_value_error_ = true;
-  }
-
-  // Two SpyHashStateImpl objects are equal if they hold equal hash
-  // representations.
-  friend bool operator==(const SpyHashStateImpl& lhs,
-                         const SpyHashStateImpl& rhs) {
-    return lhs.hash_representation_ == rhs.hash_representation_;
-  }
-
-  friend bool operator!=(const SpyHashStateImpl& lhs,
-                         const SpyHashStateImpl& rhs) {
-    return !(lhs == rhs);
-  }
-
-  enum class CompareResult {
-    kEqual,
-    kASuffixB,
-    kBSuffixA,
-    kUnequal,
-  };
-
-  static CompareResult Compare(const SpyHashStateImpl& a,
-                               const SpyHashStateImpl& b) {
-    const std::string a_flat = absl::StrJoin(a.hash_representation_, "");
-    const std::string b_flat = absl::StrJoin(b.hash_representation_, "");
-    if (a_flat == b_flat) return CompareResult::kEqual;
-    if (absl::EndsWith(a_flat, b_flat)) return CompareResult::kBSuffixA;
-    if (absl::EndsWith(b_flat, a_flat)) return CompareResult::kASuffixB;
-    return CompareResult::kUnequal;
-  }
-
-  // operator<< prints the hash representation as a hex and ASCII dump, to
-  // facilitate debugging.
-  friend std::ostream& operator<<(std::ostream& out,
-                                  const SpyHashStateImpl& hash_state) {
-    out << "[\n";
-    for (auto& s : hash_state.hash_representation_) {
-      size_t offset = 0;
-      for (char c : s) {
-        if (offset % 16 == 0) {
-          out << absl::StreamFormat("\n0x%04x: ", offset);
-        }
-        if (offset % 2 == 0) {
-          out << " ";
-        }
-        out << absl::StreamFormat("%02x", c);
-        ++offset;
-      }
-      out << "\n";
-    }
-    return out << "]";
-  }
-
-  // The base case of the combine recursion, which writes raw bytes into the
-  // internal buffer.
-  static SpyHashStateImpl combine_contiguous(SpyHashStateImpl hash_state,
-                                             const unsigned char* begin,
-                                             size_t size) {
-    const size_t large_chunk_stride = PiecewiseChunkSize();
-    if (size > large_chunk_stride) {
-      // Combining a large contiguous buffer must have the same effect as
-      // doing it piecewise by the stride length, followed by the (possibly
-      // empty) remainder.
-      while (size >= large_chunk_stride) {
-        hash_state = SpyHashStateImpl::combine_contiguous(
-            std::move(hash_state), begin, large_chunk_stride);
-        begin += large_chunk_stride;
-        size -= large_chunk_stride;
-      }
-    }
-
-    hash_state.hash_representation_.emplace_back(
-        reinterpret_cast<const char*>(begin), size);
-    return hash_state;
-  }
-
-  using SpyHashStateImpl::HashStateBase::combine_contiguous;
-
-  absl::optional<std::string> error() const {
-    if (moved_from_) {
-      return "Returned a moved-from instance of the hash state object.";
-    }
-    return *error_;
-  }
-
- private:
-  template <typename U>
-  friend class SpyHashStateImpl;
-
-  // This is true if SpyHashStateImpl<T> has been passed to a call of
-  // AbslHashValue with the wrong type. This detects that the user called
-  // AbslHashValue directly (because the hash state type does not match).
-  static bool direct_absl_hash_value_error_;
-
-  std::vector<std::string> hash_representation_;
-  // This is a shared_ptr because we want all instances of the particular
-  // SpyHashState run to share the field. This way we can set the error for
-  // use-after-move and all the copies will see it.
-  std::shared_ptr<absl::optional<std::string>> error_;
-  bool moved_from_ = false;
-};
-
-template <typename T>
-bool SpyHashStateImpl<T>::direct_absl_hash_value_error_;
-
-template <bool& B>
-struct OdrUse {
-  constexpr OdrUse() {}
-  bool& b = B;
-};
-
-template <void (*)()>
-struct RunOnStartup {
-  static bool run;
-  static constexpr OdrUse<run> kOdrUse{};
-};
-
-template <void (*f)()>
-bool RunOnStartup<f>::run = (f(), true);
-
-template <
-    typename T, typename U,
-    // Only trigger for when (T != U),
-    typename = absl::enable_if_t<!std::is_same<T, U>::value>,
-    // This statement works in two ways:
-    //  - First, it instantiates RunOnStartup and forces the initialization of
-    //    `run`, which set the global variable.
-    //  - Second, it triggers a SFINAE error disabling the overload to prevent
-    //    compile time errors. If we didn't disable the overload we would get
-    //    ambiguous overload errors, which we don't want.
-    int = RunOnStartup<SpyHashStateImpl<T>::SetDirectAbslHashValueError>::run>
-void AbslHashValue(SpyHashStateImpl<T>, const U&);
-
-using SpyHashState = SpyHashStateImpl<void>;
-
-}  // namespace hash_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_HASH_INTERNAL_SPY_HASH_STATE_H_