about summary refs log tree commit diff
path: root/third_party/abseil_cpp/absl/numeric
diff options
context:
space:
mode:
authorVincent Ambo <mail@tazj.in>2022-02-07T23·05+0300
committerclbot <clbot@tvl.fyi>2022-02-07T23·09+0000
commit5aa5d282eac56a21e74611c1cdbaa97bb5db2dca (patch)
tree8cc5dce8157a1470ff76719dd15d65f648a05522 /third_party/abseil_cpp/absl/numeric
parenta25675804c4f429fab5ee5201fe25e89865dfd13 (diff)
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>
Diffstat (limited to 'third_party/abseil_cpp/absl/numeric')
-rw-r--r--third_party/abseil_cpp/absl/numeric/BUILD.bazel74
-rw-r--r--third_party/abseil_cpp/absl/numeric/CMakeLists.txt61
-rw-r--r--third_party/abseil_cpp/absl/numeric/int128.cc390
-rw-r--r--third_party/abseil_cpp/absl/numeric/int128.h1092
-rw-r--r--third_party/abseil_cpp/absl/numeric/int128_benchmark.cc282
-rw-r--r--third_party/abseil_cpp/absl/numeric/int128_have_intrinsic.inc302
-rw-r--r--third_party/abseil_cpp/absl/numeric/int128_no_intrinsic.inc308
-rw-r--r--third_party/abseil_cpp/absl/numeric/int128_stream_test.cc1395
-rw-r--r--third_party/abseil_cpp/absl/numeric/int128_test.cc1225
9 files changed, 0 insertions, 5129 deletions
diff --git a/third_party/abseil_cpp/absl/numeric/BUILD.bazel b/third_party/abseil_cpp/absl/numeric/BUILD.bazel
deleted file mode 100644
index f808f5dab06e..000000000000
--- a/third_party/abseil_cpp/absl/numeric/BUILD.bazel
+++ /dev/null
@@ -1,74 +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.
-
-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 = "int128",
-    srcs = [
-        "int128.cc",
-        "int128_have_intrinsic.inc",
-        "int128_no_intrinsic.inc",
-    ],
-    hdrs = ["int128.h"],
-    copts = ABSL_DEFAULT_COPTS,
-    linkopts = ABSL_DEFAULT_LINKOPTS,
-    deps = [
-        "//absl/base:bits",
-        "//absl/base:config",
-        "//absl/base:core_headers",
-    ],
-)
-
-cc_test(
-    name = "int128_test",
-    size = "small",
-    srcs = [
-        "int128_stream_test.cc",
-        "int128_test.cc",
-    ],
-    copts = ABSL_TEST_COPTS,
-    linkopts = ABSL_DEFAULT_LINKOPTS,
-    deps = [
-        ":int128",
-        "//absl/base",
-        "//absl/base:core_headers",
-        "//absl/hash:hash_testing",
-        "//absl/meta:type_traits",
-        "@com_google_googletest//:gtest_main",
-    ],
-)
-
-cc_test(
-    name = "int128_benchmark",
-    srcs = ["int128_benchmark.cc"],
-    copts = ABSL_TEST_COPTS,
-    linkopts = ABSL_DEFAULT_LINKOPTS,
-    tags = ["benchmark"],
-    deps = [
-        ":int128",
-        "//absl/base:config",
-        "@com_github_google_benchmark//:benchmark_main",
-    ],
-)
diff --git a/third_party/abseil_cpp/absl/numeric/CMakeLists.txt b/third_party/abseil_cpp/absl/numeric/CMakeLists.txt
deleted file mode 100644
index 1e12d80f7ce9..000000000000
--- a/third_party/abseil_cpp/absl/numeric/CMakeLists.txt
+++ /dev/null
@@ -1,61 +0,0 @@
-#
-# Copyright 2017 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
-    int128
-  HDRS
-    "int128.h"
-  SRCS
-    "int128.cc"
-    "int128_have_intrinsic.inc"
-    "int128_no_intrinsic.inc"
-  COPTS
-    ${ABSL_DEFAULT_COPTS}
-  DEPS
-    absl::bits
-    absl::config
-    absl::core_headers
-  PUBLIC
-)
-
-absl_cc_test(
-  NAME
-    int128_test
-  SRCS
-    "int128_stream_test.cc"
-    "int128_test.cc"
-  COPTS
-    ${ABSL_TEST_COPTS}
-  DEPS
-    absl::int128
-    absl::base
-    absl::core_headers
-    absl::hash_testing
-    absl::type_traits
-    gmock_main
-)
-
-# component target
-absl_cc_library(
-  NAME
-    numeric
-  COPTS
-    ${ABSL_DEFAULT_COPTS}
-  DEPS
-    absl::int128
-  PUBLIC
-)
diff --git a/third_party/abseil_cpp/absl/numeric/int128.cc b/third_party/abseil_cpp/absl/numeric/int128.cc
deleted file mode 100644
index e21e5e9a4ad4..000000000000
--- a/third_party/abseil_cpp/absl/numeric/int128.cc
+++ /dev/null
@@ -1,390 +0,0 @@
-// Copyright 2017 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/numeric/int128.h"
-
-#include <stddef.h>
-
-#include <cassert>
-#include <iomanip>
-#include <ostream>  // NOLINT(readability/streams)
-#include <sstream>
-#include <string>
-#include <type_traits>
-
-#include "absl/base/internal/bits.h"
-#include "absl/base/optimization.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-ABSL_DLL const uint128 kuint128max = MakeUint128(
-    std::numeric_limits<uint64_t>::max(), std::numeric_limits<uint64_t>::max());
-
-namespace {
-
-// Returns the 0-based position of the last set bit (i.e., most significant bit)
-// in the given uint128. The argument is not 0.
-//
-// For example:
-//   Given: 5 (decimal) == 101 (binary)
-//   Returns: 2
-inline ABSL_ATTRIBUTE_ALWAYS_INLINE int Fls128(uint128 n) {
-  if (uint64_t hi = Uint128High64(n)) {
-    ABSL_INTERNAL_ASSUME(hi != 0);
-    return 127 - base_internal::CountLeadingZeros64(hi);
-  }
-  const uint64_t low = Uint128Low64(n);
-  ABSL_INTERNAL_ASSUME(low != 0);
-  return 63 - base_internal::CountLeadingZeros64(low);
-}
-
-// Long division/modulo for uint128 implemented using the shift-subtract
-// division algorithm adapted from:
-// https://stackoverflow.com/questions/5386377/division-without-using
-inline void DivModImpl(uint128 dividend, uint128 divisor, uint128* quotient_ret,
-                       uint128* remainder_ret) {
-  assert(divisor != 0);
-
-  if (divisor > dividend) {
-    *quotient_ret = 0;
-    *remainder_ret = dividend;
-    return;
-  }
-
-  if (divisor == dividend) {
-    *quotient_ret = 1;
-    *remainder_ret = 0;
-    return;
-  }
-
-  uint128 denominator = divisor;
-  uint128 quotient = 0;
-
-  // Left aligns the MSB of the denominator and the dividend.
-  const int shift = Fls128(dividend) - Fls128(denominator);
-  denominator <<= shift;
-
-  // Uses shift-subtract algorithm to divide dividend by denominator. The
-  // remainder will be left in dividend.
-  for (int i = 0; i <= shift; ++i) {
-    quotient <<= 1;
-    if (dividend >= denominator) {
-      dividend -= denominator;
-      quotient |= 1;
-    }
-    denominator >>= 1;
-  }
-
-  *quotient_ret = quotient;
-  *remainder_ret = dividend;
-}
-
-template <typename T>
-uint128 MakeUint128FromFloat(T v) {
-  static_assert(std::is_floating_point<T>::value, "");
-
-  // Rounding behavior is towards zero, same as for built-in types.
-
-  // Undefined behavior if v is NaN or cannot fit into uint128.
-  assert(std::isfinite(v) && v > -1 &&
-         (std::numeric_limits<T>::max_exponent <= 128 ||
-          v < std::ldexp(static_cast<T>(1), 128)));
-
-  if (v >= std::ldexp(static_cast<T>(1), 64)) {
-    uint64_t hi = static_cast<uint64_t>(std::ldexp(v, -64));
-    uint64_t lo = static_cast<uint64_t>(v - std::ldexp(static_cast<T>(hi), 64));
-    return MakeUint128(hi, lo);
-  }
-
-  return MakeUint128(0, static_cast<uint64_t>(v));
-}
-
-#if defined(__clang__) && !defined(__SSE3__)
-// Workaround for clang bug: https://bugs.llvm.org/show_bug.cgi?id=38289
-// Casting from long double to uint64_t is miscompiled and drops bits.
-// It is more work, so only use when we need the workaround.
-uint128 MakeUint128FromFloat(long double v) {
-  // Go 50 bits at a time, that fits in a double
-  static_assert(std::numeric_limits<double>::digits >= 50, "");
-  static_assert(std::numeric_limits<long double>::digits <= 150, "");
-  // Undefined behavior if v is not finite or cannot fit into uint128.
-  assert(std::isfinite(v) && v > -1 && v < std::ldexp(1.0L, 128));
-
-  v = std::ldexp(v, -100);
-  uint64_t w0 = static_cast<uint64_t>(static_cast<double>(std::trunc(v)));
-  v = std::ldexp(v - static_cast<double>(w0), 50);
-  uint64_t w1 = static_cast<uint64_t>(static_cast<double>(std::trunc(v)));
-  v = std::ldexp(v - static_cast<double>(w1), 50);
-  uint64_t w2 = static_cast<uint64_t>(static_cast<double>(std::trunc(v)));
-  return (static_cast<uint128>(w0) << 100) | (static_cast<uint128>(w1) << 50) |
-         static_cast<uint128>(w2);
-}
-#endif  // __clang__ && !__SSE3__
-}  // namespace
-
-uint128::uint128(float v) : uint128(MakeUint128FromFloat(v)) {}
-uint128::uint128(double v) : uint128(MakeUint128FromFloat(v)) {}
-uint128::uint128(long double v) : uint128(MakeUint128FromFloat(v)) {}
-
-uint128 operator/(uint128 lhs, uint128 rhs) {
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
-  return static_cast<unsigned __int128>(lhs) /
-         static_cast<unsigned __int128>(rhs);
-#else  // ABSL_HAVE_INTRINSIC_INT128
-  uint128 quotient = 0;
-  uint128 remainder = 0;
-  DivModImpl(lhs, rhs, &quotient, &remainder);
-  return quotient;
-#endif  // ABSL_HAVE_INTRINSIC_INT128
-}
-uint128 operator%(uint128 lhs, uint128 rhs) {
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
-  return static_cast<unsigned __int128>(lhs) %
-         static_cast<unsigned __int128>(rhs);
-#else  // ABSL_HAVE_INTRINSIC_INT128
-  uint128 quotient = 0;
-  uint128 remainder = 0;
-  DivModImpl(lhs, rhs, &quotient, &remainder);
-  return remainder;
-#endif  // ABSL_HAVE_INTRINSIC_INT128
-}
-
-namespace {
-
-std::string Uint128ToFormattedString(uint128 v, std::ios_base::fmtflags flags) {
-  // Select a divisor which is the largest power of the base < 2^64.
-  uint128 div;
-  int div_base_log;
-  switch (flags & std::ios::basefield) {
-    case std::ios::hex:
-      div = 0x1000000000000000;  // 16^15
-      div_base_log = 15;
-      break;
-    case std::ios::oct:
-      div = 01000000000000000000000;  // 8^21
-      div_base_log = 21;
-      break;
-    default:  // std::ios::dec
-      div = 10000000000000000000u;  // 10^19
-      div_base_log = 19;
-      break;
-  }
-
-  // Now piece together the uint128 representation from three chunks of the
-  // original value, each less than "div" and therefore representable as a
-  // uint64_t.
-  std::ostringstream os;
-  std::ios_base::fmtflags copy_mask =
-      std::ios::basefield | std::ios::showbase | std::ios::uppercase;
-  os.setf(flags & copy_mask, copy_mask);
-  uint128 high = v;
-  uint128 low;
-  DivModImpl(high, div, &high, &low);
-  uint128 mid;
-  DivModImpl(high, div, &high, &mid);
-  if (Uint128Low64(high) != 0) {
-    os << Uint128Low64(high);
-    os << std::noshowbase << std::setfill('0') << std::setw(div_base_log);
-    os << Uint128Low64(mid);
-    os << std::setw(div_base_log);
-  } else if (Uint128Low64(mid) != 0) {
-    os << Uint128Low64(mid);
-    os << std::noshowbase << std::setfill('0') << std::setw(div_base_log);
-  }
-  os << Uint128Low64(low);
-  return os.str();
-}
-
-}  // namespace
-
-std::ostream& operator<<(std::ostream& os, uint128 v) {
-  std::ios_base::fmtflags flags = os.flags();
-  std::string rep = Uint128ToFormattedString(v, flags);
-
-  // Add the requisite padding.
-  std::streamsize width = os.width(0);
-  if (static_cast<size_t>(width) > rep.size()) {
-    std::ios::fmtflags adjustfield = flags & std::ios::adjustfield;
-    if (adjustfield == std::ios::left) {
-      rep.append(width - rep.size(), os.fill());
-    } else if (adjustfield == std::ios::internal &&
-               (flags & std::ios::showbase) &&
-               (flags & std::ios::basefield) == std::ios::hex && v != 0) {
-      rep.insert(2, width - rep.size(), os.fill());
-    } else {
-      rep.insert(0, width - rep.size(), os.fill());
-    }
-  }
-
-  return os << rep;
-}
-
-namespace {
-
-uint128 UnsignedAbsoluteValue(int128 v) {
-  // Cast to uint128 before possibly negating because -Int128Min() is undefined.
-  return Int128High64(v) < 0 ? -uint128(v) : uint128(v);
-}
-
-}  // namespace
-
-#if !defined(ABSL_HAVE_INTRINSIC_INT128)
-namespace {
-
-template <typename T>
-int128 MakeInt128FromFloat(T v) {
-  // Conversion when v is NaN or cannot fit into int128 would be undefined
-  // behavior if using an intrinsic 128-bit integer.
-  assert(std::isfinite(v) && (std::numeric_limits<T>::max_exponent <= 127 ||
-                              (v >= -std::ldexp(static_cast<T>(1), 127) &&
-                               v < std::ldexp(static_cast<T>(1), 127))));
-
-  // We must convert the absolute value and then negate as needed, because
-  // floating point types are typically sign-magnitude. Otherwise, the
-  // difference between the high and low 64 bits when interpreted as two's
-  // complement overwhelms the precision of the mantissa.
-  uint128 result = v < 0 ? -MakeUint128FromFloat(-v) : MakeUint128FromFloat(v);
-  return MakeInt128(int128_internal::BitCastToSigned(Uint128High64(result)),
-                    Uint128Low64(result));
-}
-
-}  // namespace
-
-int128::int128(float v) : int128(MakeInt128FromFloat(v)) {}
-int128::int128(double v) : int128(MakeInt128FromFloat(v)) {}
-int128::int128(long double v) : int128(MakeInt128FromFloat(v)) {}
-
-int128 operator/(int128 lhs, int128 rhs) {
-  assert(lhs != Int128Min() || rhs != -1);  // UB on two's complement.
-
-  uint128 quotient = 0;
-  uint128 remainder = 0;
-  DivModImpl(UnsignedAbsoluteValue(lhs), UnsignedAbsoluteValue(rhs),
-             &quotient, &remainder);
-  if ((Int128High64(lhs) < 0) != (Int128High64(rhs) < 0)) quotient = -quotient;
-  return MakeInt128(int128_internal::BitCastToSigned(Uint128High64(quotient)),
-                    Uint128Low64(quotient));
-}
-
-int128 operator%(int128 lhs, int128 rhs) {
-  assert(lhs != Int128Min() || rhs != -1);  // UB on two's complement.
-
-  uint128 quotient = 0;
-  uint128 remainder = 0;
-  DivModImpl(UnsignedAbsoluteValue(lhs), UnsignedAbsoluteValue(rhs),
-             &quotient, &remainder);
-  if (Int128High64(lhs) < 0) remainder = -remainder;
-  return MakeInt128(int128_internal::BitCastToSigned(Uint128High64(remainder)),
-                    Uint128Low64(remainder));
-}
-#endif  // ABSL_HAVE_INTRINSIC_INT128
-
-std::ostream& operator<<(std::ostream& os, int128 v) {
-  std::ios_base::fmtflags flags = os.flags();
-  std::string rep;
-
-  // Add the sign if needed.
-  bool print_as_decimal =
-      (flags & std::ios::basefield) == std::ios::dec ||
-      (flags & std::ios::basefield) == std::ios_base::fmtflags();
-  if (print_as_decimal) {
-    if (Int128High64(v) < 0) {
-      rep = "-";
-    } else if (flags & std::ios::showpos) {
-      rep = "+";
-    }
-  }
-
-  rep.append(Uint128ToFormattedString(
-      print_as_decimal ? UnsignedAbsoluteValue(v) : uint128(v), os.flags()));
-
-  // Add the requisite padding.
-  std::streamsize width = os.width(0);
-  if (static_cast<size_t>(width) > rep.size()) {
-    switch (flags & std::ios::adjustfield) {
-      case std::ios::left:
-        rep.append(width - rep.size(), os.fill());
-        break;
-      case std::ios::internal:
-        if (print_as_decimal && (rep[0] == '+' || rep[0] == '-')) {
-          rep.insert(1, width - rep.size(), os.fill());
-        } else if ((flags & std::ios::basefield) == std::ios::hex &&
-                   (flags & std::ios::showbase) && v != 0) {
-          rep.insert(2, width - rep.size(), os.fill());
-        } else {
-          rep.insert(0, width - rep.size(), os.fill());
-        }
-        break;
-      default:  // std::ios::right
-        rep.insert(0, width - rep.size(), os.fill());
-        break;
-    }
-  }
-
-  return os << rep;
-}
-
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-namespace std {
-constexpr bool numeric_limits<absl::uint128>::is_specialized;
-constexpr bool numeric_limits<absl::uint128>::is_signed;
-constexpr bool numeric_limits<absl::uint128>::is_integer;
-constexpr bool numeric_limits<absl::uint128>::is_exact;
-constexpr bool numeric_limits<absl::uint128>::has_infinity;
-constexpr bool numeric_limits<absl::uint128>::has_quiet_NaN;
-constexpr bool numeric_limits<absl::uint128>::has_signaling_NaN;
-constexpr float_denorm_style numeric_limits<absl::uint128>::has_denorm;
-constexpr bool numeric_limits<absl::uint128>::has_denorm_loss;
-constexpr float_round_style numeric_limits<absl::uint128>::round_style;
-constexpr bool numeric_limits<absl::uint128>::is_iec559;
-constexpr bool numeric_limits<absl::uint128>::is_bounded;
-constexpr bool numeric_limits<absl::uint128>::is_modulo;
-constexpr int numeric_limits<absl::uint128>::digits;
-constexpr int numeric_limits<absl::uint128>::digits10;
-constexpr int numeric_limits<absl::uint128>::max_digits10;
-constexpr int numeric_limits<absl::uint128>::radix;
-constexpr int numeric_limits<absl::uint128>::min_exponent;
-constexpr int numeric_limits<absl::uint128>::min_exponent10;
-constexpr int numeric_limits<absl::uint128>::max_exponent;
-constexpr int numeric_limits<absl::uint128>::max_exponent10;
-constexpr bool numeric_limits<absl::uint128>::traps;
-constexpr bool numeric_limits<absl::uint128>::tinyness_before;
-
-constexpr bool numeric_limits<absl::int128>::is_specialized;
-constexpr bool numeric_limits<absl::int128>::is_signed;
-constexpr bool numeric_limits<absl::int128>::is_integer;
-constexpr bool numeric_limits<absl::int128>::is_exact;
-constexpr bool numeric_limits<absl::int128>::has_infinity;
-constexpr bool numeric_limits<absl::int128>::has_quiet_NaN;
-constexpr bool numeric_limits<absl::int128>::has_signaling_NaN;
-constexpr float_denorm_style numeric_limits<absl::int128>::has_denorm;
-constexpr bool numeric_limits<absl::int128>::has_denorm_loss;
-constexpr float_round_style numeric_limits<absl::int128>::round_style;
-constexpr bool numeric_limits<absl::int128>::is_iec559;
-constexpr bool numeric_limits<absl::int128>::is_bounded;
-constexpr bool numeric_limits<absl::int128>::is_modulo;
-constexpr int numeric_limits<absl::int128>::digits;
-constexpr int numeric_limits<absl::int128>::digits10;
-constexpr int numeric_limits<absl::int128>::max_digits10;
-constexpr int numeric_limits<absl::int128>::radix;
-constexpr int numeric_limits<absl::int128>::min_exponent;
-constexpr int numeric_limits<absl::int128>::min_exponent10;
-constexpr int numeric_limits<absl::int128>::max_exponent;
-constexpr int numeric_limits<absl::int128>::max_exponent10;
-constexpr bool numeric_limits<absl::int128>::traps;
-constexpr bool numeric_limits<absl::int128>::tinyness_before;
-}  // namespace std
diff --git a/third_party/abseil_cpp/absl/numeric/int128.h b/third_party/abseil_cpp/absl/numeric/int128.h
deleted file mode 100644
index 0dd814a890e7..000000000000
--- a/third_party/abseil_cpp/absl/numeric/int128.h
+++ /dev/null
@@ -1,1092 +0,0 @@
-//
-// Copyright 2017 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: int128.h
-// -----------------------------------------------------------------------------
-//
-// This header file defines 128-bit integer types, `uint128` and `int128`.
-
-#ifndef ABSL_NUMERIC_INT128_H_
-#define ABSL_NUMERIC_INT128_H_
-
-#include <cassert>
-#include <cmath>
-#include <cstdint>
-#include <cstring>
-#include <iosfwd>
-#include <limits>
-#include <utility>
-
-#include "absl/base/config.h"
-#include "absl/base/macros.h"
-#include "absl/base/port.h"
-
-#if defined(_MSC_VER)
-// In very old versions of MSVC and when the /Zc:wchar_t flag is off, wchar_t is
-// a typedef for unsigned short.  Otherwise wchar_t is mapped to the __wchar_t
-// builtin type.  We need to make sure not to define operator wchar_t()
-// alongside operator unsigned short() in these instances.
-#define ABSL_INTERNAL_WCHAR_T __wchar_t
-#if defined(_M_X64)
-#include <intrin.h>
-#pragma intrinsic(_umul128)
-#endif  // defined(_M_X64)
-#else   // defined(_MSC_VER)
-#define ABSL_INTERNAL_WCHAR_T wchar_t
-#endif  // defined(_MSC_VER)
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-class int128;
-
-// uint128
-//
-// An unsigned 128-bit integer type. The API is meant to mimic an intrinsic type
-// as closely as is practical, including exhibiting undefined behavior in
-// analogous cases (e.g. division by zero). This type is intended to be a
-// drop-in replacement once C++ supports an intrinsic `uint128_t` type; when
-// that occurs, existing well-behaved uses of `uint128` will continue to work
-// using that new type.
-//
-// Note: code written with this type will continue to compile once `uint128_t`
-// is introduced, provided the replacement helper functions
-// `Uint128(Low|High)64()` and `MakeUint128()` are made.
-//
-// A `uint128` supports the following:
-//
-//   * Implicit construction from integral types
-//   * Explicit conversion to integral types
-//
-// Additionally, if your compiler supports `__int128`, `uint128` is
-// interoperable with that type. (Abseil checks for this compatibility through
-// the `ABSL_HAVE_INTRINSIC_INT128` macro.)
-//
-// However, a `uint128` differs from intrinsic integral types in the following
-// ways:
-//
-//   * Errors on implicit conversions that do not preserve value (such as
-//     loss of precision when converting to float values).
-//   * Requires explicit construction from and conversion to floating point
-//     types.
-//   * Conversion to integral types requires an explicit static_cast() to
-//     mimic use of the `-Wnarrowing` compiler flag.
-//   * The alignment requirement of `uint128` may differ from that of an
-//     intrinsic 128-bit integer type depending on platform and build
-//     configuration.
-//
-// Example:
-//
-//     float y = absl::Uint128Max();  // Error. uint128 cannot be implicitly
-//                                    // converted to float.
-//
-//     absl::uint128 v;
-//     uint64_t i = v;                         // Error
-//     uint64_t i = static_cast<uint64_t>(v);  // OK
-//
-class
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
-    alignas(unsigned __int128)
-#endif  // ABSL_HAVE_INTRINSIC_INT128
-        uint128 {
- public:
-  uint128() = default;
-
-  // Constructors from arithmetic types
-  constexpr uint128(int v);                 // NOLINT(runtime/explicit)
-  constexpr uint128(unsigned int v);        // NOLINT(runtime/explicit)
-  constexpr uint128(long v);                // NOLINT(runtime/int)
-  constexpr uint128(unsigned long v);       // NOLINT(runtime/int)
-  constexpr uint128(long long v);           // NOLINT(runtime/int)
-  constexpr uint128(unsigned long long v);  // NOLINT(runtime/int)
-#ifdef ABSL_HAVE_INTRINSIC_INT128
-  constexpr uint128(__int128 v);           // NOLINT(runtime/explicit)
-  constexpr uint128(unsigned __int128 v);  // NOLINT(runtime/explicit)
-#endif  // ABSL_HAVE_INTRINSIC_INT128
-  constexpr uint128(int128 v);  // NOLINT(runtime/explicit)
-  explicit uint128(float v);
-  explicit uint128(double v);
-  explicit uint128(long double v);
-
-  // Assignment operators from arithmetic types
-  uint128& operator=(int v);
-  uint128& operator=(unsigned int v);
-  uint128& operator=(long v);                // NOLINT(runtime/int)
-  uint128& operator=(unsigned long v);       // NOLINT(runtime/int)
-  uint128& operator=(long long v);           // NOLINT(runtime/int)
-  uint128& operator=(unsigned long long v);  // NOLINT(runtime/int)
-#ifdef ABSL_HAVE_INTRINSIC_INT128
-  uint128& operator=(__int128 v);
-  uint128& operator=(unsigned __int128 v);
-#endif  // ABSL_HAVE_INTRINSIC_INT128
-  uint128& operator=(int128 v);
-
-  // Conversion operators to other arithmetic types
-  constexpr explicit operator bool() const;
-  constexpr explicit operator char() const;
-  constexpr explicit operator signed char() const;
-  constexpr explicit operator unsigned char() const;
-  constexpr explicit operator char16_t() const;
-  constexpr explicit operator char32_t() const;
-  constexpr explicit operator ABSL_INTERNAL_WCHAR_T() const;
-  constexpr explicit operator short() const;  // NOLINT(runtime/int)
-  // NOLINTNEXTLINE(runtime/int)
-  constexpr explicit operator unsigned short() const;
-  constexpr explicit operator int() const;
-  constexpr explicit operator unsigned int() const;
-  constexpr explicit operator long() const;  // NOLINT(runtime/int)
-  // NOLINTNEXTLINE(runtime/int)
-  constexpr explicit operator unsigned long() const;
-  // NOLINTNEXTLINE(runtime/int)
-  constexpr explicit operator long long() const;
-  // NOLINTNEXTLINE(runtime/int)
-  constexpr explicit operator unsigned long long() const;
-#ifdef ABSL_HAVE_INTRINSIC_INT128
-  constexpr explicit operator __int128() const;
-  constexpr explicit operator unsigned __int128() const;
-#endif  // ABSL_HAVE_INTRINSIC_INT128
-  explicit operator float() const;
-  explicit operator double() const;
-  explicit operator long double() const;
-
-  // Trivial copy constructor, assignment operator and destructor.
-
-  // Arithmetic operators.
-  uint128& operator+=(uint128 other);
-  uint128& operator-=(uint128 other);
-  uint128& operator*=(uint128 other);
-  // Long division/modulo for uint128.
-  uint128& operator/=(uint128 other);
-  uint128& operator%=(uint128 other);
-  uint128 operator++(int);
-  uint128 operator--(int);
-  uint128& operator<<=(int);
-  uint128& operator>>=(int);
-  uint128& operator&=(uint128 other);
-  uint128& operator|=(uint128 other);
-  uint128& operator^=(uint128 other);
-  uint128& operator++();
-  uint128& operator--();
-
-  // Uint128Low64()
-  //
-  // Returns the lower 64-bit value of a `uint128` value.
-  friend constexpr uint64_t Uint128Low64(uint128 v);
-
-  // Uint128High64()
-  //
-  // Returns the higher 64-bit value of a `uint128` value.
-  friend constexpr uint64_t Uint128High64(uint128 v);
-
-  // MakeUInt128()
-  //
-  // Constructs a `uint128` numeric value from two 64-bit unsigned integers.
-  // Note that this factory function is the only way to construct a `uint128`
-  // from integer values greater than 2^64.
-  //
-  // Example:
-  //
-  //   absl::uint128 big = absl::MakeUint128(1, 0);
-  friend constexpr uint128 MakeUint128(uint64_t high, uint64_t low);
-
-  // Uint128Max()
-  //
-  // Returns the highest value for a 128-bit unsigned integer.
-  friend constexpr uint128 Uint128Max();
-
-  // Support for absl::Hash.
-  template <typename H>
-  friend H AbslHashValue(H h, uint128 v) {
-    return H::combine(std::move(h), Uint128High64(v), Uint128Low64(v));
-  }
-
- private:
-  constexpr uint128(uint64_t high, uint64_t low);
-
-  // TODO(strel) Update implementation to use __int128 once all users of
-  // uint128 are fixed to not depend on alignof(uint128) == 8. Also add
-  // alignas(16) to class definition to keep alignment consistent across
-  // platforms.
-#if defined(ABSL_IS_LITTLE_ENDIAN)
-  uint64_t lo_;
-  uint64_t hi_;
-#elif defined(ABSL_IS_BIG_ENDIAN)
-  uint64_t hi_;
-  uint64_t lo_;
-#else  // byte order
-#error "Unsupported byte order: must be little-endian or big-endian."
-#endif  // byte order
-};
-
-// Prefer to use the constexpr `Uint128Max()`.
-//
-// TODO(absl-team) deprecate kuint128max once migration tool is released.
-ABSL_DLL extern const uint128 kuint128max;
-
-// allow uint128 to be logged
-std::ostream& operator<<(std::ostream& os, uint128 v);
-
-// TODO(strel) add operator>>(std::istream&, uint128)
-
-constexpr uint128 Uint128Max() {
-  return uint128((std::numeric_limits<uint64_t>::max)(),
-                 (std::numeric_limits<uint64_t>::max)());
-}
-
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-// Specialized numeric_limits for uint128.
-namespace std {
-template <>
-class numeric_limits<absl::uint128> {
- public:
-  static constexpr bool is_specialized = true;
-  static constexpr bool is_signed = false;
-  static constexpr bool is_integer = true;
-  static constexpr bool is_exact = true;
-  static constexpr bool has_infinity = false;
-  static constexpr bool has_quiet_NaN = false;
-  static constexpr bool has_signaling_NaN = false;
-  static constexpr float_denorm_style has_denorm = denorm_absent;
-  static constexpr bool has_denorm_loss = false;
-  static constexpr float_round_style round_style = round_toward_zero;
-  static constexpr bool is_iec559 = false;
-  static constexpr bool is_bounded = true;
-  static constexpr bool is_modulo = true;
-  static constexpr int digits = 128;
-  static constexpr int digits10 = 38;
-  static constexpr int max_digits10 = 0;
-  static constexpr int radix = 2;
-  static constexpr int min_exponent = 0;
-  static constexpr int min_exponent10 = 0;
-  static constexpr int max_exponent = 0;
-  static constexpr int max_exponent10 = 0;
-#ifdef ABSL_HAVE_INTRINSIC_INT128
-  static constexpr bool traps = numeric_limits<unsigned __int128>::traps;
-#else   // ABSL_HAVE_INTRINSIC_INT128
-  static constexpr bool traps = numeric_limits<uint64_t>::traps;
-#endif  // ABSL_HAVE_INTRINSIC_INT128
-  static constexpr bool tinyness_before = false;
-
-  static constexpr absl::uint128 (min)() { return 0; }
-  static constexpr absl::uint128 lowest() { return 0; }
-  static constexpr absl::uint128 (max)() { return absl::Uint128Max(); }
-  static constexpr absl::uint128 epsilon() { return 0; }
-  static constexpr absl::uint128 round_error() { return 0; }
-  static constexpr absl::uint128 infinity() { return 0; }
-  static constexpr absl::uint128 quiet_NaN() { return 0; }
-  static constexpr absl::uint128 signaling_NaN() { return 0; }
-  static constexpr absl::uint128 denorm_min() { return 0; }
-};
-}  // namespace std
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// int128
-//
-// A signed 128-bit integer type. The API is meant to mimic an intrinsic
-// integral type as closely as is practical, including exhibiting undefined
-// behavior in analogous cases (e.g. division by zero).
-//
-// An `int128` supports the following:
-//
-//   * Implicit construction from integral types
-//   * Explicit conversion to integral types
-//
-// However, an `int128` differs from intrinsic integral types in the following
-// ways:
-//
-//   * It is not implicitly convertible to other integral types.
-//   * Requires explicit construction from and conversion to floating point
-//     types.
-
-// Additionally, if your compiler supports `__int128`, `int128` is
-// interoperable with that type. (Abseil checks for this compatibility through
-// the `ABSL_HAVE_INTRINSIC_INT128` macro.)
-//
-// The design goal for `int128` is that it will be compatible with a future
-// `int128_t`, if that type becomes a part of the standard.
-//
-// Example:
-//
-//     float y = absl::int128(17);  // Error. int128 cannot be implicitly
-//                                  // converted to float.
-//
-//     absl::int128 v;
-//     int64_t i = v;                        // Error
-//     int64_t i = static_cast<int64_t>(v);  // OK
-//
-class int128 {
- public:
-  int128() = default;
-
-  // Constructors from arithmetic types
-  constexpr int128(int v);                 // NOLINT(runtime/explicit)
-  constexpr int128(unsigned int v);        // NOLINT(runtime/explicit)
-  constexpr int128(long v);                // NOLINT(runtime/int)
-  constexpr int128(unsigned long v);       // NOLINT(runtime/int)
-  constexpr int128(long long v);           // NOLINT(runtime/int)
-  constexpr int128(unsigned long long v);  // NOLINT(runtime/int)
-#ifdef ABSL_HAVE_INTRINSIC_INT128
-  constexpr int128(__int128 v);  // NOLINT(runtime/explicit)
-  constexpr explicit int128(unsigned __int128 v);
-#endif  // ABSL_HAVE_INTRINSIC_INT128
-  constexpr explicit int128(uint128 v);
-  explicit int128(float v);
-  explicit int128(double v);
-  explicit int128(long double v);
-
-  // Assignment operators from arithmetic types
-  int128& operator=(int v);
-  int128& operator=(unsigned int v);
-  int128& operator=(long v);                // NOLINT(runtime/int)
-  int128& operator=(unsigned long v);       // NOLINT(runtime/int)
-  int128& operator=(long long v);           // NOLINT(runtime/int)
-  int128& operator=(unsigned long long v);  // NOLINT(runtime/int)
-#ifdef ABSL_HAVE_INTRINSIC_INT128
-  int128& operator=(__int128 v);
-#endif  // ABSL_HAVE_INTRINSIC_INT128
-
-  // Conversion operators to other arithmetic types
-  constexpr explicit operator bool() const;
-  constexpr explicit operator char() const;
-  constexpr explicit operator signed char() const;
-  constexpr explicit operator unsigned char() const;
-  constexpr explicit operator char16_t() const;
-  constexpr explicit operator char32_t() const;
-  constexpr explicit operator ABSL_INTERNAL_WCHAR_T() const;
-  constexpr explicit operator short() const;  // NOLINT(runtime/int)
-  // NOLINTNEXTLINE(runtime/int)
-  constexpr explicit operator unsigned short() const;
-  constexpr explicit operator int() const;
-  constexpr explicit operator unsigned int() const;
-  constexpr explicit operator long() const;  // NOLINT(runtime/int)
-  // NOLINTNEXTLINE(runtime/int)
-  constexpr explicit operator unsigned long() const;
-  // NOLINTNEXTLINE(runtime/int)
-  constexpr explicit operator long long() const;
-  // NOLINTNEXTLINE(runtime/int)
-  constexpr explicit operator unsigned long long() const;
-#ifdef ABSL_HAVE_INTRINSIC_INT128
-  constexpr explicit operator __int128() const;
-  constexpr explicit operator unsigned __int128() const;
-#endif  // ABSL_HAVE_INTRINSIC_INT128
-  explicit operator float() const;
-  explicit operator double() const;
-  explicit operator long double() const;
-
-  // Trivial copy constructor, assignment operator and destructor.
-
-  // Arithmetic operators
-  int128& operator+=(int128 other);
-  int128& operator-=(int128 other);
-  int128& operator*=(int128 other);
-  int128& operator/=(int128 other);
-  int128& operator%=(int128 other);
-  int128 operator++(int);  // postfix increment: i++
-  int128 operator--(int);  // postfix decrement: i--
-  int128& operator++();    // prefix increment:  ++i
-  int128& operator--();    // prefix decrement:  --i
-  int128& operator&=(int128 other);
-  int128& operator|=(int128 other);
-  int128& operator^=(int128 other);
-  int128& operator<<=(int amount);
-  int128& operator>>=(int amount);
-
-  // Int128Low64()
-  //
-  // Returns the lower 64-bit value of a `int128` value.
-  friend constexpr uint64_t Int128Low64(int128 v);
-
-  // Int128High64()
-  //
-  // Returns the higher 64-bit value of a `int128` value.
-  friend constexpr int64_t Int128High64(int128 v);
-
-  // MakeInt128()
-  //
-  // Constructs a `int128` numeric value from two 64-bit integers. Note that
-  // signedness is conveyed in the upper `high` value.
-  //
-  //   (absl::int128(1) << 64) * high + low
-  //
-  // Note that this factory function is the only way to construct a `int128`
-  // from integer values greater than 2^64 or less than -2^64.
-  //
-  // Example:
-  //
-  //   absl::int128 big = absl::MakeInt128(1, 0);
-  //   absl::int128 big_n = absl::MakeInt128(-1, 0);
-  friend constexpr int128 MakeInt128(int64_t high, uint64_t low);
-
-  // Int128Max()
-  //
-  // Returns the maximum value for a 128-bit signed integer.
-  friend constexpr int128 Int128Max();
-
-  // Int128Min()
-  //
-  // Returns the minimum value for a 128-bit signed integer.
-  friend constexpr int128 Int128Min();
-
-  // Support for absl::Hash.
-  template <typename H>
-  friend H AbslHashValue(H h, int128 v) {
-    return H::combine(std::move(h), Int128High64(v), Int128Low64(v));
-  }
-
- private:
-  constexpr int128(int64_t high, uint64_t low);
-
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
-  __int128 v_;
-#else  // ABSL_HAVE_INTRINSIC_INT128
-#if defined(ABSL_IS_LITTLE_ENDIAN)
-  uint64_t lo_;
-  int64_t hi_;
-#elif defined(ABSL_IS_BIG_ENDIAN)
-  int64_t hi_;
-  uint64_t lo_;
-#else  // byte order
-#error "Unsupported byte order: must be little-endian or big-endian."
-#endif  // byte order
-#endif  // ABSL_HAVE_INTRINSIC_INT128
-};
-
-std::ostream& operator<<(std::ostream& os, int128 v);
-
-// TODO(absl-team) add operator>>(std::istream&, int128)
-
-constexpr int128 Int128Max() {
-  return int128((std::numeric_limits<int64_t>::max)(),
-                (std::numeric_limits<uint64_t>::max)());
-}
-
-constexpr int128 Int128Min() {
-  return int128((std::numeric_limits<int64_t>::min)(), 0);
-}
-
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-// Specialized numeric_limits for int128.
-namespace std {
-template <>
-class numeric_limits<absl::int128> {
- public:
-  static constexpr bool is_specialized = true;
-  static constexpr bool is_signed = true;
-  static constexpr bool is_integer = true;
-  static constexpr bool is_exact = true;
-  static constexpr bool has_infinity = false;
-  static constexpr bool has_quiet_NaN = false;
-  static constexpr bool has_signaling_NaN = false;
-  static constexpr float_denorm_style has_denorm = denorm_absent;
-  static constexpr bool has_denorm_loss = false;
-  static constexpr float_round_style round_style = round_toward_zero;
-  static constexpr bool is_iec559 = false;
-  static constexpr bool is_bounded = true;
-  static constexpr bool is_modulo = false;
-  static constexpr int digits = 127;
-  static constexpr int digits10 = 38;
-  static constexpr int max_digits10 = 0;
-  static constexpr int radix = 2;
-  static constexpr int min_exponent = 0;
-  static constexpr int min_exponent10 = 0;
-  static constexpr int max_exponent = 0;
-  static constexpr int max_exponent10 = 0;
-#ifdef ABSL_HAVE_INTRINSIC_INT128
-  static constexpr bool traps = numeric_limits<__int128>::traps;
-#else   // ABSL_HAVE_INTRINSIC_INT128
-  static constexpr bool traps = numeric_limits<uint64_t>::traps;
-#endif  // ABSL_HAVE_INTRINSIC_INT128
-  static constexpr bool tinyness_before = false;
-
-  static constexpr absl::int128 (min)() { return absl::Int128Min(); }
-  static constexpr absl::int128 lowest() { return absl::Int128Min(); }
-  static constexpr absl::int128 (max)() { return absl::Int128Max(); }
-  static constexpr absl::int128 epsilon() { return 0; }
-  static constexpr absl::int128 round_error() { return 0; }
-  static constexpr absl::int128 infinity() { return 0; }
-  static constexpr absl::int128 quiet_NaN() { return 0; }
-  static constexpr absl::int128 signaling_NaN() { return 0; }
-  static constexpr absl::int128 denorm_min() { return 0; }
-};
-}  // namespace std
-
-// --------------------------------------------------------------------------
-//                      Implementation details follow
-// --------------------------------------------------------------------------
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-constexpr uint128 MakeUint128(uint64_t high, uint64_t low) {
-  return uint128(high, low);
-}
-
-// Assignment from integer types.
-
-inline uint128& uint128::operator=(int v) { return *this = uint128(v); }
-
-inline uint128& uint128::operator=(unsigned int v) {
-  return *this = uint128(v);
-}
-
-inline uint128& uint128::operator=(long v) {  // NOLINT(runtime/int)
-  return *this = uint128(v);
-}
-
-// NOLINTNEXTLINE(runtime/int)
-inline uint128& uint128::operator=(unsigned long v) {
-  return *this = uint128(v);
-}
-
-// NOLINTNEXTLINE(runtime/int)
-inline uint128& uint128::operator=(long long v) {
-  return *this = uint128(v);
-}
-
-// NOLINTNEXTLINE(runtime/int)
-inline uint128& uint128::operator=(unsigned long long v) {
-  return *this = uint128(v);
-}
-
-#ifdef ABSL_HAVE_INTRINSIC_INT128
-inline uint128& uint128::operator=(__int128 v) {
-  return *this = uint128(v);
-}
-
-inline uint128& uint128::operator=(unsigned __int128 v) {
-  return *this = uint128(v);
-}
-#endif  // ABSL_HAVE_INTRINSIC_INT128
-
-inline uint128& uint128::operator=(int128 v) {
-  return *this = uint128(v);
-}
-
-// Arithmetic operators.
-
-uint128 operator<<(uint128 lhs, int amount);
-uint128 operator>>(uint128 lhs, int amount);
-uint128 operator+(uint128 lhs, uint128 rhs);
-uint128 operator-(uint128 lhs, uint128 rhs);
-uint128 operator*(uint128 lhs, uint128 rhs);
-uint128 operator/(uint128 lhs, uint128 rhs);
-uint128 operator%(uint128 lhs, uint128 rhs);
-
-inline uint128& uint128::operator<<=(int amount) {
-  *this = *this << amount;
-  return *this;
-}
-
-inline uint128& uint128::operator>>=(int amount) {
-  *this = *this >> amount;
-  return *this;
-}
-
-inline uint128& uint128::operator+=(uint128 other) {
-  *this = *this + other;
-  return *this;
-}
-
-inline uint128& uint128::operator-=(uint128 other) {
-  *this = *this - other;
-  return *this;
-}
-
-inline uint128& uint128::operator*=(uint128 other) {
-  *this = *this * other;
-  return *this;
-}
-
-inline uint128& uint128::operator/=(uint128 other) {
-  *this = *this / other;
-  return *this;
-}
-
-inline uint128& uint128::operator%=(uint128 other) {
-  *this = *this % other;
-  return *this;
-}
-
-constexpr uint64_t Uint128Low64(uint128 v) { return v.lo_; }
-
-constexpr uint64_t Uint128High64(uint128 v) { return v.hi_; }
-
-// Constructors from integer types.
-
-#if defined(ABSL_IS_LITTLE_ENDIAN)
-
-constexpr uint128::uint128(uint64_t high, uint64_t low)
-    : lo_{low}, hi_{high} {}
-
-constexpr uint128::uint128(int v)
-    : lo_{static_cast<uint64_t>(v)},
-      hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0} {}
-constexpr uint128::uint128(long v)  // NOLINT(runtime/int)
-    : lo_{static_cast<uint64_t>(v)},
-      hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0} {}
-constexpr uint128::uint128(long long v)  // NOLINT(runtime/int)
-    : lo_{static_cast<uint64_t>(v)},
-      hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0} {}
-
-constexpr uint128::uint128(unsigned int v) : lo_{v}, hi_{0} {}
-// NOLINTNEXTLINE(runtime/int)
-constexpr uint128::uint128(unsigned long v) : lo_{v}, hi_{0} {}
-// NOLINTNEXTLINE(runtime/int)
-constexpr uint128::uint128(unsigned long long v) : lo_{v}, hi_{0} {}
-
-#ifdef ABSL_HAVE_INTRINSIC_INT128
-constexpr uint128::uint128(__int128 v)
-    : lo_{static_cast<uint64_t>(v & ~uint64_t{0})},
-      hi_{static_cast<uint64_t>(static_cast<unsigned __int128>(v) >> 64)} {}
-constexpr uint128::uint128(unsigned __int128 v)
-    : lo_{static_cast<uint64_t>(v & ~uint64_t{0})},
-      hi_{static_cast<uint64_t>(v >> 64)} {}
-#endif  // ABSL_HAVE_INTRINSIC_INT128
-
-constexpr uint128::uint128(int128 v)
-    : lo_{Int128Low64(v)}, hi_{static_cast<uint64_t>(Int128High64(v))} {}
-
-#elif defined(ABSL_IS_BIG_ENDIAN)
-
-constexpr uint128::uint128(uint64_t high, uint64_t low)
-    : hi_{high}, lo_{low} {}
-
-constexpr uint128::uint128(int v)
-    : hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0},
-      lo_{static_cast<uint64_t>(v)} {}
-constexpr uint128::uint128(long v)  // NOLINT(runtime/int)
-    : hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0},
-      lo_{static_cast<uint64_t>(v)} {}
-constexpr uint128::uint128(long long v)  // NOLINT(runtime/int)
-    : hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0},
-      lo_{static_cast<uint64_t>(v)} {}
-
-constexpr uint128::uint128(unsigned int v) : hi_{0}, lo_{v} {}
-// NOLINTNEXTLINE(runtime/int)
-constexpr uint128::uint128(unsigned long v) : hi_{0}, lo_{v} {}
-// NOLINTNEXTLINE(runtime/int)
-constexpr uint128::uint128(unsigned long long v) : hi_{0}, lo_{v} {}
-
-#ifdef ABSL_HAVE_INTRINSIC_INT128
-constexpr uint128::uint128(__int128 v)
-    : hi_{static_cast<uint64_t>(static_cast<unsigned __int128>(v) >> 64)},
-      lo_{static_cast<uint64_t>(v & ~uint64_t{0})} {}
-constexpr uint128::uint128(unsigned __int128 v)
-    : hi_{static_cast<uint64_t>(v >> 64)},
-      lo_{static_cast<uint64_t>(v & ~uint64_t{0})} {}
-#endif  // ABSL_HAVE_INTRINSIC_INT128
-
-constexpr uint128::uint128(int128 v)
-    : hi_{static_cast<uint64_t>(Int128High64(v))}, lo_{Int128Low64(v)} {}
-
-#else  // byte order
-#error "Unsupported byte order: must be little-endian or big-endian."
-#endif  // byte order
-
-// Conversion operators to integer types.
-
-constexpr uint128::operator bool() const { return lo_ || hi_; }
-
-constexpr uint128::operator char() const { return static_cast<char>(lo_); }
-
-constexpr uint128::operator signed char() const {
-  return static_cast<signed char>(lo_);
-}
-
-constexpr uint128::operator unsigned char() const {
-  return static_cast<unsigned char>(lo_);
-}
-
-constexpr uint128::operator char16_t() const {
-  return static_cast<char16_t>(lo_);
-}
-
-constexpr uint128::operator char32_t() const {
-  return static_cast<char32_t>(lo_);
-}
-
-constexpr uint128::operator ABSL_INTERNAL_WCHAR_T() const {
-  return static_cast<ABSL_INTERNAL_WCHAR_T>(lo_);
-}
-
-// NOLINTNEXTLINE(runtime/int)
-constexpr uint128::operator short() const { return static_cast<short>(lo_); }
-
-constexpr uint128::operator unsigned short() const {  // NOLINT(runtime/int)
-  return static_cast<unsigned short>(lo_);            // NOLINT(runtime/int)
-}
-
-constexpr uint128::operator int() const { return static_cast<int>(lo_); }
-
-constexpr uint128::operator unsigned int() const {
-  return static_cast<unsigned int>(lo_);
-}
-
-// NOLINTNEXTLINE(runtime/int)
-constexpr uint128::operator long() const { return static_cast<long>(lo_); }
-
-constexpr uint128::operator unsigned long() const {  // NOLINT(runtime/int)
-  return static_cast<unsigned long>(lo_);            // NOLINT(runtime/int)
-}
-
-constexpr uint128::operator long long() const {  // NOLINT(runtime/int)
-  return static_cast<long long>(lo_);            // NOLINT(runtime/int)
-}
-
-constexpr uint128::operator unsigned long long() const {  // NOLINT(runtime/int)
-  return static_cast<unsigned long long>(lo_);            // NOLINT(runtime/int)
-}
-
-#ifdef ABSL_HAVE_INTRINSIC_INT128
-constexpr uint128::operator __int128() const {
-  return (static_cast<__int128>(hi_) << 64) + lo_;
-}
-
-constexpr uint128::operator unsigned __int128() const {
-  return (static_cast<unsigned __int128>(hi_) << 64) + lo_;
-}
-#endif  // ABSL_HAVE_INTRINSIC_INT128
-
-// Conversion operators to floating point types.
-
-inline uint128::operator float() const {
-  return static_cast<float>(lo_) + std::ldexp(static_cast<float>(hi_), 64);
-}
-
-inline uint128::operator double() const {
-  return static_cast<double>(lo_) + std::ldexp(static_cast<double>(hi_), 64);
-}
-
-inline uint128::operator long double() const {
-  return static_cast<long double>(lo_) +
-         std::ldexp(static_cast<long double>(hi_), 64);
-}
-
-// Comparison operators.
-
-inline bool operator==(uint128 lhs, uint128 rhs) {
-  return (Uint128Low64(lhs) == Uint128Low64(rhs) &&
-          Uint128High64(lhs) == Uint128High64(rhs));
-}
-
-inline bool operator!=(uint128 lhs, uint128 rhs) {
-  return !(lhs == rhs);
-}
-
-inline bool operator<(uint128 lhs, uint128 rhs) {
-#ifdef ABSL_HAVE_INTRINSIC_INT128
-  return static_cast<unsigned __int128>(lhs) <
-         static_cast<unsigned __int128>(rhs);
-#else
-  return (Uint128High64(lhs) == Uint128High64(rhs))
-             ? (Uint128Low64(lhs) < Uint128Low64(rhs))
-             : (Uint128High64(lhs) < Uint128High64(rhs));
-#endif
-}
-
-inline bool operator>(uint128 lhs, uint128 rhs) { return rhs < lhs; }
-
-inline bool operator<=(uint128 lhs, uint128 rhs) { return !(rhs < lhs); }
-
-inline bool operator>=(uint128 lhs, uint128 rhs) { return !(lhs < rhs); }
-
-// Unary operators.
-
-inline uint128 operator-(uint128 val) {
-  uint64_t hi = ~Uint128High64(val);
-  uint64_t lo = ~Uint128Low64(val) + 1;
-  if (lo == 0) ++hi;  // carry
-  return MakeUint128(hi, lo);
-}
-
-inline bool operator!(uint128 val) {
-  return !Uint128High64(val) && !Uint128Low64(val);
-}
-
-// Logical operators.
-
-inline uint128 operator~(uint128 val) {
-  return MakeUint128(~Uint128High64(val), ~Uint128Low64(val));
-}
-
-inline uint128 operator|(uint128 lhs, uint128 rhs) {
-  return MakeUint128(Uint128High64(lhs) | Uint128High64(rhs),
-                           Uint128Low64(lhs) | Uint128Low64(rhs));
-}
-
-inline uint128 operator&(uint128 lhs, uint128 rhs) {
-  return MakeUint128(Uint128High64(lhs) & Uint128High64(rhs),
-                           Uint128Low64(lhs) & Uint128Low64(rhs));
-}
-
-inline uint128 operator^(uint128 lhs, uint128 rhs) {
-  return MakeUint128(Uint128High64(lhs) ^ Uint128High64(rhs),
-                           Uint128Low64(lhs) ^ Uint128Low64(rhs));
-}
-
-inline uint128& uint128::operator|=(uint128 other) {
-  hi_ |= other.hi_;
-  lo_ |= other.lo_;
-  return *this;
-}
-
-inline uint128& uint128::operator&=(uint128 other) {
-  hi_ &= other.hi_;
-  lo_ &= other.lo_;
-  return *this;
-}
-
-inline uint128& uint128::operator^=(uint128 other) {
-  hi_ ^= other.hi_;
-  lo_ ^= other.lo_;
-  return *this;
-}
-
-// Arithmetic operators.
-
-inline uint128 operator<<(uint128 lhs, int amount) {
-#ifdef ABSL_HAVE_INTRINSIC_INT128
-  return static_cast<unsigned __int128>(lhs) << amount;
-#else
-  // uint64_t shifts of >= 64 are undefined, so we will need some
-  // special-casing.
-  if (amount < 64) {
-    if (amount != 0) {
-      return MakeUint128(
-          (Uint128High64(lhs) << amount) | (Uint128Low64(lhs) >> (64 - amount)),
-          Uint128Low64(lhs) << amount);
-    }
-    return lhs;
-  }
-  return MakeUint128(Uint128Low64(lhs) << (amount - 64), 0);
-#endif
-}
-
-inline uint128 operator>>(uint128 lhs, int amount) {
-#ifdef ABSL_HAVE_INTRINSIC_INT128
-  return static_cast<unsigned __int128>(lhs) >> amount;
-#else
-  // uint64_t shifts of >= 64 are undefined, so we will need some
-  // special-casing.
-  if (amount < 64) {
-    if (amount != 0) {
-      return MakeUint128(Uint128High64(lhs) >> amount,
-                         (Uint128Low64(lhs) >> amount) |
-                             (Uint128High64(lhs) << (64 - amount)));
-    }
-    return lhs;
-  }
-  return MakeUint128(0, Uint128High64(lhs) >> (amount - 64));
-#endif
-}
-
-inline uint128 operator+(uint128 lhs, uint128 rhs) {
-  uint128 result = MakeUint128(Uint128High64(lhs) + Uint128High64(rhs),
-                               Uint128Low64(lhs) + Uint128Low64(rhs));
-  if (Uint128Low64(result) < Uint128Low64(lhs)) {  // check for carry
-    return MakeUint128(Uint128High64(result) + 1, Uint128Low64(result));
-  }
-  return result;
-}
-
-inline uint128 operator-(uint128 lhs, uint128 rhs) {
-  uint128 result = MakeUint128(Uint128High64(lhs) - Uint128High64(rhs),
-                               Uint128Low64(lhs) - Uint128Low64(rhs));
-  if (Uint128Low64(lhs) < Uint128Low64(rhs)) {  // check for carry
-    return MakeUint128(Uint128High64(result) - 1, Uint128Low64(result));
-  }
-  return result;
-}
-
-inline uint128 operator*(uint128 lhs, uint128 rhs) {
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
-  // TODO(strel) Remove once alignment issues are resolved and unsigned __int128
-  // can be used for uint128 storage.
-  return static_cast<unsigned __int128>(lhs) *
-         static_cast<unsigned __int128>(rhs);
-#elif defined(_MSC_VER) && defined(_M_X64)
-  uint64_t carry;
-  uint64_t low = _umul128(Uint128Low64(lhs), Uint128Low64(rhs), &carry);
-  return MakeUint128(Uint128Low64(lhs) * Uint128High64(rhs) +
-                         Uint128High64(lhs) * Uint128Low64(rhs) + carry,
-                     low);
-#else   // ABSL_HAVE_INTRINSIC128
-  uint64_t a32 = Uint128Low64(lhs) >> 32;
-  uint64_t a00 = Uint128Low64(lhs) & 0xffffffff;
-  uint64_t b32 = Uint128Low64(rhs) >> 32;
-  uint64_t b00 = Uint128Low64(rhs) & 0xffffffff;
-  uint128 result =
-      MakeUint128(Uint128High64(lhs) * Uint128Low64(rhs) +
-                      Uint128Low64(lhs) * Uint128High64(rhs) + a32 * b32,
-                  a00 * b00);
-  result += uint128(a32 * b00) << 32;
-  result += uint128(a00 * b32) << 32;
-  return result;
-#endif  // ABSL_HAVE_INTRINSIC128
-}
-
-// Increment/decrement operators.
-
-inline uint128 uint128::operator++(int) {
-  uint128 tmp(*this);
-  *this += 1;
-  return tmp;
-}
-
-inline uint128 uint128::operator--(int) {
-  uint128 tmp(*this);
-  *this -= 1;
-  return tmp;
-}
-
-inline uint128& uint128::operator++() {
-  *this += 1;
-  return *this;
-}
-
-inline uint128& uint128::operator--() {
-  *this -= 1;
-  return *this;
-}
-
-constexpr int128 MakeInt128(int64_t high, uint64_t low) {
-  return int128(high, low);
-}
-
-// Assignment from integer types.
-inline int128& int128::operator=(int v) {
-  return *this = int128(v);
-}
-
-inline int128& int128::operator=(unsigned int v) {
-  return *this = int128(v);
-}
-
-inline int128& int128::operator=(long v) {  // NOLINT(runtime/int)
-  return *this = int128(v);
-}
-
-// NOLINTNEXTLINE(runtime/int)
-inline int128& int128::operator=(unsigned long v) {
-  return *this = int128(v);
-}
-
-// NOLINTNEXTLINE(runtime/int)
-inline int128& int128::operator=(long long v) {
-  return *this = int128(v);
-}
-
-// NOLINTNEXTLINE(runtime/int)
-inline int128& int128::operator=(unsigned long long v) {
-  return *this = int128(v);
-}
-
-// Arithmetic operators.
-
-int128 operator+(int128 lhs, int128 rhs);
-int128 operator-(int128 lhs, int128 rhs);
-int128 operator*(int128 lhs, int128 rhs);
-int128 operator/(int128 lhs, int128 rhs);
-int128 operator%(int128 lhs, int128 rhs);
-int128 operator|(int128 lhs, int128 rhs);
-int128 operator&(int128 lhs, int128 rhs);
-int128 operator^(int128 lhs, int128 rhs);
-int128 operator<<(int128 lhs, int amount);
-int128 operator>>(int128 lhs, int amount);
-
-inline int128& int128::operator+=(int128 other) {
-  *this = *this + other;
-  return *this;
-}
-
-inline int128& int128::operator-=(int128 other) {
-  *this = *this - other;
-  return *this;
-}
-
-inline int128& int128::operator*=(int128 other) {
-  *this = *this * other;
-  return *this;
-}
-
-inline int128& int128::operator/=(int128 other) {
-  *this = *this / other;
-  return *this;
-}
-
-inline int128& int128::operator%=(int128 other) {
-  *this = *this % other;
-  return *this;
-}
-
-inline int128& int128::operator|=(int128 other) {
-  *this = *this | other;
-  return *this;
-}
-
-inline int128& int128::operator&=(int128 other) {
-  *this = *this & other;
-  return *this;
-}
-
-inline int128& int128::operator^=(int128 other) {
-  *this = *this ^ other;
-  return *this;
-}
-
-inline int128& int128::operator<<=(int amount) {
-  *this = *this << amount;
-  return *this;
-}
-
-inline int128& int128::operator>>=(int amount) {
-  *this = *this >> amount;
-  return *this;
-}
-
-namespace int128_internal {
-
-// Casts from unsigned to signed while preserving the underlying binary
-// representation.
-constexpr int64_t BitCastToSigned(uint64_t v) {
-  // Casting an unsigned integer to a signed integer of the same
-  // width is implementation defined behavior if the source value would not fit
-  // in the destination type. We step around it with a roundtrip bitwise not
-  // operation to make sure this function remains constexpr. Clang, GCC, and
-  // MSVC optimize this to a no-op on x86-64.
-  return v & (uint64_t{1} << 63) ? ~static_cast<int64_t>(~v)
-                                 : static_cast<int64_t>(v);
-}
-
-}  // namespace int128_internal
-
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
-#include "absl/numeric/int128_have_intrinsic.inc"  // IWYU pragma: export
-#else  // ABSL_HAVE_INTRINSIC_INT128
-#include "absl/numeric/int128_no_intrinsic.inc"  // IWYU pragma: export
-#endif  // ABSL_HAVE_INTRINSIC_INT128
-
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#undef ABSL_INTERNAL_WCHAR_T
-
-#endif  // ABSL_NUMERIC_INT128_H_
diff --git a/third_party/abseil_cpp/absl/numeric/int128_benchmark.cc b/third_party/abseil_cpp/absl/numeric/int128_benchmark.cc
deleted file mode 100644
index eab1515c0ad8..000000000000
--- a/third_party/abseil_cpp/absl/numeric/int128_benchmark.cc
+++ /dev/null
@@ -1,282 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <algorithm>
-#include <cstdint>
-#include <limits>
-#include <random>
-#include <vector>
-
-#include "benchmark/benchmark.h"
-#include "absl/base/config.h"
-#include "absl/numeric/int128.h"
-
-namespace {
-
-constexpr size_t kSampleSize = 1000000;
-
-std::mt19937 MakeRandomEngine() {
-  std::random_device r;
-  std::seed_seq seed({r(), r(), r(), r(), r(), r(), r(), r()});
-  return std::mt19937(seed);
-}
-
-template <typename T,
-          typename H = typename std::conditional<
-              std::numeric_limits<T>::is_signed, int64_t, uint64_t>::type>
-std::vector<std::pair<T, T>> GetRandomClass128SampleUniformDivisor() {
-  std::vector<std::pair<T, T>> values;
-  std::mt19937 random = MakeRandomEngine();
-  std::uniform_int_distribution<H> uniform_h;
-  values.reserve(kSampleSize);
-  for (size_t i = 0; i < kSampleSize; ++i) {
-    T a{absl::MakeUint128(uniform_h(random), uniform_h(random))};
-    T b{absl::MakeUint128(uniform_h(random), uniform_h(random))};
-    values.emplace_back(std::max(a, b), std::max(T(2), std::min(a, b)));
-  }
-  return values;
-}
-
-template <typename T>
-void BM_DivideClass128UniformDivisor(benchmark::State& state) {
-  auto values = GetRandomClass128SampleUniformDivisor<T>();
-  while (state.KeepRunningBatch(values.size())) {
-    for (const auto& pair : values) {
-      benchmark::DoNotOptimize(pair.first / pair.second);
-    }
-  }
-}
-BENCHMARK_TEMPLATE(BM_DivideClass128UniformDivisor, absl::uint128);
-BENCHMARK_TEMPLATE(BM_DivideClass128UniformDivisor, absl::int128);
-
-template <typename T>
-void BM_RemainderClass128UniformDivisor(benchmark::State& state) {
-  auto values = GetRandomClass128SampleUniformDivisor<T>();
-  while (state.KeepRunningBatch(values.size())) {
-    for (const auto& pair : values) {
-      benchmark::DoNotOptimize(pair.first % pair.second);
-    }
-  }
-}
-BENCHMARK_TEMPLATE(BM_RemainderClass128UniformDivisor, absl::uint128);
-BENCHMARK_TEMPLATE(BM_RemainderClass128UniformDivisor, absl::int128);
-
-template <typename T,
-          typename H = typename std::conditional<
-              std::numeric_limits<T>::is_signed, int64_t, uint64_t>::type>
-std::vector<std::pair<T, H>> GetRandomClass128SampleSmallDivisor() {
-  std::vector<std::pair<T, H>> values;
-  std::mt19937 random = MakeRandomEngine();
-  std::uniform_int_distribution<H> uniform_h;
-  values.reserve(kSampleSize);
-  for (size_t i = 0; i < kSampleSize; ++i) {
-    T a{absl::MakeUint128(uniform_h(random), uniform_h(random))};
-    H b{std::max(H{2}, uniform_h(random))};
-    values.emplace_back(std::max(a, T(b)), b);
-  }
-  return values;
-}
-
-template <typename T>
-void BM_DivideClass128SmallDivisor(benchmark::State& state) {
-  auto values = GetRandomClass128SampleSmallDivisor<T>();
-  while (state.KeepRunningBatch(values.size())) {
-    for (const auto& pair : values) {
-      benchmark::DoNotOptimize(pair.first / pair.second);
-    }
-  }
-}
-BENCHMARK_TEMPLATE(BM_DivideClass128SmallDivisor, absl::uint128);
-BENCHMARK_TEMPLATE(BM_DivideClass128SmallDivisor, absl::int128);
-
-template <typename T>
-void BM_RemainderClass128SmallDivisor(benchmark::State& state) {
-  auto values = GetRandomClass128SampleSmallDivisor<T>();
-  while (state.KeepRunningBatch(values.size())) {
-    for (const auto& pair : values) {
-      benchmark::DoNotOptimize(pair.first % pair.second);
-    }
-  }
-}
-BENCHMARK_TEMPLATE(BM_RemainderClass128SmallDivisor, absl::uint128);
-BENCHMARK_TEMPLATE(BM_RemainderClass128SmallDivisor, absl::int128);
-
-std::vector<std::pair<absl::uint128, absl::uint128>> GetRandomClass128Sample() {
-  std::vector<std::pair<absl::uint128, absl::uint128>> values;
-  std::mt19937 random = MakeRandomEngine();
-  std::uniform_int_distribution<uint64_t> uniform_uint64;
-  values.reserve(kSampleSize);
-  for (size_t i = 0; i < kSampleSize; ++i) {
-    values.emplace_back(
-        absl::MakeUint128(uniform_uint64(random), uniform_uint64(random)),
-        absl::MakeUint128(uniform_uint64(random), uniform_uint64(random)));
-  }
-  return values;
-}
-
-void BM_MultiplyClass128(benchmark::State& state) {
-  auto values = GetRandomClass128Sample();
-  while (state.KeepRunningBatch(values.size())) {
-    for (const auto& pair : values) {
-      benchmark::DoNotOptimize(pair.first * pair.second);
-    }
-  }
-}
-BENCHMARK(BM_MultiplyClass128);
-
-void BM_AddClass128(benchmark::State& state) {
-  auto values = GetRandomClass128Sample();
-  while (state.KeepRunningBatch(values.size())) {
-    for (const auto& pair : values) {
-      benchmark::DoNotOptimize(pair.first + pair.second);
-    }
-  }
-}
-BENCHMARK(BM_AddClass128);
-
-#ifdef ABSL_HAVE_INTRINSIC_INT128
-
-// Some implementations of <random> do not support __int128 when it is
-// available, so we make our own uniform_int_distribution-like type.
-template <typename T,
-          typename H = typename std::conditional<
-              std::is_same<T, __int128>::value, int64_t, uint64_t>::type>
-class UniformIntDistribution128 {
- public:
-  // NOLINTNEXTLINE: mimicking std::uniform_int_distribution API
-  T operator()(std::mt19937& generator) {
-    return (static_cast<T>(dist64_(generator)) << 64) | dist64_(generator);
-  }
-
- private:
-  std::uniform_int_distribution<H> dist64_;
-};
-
-template <typename T,
-          typename H = typename std::conditional<
-              std::is_same<T, __int128>::value, int64_t, uint64_t>::type>
-std::vector<std::pair<T, T>> GetRandomIntrinsic128SampleUniformDivisor() {
-  std::vector<std::pair<T, T>> values;
-  std::mt19937 random = MakeRandomEngine();
-  UniformIntDistribution128<T> uniform_128;
-  values.reserve(kSampleSize);
-  for (size_t i = 0; i < kSampleSize; ++i) {
-    T a = uniform_128(random);
-    T b = uniform_128(random);
-    values.emplace_back(std::max(a, b),
-                        std::max(static_cast<T>(2), std::min(a, b)));
-  }
-  return values;
-}
-
-template <typename T>
-void BM_DivideIntrinsic128UniformDivisor(benchmark::State& state) {
-  auto values = GetRandomIntrinsic128SampleUniformDivisor<T>();
-  while (state.KeepRunningBatch(values.size())) {
-    for (const auto& pair : values) {
-      benchmark::DoNotOptimize(pair.first / pair.second);
-    }
-  }
-}
-BENCHMARK_TEMPLATE(BM_DivideIntrinsic128UniformDivisor, unsigned __int128);
-BENCHMARK_TEMPLATE(BM_DivideIntrinsic128UniformDivisor, __int128);
-
-template <typename T>
-void BM_RemainderIntrinsic128UniformDivisor(benchmark::State& state) {
-  auto values = GetRandomIntrinsic128SampleUniformDivisor<T>();
-  while (state.KeepRunningBatch(values.size())) {
-    for (const auto& pair : values) {
-      benchmark::DoNotOptimize(pair.first % pair.second);
-    }
-  }
-}
-BENCHMARK_TEMPLATE(BM_RemainderIntrinsic128UniformDivisor, unsigned __int128);
-BENCHMARK_TEMPLATE(BM_RemainderIntrinsic128UniformDivisor, __int128);
-
-template <typename T,
-          typename H = typename std::conditional<
-              std::is_same<T, __int128>::value, int64_t, uint64_t>::type>
-std::vector<std::pair<T, H>> GetRandomIntrinsic128SampleSmallDivisor() {
-  std::vector<std::pair<T, H>> values;
-  std::mt19937 random = MakeRandomEngine();
-  UniformIntDistribution128<T> uniform_int128;
-  std::uniform_int_distribution<H> uniform_int64;
-  values.reserve(kSampleSize);
-  for (size_t i = 0; i < kSampleSize; ++i) {
-    T a = uniform_int128(random);
-    H b = std::max(H{2}, uniform_int64(random));
-    values.emplace_back(std::max(a, static_cast<T>(b)), b);
-  }
-  return values;
-}
-
-template <typename T>
-void BM_DivideIntrinsic128SmallDivisor(benchmark::State& state) {
-  auto values = GetRandomIntrinsic128SampleSmallDivisor<T>();
-  while (state.KeepRunningBatch(values.size())) {
-    for (const auto& pair : values) {
-      benchmark::DoNotOptimize(pair.first / pair.second);
-    }
-  }
-}
-BENCHMARK_TEMPLATE(BM_DivideIntrinsic128SmallDivisor, unsigned __int128);
-BENCHMARK_TEMPLATE(BM_DivideIntrinsic128SmallDivisor, __int128);
-
-template <typename T>
-void BM_RemainderIntrinsic128SmallDivisor(benchmark::State& state) {
-  auto values = GetRandomIntrinsic128SampleSmallDivisor<T>();
-  while (state.KeepRunningBatch(values.size())) {
-    for (const auto& pair : values) {
-      benchmark::DoNotOptimize(pair.first % pair.second);
-    }
-  }
-}
-BENCHMARK_TEMPLATE(BM_RemainderIntrinsic128SmallDivisor, unsigned __int128);
-BENCHMARK_TEMPLATE(BM_RemainderIntrinsic128SmallDivisor, __int128);
-
-std::vector<std::pair<unsigned __int128, unsigned __int128>>
-      GetRandomIntrinsic128Sample() {
-  std::vector<std::pair<unsigned __int128, unsigned __int128>> values;
-  std::mt19937 random = MakeRandomEngine();
-  UniformIntDistribution128<unsigned __int128> uniform_uint128;
-  values.reserve(kSampleSize);
-  for (size_t i = 0; i < kSampleSize; ++i) {
-    values.emplace_back(uniform_uint128(random), uniform_uint128(random));
-  }
-  return values;
-}
-
-void BM_MultiplyIntrinsic128(benchmark::State& state) {
-  auto values = GetRandomIntrinsic128Sample();
-  while (state.KeepRunningBatch(values.size())) {
-    for (const auto& pair : values) {
-      benchmark::DoNotOptimize(pair.first * pair.second);
-    }
-  }
-}
-BENCHMARK(BM_MultiplyIntrinsic128);
-
-void BM_AddIntrinsic128(benchmark::State& state) {
-  auto values = GetRandomIntrinsic128Sample();
-  while (state.KeepRunningBatch(values.size())) {
-    for (const auto& pair : values) {
-      benchmark::DoNotOptimize(pair.first + pair.second);
-    }
-  }
-}
-BENCHMARK(BM_AddIntrinsic128);
-
-#endif  // ABSL_HAVE_INTRINSIC_INT128
-
-}  // namespace
diff --git a/third_party/abseil_cpp/absl/numeric/int128_have_intrinsic.inc b/third_party/abseil_cpp/absl/numeric/int128_have_intrinsic.inc
deleted file mode 100644
index d6c76dd320ce..000000000000
--- a/third_party/abseil_cpp/absl/numeric/int128_have_intrinsic.inc
+++ /dev/null
@@ -1,302 +0,0 @@
-//
-// Copyright 2017 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 contains :int128 implementation details that depend on internal
-// representation when ABSL_HAVE_INTRINSIC_INT128 is defined. This file is
-// included by int128.h and relies on ABSL_INTERNAL_WCHAR_T being defined.
-
-namespace int128_internal {
-
-// Casts from unsigned to signed while preserving the underlying binary
-// representation.
-constexpr __int128 BitCastToSigned(unsigned __int128 v) {
-  // Casting an unsigned integer to a signed integer of the same
-  // width is implementation defined behavior if the source value would not fit
-  // in the destination type. We step around it with a roundtrip bitwise not
-  // operation to make sure this function remains constexpr. Clang and GCC
-  // optimize this to a no-op on x86-64.
-  return v & (static_cast<unsigned __int128>(1) << 127)
-             ? ~static_cast<__int128>(~v)
-             : static_cast<__int128>(v);
-}
-
-}  // namespace int128_internal
-
-inline int128& int128::operator=(__int128 v) {
-  v_ = v;
-  return *this;
-}
-
-constexpr uint64_t Int128Low64(int128 v) {
-  return static_cast<uint64_t>(v.v_ & ~uint64_t{0});
-}
-
-constexpr int64_t Int128High64(int128 v) {
-  // Initially cast to unsigned to prevent a right shift on a negative value.
-  return int128_internal::BitCastToSigned(
-      static_cast<uint64_t>(static_cast<unsigned __int128>(v.v_) >> 64));
-}
-
-constexpr int128::int128(int64_t high, uint64_t low)
-    // Initially cast to unsigned to prevent a left shift that overflows.
-    : v_(int128_internal::BitCastToSigned(static_cast<unsigned __int128>(high)
-                                           << 64) |
-         low) {}
-
-
-constexpr int128::int128(int v) : v_{v} {}
-
-constexpr int128::int128(long v) : v_{v} {}       // NOLINT(runtime/int)
-
-constexpr int128::int128(long long v) : v_{v} {}  // NOLINT(runtime/int)
-
-constexpr int128::int128(__int128 v) : v_{v} {}
-
-constexpr int128::int128(unsigned int v) : v_{v} {}
-
-constexpr int128::int128(unsigned long v) : v_{v} {}  // NOLINT(runtime/int)
-
-// NOLINTNEXTLINE(runtime/int)
-constexpr int128::int128(unsigned long long v) : v_{v} {}
-
-constexpr int128::int128(unsigned __int128 v) : v_{static_cast<__int128>(v)} {}
-
-inline int128::int128(float v) {
-  v_ = static_cast<__int128>(v);
-}
-
-inline int128::int128(double v) {
-  v_ = static_cast<__int128>(v);
-}
-
-inline int128::int128(long double v) {
-  v_ = static_cast<__int128>(v);
-}
-
-constexpr int128::int128(uint128 v) : v_{static_cast<__int128>(v)} {}
-
-constexpr int128::operator bool() const { return static_cast<bool>(v_); }
-
-constexpr int128::operator char() const { return static_cast<char>(v_); }
-
-constexpr int128::operator signed char() const {
-  return static_cast<signed char>(v_);
-}
-
-constexpr int128::operator unsigned char() const {
-  return static_cast<unsigned char>(v_);
-}
-
-constexpr int128::operator char16_t() const {
-  return static_cast<char16_t>(v_);
-}
-
-constexpr int128::operator char32_t() const {
-  return static_cast<char32_t>(v_);
-}
-
-constexpr int128::operator ABSL_INTERNAL_WCHAR_T() const {
-  return static_cast<ABSL_INTERNAL_WCHAR_T>(v_);
-}
-
-constexpr int128::operator short() const {  // NOLINT(runtime/int)
-  return static_cast<short>(v_);            // NOLINT(runtime/int)
-}
-
-constexpr int128::operator unsigned short() const {  // NOLINT(runtime/int)
-  return static_cast<unsigned short>(v_);            // NOLINT(runtime/int)
-}
-
-constexpr int128::operator int() const {
-  return static_cast<int>(v_);
-}
-
-constexpr int128::operator unsigned int() const {
-  return static_cast<unsigned int>(v_);
-}
-
-constexpr int128::operator long() const {  // NOLINT(runtime/int)
-  return static_cast<long>(v_);            // NOLINT(runtime/int)
-}
-
-constexpr int128::operator unsigned long() const {  // NOLINT(runtime/int)
-  return static_cast<unsigned long>(v_);            // NOLINT(runtime/int)
-}
-
-constexpr int128::operator long long() const {  // NOLINT(runtime/int)
-  return static_cast<long long>(v_);            // NOLINT(runtime/int)
-}
-
-constexpr int128::operator unsigned long long() const {  // NOLINT(runtime/int)
-  return static_cast<unsigned long long>(v_);            // NOLINT(runtime/int)
-}
-
-constexpr int128::operator __int128() const { return v_; }
-
-constexpr int128::operator unsigned __int128() const {
-  return static_cast<unsigned __int128>(v_);
-}
-
-// Clang on PowerPC sometimes produces incorrect __int128 to floating point
-// conversions. In that case, we do the conversion with a similar implementation
-// to the conversion operators in int128_no_intrinsic.inc.
-#if defined(__clang__) && !defined(__ppc64__)
-inline int128::operator float() const { return static_cast<float>(v_); }
-
-inline int128::operator double () const { return static_cast<double>(v_); }
-
-inline int128::operator long double() const {
-  return static_cast<long double>(v_);
-}
-
-#else  // Clang on PowerPC
-// Forward declaration for conversion operators to floating point types.
-int128 operator-(int128 v);
-bool operator!=(int128 lhs, int128 rhs);
-
-inline int128::operator float() const {
-  // We must convert the absolute value and then negate as needed, because
-  // floating point types are typically sign-magnitude. Otherwise, the
-  // difference between the high and low 64 bits when interpreted as two's
-  // complement overwhelms the precision of the mantissa.
-  //
-  // Also check to make sure we don't negate Int128Min()
-  return v_ < 0 && *this != Int128Min()
-             ? -static_cast<float>(-*this)
-             : static_cast<float>(Int128Low64(*this)) +
-                   std::ldexp(static_cast<float>(Int128High64(*this)), 64);
-}
-
-inline int128::operator double() const {
-  // See comment in int128::operator float() above.
-  return v_ < 0 && *this != Int128Min()
-             ? -static_cast<double>(-*this)
-             : static_cast<double>(Int128Low64(*this)) +
-                   std::ldexp(static_cast<double>(Int128High64(*this)), 64);
-}
-
-inline int128::operator long double() const {
-  // See comment in int128::operator float() above.
-  return v_ < 0 && *this != Int128Min()
-             ? -static_cast<long double>(-*this)
-             : static_cast<long double>(Int128Low64(*this)) +
-                   std::ldexp(static_cast<long double>(Int128High64(*this)),
-                              64);
-}
-#endif  // Clang on PowerPC
-
-// Comparison operators.
-
-inline bool operator==(int128 lhs, int128 rhs) {
-  return static_cast<__int128>(lhs) == static_cast<__int128>(rhs);
-}
-
-inline bool operator!=(int128 lhs, int128 rhs) {
-  return static_cast<__int128>(lhs) != static_cast<__int128>(rhs);
-}
-
-inline bool operator<(int128 lhs, int128 rhs) {
-  return static_cast<__int128>(lhs) < static_cast<__int128>(rhs);
-}
-
-inline bool operator>(int128 lhs, int128 rhs) {
-  return static_cast<__int128>(lhs) > static_cast<__int128>(rhs);
-}
-
-inline bool operator<=(int128 lhs, int128 rhs) {
-  return static_cast<__int128>(lhs) <= static_cast<__int128>(rhs);
-}
-
-inline bool operator>=(int128 lhs, int128 rhs) {
-  return static_cast<__int128>(lhs) >= static_cast<__int128>(rhs);
-}
-
-// Unary operators.
-
-inline int128 operator-(int128 v) {
-  return -static_cast<__int128>(v);
-}
-
-inline bool operator!(int128 v) {
-  return !static_cast<__int128>(v);
-}
-
-inline int128 operator~(int128 val) {
-  return ~static_cast<__int128>(val);
-}
-
-// Arithmetic operators.
-
-inline int128 operator+(int128 lhs, int128 rhs) {
-  return static_cast<__int128>(lhs) + static_cast<__int128>(rhs);
-}
-
-inline int128 operator-(int128 lhs, int128 rhs) {
-  return static_cast<__int128>(lhs) - static_cast<__int128>(rhs);
-}
-
-inline int128 operator*(int128 lhs, int128 rhs) {
-  return static_cast<__int128>(lhs) * static_cast<__int128>(rhs);
-}
-
-inline int128 operator/(int128 lhs, int128 rhs) {
-  return static_cast<__int128>(lhs) / static_cast<__int128>(rhs);
-}
-
-inline int128 operator%(int128 lhs, int128 rhs) {
-  return static_cast<__int128>(lhs) % static_cast<__int128>(rhs);
-}
-
-inline int128 int128::operator++(int) {
-  int128 tmp(*this);
-  ++v_;
-  return tmp;
-}
-
-inline int128 int128::operator--(int) {
-  int128 tmp(*this);
-  --v_;
-  return tmp;
-}
-
-inline int128& int128::operator++() {
-  ++v_;
-  return *this;
-}
-
-inline int128& int128::operator--() {
-  --v_;
-  return *this;
-}
-
-inline int128 operator|(int128 lhs, int128 rhs) {
-  return static_cast<__int128>(lhs) | static_cast<__int128>(rhs);
-}
-
-inline int128 operator&(int128 lhs, int128 rhs) {
-  return static_cast<__int128>(lhs) & static_cast<__int128>(rhs);
-}
-
-inline int128 operator^(int128 lhs, int128 rhs) {
-  return static_cast<__int128>(lhs) ^ static_cast<__int128>(rhs);
-}
-
-inline int128 operator<<(int128 lhs, int amount) {
-  return static_cast<__int128>(lhs) << amount;
-}
-
-inline int128 operator>>(int128 lhs, int amount) {
-  return static_cast<__int128>(lhs) >> amount;
-}
diff --git a/third_party/abseil_cpp/absl/numeric/int128_no_intrinsic.inc b/third_party/abseil_cpp/absl/numeric/int128_no_intrinsic.inc
deleted file mode 100644
index c753771ae73a..000000000000
--- a/third_party/abseil_cpp/absl/numeric/int128_no_intrinsic.inc
+++ /dev/null
@@ -1,308 +0,0 @@
-//
-// Copyright 2017 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 contains :int128 implementation details that depend on internal
-// representation when ABSL_HAVE_INTRINSIC_INT128 is *not* defined. This file
-// is included by int128.h and relies on ABSL_INTERNAL_WCHAR_T being defined.
-
-constexpr uint64_t Int128Low64(int128 v) { return v.lo_; }
-
-constexpr int64_t Int128High64(int128 v) { return v.hi_; }
-
-#if defined(ABSL_IS_LITTLE_ENDIAN)
-
-constexpr int128::int128(int64_t high, uint64_t low) :
-    lo_(low), hi_(high) {}
-
-constexpr int128::int128(int v)
-    : lo_{static_cast<uint64_t>(v)}, hi_{v < 0 ? ~int64_t{0} : 0} {}
-constexpr int128::int128(long v)  // NOLINT(runtime/int)
-    : lo_{static_cast<uint64_t>(v)}, hi_{v < 0 ? ~int64_t{0} : 0} {}
-constexpr int128::int128(long long v)  // NOLINT(runtime/int)
-    : lo_{static_cast<uint64_t>(v)}, hi_{v < 0 ? ~int64_t{0} : 0} {}
-
-constexpr int128::int128(unsigned int v) : lo_{v}, hi_{0} {}
-// NOLINTNEXTLINE(runtime/int)
-constexpr int128::int128(unsigned long v) : lo_{v}, hi_{0} {}
-// NOLINTNEXTLINE(runtime/int)
-constexpr int128::int128(unsigned long long v) : lo_{v}, hi_{0} {}
-
-constexpr int128::int128(uint128 v)
-    : lo_{Uint128Low64(v)}, hi_{static_cast<int64_t>(Uint128High64(v))} {}
-
-#elif defined(ABSL_IS_BIG_ENDIAN)
-
-constexpr int128::int128(int64_t high, uint64_t low) :
-    hi_{high}, lo_{low} {}
-
-constexpr int128::int128(int v)
-    : hi_{v < 0 ? ~int64_t{0} : 0}, lo_{static_cast<uint64_t>(v)} {}
-constexpr int128::int128(long v)  // NOLINT(runtime/int)
-    : hi_{v < 0 ? ~int64_t{0} : 0}, lo_{static_cast<uint64_t>(v)} {}
-constexpr int128::int128(long long v)  // NOLINT(runtime/int)
-    : hi_{v < 0 ? ~int64_t{0} : 0}, lo_{static_cast<uint64_t>(v)} {}
-
-constexpr int128::int128(unsigned int v) : hi_{0}, lo_{v} {}
-// NOLINTNEXTLINE(runtime/int)
-constexpr int128::int128(unsigned long v) : hi_{0}, lo_{v} {}
-// NOLINTNEXTLINE(runtime/int)
-constexpr int128::int128(unsigned long long v) : hi_{0}, lo_{v} {}
-
-constexpr int128::int128(uint128 v)
-    : hi_{static_cast<int64_t>(Uint128High64(v))}, lo_{Uint128Low64(v)} {}
-
-#else  // byte order
-#error "Unsupported byte order: must be little-endian or big-endian."
-#endif  // byte order
-
-constexpr int128::operator bool() const { return lo_ || hi_; }
-
-constexpr int128::operator char() const {
-  // NOLINTNEXTLINE(runtime/int)
-  return static_cast<char>(static_cast<long long>(*this));
-}
-
-constexpr int128::operator signed char() const {
-  // NOLINTNEXTLINE(runtime/int)
-  return static_cast<signed char>(static_cast<long long>(*this));
-}
-
-constexpr int128::operator unsigned char() const {
-  return static_cast<unsigned char>(lo_);
-}
-
-constexpr int128::operator char16_t() const {
-  return static_cast<char16_t>(lo_);
-}
-
-constexpr int128::operator char32_t() const {
-  return static_cast<char32_t>(lo_);
-}
-
-constexpr int128::operator ABSL_INTERNAL_WCHAR_T() const {
-  // NOLINTNEXTLINE(runtime/int)
-  return static_cast<ABSL_INTERNAL_WCHAR_T>(static_cast<long long>(*this));
-}
-
-constexpr int128::operator short() const {  // NOLINT(runtime/int)
-  // NOLINTNEXTLINE(runtime/int)
-  return static_cast<short>(static_cast<long long>(*this));
-}
-
-constexpr int128::operator unsigned short() const {  // NOLINT(runtime/int)
-  return static_cast<unsigned short>(lo_);           // NOLINT(runtime/int)
-}
-
-constexpr int128::operator int() const {
-  // NOLINTNEXTLINE(runtime/int)
-  return static_cast<int>(static_cast<long long>(*this));
-}
-
-constexpr int128::operator unsigned int() const {
-  return static_cast<unsigned int>(lo_);
-}
-
-constexpr int128::operator long() const {  // NOLINT(runtime/int)
-  // NOLINTNEXTLINE(runtime/int)
-  return static_cast<long>(static_cast<long long>(*this));
-}
-
-constexpr int128::operator unsigned long() const {  // NOLINT(runtime/int)
-  return static_cast<unsigned long>(lo_);           // NOLINT(runtime/int)
-}
-
-constexpr int128::operator long long() const {  // NOLINT(runtime/int)
-  // We don't bother checking the value of hi_. If *this < 0, lo_'s high bit
-  // must be set in order for the value to fit into a long long. Conversely, if
-  // lo_'s high bit is set, *this must be < 0 for the value to fit.
-  return int128_internal::BitCastToSigned(lo_);
-}
-
-constexpr int128::operator unsigned long long() const {  // NOLINT(runtime/int)
-  return static_cast<unsigned long long>(lo_);           // NOLINT(runtime/int)
-}
-
-// Forward declaration for conversion operators to floating point types.
-int128 operator-(int128 v);
-bool operator!=(int128 lhs, int128 rhs);
-
-inline int128::operator float() const {
-  // We must convert the absolute value and then negate as needed, because
-  // floating point types are typically sign-magnitude. Otherwise, the
-  // difference between the high and low 64 bits when interpreted as two's
-  // complement overwhelms the precision of the mantissa.
-  //
-  // Also check to make sure we don't negate Int128Min()
-  return hi_ < 0 && *this != Int128Min()
-             ? -static_cast<float>(-*this)
-             : static_cast<float>(lo_) +
-                   std::ldexp(static_cast<float>(hi_), 64);
-}
-
-inline int128::operator double() const {
-  // See comment in int128::operator float() above.
-  return hi_ < 0 && *this != Int128Min()
-             ? -static_cast<double>(-*this)
-             : static_cast<double>(lo_) +
-                   std::ldexp(static_cast<double>(hi_), 64);
-}
-
-inline int128::operator long double() const {
-  // See comment in int128::operator float() above.
-  return hi_ < 0 && *this != Int128Min()
-             ? -static_cast<long double>(-*this)
-             : static_cast<long double>(lo_) +
-                   std::ldexp(static_cast<long double>(hi_), 64);
-}
-
-// Comparison operators.
-
-inline bool operator==(int128 lhs, int128 rhs) {
-  return (Int128Low64(lhs) == Int128Low64(rhs) &&
-          Int128High64(lhs) == Int128High64(rhs));
-}
-
-inline bool operator!=(int128 lhs, int128 rhs) {
-  return !(lhs == rhs);
-}
-
-inline bool operator<(int128 lhs, int128 rhs) {
-  return (Int128High64(lhs) == Int128High64(rhs))
-             ? (Int128Low64(lhs) < Int128Low64(rhs))
-             : (Int128High64(lhs) < Int128High64(rhs));
-}
-
-inline bool operator>(int128 lhs, int128 rhs) {
-  return (Int128High64(lhs) == Int128High64(rhs))
-             ? (Int128Low64(lhs) > Int128Low64(rhs))
-             : (Int128High64(lhs) > Int128High64(rhs));
-}
-
-inline bool operator<=(int128 lhs, int128 rhs) {
-  return !(lhs > rhs);
-}
-
-inline bool operator>=(int128 lhs, int128 rhs) {
-  return !(lhs < rhs);
-}
-
-// Unary operators.
-
-inline int128 operator-(int128 v) {
-  int64_t hi = ~Int128High64(v);
-  uint64_t lo = ~Int128Low64(v) + 1;
-  if (lo == 0) ++hi;  // carry
-  return MakeInt128(hi, lo);
-}
-
-inline bool operator!(int128 v) {
-  return !Int128Low64(v) && !Int128High64(v);
-}
-
-inline int128 operator~(int128 val) {
-  return MakeInt128(~Int128High64(val), ~Int128Low64(val));
-}
-
-// Arithmetic operators.
-
-inline int128 operator+(int128 lhs, int128 rhs) {
-  int128 result = MakeInt128(Int128High64(lhs) + Int128High64(rhs),
-                             Int128Low64(lhs) + Int128Low64(rhs));
-  if (Int128Low64(result) < Int128Low64(lhs)) {  // check for carry
-    return MakeInt128(Int128High64(result) + 1, Int128Low64(result));
-  }
-  return result;
-}
-
-inline int128 operator-(int128 lhs, int128 rhs) {
-  int128 result = MakeInt128(Int128High64(lhs) - Int128High64(rhs),
-                             Int128Low64(lhs) - Int128Low64(rhs));
-  if (Int128Low64(lhs) < Int128Low64(rhs)) {  // check for carry
-    return MakeInt128(Int128High64(result) - 1, Int128Low64(result));
-  }
-  return result;
-}
-
-inline int128 operator*(int128 lhs, int128 rhs) {
-  uint128 result = uint128(lhs) * rhs;
-  return MakeInt128(int128_internal::BitCastToSigned(Uint128High64(result)),
-                    Uint128Low64(result));
-}
-
-inline int128 int128::operator++(int) {
-  int128 tmp(*this);
-  *this += 1;
-  return tmp;
-}
-
-inline int128 int128::operator--(int) {
-  int128 tmp(*this);
-  *this -= 1;
-  return tmp;
-}
-
-inline int128& int128::operator++() {
-  *this += 1;
-  return *this;
-}
-
-inline int128& int128::operator--() {
-  *this -= 1;
-  return *this;
-}
-
-inline int128 operator|(int128 lhs, int128 rhs) {
-  return MakeInt128(Int128High64(lhs) | Int128High64(rhs),
-                    Int128Low64(lhs) | Int128Low64(rhs));
-}
-
-inline int128 operator&(int128 lhs, int128 rhs) {
-  return MakeInt128(Int128High64(lhs) & Int128High64(rhs),
-                    Int128Low64(lhs) & Int128Low64(rhs));
-}
-
-inline int128 operator^(int128 lhs, int128 rhs) {
-  return MakeInt128(Int128High64(lhs) ^ Int128High64(rhs),
-                    Int128Low64(lhs) ^ Int128Low64(rhs));
-}
-
-inline int128 operator<<(int128 lhs, int amount) {
-  // uint64_t shifts of >= 64 are undefined, so we need some special-casing.
-  if (amount < 64) {
-    if (amount != 0) {
-      return MakeInt128(
-          (Int128High64(lhs) << amount) |
-              static_cast<int64_t>(Int128Low64(lhs) >> (64 - amount)),
-          Int128Low64(lhs) << amount);
-    }
-    return lhs;
-  }
-  return MakeInt128(static_cast<int64_t>(Int128Low64(lhs) << (amount - 64)), 0);
-}
-
-inline int128 operator>>(int128 lhs, int amount) {
-  // uint64_t shifts of >= 64 are undefined, so we need some special-casing.
-  if (amount < 64) {
-    if (amount != 0) {
-      return MakeInt128(
-          Int128High64(lhs) >> amount,
-          (Int128Low64(lhs) >> amount) |
-              (static_cast<uint64_t>(Int128High64(lhs)) << (64 - amount)));
-    }
-    return lhs;
-  }
-  return MakeInt128(0,
-                    static_cast<uint64_t>(Int128High64(lhs) >> (amount - 64)));
-}
diff --git a/third_party/abseil_cpp/absl/numeric/int128_stream_test.cc b/third_party/abseil_cpp/absl/numeric/int128_stream_test.cc
deleted file mode 100644
index 479ad66cf4d5..000000000000
--- a/third_party/abseil_cpp/absl/numeric/int128_stream_test.cc
+++ /dev/null
@@ -1,1395 +0,0 @@
-// Copyright 2017 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/numeric/int128.h"
-
-#include <sstream>
-#include <string>
-
-#include "gtest/gtest.h"
-
-namespace {
-
-struct Uint128TestCase {
-  absl::uint128 value;
-  std::ios_base::fmtflags flags;
-  std::streamsize width;
-  const char* expected;
-};
-
-constexpr char kFill = '_';
-
-std::string StreamFormatToString(std::ios_base::fmtflags flags,
-                                 std::streamsize width) {
-  std::vector<const char*> flagstr;
-  switch (flags & std::ios::basefield) {
-    case std::ios::dec:
-      flagstr.push_back("std::ios::dec");
-      break;
-    case std::ios::oct:
-      flagstr.push_back("std::ios::oct");
-      break;
-    case std::ios::hex:
-      flagstr.push_back("std::ios::hex");
-      break;
-    default:  // basefield not specified
-      break;
-  }
-  switch (flags & std::ios::adjustfield) {
-    case std::ios::left:
-      flagstr.push_back("std::ios::left");
-      break;
-    case std::ios::internal:
-      flagstr.push_back("std::ios::internal");
-      break;
-    case std::ios::right:
-      flagstr.push_back("std::ios::right");
-      break;
-    default:  // adjustfield not specified
-      break;
-  }
-  if (flags & std::ios::uppercase) flagstr.push_back("std::ios::uppercase");
-  if (flags & std::ios::showbase) flagstr.push_back("std::ios::showbase");
-  if (flags & std::ios::showpos) flagstr.push_back("std::ios::showpos");
-
-  std::ostringstream msg;
-  msg << "\n  StreamFormatToString(test_case.flags, test_case.width)\n    "
-         "flags: ";
-  if (!flagstr.empty()) {
-    for (size_t i = 0; i < flagstr.size() - 1; ++i) msg << flagstr[i] << " | ";
-    msg << flagstr.back();
-  } else {
-    msg << "(default)";
-  }
-  msg << "\n    width: " << width << "\n    fill: '" << kFill << "'";
-  return msg.str();
-}
-
-void CheckUint128Case(const Uint128TestCase& test_case) {
-  std::ostringstream os;
-  os.flags(test_case.flags);
-  os.width(test_case.width);
-  os.fill(kFill);
-  os << test_case.value;
-  SCOPED_TRACE(StreamFormatToString(test_case.flags, test_case.width));
-  EXPECT_EQ(test_case.expected, os.str());
-}
-
-constexpr std::ios::fmtflags kDec = std::ios::dec;
-constexpr std::ios::fmtflags kOct = std::ios::oct;
-constexpr std::ios::fmtflags kHex = std::ios::hex;
-constexpr std::ios::fmtflags kLeft = std::ios::left;
-constexpr std::ios::fmtflags kInt = std::ios::internal;
-constexpr std::ios::fmtflags kRight = std::ios::right;
-constexpr std::ios::fmtflags kUpper = std::ios::uppercase;
-constexpr std::ios::fmtflags kBase = std::ios::showbase;
-constexpr std::ios::fmtflags kPos = std::ios::showpos;
-
-TEST(Uint128, OStreamValueTest) {
-  CheckUint128Case({1, kDec, /*width = */ 0, "1"});
-  CheckUint128Case({1, kOct, /*width = */ 0, "1"});
-  CheckUint128Case({1, kHex, /*width = */ 0, "1"});
-  CheckUint128Case({9, kDec, /*width = */ 0, "9"});
-  CheckUint128Case({9, kOct, /*width = */ 0, "11"});
-  CheckUint128Case({9, kHex, /*width = */ 0, "9"});
-  CheckUint128Case({12345, kDec, /*width = */ 0, "12345"});
-  CheckUint128Case({12345, kOct, /*width = */ 0, "30071"});
-  CheckUint128Case({12345, kHex, /*width = */ 0, "3039"});
-  CheckUint128Case(
-      {0x8000000000000000, kDec, /*width = */ 0, "9223372036854775808"});
-  CheckUint128Case(
-      {0x8000000000000000, kOct, /*width = */ 0, "1000000000000000000000"});
-  CheckUint128Case(
-      {0x8000000000000000, kHex, /*width = */ 0, "8000000000000000"});
-  CheckUint128Case({std::numeric_limits<uint64_t>::max(), kDec,
-                    /*width = */ 0, "18446744073709551615"});
-  CheckUint128Case({std::numeric_limits<uint64_t>::max(), kOct,
-                    /*width = */ 0, "1777777777777777777777"});
-  CheckUint128Case({std::numeric_limits<uint64_t>::max(), kHex,
-                    /*width = */ 0, "ffffffffffffffff"});
-  CheckUint128Case(
-      {absl::MakeUint128(1, 0), kDec, /*width = */ 0, "18446744073709551616"});
-  CheckUint128Case({absl::MakeUint128(1, 0), kOct, /*width = */ 0,
-                    "2000000000000000000000"});
-  CheckUint128Case(
-      {absl::MakeUint128(1, 0), kHex, /*width = */ 0, "10000000000000000"});
-  CheckUint128Case({absl::MakeUint128(0x8000000000000000, 0), kDec,
-                    /*width = */ 0, "170141183460469231731687303715884105728"});
-  CheckUint128Case({absl::MakeUint128(0x8000000000000000, 0), kOct,
-                    /*width = */ 0,
-                    "2000000000000000000000000000000000000000000"});
-  CheckUint128Case({absl::MakeUint128(0x8000000000000000, 0), kHex,
-                    /*width = */ 0, "80000000000000000000000000000000"});
-  CheckUint128Case({absl::kuint128max, kDec, /*width = */ 0,
-                    "340282366920938463463374607431768211455"});
-  CheckUint128Case({absl::kuint128max, kOct, /*width = */ 0,
-                    "3777777777777777777777777777777777777777777"});
-  CheckUint128Case({absl::kuint128max, kHex, /*width = */ 0,
-                    "ffffffffffffffffffffffffffffffff"});
-}
-
-std::vector<Uint128TestCase> GetUint128FormatCases();
-
-TEST(Uint128, OStreamFormatTest) {
-  for (const Uint128TestCase& test_case : GetUint128FormatCases()) {
-    CheckUint128Case(test_case);
-  }
-}
-
-struct Int128TestCase {
-  absl::int128 value;
-  std::ios_base::fmtflags flags;
-  std::streamsize width;
-  const char* expected;
-};
-
-void CheckInt128Case(const Int128TestCase& test_case) {
-  std::ostringstream os;
-  os.flags(test_case.flags);
-  os.width(test_case.width);
-  os.fill(kFill);
-  os << test_case.value;
-  SCOPED_TRACE(StreamFormatToString(test_case.flags, test_case.width));
-  EXPECT_EQ(test_case.expected, os.str());
-}
-
-TEST(Int128, OStreamValueTest) {
-  CheckInt128Case({1, kDec, /*width = */ 0, "1"});
-  CheckInt128Case({1, kOct, /*width = */ 0, "1"});
-  CheckInt128Case({1, kHex, /*width = */ 0, "1"});
-  CheckInt128Case({9, kDec, /*width = */ 0, "9"});
-  CheckInt128Case({9, kOct, /*width = */ 0, "11"});
-  CheckInt128Case({9, kHex, /*width = */ 0, "9"});
-  CheckInt128Case({12345, kDec, /*width = */ 0, "12345"});
-  CheckInt128Case({12345, kOct, /*width = */ 0, "30071"});
-  CheckInt128Case({12345, kHex, /*width = */ 0, "3039"});
-  CheckInt128Case(
-      {0x8000000000000000, kDec, /*width = */ 0, "9223372036854775808"});
-  CheckInt128Case(
-      {0x8000000000000000, kOct, /*width = */ 0, "1000000000000000000000"});
-  CheckInt128Case(
-      {0x8000000000000000, kHex, /*width = */ 0, "8000000000000000"});
-  CheckInt128Case({std::numeric_limits<uint64_t>::max(), kDec,
-                   /*width = */ 0, "18446744073709551615"});
-  CheckInt128Case({std::numeric_limits<uint64_t>::max(), kOct,
-                   /*width = */ 0, "1777777777777777777777"});
-  CheckInt128Case({std::numeric_limits<uint64_t>::max(), kHex,
-                   /*width = */ 0, "ffffffffffffffff"});
-  CheckInt128Case(
-      {absl::MakeInt128(1, 0), kDec, /*width = */ 0, "18446744073709551616"});
-  CheckInt128Case(
-      {absl::MakeInt128(1, 0), kOct, /*width = */ 0, "2000000000000000000000"});
-  CheckInt128Case(
-      {absl::MakeInt128(1, 0), kHex, /*width = */ 0, "10000000000000000"});
-  CheckInt128Case({absl::MakeInt128(std::numeric_limits<int64_t>::max(),
-                                    std::numeric_limits<uint64_t>::max()),
-                   std::ios::dec, /*width = */ 0,
-                   "170141183460469231731687303715884105727"});
-  CheckInt128Case({absl::MakeInt128(std::numeric_limits<int64_t>::max(),
-                                    std::numeric_limits<uint64_t>::max()),
-                   std::ios::oct, /*width = */ 0,
-                   "1777777777777777777777777777777777777777777"});
-  CheckInt128Case({absl::MakeInt128(std::numeric_limits<int64_t>::max(),
-                                    std::numeric_limits<uint64_t>::max()),
-                   std::ios::hex, /*width = */ 0,
-                   "7fffffffffffffffffffffffffffffff"});
-  CheckInt128Case({absl::MakeInt128(std::numeric_limits<int64_t>::min(), 0),
-                   std::ios::dec, /*width = */ 0,
-                   "-170141183460469231731687303715884105728"});
-  CheckInt128Case({absl::MakeInt128(std::numeric_limits<int64_t>::min(), 0),
-                   std::ios::oct, /*width = */ 0,
-                   "2000000000000000000000000000000000000000000"});
-  CheckInt128Case({absl::MakeInt128(std::numeric_limits<int64_t>::min(), 0),
-                   std::ios::hex, /*width = */ 0,
-                   "80000000000000000000000000000000"});
-  CheckInt128Case({-1, std::ios::dec, /*width = */ 0, "-1"});
-  CheckInt128Case({-1, std::ios::oct, /*width = */ 0,
-                   "3777777777777777777777777777777777777777777"});
-  CheckInt128Case(
-      {-1, std::ios::hex, /*width = */ 0, "ffffffffffffffffffffffffffffffff"});
-  CheckInt128Case({-12345, std::ios::dec, /*width = */ 0, "-12345"});
-  CheckInt128Case({-12345, std::ios::oct, /*width = */ 0,
-                   "3777777777777777777777777777777777777747707"});
-  CheckInt128Case({-12345, std::ios::hex, /*width = */ 0,
-                   "ffffffffffffffffffffffffffffcfc7"});
-}
-
-std::vector<Int128TestCase> GetInt128FormatCases();
-TEST(Int128, OStreamFormatTest) {
-  for (const Int128TestCase& test_case : GetInt128FormatCases()) {
-    CheckInt128Case(test_case);
-  }
-}
-
-std::vector<Int128TestCase> GetInt128FormatCases() {
-  return {
-      {0, std::ios_base::fmtflags(), /*width = */ 0, "0"},
-      {0, std::ios_base::fmtflags(), /*width = */ 6, "_____0"},
-      {0, kPos, /*width = */ 0, "+0"},
-      {0, kPos, /*width = */ 6, "____+0"},
-      {0, kBase, /*width = */ 0, "0"},
-      {0, kBase, /*width = */ 6, "_____0"},
-      {0, kBase | kPos, /*width = */ 0, "+0"},
-      {0, kBase | kPos, /*width = */ 6, "____+0"},
-      {0, kUpper, /*width = */ 0, "0"},
-      {0, kUpper, /*width = */ 6, "_____0"},
-      {0, kUpper | kPos, /*width = */ 0, "+0"},
-      {0, kUpper | kPos, /*width = */ 6, "____+0"},
-      {0, kUpper | kBase, /*width = */ 0, "0"},
-      {0, kUpper | kBase, /*width = */ 6, "_____0"},
-      {0, kUpper | kBase | kPos, /*width = */ 0, "+0"},
-      {0, kUpper | kBase | kPos, /*width = */ 6, "____+0"},
-      {0, kLeft, /*width = */ 0, "0"},
-      {0, kLeft, /*width = */ 6, "0_____"},
-      {0, kLeft | kPos, /*width = */ 0, "+0"},
-      {0, kLeft | kPos, /*width = */ 6, "+0____"},
-      {0, kLeft | kBase, /*width = */ 0, "0"},
-      {0, kLeft | kBase, /*width = */ 6, "0_____"},
-      {0, kLeft | kBase | kPos, /*width = */ 0, "+0"},
-      {0, kLeft | kBase | kPos, /*width = */ 6, "+0____"},
-      {0, kLeft | kUpper, /*width = */ 0, "0"},
-      {0, kLeft | kUpper, /*width = */ 6, "0_____"},
-      {0, kLeft | kUpper | kPos, /*width = */ 0, "+0"},
-      {0, kLeft | kUpper | kPos, /*width = */ 6, "+0____"},
-      {0, kLeft | kUpper | kBase, /*width = */ 0, "0"},
-      {0, kLeft | kUpper | kBase, /*width = */ 6, "0_____"},
-      {0, kLeft | kUpper | kBase | kPos, /*width = */ 0, "+0"},
-      {0, kLeft | kUpper | kBase | kPos, /*width = */ 6, "+0____"},
-      {0, kInt, /*width = */ 0, "0"},
-      {0, kInt, /*width = */ 6, "_____0"},
-      {0, kInt | kPos, /*width = */ 0, "+0"},
-      {0, kInt | kPos, /*width = */ 6, "+____0"},
-      {0, kInt | kBase, /*width = */ 0, "0"},
-      {0, kInt | kBase, /*width = */ 6, "_____0"},
-      {0, kInt | kBase | kPos, /*width = */ 0, "+0"},
-      {0, kInt | kBase | kPos, /*width = */ 6, "+____0"},
-      {0, kInt | kUpper, /*width = */ 0, "0"},
-      {0, kInt | kUpper, /*width = */ 6, "_____0"},
-      {0, kInt | kUpper | kPos, /*width = */ 0, "+0"},
-      {0, kInt | kUpper | kPos, /*width = */ 6, "+____0"},
-      {0, kInt | kUpper | kBase, /*width = */ 0, "0"},
-      {0, kInt | kUpper | kBase, /*width = */ 6, "_____0"},
-      {0, kInt | kUpper | kBase | kPos, /*width = */ 0, "+0"},
-      {0, kInt | kUpper | kBase | kPos, /*width = */ 6, "+____0"},
-      {0, kRight, /*width = */ 0, "0"},
-      {0, kRight, /*width = */ 6, "_____0"},
-      {0, kRight | kPos, /*width = */ 0, "+0"},
-      {0, kRight | kPos, /*width = */ 6, "____+0"},
-      {0, kRight | kBase, /*width = */ 0, "0"},
-      {0, kRight | kBase, /*width = */ 6, "_____0"},
-      {0, kRight | kBase | kPos, /*width = */ 0, "+0"},
-      {0, kRight | kBase | kPos, /*width = */ 6, "____+0"},
-      {0, kRight | kUpper, /*width = */ 0, "0"},
-      {0, kRight | kUpper, /*width = */ 6, "_____0"},
-      {0, kRight | kUpper | kPos, /*width = */ 0, "+0"},
-      {0, kRight | kUpper | kPos, /*width = */ 6, "____+0"},
-      {0, kRight | kUpper | kBase, /*width = */ 0, "0"},
-      {0, kRight | kUpper | kBase, /*width = */ 6, "_____0"},
-      {0, kRight | kUpper | kBase | kPos, /*width = */ 0, "+0"},
-      {0, kRight | kUpper | kBase | kPos, /*width = */ 6, "____+0"},
-      {0, kDec, /*width = */ 0, "0"},
-      {0, kDec, /*width = */ 6, "_____0"},
-      {0, kDec | kPos, /*width = */ 0, "+0"},
-      {0, kDec | kPos, /*width = */ 6, "____+0"},
-      {0, kDec | kBase, /*width = */ 0, "0"},
-      {0, kDec | kBase, /*width = */ 6, "_____0"},
-      {0, kDec | kBase | kPos, /*width = */ 0, "+0"},
-      {0, kDec | kBase | kPos, /*width = */ 6, "____+0"},
-      {0, kDec | kUpper, /*width = */ 0, "0"},
-      {0, kDec | kUpper, /*width = */ 6, "_____0"},
-      {0, kDec | kUpper | kPos, /*width = */ 0, "+0"},
-      {0, kDec | kUpper | kPos, /*width = */ 6, "____+0"},
-      {0, kDec | kUpper | kBase, /*width = */ 0, "0"},
-      {0, kDec | kUpper | kBase, /*width = */ 6, "_____0"},
-      {0, kDec | kUpper | kBase | kPos, /*width = */ 0, "+0"},
-      {0, kDec | kUpper | kBase | kPos, /*width = */ 6, "____+0"},
-      {0, kDec | kLeft, /*width = */ 0, "0"},
-      {0, kDec | kLeft, /*width = */ 6, "0_____"},
-      {0, kDec | kLeft | kPos, /*width = */ 0, "+0"},
-      {0, kDec | kLeft | kPos, /*width = */ 6, "+0____"},
-      {0, kDec | kLeft | kBase, /*width = */ 0, "0"},
-      {0, kDec | kLeft | kBase, /*width = */ 6, "0_____"},
-      {0, kDec | kLeft | kBase | kPos, /*width = */ 0, "+0"},
-      {0, kDec | kLeft | kBase | kPos, /*width = */ 6, "+0____"},
-      {0, kDec | kLeft | kUpper, /*width = */ 0, "0"},
-      {0, kDec | kLeft | kUpper, /*width = */ 6, "0_____"},
-      {0, kDec | kLeft | kUpper | kPos, /*width = */ 0, "+0"},
-      {0, kDec | kLeft | kUpper | kPos, /*width = */ 6, "+0____"},
-      {0, kDec | kLeft | kUpper | kBase, /*width = */ 0, "0"},
-      {0, kDec | kLeft | kUpper | kBase, /*width = */ 6, "0_____"},
-      {0, kDec | kLeft | kUpper | kBase | kPos, /*width = */ 0, "+0"},
-      {0, kDec | kLeft | kUpper | kBase | kPos, /*width = */ 6, "+0____"},
-      {0, kDec | kInt, /*width = */ 0, "0"},
-      {0, kDec | kInt, /*width = */ 6, "_____0"},
-      {0, kDec | kInt | kPos, /*width = */ 0, "+0"},
-      {0, kDec | kInt | kPos, /*width = */ 6, "+____0"},
-      {0, kDec | kInt | kBase, /*width = */ 0, "0"},
-      {0, kDec | kInt | kBase, /*width = */ 6, "_____0"},
-      {0, kDec | kInt | kBase | kPos, /*width = */ 0, "+0"},
-      {0, kDec | kInt | kBase | kPos, /*width = */ 6, "+____0"},
-      {0, kDec | kInt | kUpper, /*width = */ 0, "0"},
-      {0, kDec | kInt | kUpper, /*width = */ 6, "_____0"},
-      {0, kDec | kInt | kUpper | kPos, /*width = */ 0, "+0"},
-      {0, kDec | kInt | kUpper | kPos, /*width = */ 6, "+____0"},
-      {0, kDec | kInt | kUpper | kBase, /*width = */ 0, "0"},
-      {0, kDec | kInt | kUpper | kBase, /*width = */ 6, "_____0"},
-      {0, kDec | kInt | kUpper | kBase | kPos, /*width = */ 0, "+0"},
-      {0, kDec | kInt | kUpper | kBase | kPos, /*width = */ 6, "+____0"},
-      {0, kDec | kRight, /*width = */ 0, "0"},
-      {0, kDec | kRight, /*width = */ 6, "_____0"},
-      {0, kDec | kRight | kPos, /*width = */ 0, "+0"},
-      {0, kDec | kRight | kPos, /*width = */ 6, "____+0"},
-      {0, kDec | kRight | kBase, /*width = */ 0, "0"},
-      {0, kDec | kRight | kBase, /*width = */ 6, "_____0"},
-      {0, kDec | kRight | kBase | kPos, /*width = */ 0, "+0"},
-      {0, kDec | kRight | kBase | kPos, /*width = */ 6, "____+0"},
-      {0, kDec | kRight | kUpper, /*width = */ 0, "0"},
-      {0, kDec | kRight | kUpper, /*width = */ 6, "_____0"},
-      {0, kDec | kRight | kUpper | kPos, /*width = */ 0, "+0"},
-      {0, kDec | kRight | kUpper | kPos, /*width = */ 6, "____+0"},
-      {0, kDec | kRight | kUpper | kBase, /*width = */ 0, "0"},
-      {0, kDec | kRight | kUpper | kBase, /*width = */ 6, "_____0"},
-      {0, kDec | kRight | kUpper | kBase | kPos, /*width = */ 0, "+0"},
-      {0, kDec | kRight | kUpper | kBase | kPos, /*width = */ 6, "____+0"},
-      {0, kOct, /*width = */ 0, "0"},
-      {0, kOct, /*width = */ 6, "_____0"},
-      {0, kOct | kPos, /*width = */ 0, "0"},
-      {0, kOct | kPos, /*width = */ 6, "_____0"},
-      {0, kOct | kBase, /*width = */ 0, "0"},
-      {0, kOct | kBase, /*width = */ 6, "_____0"},
-      {0, kOct | kBase | kPos, /*width = */ 0, "0"},
-      {0, kOct | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kOct | kUpper, /*width = */ 0, "0"},
-      {0, kOct | kUpper, /*width = */ 6, "_____0"},
-      {0, kOct | kUpper | kPos, /*width = */ 0, "0"},
-      {0, kOct | kUpper | kPos, /*width = */ 6, "_____0"},
-      {0, kOct | kUpper | kBase, /*width = */ 0, "0"},
-      {0, kOct | kUpper | kBase, /*width = */ 6, "_____0"},
-      {0, kOct | kUpper | kBase | kPos, /*width = */ 0, "0"},
-      {0, kOct | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kOct | kLeft, /*width = */ 0, "0"},
-      {0, kOct | kLeft, /*width = */ 6, "0_____"},
-      {0, kOct | kLeft | kPos, /*width = */ 0, "0"},
-      {0, kOct | kLeft | kPos, /*width = */ 6, "0_____"},
-      {0, kOct | kLeft | kBase, /*width = */ 0, "0"},
-      {0, kOct | kLeft | kBase, /*width = */ 6, "0_____"},
-      {0, kOct | kLeft | kBase | kPos, /*width = */ 0, "0"},
-      {0, kOct | kLeft | kBase | kPos, /*width = */ 6, "0_____"},
-      {0, kOct | kLeft | kUpper, /*width = */ 0, "0"},
-      {0, kOct | kLeft | kUpper, /*width = */ 6, "0_____"},
-      {0, kOct | kLeft | kUpper | kPos, /*width = */ 0, "0"},
-      {0, kOct | kLeft | kUpper | kPos, /*width = */ 6, "0_____"},
-      {0, kOct | kLeft | kUpper | kBase, /*width = */ 0, "0"},
-      {0, kOct | kLeft | kUpper | kBase, /*width = */ 6, "0_____"},
-      {0, kOct | kLeft | kUpper | kBase | kPos, /*width = */ 0, "0"},
-      {0, kOct | kLeft | kUpper | kBase | kPos, /*width = */ 6, "0_____"},
-      {0, kOct | kInt, /*width = */ 0, "0"},
-      {0, kOct | kInt, /*width = */ 6, "_____0"},
-      {0, kOct | kInt | kPos, /*width = */ 0, "0"},
-      {0, kOct | kInt | kPos, /*width = */ 6, "_____0"},
-      {0, kOct | kInt | kBase, /*width = */ 0, "0"},
-      {0, kOct | kInt | kBase, /*width = */ 6, "_____0"},
-      {0, kOct | kInt | kBase | kPos, /*width = */ 0, "0"},
-      {0, kOct | kInt | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kOct | kInt | kUpper, /*width = */ 0, "0"},
-      {0, kOct | kInt | kUpper, /*width = */ 6, "_____0"},
-      {0, kOct | kInt | kUpper | kPos, /*width = */ 0, "0"},
-      {0, kOct | kInt | kUpper | kPos, /*width = */ 6, "_____0"},
-      {0, kOct | kInt | kUpper | kBase, /*width = */ 0, "0"},
-      {0, kOct | kInt | kUpper | kBase, /*width = */ 6, "_____0"},
-      {0, kOct | kInt | kUpper | kBase | kPos, /*width = */ 0, "0"},
-      {0, kOct | kInt | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kOct | kRight, /*width = */ 0, "0"},
-      {0, kOct | kRight, /*width = */ 6, "_____0"},
-      {0, kOct | kRight | kPos, /*width = */ 0, "0"},
-      {0, kOct | kRight | kPos, /*width = */ 6, "_____0"},
-      {0, kOct | kRight | kBase, /*width = */ 0, "0"},
-      {0, kOct | kRight | kBase, /*width = */ 6, "_____0"},
-      {0, kOct | kRight | kBase | kPos, /*width = */ 0, "0"},
-      {0, kOct | kRight | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kOct | kRight | kUpper, /*width = */ 0, "0"},
-      {0, kOct | kRight | kUpper, /*width = */ 6, "_____0"},
-      {0, kOct | kRight | kUpper | kPos, /*width = */ 0, "0"},
-      {0, kOct | kRight | kUpper | kPos, /*width = */ 6, "_____0"},
-      {0, kOct | kRight | kUpper | kBase, /*width = */ 0, "0"},
-      {0, kOct | kRight | kUpper | kBase, /*width = */ 6, "_____0"},
-      {0, kOct | kRight | kUpper | kBase | kPos, /*width = */ 0, "0"},
-      {0, kOct | kRight | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kHex, /*width = */ 0, "0"},
-      {0, kHex, /*width = */ 6, "_____0"},
-      {0, kHex | kPos, /*width = */ 0, "0"},
-      {0, kHex | kPos, /*width = */ 6, "_____0"},
-      {0, kHex | kBase, /*width = */ 0, "0"},
-      {0, kHex | kBase, /*width = */ 6, "_____0"},
-      {0, kHex | kBase | kPos, /*width = */ 0, "0"},
-      {0, kHex | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kHex | kUpper, /*width = */ 0, "0"},
-      {0, kHex | kUpper, /*width = */ 6, "_____0"},
-      {0, kHex | kUpper | kPos, /*width = */ 0, "0"},
-      {0, kHex | kUpper | kPos, /*width = */ 6, "_____0"},
-      {0, kHex | kUpper | kBase, /*width = */ 0, "0"},
-      {0, kHex | kUpper | kBase, /*width = */ 6, "_____0"},
-      {0, kHex | kUpper | kBase | kPos, /*width = */ 0, "0"},
-      {0, kHex | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kHex | kLeft, /*width = */ 0, "0"},
-      {0, kHex | kLeft, /*width = */ 6, "0_____"},
-      {0, kHex | kLeft | kPos, /*width = */ 0, "0"},
-      {0, kHex | kLeft | kPos, /*width = */ 6, "0_____"},
-      {0, kHex | kLeft | kBase, /*width = */ 0, "0"},
-      {0, kHex | kLeft | kBase, /*width = */ 6, "0_____"},
-      {0, kHex | kLeft | kBase | kPos, /*width = */ 0, "0"},
-      {0, kHex | kLeft | kBase | kPos, /*width = */ 6, "0_____"},
-      {0, kHex | kLeft | kUpper, /*width = */ 0, "0"},
-      {0, kHex | kLeft | kUpper, /*width = */ 6, "0_____"},
-      {0, kHex | kLeft | kUpper | kPos, /*width = */ 0, "0"},
-      {0, kHex | kLeft | kUpper | kPos, /*width = */ 6, "0_____"},
-      {0, kHex | kLeft | kUpper | kBase, /*width = */ 0, "0"},
-      {0, kHex | kLeft | kUpper | kBase, /*width = */ 6, "0_____"},
-      {0, kHex | kLeft | kUpper | kBase | kPos, /*width = */ 0, "0"},
-      {0, kHex | kLeft | kUpper | kBase | kPos, /*width = */ 6, "0_____"},
-      {0, kHex | kInt, /*width = */ 0, "0"},
-      {0, kHex | kInt, /*width = */ 6, "_____0"},
-      {0, kHex | kInt | kPos, /*width = */ 0, "0"},
-      {0, kHex | kInt | kPos, /*width = */ 6, "_____0"},
-      {0, kHex | kInt | kBase, /*width = */ 0, "0"},
-      {0, kHex | kInt | kBase, /*width = */ 6, "_____0"},
-      {0, kHex | kInt | kBase | kPos, /*width = */ 0, "0"},
-      {0, kHex | kInt | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kHex | kInt | kUpper, /*width = */ 0, "0"},
-      {0, kHex | kInt | kUpper, /*width = */ 6, "_____0"},
-      {0, kHex | kInt | kUpper | kPos, /*width = */ 0, "0"},
-      {0, kHex | kInt | kUpper | kPos, /*width = */ 6, "_____0"},
-      {0, kHex | kInt | kUpper | kBase, /*width = */ 0, "0"},
-      {0, kHex | kInt | kUpper | kBase, /*width = */ 6, "_____0"},
-      {0, kHex | kInt | kUpper | kBase | kPos, /*width = */ 0, "0"},
-      {0, kHex | kInt | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kHex | kRight, /*width = */ 0, "0"},
-      {0, kHex | kRight, /*width = */ 6, "_____0"},
-      {0, kHex | kRight | kPos, /*width = */ 0, "0"},
-      {0, kHex | kRight | kPos, /*width = */ 6, "_____0"},
-      {0, kHex | kRight | kBase, /*width = */ 0, "0"},
-      {0, kHex | kRight | kBase, /*width = */ 6, "_____0"},
-      {0, kHex | kRight | kBase | kPos, /*width = */ 0, "0"},
-      {0, kHex | kRight | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kHex | kRight | kUpper, /*width = */ 0, "0"},
-      {0, kHex | kRight | kUpper, /*width = */ 6, "_____0"},
-      {0, kHex | kRight | kUpper | kPos, /*width = */ 0, "0"},
-      {0, kHex | kRight | kUpper | kPos, /*width = */ 6, "_____0"},
-      {0, kHex | kRight | kUpper | kBase, /*width = */ 0, "0"},
-      {0, kHex | kRight | kUpper | kBase, /*width = */ 6, "_____0"},
-      {0, kHex | kRight | kUpper | kBase | kPos, /*width = */ 0, "0"},
-      {0, kHex | kRight | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
-      {42, std::ios_base::fmtflags(), /*width = */ 0, "42"},
-      {42, std::ios_base::fmtflags(), /*width = */ 6, "____42"},
-      {42, kPos, /*width = */ 0, "+42"},
-      {42, kPos, /*width = */ 6, "___+42"},
-      {42, kBase, /*width = */ 0, "42"},
-      {42, kBase, /*width = */ 6, "____42"},
-      {42, kBase | kPos, /*width = */ 0, "+42"},
-      {42, kBase | kPos, /*width = */ 6, "___+42"},
-      {42, kUpper, /*width = */ 0, "42"},
-      {42, kUpper, /*width = */ 6, "____42"},
-      {42, kUpper | kPos, /*width = */ 0, "+42"},
-      {42, kUpper | kPos, /*width = */ 6, "___+42"},
-      {42, kUpper | kBase, /*width = */ 0, "42"},
-      {42, kUpper | kBase, /*width = */ 6, "____42"},
-      {42, kUpper | kBase | kPos, /*width = */ 0, "+42"},
-      {42, kUpper | kBase | kPos, /*width = */ 6, "___+42"},
-      {42, kLeft, /*width = */ 0, "42"},
-      {42, kLeft, /*width = */ 6, "42____"},
-      {42, kLeft | kPos, /*width = */ 0, "+42"},
-      {42, kLeft | kPos, /*width = */ 6, "+42___"},
-      {42, kLeft | kBase, /*width = */ 0, "42"},
-      {42, kLeft | kBase, /*width = */ 6, "42____"},
-      {42, kLeft | kBase | kPos, /*width = */ 0, "+42"},
-      {42, kLeft | kBase | kPos, /*width = */ 6, "+42___"},
-      {42, kLeft | kUpper, /*width = */ 0, "42"},
-      {42, kLeft | kUpper, /*width = */ 6, "42____"},
-      {42, kLeft | kUpper | kPos, /*width = */ 0, "+42"},
-      {42, kLeft | kUpper | kPos, /*width = */ 6, "+42___"},
-      {42, kLeft | kUpper | kBase, /*width = */ 0, "42"},
-      {42, kLeft | kUpper | kBase, /*width = */ 6, "42____"},
-      {42, kLeft | kUpper | kBase | kPos, /*width = */ 0, "+42"},
-      {42, kLeft | kUpper | kBase | kPos, /*width = */ 6, "+42___"},
-      {42, kInt, /*width = */ 0, "42"},
-      {42, kInt, /*width = */ 6, "____42"},
-      {42, kInt | kPos, /*width = */ 0, "+42"},
-      {42, kInt | kPos, /*width = */ 6, "+___42"},
-      {42, kInt | kBase, /*width = */ 0, "42"},
-      {42, kInt | kBase, /*width = */ 6, "____42"},
-      {42, kInt | kBase | kPos, /*width = */ 0, "+42"},
-      {42, kInt | kBase | kPos, /*width = */ 6, "+___42"},
-      {42, kInt | kUpper, /*width = */ 0, "42"},
-      {42, kInt | kUpper, /*width = */ 6, "____42"},
-      {42, kInt | kUpper | kPos, /*width = */ 0, "+42"},
-      {42, kInt | kUpper | kPos, /*width = */ 6, "+___42"},
-      {42, kInt | kUpper | kBase, /*width = */ 0, "42"},
-      {42, kInt | kUpper | kBase, /*width = */ 6, "____42"},
-      {42, kInt | kUpper | kBase | kPos, /*width = */ 0, "+42"},
-      {42, kInt | kUpper | kBase | kPos, /*width = */ 6, "+___42"},
-      {42, kRight, /*width = */ 0, "42"},
-      {42, kRight, /*width = */ 6, "____42"},
-      {42, kRight | kPos, /*width = */ 0, "+42"},
-      {42, kRight | kPos, /*width = */ 6, "___+42"},
-      {42, kRight | kBase, /*width = */ 0, "42"},
-      {42, kRight | kBase, /*width = */ 6, "____42"},
-      {42, kRight | kBase | kPos, /*width = */ 0, "+42"},
-      {42, kRight | kBase | kPos, /*width = */ 6, "___+42"},
-      {42, kRight | kUpper, /*width = */ 0, "42"},
-      {42, kRight | kUpper, /*width = */ 6, "____42"},
-      {42, kRight | kUpper | kPos, /*width = */ 0, "+42"},
-      {42, kRight | kUpper | kPos, /*width = */ 6, "___+42"},
-      {42, kRight | kUpper | kBase, /*width = */ 0, "42"},
-      {42, kRight | kUpper | kBase, /*width = */ 6, "____42"},
-      {42, kRight | kUpper | kBase | kPos, /*width = */ 0, "+42"},
-      {42, kRight | kUpper | kBase | kPos, /*width = */ 6, "___+42"},
-      {42, kDec, /*width = */ 0, "42"},
-      {42, kDec, /*width = */ 6, "____42"},
-      {42, kDec | kPos, /*width = */ 0, "+42"},
-      {42, kDec | kPos, /*width = */ 6, "___+42"},
-      {42, kDec | kBase, /*width = */ 0, "42"},
-      {42, kDec | kBase, /*width = */ 6, "____42"},
-      {42, kDec | kBase | kPos, /*width = */ 0, "+42"},
-      {42, kDec | kBase | kPos, /*width = */ 6, "___+42"},
-      {42, kDec | kUpper, /*width = */ 0, "42"},
-      {42, kDec | kUpper, /*width = */ 6, "____42"},
-      {42, kDec | kUpper | kPos, /*width = */ 0, "+42"},
-      {42, kDec | kUpper | kPos, /*width = */ 6, "___+42"},
-      {42, kDec | kUpper | kBase, /*width = */ 0, "42"},
-      {42, kDec | kUpper | kBase, /*width = */ 6, "____42"},
-      {42, kDec | kUpper | kBase | kPos, /*width = */ 0, "+42"},
-      {42, kDec | kUpper | kBase | kPos, /*width = */ 6, "___+42"},
-      {42, kDec | kLeft, /*width = */ 0, "42"},
-      {42, kDec | kLeft, /*width = */ 6, "42____"},
-      {42, kDec | kLeft | kPos, /*width = */ 0, "+42"},
-      {42, kDec | kLeft | kPos, /*width = */ 6, "+42___"},
-      {42, kDec | kLeft | kBase, /*width = */ 0, "42"},
-      {42, kDec | kLeft | kBase, /*width = */ 6, "42____"},
-      {42, kDec | kLeft | kBase | kPos, /*width = */ 0, "+42"},
-      {42, kDec | kLeft | kBase | kPos, /*width = */ 6, "+42___"},
-      {42, kDec | kLeft | kUpper, /*width = */ 0, "42"},
-      {42, kDec | kLeft | kUpper, /*width = */ 6, "42____"},
-      {42, kDec | kLeft | kUpper | kPos, /*width = */ 0, "+42"},
-      {42, kDec | kLeft | kUpper | kPos, /*width = */ 6, "+42___"},
-      {42, kDec | kLeft | kUpper | kBase, /*width = */ 0, "42"},
-      {42, kDec | kLeft | kUpper | kBase, /*width = */ 6, "42____"},
-      {42, kDec | kLeft | kUpper | kBase | kPos, /*width = */ 0, "+42"},
-      {42, kDec | kLeft | kUpper | kBase | kPos, /*width = */ 6, "+42___"},
-      {42, kDec | kInt, /*width = */ 0, "42"},
-      {42, kDec | kInt, /*width = */ 6, "____42"},
-      {42, kDec | kInt | kPos, /*width = */ 0, "+42"},
-      {42, kDec | kInt | kPos, /*width = */ 6, "+___42"},
-      {42, kDec | kInt | kBase, /*width = */ 0, "42"},
-      {42, kDec | kInt | kBase, /*width = */ 6, "____42"},
-      {42, kDec | kInt | kBase | kPos, /*width = */ 0, "+42"},
-      {42, kDec | kInt | kBase | kPos, /*width = */ 6, "+___42"},
-      {42, kDec | kInt | kUpper, /*width = */ 0, "42"},
-      {42, kDec | kInt | kUpper, /*width = */ 6, "____42"},
-      {42, kDec | kInt | kUpper | kPos, /*width = */ 0, "+42"},
-      {42, kDec | kInt | kUpper | kPos, /*width = */ 6, "+___42"},
-      {42, kDec | kInt | kUpper | kBase, /*width = */ 0, "42"},
-      {42, kDec | kInt | kUpper | kBase, /*width = */ 6, "____42"},
-      {42, kDec | kInt | kUpper | kBase | kPos, /*width = */ 0, "+42"},
-      {42, kDec | kInt | kUpper | kBase | kPos, /*width = */ 6, "+___42"},
-      {42, kDec | kRight, /*width = */ 0, "42"},
-      {42, kDec | kRight, /*width = */ 6, "____42"},
-      {42, kDec | kRight | kPos, /*width = */ 0, "+42"},
-      {42, kDec | kRight | kPos, /*width = */ 6, "___+42"},
-      {42, kDec | kRight | kBase, /*width = */ 0, "42"},
-      {42, kDec | kRight | kBase, /*width = */ 6, "____42"},
-      {42, kDec | kRight | kBase | kPos, /*width = */ 0, "+42"},
-      {42, kDec | kRight | kBase | kPos, /*width = */ 6, "___+42"},
-      {42, kDec | kRight | kUpper, /*width = */ 0, "42"},
-      {42, kDec | kRight | kUpper, /*width = */ 6, "____42"},
-      {42, kDec | kRight | kUpper | kPos, /*width = */ 0, "+42"},
-      {42, kDec | kRight | kUpper | kPos, /*width = */ 6, "___+42"},
-      {42, kDec | kRight | kUpper | kBase, /*width = */ 0, "42"},
-      {42, kDec | kRight | kUpper | kBase, /*width = */ 6, "____42"},
-      {42, kDec | kRight | kUpper | kBase | kPos, /*width = */ 0, "+42"},
-      {42, kDec | kRight | kUpper | kBase | kPos, /*width = */ 6, "___+42"},
-      {42, kOct, /*width = */ 0, "52"},
-      {42, kOct, /*width = */ 6, "____52"},
-      {42, kOct | kPos, /*width = */ 0, "52"},
-      {42, kOct | kPos, /*width = */ 6, "____52"},
-      {42, kOct | kBase, /*width = */ 0, "052"},
-      {42, kOct | kBase, /*width = */ 6, "___052"},
-      {42, kOct | kBase | kPos, /*width = */ 0, "052"},
-      {42, kOct | kBase | kPos, /*width = */ 6, "___052"},
-      {42, kOct | kUpper, /*width = */ 0, "52"},
-      {42, kOct | kUpper, /*width = */ 6, "____52"},
-      {42, kOct | kUpper | kPos, /*width = */ 0, "52"},
-      {42, kOct | kUpper | kPos, /*width = */ 6, "____52"},
-      {42, kOct | kUpper | kBase, /*width = */ 0, "052"},
-      {42, kOct | kUpper | kBase, /*width = */ 6, "___052"},
-      {42, kOct | kUpper | kBase | kPos, /*width = */ 0, "052"},
-      {42, kOct | kUpper | kBase | kPos, /*width = */ 6, "___052"},
-      {42, kOct | kLeft, /*width = */ 0, "52"},
-      {42, kOct | kLeft, /*width = */ 6, "52____"},
-      {42, kOct | kLeft | kPos, /*width = */ 0, "52"},
-      {42, kOct | kLeft | kPos, /*width = */ 6, "52____"},
-      {42, kOct | kLeft | kBase, /*width = */ 0, "052"},
-      {42, kOct | kLeft | kBase, /*width = */ 6, "052___"},
-      {42, kOct | kLeft | kBase | kPos, /*width = */ 0, "052"},
-      {42, kOct | kLeft | kBase | kPos, /*width = */ 6, "052___"},
-      {42, kOct | kLeft | kUpper, /*width = */ 0, "52"},
-      {42, kOct | kLeft | kUpper, /*width = */ 6, "52____"},
-      {42, kOct | kLeft | kUpper | kPos, /*width = */ 0, "52"},
-      {42, kOct | kLeft | kUpper | kPos, /*width = */ 6, "52____"},
-      {42, kOct | kLeft | kUpper | kBase, /*width = */ 0, "052"},
-      {42, kOct | kLeft | kUpper | kBase, /*width = */ 6, "052___"},
-      {42, kOct | kLeft | kUpper | kBase | kPos, /*width = */ 0, "052"},
-      {42, kOct | kLeft | kUpper | kBase | kPos, /*width = */ 6, "052___"},
-      {42, kOct | kInt, /*width = */ 0, "52"},
-      {42, kOct | kInt, /*width = */ 6, "____52"},
-      {42, kOct | kInt | kPos, /*width = */ 0, "52"},
-      {42, kOct | kInt | kPos, /*width = */ 6, "____52"},
-      {42, kOct | kInt | kBase, /*width = */ 0, "052"},
-      {42, kOct | kInt | kBase, /*width = */ 6, "___052"},
-      {42, kOct | kInt | kBase | kPos, /*width = */ 0, "052"},
-      {42, kOct | kInt | kBase | kPos, /*width = */ 6, "___052"},
-      {42, kOct | kInt | kUpper, /*width = */ 0, "52"},
-      {42, kOct | kInt | kUpper, /*width = */ 6, "____52"},
-      {42, kOct | kInt | kUpper | kPos, /*width = */ 0, "52"},
-      {42, kOct | kInt | kUpper | kPos, /*width = */ 6, "____52"},
-      {42, kOct | kInt | kUpper | kBase, /*width = */ 0, "052"},
-      {42, kOct | kInt | kUpper | kBase, /*width = */ 6, "___052"},
-      {42, kOct | kInt | kUpper | kBase | kPos, /*width = */ 0, "052"},
-      {42, kOct | kInt | kUpper | kBase | kPos, /*width = */ 6, "___052"},
-      {42, kOct | kRight, /*width = */ 0, "52"},
-      {42, kOct | kRight, /*width = */ 6, "____52"},
-      {42, kOct | kRight | kPos, /*width = */ 0, "52"},
-      {42, kOct | kRight | kPos, /*width = */ 6, "____52"},
-      {42, kOct | kRight | kBase, /*width = */ 0, "052"},
-      {42, kOct | kRight | kBase, /*width = */ 6, "___052"},
-      {42, kOct | kRight | kBase | kPos, /*width = */ 0, "052"},
-      {42, kOct | kRight | kBase | kPos, /*width = */ 6, "___052"},
-      {42, kOct | kRight | kUpper, /*width = */ 0, "52"},
-      {42, kOct | kRight | kUpper, /*width = */ 6, "____52"},
-      {42, kOct | kRight | kUpper | kPos, /*width = */ 0, "52"},
-      {42, kOct | kRight | kUpper | kPos, /*width = */ 6, "____52"},
-      {42, kOct | kRight | kUpper | kBase, /*width = */ 0, "052"},
-      {42, kOct | kRight | kUpper | kBase, /*width = */ 6, "___052"},
-      {42, kOct | kRight | kUpper | kBase | kPos, /*width = */ 0, "052"},
-      {42, kOct | kRight | kUpper | kBase | kPos, /*width = */ 6, "___052"},
-      {42, kHex, /*width = */ 0, "2a"},
-      {42, kHex, /*width = */ 6, "____2a"},
-      {42, kHex | kPos, /*width = */ 0, "2a"},
-      {42, kHex | kPos, /*width = */ 6, "____2a"},
-      {42, kHex | kBase, /*width = */ 0, "0x2a"},
-      {42, kHex | kBase, /*width = */ 6, "__0x2a"},
-      {42, kHex | kBase | kPos, /*width = */ 0, "0x2a"},
-      {42, kHex | kBase | kPos, /*width = */ 6, "__0x2a"},
-      {42, kHex | kUpper, /*width = */ 0, "2A"},
-      {42, kHex | kUpper, /*width = */ 6, "____2A"},
-      {42, kHex | kUpper | kPos, /*width = */ 0, "2A"},
-      {42, kHex | kUpper | kPos, /*width = */ 6, "____2A"},
-      {42, kHex | kUpper | kBase, /*width = */ 0, "0X2A"},
-      {42, kHex | kUpper | kBase, /*width = */ 6, "__0X2A"},
-      {42, kHex | kUpper | kBase | kPos, /*width = */ 0, "0X2A"},
-      {42, kHex | kUpper | kBase | kPos, /*width = */ 6, "__0X2A"},
-      {42, kHex | kLeft, /*width = */ 0, "2a"},
-      {42, kHex | kLeft, /*width = */ 6, "2a____"},
-      {42, kHex | kLeft | kPos, /*width = */ 0, "2a"},
-      {42, kHex | kLeft | kPos, /*width = */ 6, "2a____"},
-      {42, kHex | kLeft | kBase, /*width = */ 0, "0x2a"},
-      {42, kHex | kLeft | kBase, /*width = */ 6, "0x2a__"},
-      {42, kHex | kLeft | kBase | kPos, /*width = */ 0, "0x2a"},
-      {42, kHex | kLeft | kBase | kPos, /*width = */ 6, "0x2a__"},
-      {42, kHex | kLeft | kUpper, /*width = */ 0, "2A"},
-      {42, kHex | kLeft | kUpper, /*width = */ 6, "2A____"},
-      {42, kHex | kLeft | kUpper | kPos, /*width = */ 0, "2A"},
-      {42, kHex | kLeft | kUpper | kPos, /*width = */ 6, "2A____"},
-      {42, kHex | kLeft | kUpper | kBase, /*width = */ 0, "0X2A"},
-      {42, kHex | kLeft | kUpper | kBase, /*width = */ 6, "0X2A__"},
-      {42, kHex | kLeft | kUpper | kBase | kPos, /*width = */ 0, "0X2A"},
-      {42, kHex | kLeft | kUpper | kBase | kPos, /*width = */ 6, "0X2A__"},
-      {42, kHex | kInt, /*width = */ 0, "2a"},
-      {42, kHex | kInt, /*width = */ 6, "____2a"},
-      {42, kHex | kInt | kPos, /*width = */ 0, "2a"},
-      {42, kHex | kInt | kPos, /*width = */ 6, "____2a"},
-      {42, kHex | kInt | kBase, /*width = */ 0, "0x2a"},
-      {42, kHex | kInt | kBase, /*width = */ 6, "0x__2a"},
-      {42, kHex | kInt | kBase | kPos, /*width = */ 0, "0x2a"},
-      {42, kHex | kInt | kBase | kPos, /*width = */ 6, "0x__2a"},
-      {42, kHex | kInt | kUpper, /*width = */ 0, "2A"},
-      {42, kHex | kInt | kUpper, /*width = */ 6, "____2A"},
-      {42, kHex | kInt | kUpper | kPos, /*width = */ 0, "2A"},
-      {42, kHex | kInt | kUpper | kPos, /*width = */ 6, "____2A"},
-      {42, kHex | kInt | kUpper | kBase, /*width = */ 0, "0X2A"},
-      {42, kHex | kInt | kUpper | kBase, /*width = */ 6, "0X__2A"},
-      {42, kHex | kInt | kUpper | kBase | kPos, /*width = */ 0, "0X2A"},
-      {42, kHex | kInt | kUpper | kBase | kPos, /*width = */ 6, "0X__2A"},
-      {42, kHex | kRight, /*width = */ 0, "2a"},
-      {42, kHex | kRight, /*width = */ 6, "____2a"},
-      {42, kHex | kRight | kPos, /*width = */ 0, "2a"},
-      {42, kHex | kRight | kPos, /*width = */ 6, "____2a"},
-      {42, kHex | kRight | kBase, /*width = */ 0, "0x2a"},
-      {42, kHex | kRight | kBase, /*width = */ 6, "__0x2a"},
-      {42, kHex | kRight | kBase | kPos, /*width = */ 0, "0x2a"},
-      {42, kHex | kRight | kBase | kPos, /*width = */ 6, "__0x2a"},
-      {42, kHex | kRight | kUpper, /*width = */ 0, "2A"},
-      {42, kHex | kRight | kUpper, /*width = */ 6, "____2A"},
-      {42, kHex | kRight | kUpper | kPos, /*width = */ 0, "2A"},
-      {42, kHex | kRight | kUpper | kPos, /*width = */ 6, "____2A"},
-      {42, kHex | kRight | kUpper | kBase, /*width = */ 0, "0X2A"},
-      {42, kHex | kRight | kUpper | kBase, /*width = */ 6, "__0X2A"},
-      {42, kHex | kRight | kUpper | kBase | kPos, /*width = */ 0, "0X2A"},
-      {42, kHex | kRight | kUpper | kBase | kPos, /*width = */ 6, "__0X2A"},
-      {-321, std::ios_base::fmtflags(), /*width = */ 0, "-321"},
-      {-321, std::ios_base::fmtflags(), /*width = */ 6, "__-321"},
-      {-321, kPos, /*width = */ 0, "-321"},
-      {-321, kPos, /*width = */ 6, "__-321"},
-      {-321, kBase, /*width = */ 0, "-321"},
-      {-321, kBase, /*width = */ 6, "__-321"},
-      {-321, kBase | kPos, /*width = */ 0, "-321"},
-      {-321, kBase | kPos, /*width = */ 6, "__-321"},
-      {-321, kUpper, /*width = */ 0, "-321"},
-      {-321, kUpper, /*width = */ 6, "__-321"},
-      {-321, kUpper | kPos, /*width = */ 0, "-321"},
-      {-321, kUpper | kPos, /*width = */ 6, "__-321"},
-      {-321, kUpper | kBase, /*width = */ 0, "-321"},
-      {-321, kUpper | kBase, /*width = */ 6, "__-321"},
-      {-321, kUpper | kBase | kPos, /*width = */ 0, "-321"},
-      {-321, kUpper | kBase | kPos, /*width = */ 6, "__-321"},
-      {-321, kLeft, /*width = */ 0, "-321"},
-      {-321, kLeft, /*width = */ 6, "-321__"},
-      {-321, kLeft | kPos, /*width = */ 0, "-321"},
-      {-321, kLeft | kPos, /*width = */ 6, "-321__"},
-      {-321, kLeft | kBase, /*width = */ 0, "-321"},
-      {-321, kLeft | kBase, /*width = */ 6, "-321__"},
-      {-321, kLeft | kBase | kPos, /*width = */ 0, "-321"},
-      {-321, kLeft | kBase | kPos, /*width = */ 6, "-321__"},
-      {-321, kLeft | kUpper, /*width = */ 0, "-321"},
-      {-321, kLeft | kUpper, /*width = */ 6, "-321__"},
-      {-321, kLeft | kUpper | kPos, /*width = */ 0, "-321"},
-      {-321, kLeft | kUpper | kPos, /*width = */ 6, "-321__"},
-      {-321, kLeft | kUpper | kBase, /*width = */ 0, "-321"},
-      {-321, kLeft | kUpper | kBase, /*width = */ 6, "-321__"},
-      {-321, kLeft | kUpper | kBase | kPos, /*width = */ 0, "-321"},
-      {-321, kLeft | kUpper | kBase | kPos, /*width = */ 6, "-321__"},
-      {-321, kInt, /*width = */ 0, "-321"},
-      {-321, kInt, /*width = */ 6, "-__321"},
-      {-321, kInt | kPos, /*width = */ 0, "-321"},
-      {-321, kInt | kPos, /*width = */ 6, "-__321"},
-      {-321, kInt | kBase, /*width = */ 0, "-321"},
-      {-321, kInt | kBase, /*width = */ 6, "-__321"},
-      {-321, kInt | kBase | kPos, /*width = */ 0, "-321"},
-      {-321, kInt | kBase | kPos, /*width = */ 6, "-__321"},
-      {-321, kInt | kUpper, /*width = */ 0, "-321"},
-      {-321, kInt | kUpper, /*width = */ 6, "-__321"},
-      {-321, kInt | kUpper | kPos, /*width = */ 0, "-321"},
-      {-321, kInt | kUpper | kPos, /*width = */ 6, "-__321"},
-      {-321, kInt | kUpper | kBase, /*width = */ 0, "-321"},
-      {-321, kInt | kUpper | kBase, /*width = */ 6, "-__321"},
-      {-321, kInt | kUpper | kBase | kPos, /*width = */ 0, "-321"},
-      {-321, kInt | kUpper | kBase | kPos, /*width = */ 6, "-__321"},
-      {-321, kRight, /*width = */ 0, "-321"},
-      {-321, kRight, /*width = */ 6, "__-321"},
-      {-321, kRight | kPos, /*width = */ 0, "-321"},
-      {-321, kRight | kPos, /*width = */ 6, "__-321"},
-      {-321, kRight | kBase, /*width = */ 0, "-321"},
-      {-321, kRight | kBase, /*width = */ 6, "__-321"},
-      {-321, kRight | kBase | kPos, /*width = */ 0, "-321"},
-      {-321, kRight | kBase | kPos, /*width = */ 6, "__-321"},
-      {-321, kRight | kUpper, /*width = */ 0, "-321"},
-      {-321, kRight | kUpper, /*width = */ 6, "__-321"},
-      {-321, kRight | kUpper | kPos, /*width = */ 0, "-321"},
-      {-321, kRight | kUpper | kPos, /*width = */ 6, "__-321"},
-      {-321, kRight | kUpper | kBase, /*width = */ 0, "-321"},
-      {-321, kRight | kUpper | kBase, /*width = */ 6, "__-321"},
-      {-321, kRight | kUpper | kBase | kPos, /*width = */ 0, "-321"},
-      {-321, kRight | kUpper | kBase | kPos, /*width = */ 6, "__-321"},
-      {-321, kDec, /*width = */ 0, "-321"},
-      {-321, kDec, /*width = */ 6, "__-321"},
-      {-321, kDec | kPos, /*width = */ 0, "-321"},
-      {-321, kDec | kPos, /*width = */ 6, "__-321"},
-      {-321, kDec | kBase, /*width = */ 0, "-321"},
-      {-321, kDec | kBase, /*width = */ 6, "__-321"},
-      {-321, kDec | kBase | kPos, /*width = */ 0, "-321"},
-      {-321, kDec | kBase | kPos, /*width = */ 6, "__-321"},
-      {-321, kDec | kUpper, /*width = */ 0, "-321"},
-      {-321, kDec | kUpper, /*width = */ 6, "__-321"},
-      {-321, kDec | kUpper | kPos, /*width = */ 0, "-321"},
-      {-321, kDec | kUpper | kPos, /*width = */ 6, "__-321"},
-      {-321, kDec | kUpper | kBase, /*width = */ 0, "-321"},
-      {-321, kDec | kUpper | kBase, /*width = */ 6, "__-321"},
-      {-321, kDec | kUpper | kBase | kPos, /*width = */ 0, "-321"},
-      {-321, kDec | kUpper | kBase | kPos, /*width = */ 6, "__-321"},
-      {-321, kDec | kLeft, /*width = */ 0, "-321"},
-      {-321, kDec | kLeft, /*width = */ 6, "-321__"},
-      {-321, kDec | kLeft | kPos, /*width = */ 0, "-321"},
-      {-321, kDec | kLeft | kPos, /*width = */ 6, "-321__"},
-      {-321, kDec | kLeft | kBase, /*width = */ 0, "-321"},
-      {-321, kDec | kLeft | kBase, /*width = */ 6, "-321__"},
-      {-321, kDec | kLeft | kBase | kPos, /*width = */ 0, "-321"},
-      {-321, kDec | kLeft | kBase | kPos, /*width = */ 6, "-321__"},
-      {-321, kDec | kLeft | kUpper, /*width = */ 0, "-321"},
-      {-321, kDec | kLeft | kUpper, /*width = */ 6, "-321__"},
-      {-321, kDec | kLeft | kUpper | kPos, /*width = */ 0, "-321"},
-      {-321, kDec | kLeft | kUpper | kPos, /*width = */ 6, "-321__"},
-      {-321, kDec | kLeft | kUpper | kBase, /*width = */ 0, "-321"},
-      {-321, kDec | kLeft | kUpper | kBase, /*width = */ 6, "-321__"},
-      {-321, kDec | kLeft | kUpper | kBase | kPos, /*width = */ 0, "-321"},
-      {-321, kDec | kLeft | kUpper | kBase | kPos, /*width = */ 6, "-321__"},
-      {-321, kDec | kInt, /*width = */ 0, "-321"},
-      {-321, kDec | kInt, /*width = */ 6, "-__321"},
-      {-321, kDec | kInt | kPos, /*width = */ 0, "-321"},
-      {-321, kDec | kInt | kPos, /*width = */ 6, "-__321"},
-      {-321, kDec | kInt | kBase, /*width = */ 0, "-321"},
-      {-321, kDec | kInt | kBase, /*width = */ 6, "-__321"},
-      {-321, kDec | kInt | kBase | kPos, /*width = */ 0, "-321"},
-      {-321, kDec | kInt | kBase | kPos, /*width = */ 6, "-__321"},
-      {-321, kDec | kInt | kUpper, /*width = */ 0, "-321"},
-      {-321, kDec | kInt | kUpper, /*width = */ 6, "-__321"},
-      {-321, kDec | kInt | kUpper | kPos, /*width = */ 0, "-321"},
-      {-321, kDec | kInt | kUpper | kPos, /*width = */ 6, "-__321"},
-      {-321, kDec | kInt | kUpper | kBase, /*width = */ 0, "-321"},
-      {-321, kDec | kInt | kUpper | kBase, /*width = */ 6, "-__321"},
-      {-321, kDec | kInt | kUpper | kBase | kPos, /*width = */ 0, "-321"},
-      {-321, kDec | kInt | kUpper | kBase | kPos, /*width = */ 6, "-__321"},
-      {-321, kDec | kRight, /*width = */ 0, "-321"},
-      {-321, kDec | kRight, /*width = */ 6, "__-321"},
-      {-321, kDec | kRight | kPos, /*width = */ 0, "-321"},
-      {-321, kDec | kRight | kPos, /*width = */ 6, "__-321"},
-      {-321, kDec | kRight | kBase, /*width = */ 0, "-321"},
-      {-321, kDec | kRight | kBase, /*width = */ 6, "__-321"},
-      {-321, kDec | kRight | kBase | kPos, /*width = */ 0, "-321"},
-      {-321, kDec | kRight | kBase | kPos, /*width = */ 6, "__-321"},
-      {-321, kDec | kRight | kUpper, /*width = */ 0, "-321"},
-      {-321, kDec | kRight | kUpper, /*width = */ 6, "__-321"},
-      {-321, kDec | kRight | kUpper | kPos, /*width = */ 0, "-321"},
-      {-321, kDec | kRight | kUpper | kPos, /*width = */ 6, "__-321"},
-      {-321, kDec | kRight | kUpper | kBase, /*width = */ 0, "-321"},
-      {-321, kDec | kRight | kUpper | kBase, /*width = */ 6, "__-321"},
-      {-321, kDec | kRight | kUpper | kBase | kPos, /*width = */ 0, "-321"},
-      {-321, kDec | kRight | kUpper | kBase | kPos, /*width = */ 6, "__-321"}};
-}
-
-std::vector<Uint128TestCase> GetUint128FormatCases() {
-  return {
-      {0, std::ios_base::fmtflags(), /*width = */ 0, "0"},
-      {0, std::ios_base::fmtflags(), /*width = */ 6, "_____0"},
-      {0, kPos, /*width = */ 0, "0"},
-      {0, kPos, /*width = */ 6, "_____0"},
-      {0, kBase, /*width = */ 0, "0"},
-      {0, kBase, /*width = */ 6, "_____0"},
-      {0, kBase | kPos, /*width = */ 0, "0"},
-      {0, kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kUpper, /*width = */ 0, "0"},
-      {0, kUpper, /*width = */ 6, "_____0"},
-      {0, kUpper | kPos, /*width = */ 0, "0"},
-      {0, kUpper | kPos, /*width = */ 6, "_____0"},
-      {0, kUpper | kBase, /*width = */ 0, "0"},
-      {0, kUpper | kBase, /*width = */ 6, "_____0"},
-      {0, kUpper | kBase | kPos, /*width = */ 0, "0"},
-      {0, kUpper | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kLeft, /*width = */ 0, "0"},
-      {0, kLeft, /*width = */ 6, "0_____"},
-      {0, kLeft | kPos, /*width = */ 0, "0"},
-      {0, kLeft | kPos, /*width = */ 6, "0_____"},
-      {0, kLeft | kBase, /*width = */ 0, "0"},
-      {0, kLeft | kBase, /*width = */ 6, "0_____"},
-      {0, kLeft | kBase | kPos, /*width = */ 0, "0"},
-      {0, kLeft | kBase | kPos, /*width = */ 6, "0_____"},
-      {0, kLeft | kUpper, /*width = */ 0, "0"},
-      {0, kLeft | kUpper, /*width = */ 6, "0_____"},
-      {0, kLeft | kUpper | kPos, /*width = */ 0, "0"},
-      {0, kLeft | kUpper | kPos, /*width = */ 6, "0_____"},
-      {0, kLeft | kUpper | kBase, /*width = */ 0, "0"},
-      {0, kLeft | kUpper | kBase, /*width = */ 6, "0_____"},
-      {0, kLeft | kUpper | kBase | kPos, /*width = */ 0, "0"},
-      {0, kLeft | kUpper | kBase | kPos, /*width = */ 6, "0_____"},
-      {0, kInt, /*width = */ 0, "0"},
-      {0, kInt, /*width = */ 6, "_____0"},
-      {0, kInt | kPos, /*width = */ 0, "0"},
-      {0, kInt | kPos, /*width = */ 6, "_____0"},
-      {0, kInt | kBase, /*width = */ 0, "0"},
-      {0, kInt | kBase, /*width = */ 6, "_____0"},
-      {0, kInt | kBase | kPos, /*width = */ 0, "0"},
-      {0, kInt | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kInt | kUpper, /*width = */ 0, "0"},
-      {0, kInt | kUpper, /*width = */ 6, "_____0"},
-      {0, kInt | kUpper | kPos, /*width = */ 0, "0"},
-      {0, kInt | kUpper | kPos, /*width = */ 6, "_____0"},
-      {0, kInt | kUpper | kBase, /*width = */ 0, "0"},
-      {0, kInt | kUpper | kBase, /*width = */ 6, "_____0"},
-      {0, kInt | kUpper | kBase | kPos, /*width = */ 0, "0"},
-      {0, kInt | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kRight, /*width = */ 0, "0"},
-      {0, kRight, /*width = */ 6, "_____0"},
-      {0, kRight | kPos, /*width = */ 0, "0"},
-      {0, kRight | kPos, /*width = */ 6, "_____0"},
-      {0, kRight | kBase, /*width = */ 0, "0"},
-      {0, kRight | kBase, /*width = */ 6, "_____0"},
-      {0, kRight | kBase | kPos, /*width = */ 0, "0"},
-      {0, kRight | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kRight | kUpper, /*width = */ 0, "0"},
-      {0, kRight | kUpper, /*width = */ 6, "_____0"},
-      {0, kRight | kUpper | kPos, /*width = */ 0, "0"},
-      {0, kRight | kUpper | kPos, /*width = */ 6, "_____0"},
-      {0, kRight | kUpper | kBase, /*width = */ 0, "0"},
-      {0, kRight | kUpper | kBase, /*width = */ 6, "_____0"},
-      {0, kRight | kUpper | kBase | kPos, /*width = */ 0, "0"},
-      {0, kRight | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kDec, /*width = */ 0, "0"},
-      {0, kDec, /*width = */ 6, "_____0"},
-      {0, kDec | kPos, /*width = */ 0, "0"},
-      {0, kDec | kPos, /*width = */ 6, "_____0"},
-      {0, kDec | kBase, /*width = */ 0, "0"},
-      {0, kDec | kBase, /*width = */ 6, "_____0"},
-      {0, kDec | kBase | kPos, /*width = */ 0, "0"},
-      {0, kDec | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kDec | kUpper, /*width = */ 0, "0"},
-      {0, kDec | kUpper, /*width = */ 6, "_____0"},
-      {0, kDec | kUpper | kPos, /*width = */ 0, "0"},
-      {0, kDec | kUpper | kPos, /*width = */ 6, "_____0"},
-      {0, kDec | kUpper | kBase, /*width = */ 0, "0"},
-      {0, kDec | kUpper | kBase, /*width = */ 6, "_____0"},
-      {0, kDec | kUpper | kBase | kPos, /*width = */ 0, "0"},
-      {0, kDec | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kDec | kLeft, /*width = */ 0, "0"},
-      {0, kDec | kLeft, /*width = */ 6, "0_____"},
-      {0, kDec | kLeft | kPos, /*width = */ 0, "0"},
-      {0, kDec | kLeft | kPos, /*width = */ 6, "0_____"},
-      {0, kDec | kLeft | kBase, /*width = */ 0, "0"},
-      {0, kDec | kLeft | kBase, /*width = */ 6, "0_____"},
-      {0, kDec | kLeft | kBase | kPos, /*width = */ 0, "0"},
-      {0, kDec | kLeft | kBase | kPos, /*width = */ 6, "0_____"},
-      {0, kDec | kLeft | kUpper, /*width = */ 0, "0"},
-      {0, kDec | kLeft | kUpper, /*width = */ 6, "0_____"},
-      {0, kDec | kLeft | kUpper | kPos, /*width = */ 0, "0"},
-      {0, kDec | kLeft | kUpper | kPos, /*width = */ 6, "0_____"},
-      {0, kDec | kLeft | kUpper | kBase, /*width = */ 0, "0"},
-      {0, kDec | kLeft | kUpper | kBase, /*width = */ 6, "0_____"},
-      {0, kDec | kLeft | kUpper | kBase | kPos, /*width = */ 0, "0"},
-      {0, kDec | kLeft | kUpper | kBase | kPos, /*width = */ 6, "0_____"},
-      {0, kDec | kInt, /*width = */ 0, "0"},
-      {0, kDec | kInt, /*width = */ 6, "_____0"},
-      {0, kDec | kInt | kPos, /*width = */ 0, "0"},
-      {0, kDec | kInt | kPos, /*width = */ 6, "_____0"},
-      {0, kDec | kInt | kBase, /*width = */ 0, "0"},
-      {0, kDec | kInt | kBase, /*width = */ 6, "_____0"},
-      {0, kDec | kInt | kBase | kPos, /*width = */ 0, "0"},
-      {0, kDec | kInt | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kDec | kInt | kUpper, /*width = */ 0, "0"},
-      {0, kDec | kInt | kUpper, /*width = */ 6, "_____0"},
-      {0, kDec | kInt | kUpper | kPos, /*width = */ 0, "0"},
-      {0, kDec | kInt | kUpper | kPos, /*width = */ 6, "_____0"},
-      {0, kDec | kInt | kUpper | kBase, /*width = */ 0, "0"},
-      {0, kDec | kInt | kUpper | kBase, /*width = */ 6, "_____0"},
-      {0, kDec | kInt | kUpper | kBase | kPos, /*width = */ 0, "0"},
-      {0, kDec | kInt | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kDec | kRight, /*width = */ 0, "0"},
-      {0, kDec | kRight, /*width = */ 6, "_____0"},
-      {0, kDec | kRight | kPos, /*width = */ 0, "0"},
-      {0, kDec | kRight | kPos, /*width = */ 6, "_____0"},
-      {0, kDec | kRight | kBase, /*width = */ 0, "0"},
-      {0, kDec | kRight | kBase, /*width = */ 6, "_____0"},
-      {0, kDec | kRight | kBase | kPos, /*width = */ 0, "0"},
-      {0, kDec | kRight | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kDec | kRight | kUpper, /*width = */ 0, "0"},
-      {0, kDec | kRight | kUpper, /*width = */ 6, "_____0"},
-      {0, kDec | kRight | kUpper | kPos, /*width = */ 0, "0"},
-      {0, kDec | kRight | kUpper | kPos, /*width = */ 6, "_____0"},
-      {0, kDec | kRight | kUpper | kBase, /*width = */ 0, "0"},
-      {0, kDec | kRight | kUpper | kBase, /*width = */ 6, "_____0"},
-      {0, kDec | kRight | kUpper | kBase | kPos, /*width = */ 0, "0"},
-      {0, kDec | kRight | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kOct, /*width = */ 0, "0"},
-      {0, kOct, /*width = */ 6, "_____0"},
-      {0, kOct | kPos, /*width = */ 0, "0"},
-      {0, kOct | kPos, /*width = */ 6, "_____0"},
-      {0, kOct | kBase, /*width = */ 0, "0"},
-      {0, kOct | kBase, /*width = */ 6, "_____0"},
-      {0, kOct | kBase | kPos, /*width = */ 0, "0"},
-      {0, kOct | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kOct | kUpper, /*width = */ 0, "0"},
-      {0, kOct | kUpper, /*width = */ 6, "_____0"},
-      {0, kOct | kUpper | kPos, /*width = */ 0, "0"},
-      {0, kOct | kUpper | kPos, /*width = */ 6, "_____0"},
-      {0, kOct | kUpper | kBase, /*width = */ 0, "0"},
-      {0, kOct | kUpper | kBase, /*width = */ 6, "_____0"},
-      {0, kOct | kUpper | kBase | kPos, /*width = */ 0, "0"},
-      {0, kOct | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kOct | kLeft, /*width = */ 0, "0"},
-      {0, kOct | kLeft, /*width = */ 6, "0_____"},
-      {0, kOct | kLeft | kPos, /*width = */ 0, "0"},
-      {0, kOct | kLeft | kPos, /*width = */ 6, "0_____"},
-      {0, kOct | kLeft | kBase, /*width = */ 0, "0"},
-      {0, kOct | kLeft | kBase, /*width = */ 6, "0_____"},
-      {0, kOct | kLeft | kBase | kPos, /*width = */ 0, "0"},
-      {0, kOct | kLeft | kBase | kPos, /*width = */ 6, "0_____"},
-      {0, kOct | kLeft | kUpper, /*width = */ 0, "0"},
-      {0, kOct | kLeft | kUpper, /*width = */ 6, "0_____"},
-      {0, kOct | kLeft | kUpper | kPos, /*width = */ 0, "0"},
-      {0, kOct | kLeft | kUpper | kPos, /*width = */ 6, "0_____"},
-      {0, kOct | kLeft | kUpper | kBase, /*width = */ 0, "0"},
-      {0, kOct | kLeft | kUpper | kBase, /*width = */ 6, "0_____"},
-      {0, kOct | kLeft | kUpper | kBase | kPos, /*width = */ 0, "0"},
-      {0, kOct | kLeft | kUpper | kBase | kPos, /*width = */ 6, "0_____"},
-      {0, kOct | kInt, /*width = */ 0, "0"},
-      {0, kOct | kInt, /*width = */ 6, "_____0"},
-      {0, kOct | kInt | kPos, /*width = */ 0, "0"},
-      {0, kOct | kInt | kPos, /*width = */ 6, "_____0"},
-      {0, kOct | kInt | kBase, /*width = */ 0, "0"},
-      {0, kOct | kInt | kBase, /*width = */ 6, "_____0"},
-      {0, kOct | kInt | kBase | kPos, /*width = */ 0, "0"},
-      {0, kOct | kInt | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kOct | kInt | kUpper, /*width = */ 0, "0"},
-      {0, kOct | kInt | kUpper, /*width = */ 6, "_____0"},
-      {0, kOct | kInt | kUpper | kPos, /*width = */ 0, "0"},
-      {0, kOct | kInt | kUpper | kPos, /*width = */ 6, "_____0"},
-      {0, kOct | kInt | kUpper | kBase, /*width = */ 0, "0"},
-      {0, kOct | kInt | kUpper | kBase, /*width = */ 6, "_____0"},
-      {0, kOct | kInt | kUpper | kBase | kPos, /*width = */ 0, "0"},
-      {0, kOct | kInt | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kOct | kRight, /*width = */ 0, "0"},
-      {0, kOct | kRight, /*width = */ 6, "_____0"},
-      {0, kOct | kRight | kPos, /*width = */ 0, "0"},
-      {0, kOct | kRight | kPos, /*width = */ 6, "_____0"},
-      {0, kOct | kRight | kBase, /*width = */ 0, "0"},
-      {0, kOct | kRight | kBase, /*width = */ 6, "_____0"},
-      {0, kOct | kRight | kBase | kPos, /*width = */ 0, "0"},
-      {0, kOct | kRight | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kOct | kRight | kUpper, /*width = */ 0, "0"},
-      {0, kOct | kRight | kUpper, /*width = */ 6, "_____0"},
-      {0, kOct | kRight | kUpper | kPos, /*width = */ 0, "0"},
-      {0, kOct | kRight | kUpper | kPos, /*width = */ 6, "_____0"},
-      {0, kOct | kRight | kUpper | kBase, /*width = */ 0, "0"},
-      {0, kOct | kRight | kUpper | kBase, /*width = */ 6, "_____0"},
-      {0, kOct | kRight | kUpper | kBase | kPos, /*width = */ 0, "0"},
-      {0, kOct | kRight | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kHex, /*width = */ 0, "0"},
-      {0, kHex, /*width = */ 6, "_____0"},
-      {0, kHex | kPos, /*width = */ 0, "0"},
-      {0, kHex | kPos, /*width = */ 6, "_____0"},
-      {0, kHex | kBase, /*width = */ 0, "0"},
-      {0, kHex | kBase, /*width = */ 6, "_____0"},
-      {0, kHex | kBase | kPos, /*width = */ 0, "0"},
-      {0, kHex | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kHex | kUpper, /*width = */ 0, "0"},
-      {0, kHex | kUpper, /*width = */ 6, "_____0"},
-      {0, kHex | kUpper | kPos, /*width = */ 0, "0"},
-      {0, kHex | kUpper | kPos, /*width = */ 6, "_____0"},
-      {0, kHex | kUpper | kBase, /*width = */ 0, "0"},
-      {0, kHex | kUpper | kBase, /*width = */ 6, "_____0"},
-      {0, kHex | kUpper | kBase | kPos, /*width = */ 0, "0"},
-      {0, kHex | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kHex | kLeft, /*width = */ 0, "0"},
-      {0, kHex | kLeft, /*width = */ 6, "0_____"},
-      {0, kHex | kLeft | kPos, /*width = */ 0, "0"},
-      {0, kHex | kLeft | kPos, /*width = */ 6, "0_____"},
-      {0, kHex | kLeft | kBase, /*width = */ 0, "0"},
-      {0, kHex | kLeft | kBase, /*width = */ 6, "0_____"},
-      {0, kHex | kLeft | kBase | kPos, /*width = */ 0, "0"},
-      {0, kHex | kLeft | kBase | kPos, /*width = */ 6, "0_____"},
-      {0, kHex | kLeft | kUpper, /*width = */ 0, "0"},
-      {0, kHex | kLeft | kUpper, /*width = */ 6, "0_____"},
-      {0, kHex | kLeft | kUpper | kPos, /*width = */ 0, "0"},
-      {0, kHex | kLeft | kUpper | kPos, /*width = */ 6, "0_____"},
-      {0, kHex | kLeft | kUpper | kBase, /*width = */ 0, "0"},
-      {0, kHex | kLeft | kUpper | kBase, /*width = */ 6, "0_____"},
-      {0, kHex | kLeft | kUpper | kBase | kPos, /*width = */ 0, "0"},
-      {0, kHex | kLeft | kUpper | kBase | kPos, /*width = */ 6, "0_____"},
-      {0, kHex | kInt, /*width = */ 0, "0"},
-      {0, kHex | kInt, /*width = */ 6, "_____0"},
-      {0, kHex | kInt | kPos, /*width = */ 0, "0"},
-      {0, kHex | kInt | kPos, /*width = */ 6, "_____0"},
-      {0, kHex | kInt | kBase, /*width = */ 0, "0"},
-      {0, kHex | kInt | kBase, /*width = */ 6, "_____0"},
-      {0, kHex | kInt | kBase | kPos, /*width = */ 0, "0"},
-      {0, kHex | kInt | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kHex | kInt | kUpper, /*width = */ 0, "0"},
-      {0, kHex | kInt | kUpper, /*width = */ 6, "_____0"},
-      {0, kHex | kInt | kUpper | kPos, /*width = */ 0, "0"},
-      {0, kHex | kInt | kUpper | kPos, /*width = */ 6, "_____0"},
-      {0, kHex | kInt | kUpper | kBase, /*width = */ 0, "0"},
-      {0, kHex | kInt | kUpper | kBase, /*width = */ 6, "_____0"},
-      {0, kHex | kInt | kUpper | kBase | kPos, /*width = */ 0, "0"},
-      {0, kHex | kInt | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kHex | kRight, /*width = */ 0, "0"},
-      {0, kHex | kRight, /*width = */ 6, "_____0"},
-      {0, kHex | kRight | kPos, /*width = */ 0, "0"},
-      {0, kHex | kRight | kPos, /*width = */ 6, "_____0"},
-      {0, kHex | kRight | kBase, /*width = */ 0, "0"},
-      {0, kHex | kRight | kBase, /*width = */ 6, "_____0"},
-      {0, kHex | kRight | kBase | kPos, /*width = */ 0, "0"},
-      {0, kHex | kRight | kBase | kPos, /*width = */ 6, "_____0"},
-      {0, kHex | kRight | kUpper, /*width = */ 0, "0"},
-      {0, kHex | kRight | kUpper, /*width = */ 6, "_____0"},
-      {0, kHex | kRight | kUpper | kPos, /*width = */ 0, "0"},
-      {0, kHex | kRight | kUpper | kPos, /*width = */ 6, "_____0"},
-      {0, kHex | kRight | kUpper | kBase, /*width = */ 0, "0"},
-      {0, kHex | kRight | kUpper | kBase, /*width = */ 6, "_____0"},
-      {0, kHex | kRight | kUpper | kBase | kPos, /*width = */ 0, "0"},
-      {0, kHex | kRight | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
-      {37, std::ios_base::fmtflags(), /*width = */ 0, "37"},
-      {37, std::ios_base::fmtflags(), /*width = */ 6, "____37"},
-      {37, kPos, /*width = */ 0, "37"},
-      {37, kPos, /*width = */ 6, "____37"},
-      {37, kBase, /*width = */ 0, "37"},
-      {37, kBase, /*width = */ 6, "____37"},
-      {37, kBase | kPos, /*width = */ 0, "37"},
-      {37, kBase | kPos, /*width = */ 6, "____37"},
-      {37, kUpper, /*width = */ 0, "37"},
-      {37, kUpper, /*width = */ 6, "____37"},
-      {37, kUpper | kPos, /*width = */ 0, "37"},
-      {37, kUpper | kPos, /*width = */ 6, "____37"},
-      {37, kUpper | kBase, /*width = */ 0, "37"},
-      {37, kUpper | kBase, /*width = */ 6, "____37"},
-      {37, kUpper | kBase | kPos, /*width = */ 0, "37"},
-      {37, kUpper | kBase | kPos, /*width = */ 6, "____37"},
-      {37, kLeft, /*width = */ 0, "37"},
-      {37, kLeft, /*width = */ 6, "37____"},
-      {37, kLeft | kPos, /*width = */ 0, "37"},
-      {37, kLeft | kPos, /*width = */ 6, "37____"},
-      {37, kLeft | kBase, /*width = */ 0, "37"},
-      {37, kLeft | kBase, /*width = */ 6, "37____"},
-      {37, kLeft | kBase | kPos, /*width = */ 0, "37"},
-      {37, kLeft | kBase | kPos, /*width = */ 6, "37____"},
-      {37, kLeft | kUpper, /*width = */ 0, "37"},
-      {37, kLeft | kUpper, /*width = */ 6, "37____"},
-      {37, kLeft | kUpper | kPos, /*width = */ 0, "37"},
-      {37, kLeft | kUpper | kPos, /*width = */ 6, "37____"},
-      {37, kLeft | kUpper | kBase, /*width = */ 0, "37"},
-      {37, kLeft | kUpper | kBase, /*width = */ 6, "37____"},
-      {37, kLeft | kUpper | kBase | kPos, /*width = */ 0, "37"},
-      {37, kLeft | kUpper | kBase | kPos, /*width = */ 6, "37____"},
-      {37, kInt, /*width = */ 0, "37"},
-      {37, kInt, /*width = */ 6, "____37"},
-      {37, kInt | kPos, /*width = */ 0, "37"},
-      {37, kInt | kPos, /*width = */ 6, "____37"},
-      {37, kInt | kBase, /*width = */ 0, "37"},
-      {37, kInt | kBase, /*width = */ 6, "____37"},
-      {37, kInt | kBase | kPos, /*width = */ 0, "37"},
-      {37, kInt | kBase | kPos, /*width = */ 6, "____37"},
-      {37, kInt | kUpper, /*width = */ 0, "37"},
-      {37, kInt | kUpper, /*width = */ 6, "____37"},
-      {37, kInt | kUpper | kPos, /*width = */ 0, "37"},
-      {37, kInt | kUpper | kPos, /*width = */ 6, "____37"},
-      {37, kInt | kUpper | kBase, /*width = */ 0, "37"},
-      {37, kInt | kUpper | kBase, /*width = */ 6, "____37"},
-      {37, kInt | kUpper | kBase | kPos, /*width = */ 0, "37"},
-      {37, kInt | kUpper | kBase | kPos, /*width = */ 6, "____37"},
-      {37, kRight, /*width = */ 0, "37"},
-      {37, kRight, /*width = */ 6, "____37"},
-      {37, kRight | kPos, /*width = */ 0, "37"},
-      {37, kRight | kPos, /*width = */ 6, "____37"},
-      {37, kRight | kBase, /*width = */ 0, "37"},
-      {37, kRight | kBase, /*width = */ 6, "____37"},
-      {37, kRight | kBase | kPos, /*width = */ 0, "37"},
-      {37, kRight | kBase | kPos, /*width = */ 6, "____37"},
-      {37, kRight | kUpper, /*width = */ 0, "37"},
-      {37, kRight | kUpper, /*width = */ 6, "____37"},
-      {37, kRight | kUpper | kPos, /*width = */ 0, "37"},
-      {37, kRight | kUpper | kPos, /*width = */ 6, "____37"},
-      {37, kRight | kUpper | kBase, /*width = */ 0, "37"},
-      {37, kRight | kUpper | kBase, /*width = */ 6, "____37"},
-      {37, kRight | kUpper | kBase | kPos, /*width = */ 0, "37"},
-      {37, kRight | kUpper | kBase | kPos, /*width = */ 6, "____37"},
-      {37, kDec, /*width = */ 0, "37"},
-      {37, kDec, /*width = */ 6, "____37"},
-      {37, kDec | kPos, /*width = */ 0, "37"},
-      {37, kDec | kPos, /*width = */ 6, "____37"},
-      {37, kDec | kBase, /*width = */ 0, "37"},
-      {37, kDec | kBase, /*width = */ 6, "____37"},
-      {37, kDec | kBase | kPos, /*width = */ 0, "37"},
-      {37, kDec | kBase | kPos, /*width = */ 6, "____37"},
-      {37, kDec | kUpper, /*width = */ 0, "37"},
-      {37, kDec | kUpper, /*width = */ 6, "____37"},
-      {37, kDec | kUpper | kPos, /*width = */ 0, "37"},
-      {37, kDec | kUpper | kPos, /*width = */ 6, "____37"},
-      {37, kDec | kUpper | kBase, /*width = */ 0, "37"},
-      {37, kDec | kUpper | kBase, /*width = */ 6, "____37"},
-      {37, kDec | kUpper | kBase | kPos, /*width = */ 0, "37"},
-      {37, kDec | kUpper | kBase | kPos, /*width = */ 6, "____37"},
-      {37, kDec | kLeft, /*width = */ 0, "37"},
-      {37, kDec | kLeft, /*width = */ 6, "37____"},
-      {37, kDec | kLeft | kPos, /*width = */ 0, "37"},
-      {37, kDec | kLeft | kPos, /*width = */ 6, "37____"},
-      {37, kDec | kLeft | kBase, /*width = */ 0, "37"},
-      {37, kDec | kLeft | kBase, /*width = */ 6, "37____"},
-      {37, kDec | kLeft | kBase | kPos, /*width = */ 0, "37"},
-      {37, kDec | kLeft | kBase | kPos, /*width = */ 6, "37____"},
-      {37, kDec | kLeft | kUpper, /*width = */ 0, "37"},
-      {37, kDec | kLeft | kUpper, /*width = */ 6, "37____"},
-      {37, kDec | kLeft | kUpper | kPos, /*width = */ 0, "37"},
-      {37, kDec | kLeft | kUpper | kPos, /*width = */ 6, "37____"},
-      {37, kDec | kLeft | kUpper | kBase, /*width = */ 0, "37"},
-      {37, kDec | kLeft | kUpper | kBase, /*width = */ 6, "37____"},
-      {37, kDec | kLeft | kUpper | kBase | kPos, /*width = */ 0, "37"},
-      {37, kDec | kLeft | kUpper | kBase | kPos, /*width = */ 6, "37____"},
-      {37, kDec | kInt, /*width = */ 0, "37"},
-      {37, kDec | kInt, /*width = */ 6, "____37"},
-      {37, kDec | kInt | kPos, /*width = */ 0, "37"},
-      {37, kDec | kInt | kPos, /*width = */ 6, "____37"},
-      {37, kDec | kInt | kBase, /*width = */ 0, "37"},
-      {37, kDec | kInt | kBase, /*width = */ 6, "____37"},
-      {37, kDec | kInt | kBase | kPos, /*width = */ 0, "37"},
-      {37, kDec | kInt | kBase | kPos, /*width = */ 6, "____37"},
-      {37, kDec | kInt | kUpper, /*width = */ 0, "37"},
-      {37, kDec | kInt | kUpper, /*width = */ 6, "____37"},
-      {37, kDec | kInt | kUpper | kPos, /*width = */ 0, "37"},
-      {37, kDec | kInt | kUpper | kPos, /*width = */ 6, "____37"},
-      {37, kDec | kInt | kUpper | kBase, /*width = */ 0, "37"},
-      {37, kDec | kInt | kUpper | kBase, /*width = */ 6, "____37"},
-      {37, kDec | kInt | kUpper | kBase | kPos, /*width = */ 0, "37"},
-      {37, kDec | kInt | kUpper | kBase | kPos, /*width = */ 6, "____37"},
-      {37, kDec | kRight, /*width = */ 0, "37"},
-      {37, kDec | kRight, /*width = */ 6, "____37"},
-      {37, kDec | kRight | kPos, /*width = */ 0, "37"},
-      {37, kDec | kRight | kPos, /*width = */ 6, "____37"},
-      {37, kDec | kRight | kBase, /*width = */ 0, "37"},
-      {37, kDec | kRight | kBase, /*width = */ 6, "____37"},
-      {37, kDec | kRight | kBase | kPos, /*width = */ 0, "37"},
-      {37, kDec | kRight | kBase | kPos, /*width = */ 6, "____37"},
-      {37, kDec | kRight | kUpper, /*width = */ 0, "37"},
-      {37, kDec | kRight | kUpper, /*width = */ 6, "____37"},
-      {37, kDec | kRight | kUpper | kPos, /*width = */ 0, "37"},
-      {37, kDec | kRight | kUpper | kPos, /*width = */ 6, "____37"},
-      {37, kDec | kRight | kUpper | kBase, /*width = */ 0, "37"},
-      {37, kDec | kRight | kUpper | kBase, /*width = */ 6, "____37"},
-      {37, kDec | kRight | kUpper | kBase | kPos, /*width = */ 0, "37"},
-      {37, kDec | kRight | kUpper | kBase | kPos, /*width = */ 6, "____37"},
-      {37, kOct, /*width = */ 0, "45"},
-      {37, kOct, /*width = */ 6, "____45"},
-      {37, kOct | kPos, /*width = */ 0, "45"},
-      {37, kOct | kPos, /*width = */ 6, "____45"},
-      {37, kOct | kBase, /*width = */ 0, "045"},
-      {37, kOct | kBase, /*width = */ 6, "___045"},
-      {37, kOct | kBase | kPos, /*width = */ 0, "045"},
-      {37, kOct | kBase | kPos, /*width = */ 6, "___045"},
-      {37, kOct | kUpper, /*width = */ 0, "45"},
-      {37, kOct | kUpper, /*width = */ 6, "____45"},
-      {37, kOct | kUpper | kPos, /*width = */ 0, "45"},
-      {37, kOct | kUpper | kPos, /*width = */ 6, "____45"},
-      {37, kOct | kUpper | kBase, /*width = */ 0, "045"},
-      {37, kOct | kUpper | kBase, /*width = */ 6, "___045"},
-      {37, kOct | kUpper | kBase | kPos, /*width = */ 0, "045"},
-      {37, kOct | kUpper | kBase | kPos, /*width = */ 6, "___045"},
-      {37, kOct | kLeft, /*width = */ 0, "45"},
-      {37, kOct | kLeft, /*width = */ 6, "45____"},
-      {37, kOct | kLeft | kPos, /*width = */ 0, "45"},
-      {37, kOct | kLeft | kPos, /*width = */ 6, "45____"},
-      {37, kOct | kLeft | kBase, /*width = */ 0, "045"},
-      {37, kOct | kLeft | kBase, /*width = */ 6, "045___"},
-      {37, kOct | kLeft | kBase | kPos, /*width = */ 0, "045"},
-      {37, kOct | kLeft | kBase | kPos, /*width = */ 6, "045___"},
-      {37, kOct | kLeft | kUpper, /*width = */ 0, "45"},
-      {37, kOct | kLeft | kUpper, /*width = */ 6, "45____"},
-      {37, kOct | kLeft | kUpper | kPos, /*width = */ 0, "45"},
-      {37, kOct | kLeft | kUpper | kPos, /*width = */ 6, "45____"},
-      {37, kOct | kLeft | kUpper | kBase, /*width = */ 0, "045"},
-      {37, kOct | kLeft | kUpper | kBase, /*width = */ 6, "045___"},
-      {37, kOct | kLeft | kUpper | kBase | kPos, /*width = */ 0, "045"},
-      {37, kOct | kLeft | kUpper | kBase | kPos, /*width = */ 6, "045___"},
-      {37, kOct | kInt, /*width = */ 0, "45"},
-      {37, kOct | kInt, /*width = */ 6, "____45"},
-      {37, kOct | kInt | kPos, /*width = */ 0, "45"},
-      {37, kOct | kInt | kPos, /*width = */ 6, "____45"},
-      {37, kOct | kInt | kBase, /*width = */ 0, "045"},
-      {37, kOct | kInt | kBase, /*width = */ 6, "___045"},
-      {37, kOct | kInt | kBase | kPos, /*width = */ 0, "045"},
-      {37, kOct | kInt | kBase | kPos, /*width = */ 6, "___045"},
-      {37, kOct | kInt | kUpper, /*width = */ 0, "45"},
-      {37, kOct | kInt | kUpper, /*width = */ 6, "____45"},
-      {37, kOct | kInt | kUpper | kPos, /*width = */ 0, "45"},
-      {37, kOct | kInt | kUpper | kPos, /*width = */ 6, "____45"},
-      {37, kOct | kInt | kUpper | kBase, /*width = */ 0, "045"},
-      {37, kOct | kInt | kUpper | kBase, /*width = */ 6, "___045"},
-      {37, kOct | kInt | kUpper | kBase | kPos, /*width = */ 0, "045"},
-      {37, kOct | kInt | kUpper | kBase | kPos, /*width = */ 6, "___045"},
-      {37, kOct | kRight, /*width = */ 0, "45"},
-      {37, kOct | kRight, /*width = */ 6, "____45"},
-      {37, kOct | kRight | kPos, /*width = */ 0, "45"},
-      {37, kOct | kRight | kPos, /*width = */ 6, "____45"},
-      {37, kOct | kRight | kBase, /*width = */ 0, "045"},
-      {37, kOct | kRight | kBase, /*width = */ 6, "___045"},
-      {37, kOct | kRight | kBase | kPos, /*width = */ 0, "045"},
-      {37, kOct | kRight | kBase | kPos, /*width = */ 6, "___045"},
-      {37, kOct | kRight | kUpper, /*width = */ 0, "45"},
-      {37, kOct | kRight | kUpper, /*width = */ 6, "____45"},
-      {37, kOct | kRight | kUpper | kPos, /*width = */ 0, "45"},
-      {37, kOct | kRight | kUpper | kPos, /*width = */ 6, "____45"},
-      {37, kOct | kRight | kUpper | kBase, /*width = */ 0, "045"},
-      {37, kOct | kRight | kUpper | kBase, /*width = */ 6, "___045"},
-      {37, kOct | kRight | kUpper | kBase | kPos, /*width = */ 0, "045"},
-      {37, kOct | kRight | kUpper | kBase | kPos, /*width = */ 6, "___045"},
-      {37, kHex, /*width = */ 0, "25"},
-      {37, kHex, /*width = */ 6, "____25"},
-      {37, kHex | kPos, /*width = */ 0, "25"},
-      {37, kHex | kPos, /*width = */ 6, "____25"},
-      {37, kHex | kBase, /*width = */ 0, "0x25"},
-      {37, kHex | kBase, /*width = */ 6, "__0x25"},
-      {37, kHex | kBase | kPos, /*width = */ 0, "0x25"},
-      {37, kHex | kBase | kPos, /*width = */ 6, "__0x25"},
-      {37, kHex | kUpper, /*width = */ 0, "25"},
-      {37, kHex | kUpper, /*width = */ 6, "____25"},
-      {37, kHex | kUpper | kPos, /*width = */ 0, "25"},
-      {37, kHex | kUpper | kPos, /*width = */ 6, "____25"},
-      {37, kHex | kUpper | kBase, /*width = */ 0, "0X25"},
-      {37, kHex | kUpper | kBase, /*width = */ 6, "__0X25"},
-      {37, kHex | kUpper | kBase | kPos, /*width = */ 0, "0X25"},
-      {37, kHex | kUpper | kBase | kPos, /*width = */ 6, "__0X25"},
-      {37, kHex | kLeft, /*width = */ 0, "25"},
-      {37, kHex | kLeft, /*width = */ 6, "25____"},
-      {37, kHex | kLeft | kPos, /*width = */ 0, "25"},
-      {37, kHex | kLeft | kPos, /*width = */ 6, "25____"},
-      {37, kHex | kLeft | kBase, /*width = */ 0, "0x25"},
-      {37, kHex | kLeft | kBase, /*width = */ 6, "0x25__"},
-      {37, kHex | kLeft | kBase | kPos, /*width = */ 0, "0x25"},
-      {37, kHex | kLeft | kBase | kPos, /*width = */ 6, "0x25__"},
-      {37, kHex | kLeft | kUpper, /*width = */ 0, "25"},
-      {37, kHex | kLeft | kUpper, /*width = */ 6, "25____"},
-      {37, kHex | kLeft | kUpper | kPos, /*width = */ 0, "25"},
-      {37, kHex | kLeft | kUpper | kPos, /*width = */ 6, "25____"},
-      {37, kHex | kLeft | kUpper | kBase, /*width = */ 0, "0X25"},
-      {37, kHex | kLeft | kUpper | kBase, /*width = */ 6, "0X25__"},
-      {37, kHex | kLeft | kUpper | kBase | kPos, /*width = */ 0, "0X25"},
-      {37, kHex | kLeft | kUpper | kBase | kPos, /*width = */ 6, "0X25__"},
-      {37, kHex | kInt, /*width = */ 0, "25"},
-      {37, kHex | kInt, /*width = */ 6, "____25"},
-      {37, kHex | kInt | kPos, /*width = */ 0, "25"},
-      {37, kHex | kInt | kPos, /*width = */ 6, "____25"},
-      {37, kHex | kInt | kBase, /*width = */ 0, "0x25"},
-      {37, kHex | kInt | kBase, /*width = */ 6, "0x__25"},
-      {37, kHex | kInt | kBase | kPos, /*width = */ 0, "0x25"},
-      {37, kHex | kInt | kBase | kPos, /*width = */ 6, "0x__25"},
-      {37, kHex | kInt | kUpper, /*width = */ 0, "25"},
-      {37, kHex | kInt | kUpper, /*width = */ 6, "____25"},
-      {37, kHex | kInt | kUpper | kPos, /*width = */ 0, "25"},
-      {37, kHex | kInt | kUpper | kPos, /*width = */ 6, "____25"},
-      {37, kHex | kInt | kUpper | kBase, /*width = */ 0, "0X25"},
-      {37, kHex | kInt | kUpper | kBase, /*width = */ 6, "0X__25"},
-      {37, kHex | kInt | kUpper | kBase | kPos, /*width = */ 0, "0X25"},
-      {37, kHex | kInt | kUpper | kBase | kPos, /*width = */ 6, "0X__25"},
-      {37, kHex | kRight, /*width = */ 0, "25"},
-      {37, kHex | kRight, /*width = */ 6, "____25"},
-      {37, kHex | kRight | kPos, /*width = */ 0, "25"},
-      {37, kHex | kRight | kPos, /*width = */ 6, "____25"},
-      {37, kHex | kRight | kBase, /*width = */ 0, "0x25"},
-      {37, kHex | kRight | kBase, /*width = */ 6, "__0x25"},
-      {37, kHex | kRight | kBase | kPos, /*width = */ 0, "0x25"},
-      {37, kHex | kRight | kBase | kPos, /*width = */ 6, "__0x25"},
-      {37, kHex | kRight | kUpper, /*width = */ 0, "25"},
-      {37, kHex | kRight | kUpper, /*width = */ 6, "____25"},
-      {37, kHex | kRight | kUpper | kPos, /*width = */ 0, "25"},
-      {37, kHex | kRight | kUpper | kPos, /*width = */ 6, "____25"},
-      {37, kHex | kRight | kUpper | kBase, /*width = */ 0, "0X25"},
-      {37, kHex | kRight | kUpper | kBase, /*width = */ 6, "__0X25"},
-      {37, kHex | kRight | kUpper | kBase | kPos, /*width = */ 0, "0X25"},
-      {37, kHex | kRight | kUpper | kBase | kPos, /*width = */ 6, "__0X25"}};
-}
-
-}  // namespace
diff --git a/third_party/abseil_cpp/absl/numeric/int128_test.cc b/third_party/abseil_cpp/absl/numeric/int128_test.cc
deleted file mode 100644
index bc86c714acce..000000000000
--- a/third_party/abseil_cpp/absl/numeric/int128_test.cc
+++ /dev/null
@@ -1,1225 +0,0 @@
-// Copyright 2017 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/numeric/int128.h"
-
-#include <algorithm>
-#include <limits>
-#include <random>
-#include <type_traits>
-#include <utility>
-#include <vector>
-
-#include "gtest/gtest.h"
-#include "absl/base/internal/cycleclock.h"
-#include "absl/hash/hash_testing.h"
-#include "absl/meta/type_traits.h"
-
-#if defined(_MSC_VER) && _MSC_VER == 1900
-// Disable "unary minus operator applied to unsigned type" warnings in Microsoft
-// Visual C++ 14 (2015).
-#pragma warning(disable:4146)
-#endif
-
-namespace {
-
-template <typename T>
-class Uint128IntegerTraitsTest : public ::testing::Test {};
-typedef ::testing::Types<bool, char, signed char, unsigned char, char16_t,
-                         char32_t, wchar_t,
-                         short,           // NOLINT(runtime/int)
-                         unsigned short,  // NOLINT(runtime/int)
-                         int, unsigned int,
-                         long,                // NOLINT(runtime/int)
-                         unsigned long,       // NOLINT(runtime/int)
-                         long long,           // NOLINT(runtime/int)
-                         unsigned long long>  // NOLINT(runtime/int)
-    IntegerTypes;
-
-template <typename T>
-class Uint128FloatTraitsTest : public ::testing::Test {};
-typedef ::testing::Types<float, double, long double> FloatingPointTypes;
-
-TYPED_TEST_SUITE(Uint128IntegerTraitsTest, IntegerTypes);
-
-TYPED_TEST(Uint128IntegerTraitsTest, ConstructAssignTest) {
-  static_assert(std::is_constructible<absl::uint128, TypeParam>::value,
-                "absl::uint128 must be constructible from TypeParam");
-  static_assert(std::is_assignable<absl::uint128&, TypeParam>::value,
-                "absl::uint128 must be assignable from TypeParam");
-  static_assert(!std::is_assignable<TypeParam&, absl::uint128>::value,
-                "TypeParam must not be assignable from absl::uint128");
-}
-
-TYPED_TEST_SUITE(Uint128FloatTraitsTest, FloatingPointTypes);
-
-TYPED_TEST(Uint128FloatTraitsTest, ConstructAssignTest) {
-  static_assert(std::is_constructible<absl::uint128, TypeParam>::value,
-                "absl::uint128 must be constructible from TypeParam");
-  static_assert(!std::is_assignable<absl::uint128&, TypeParam>::value,
-                "absl::uint128 must not be assignable from TypeParam");
-  static_assert(!std::is_assignable<TypeParam&, absl::uint128>::value,
-                "TypeParam must not be assignable from absl::uint128");
-}
-
-#ifdef ABSL_HAVE_INTRINSIC_INT128
-// These type traits done separately as TYPED_TEST requires typeinfo, and not
-// all platforms have this for __int128 even though they define the type.
-TEST(Uint128, IntrinsicTypeTraitsTest) {
-  static_assert(std::is_constructible<absl::uint128, __int128>::value,
-                "absl::uint128 must be constructible from __int128");
-  static_assert(std::is_assignable<absl::uint128&, __int128>::value,
-                "absl::uint128 must be assignable from __int128");
-  static_assert(!std::is_assignable<__int128&, absl::uint128>::value,
-                "__int128 must not be assignable from absl::uint128");
-
-  static_assert(std::is_constructible<absl::uint128, unsigned __int128>::value,
-                "absl::uint128 must be constructible from unsigned __int128");
-  static_assert(std::is_assignable<absl::uint128&, unsigned __int128>::value,
-                "absl::uint128 must be assignable from unsigned __int128");
-  static_assert(!std::is_assignable<unsigned __int128&, absl::uint128>::value,
-                "unsigned __int128 must not be assignable from absl::uint128");
-}
-#endif  // ABSL_HAVE_INTRINSIC_INT128
-
-TEST(Uint128, TrivialTraitsTest) {
-  static_assert(absl::is_trivially_default_constructible<absl::uint128>::value,
-                "");
-  static_assert(absl::is_trivially_copy_constructible<absl::uint128>::value,
-                "");
-  static_assert(absl::is_trivially_copy_assignable<absl::uint128>::value, "");
-  static_assert(std::is_trivially_destructible<absl::uint128>::value, "");
-}
-
-TEST(Uint128, AllTests) {
-  absl::uint128 zero = 0;
-  absl::uint128 one = 1;
-  absl::uint128 one_2arg = absl::MakeUint128(0, 1);
-  absl::uint128 two = 2;
-  absl::uint128 three = 3;
-  absl::uint128 big = absl::MakeUint128(2000, 2);
-  absl::uint128 big_minus_one = absl::MakeUint128(2000, 1);
-  absl::uint128 bigger = absl::MakeUint128(2001, 1);
-  absl::uint128 biggest = absl::Uint128Max();
-  absl::uint128 high_low = absl::MakeUint128(1, 0);
-  absl::uint128 low_high =
-      absl::MakeUint128(0, std::numeric_limits<uint64_t>::max());
-  EXPECT_LT(one, two);
-  EXPECT_GT(two, one);
-  EXPECT_LT(one, big);
-  EXPECT_LT(one, big);
-  EXPECT_EQ(one, one_2arg);
-  EXPECT_NE(one, two);
-  EXPECT_GT(big, one);
-  EXPECT_GE(big, two);
-  EXPECT_GE(big, big_minus_one);
-  EXPECT_GT(big, big_minus_one);
-  EXPECT_LT(big_minus_one, big);
-  EXPECT_LE(big_minus_one, big);
-  EXPECT_NE(big_minus_one, big);
-  EXPECT_LT(big, biggest);
-  EXPECT_LE(big, biggest);
-  EXPECT_GT(biggest, big);
-  EXPECT_GE(biggest, big);
-  EXPECT_EQ(big, ~~big);
-  EXPECT_EQ(one, one | one);
-  EXPECT_EQ(big, big | big);
-  EXPECT_EQ(one, one | zero);
-  EXPECT_EQ(one, one & one);
-  EXPECT_EQ(big, big & big);
-  EXPECT_EQ(zero, one & zero);
-  EXPECT_EQ(zero, big & ~big);
-  EXPECT_EQ(zero, one ^ one);
-  EXPECT_EQ(zero, big ^ big);
-  EXPECT_EQ(one, one ^ zero);
-
-  // Shift operators.
-  EXPECT_EQ(big, big << 0);
-  EXPECT_EQ(big, big >> 0);
-  EXPECT_GT(big << 1, big);
-  EXPECT_LT(big >> 1, big);
-  EXPECT_EQ(big, (big << 10) >> 10);
-  EXPECT_EQ(big, (big >> 1) << 1);
-  EXPECT_EQ(one, (one << 80) >> 80);
-  EXPECT_EQ(zero, (one >> 80) << 80);
-
-  // Shift assignments.
-  absl::uint128 big_copy = big;
-  EXPECT_EQ(big << 0, big_copy <<= 0);
-  big_copy = big;
-  EXPECT_EQ(big >> 0, big_copy >>= 0);
-  big_copy = big;
-  EXPECT_EQ(big << 1, big_copy <<= 1);
-  big_copy = big;
-  EXPECT_EQ(big >> 1, big_copy >>= 1);
-  big_copy = big;
-  EXPECT_EQ(big << 10, big_copy <<= 10);
-  big_copy = big;
-  EXPECT_EQ(big >> 10, big_copy >>= 10);
-  big_copy = big;
-  EXPECT_EQ(big << 64, big_copy <<= 64);
-  big_copy = big;
-  EXPECT_EQ(big >> 64, big_copy >>= 64);
-  big_copy = big;
-  EXPECT_EQ(big << 73, big_copy <<= 73);
-  big_copy = big;
-  EXPECT_EQ(big >> 73, big_copy >>= 73);
-
-  EXPECT_EQ(absl::Uint128High64(biggest), std::numeric_limits<uint64_t>::max());
-  EXPECT_EQ(absl::Uint128Low64(biggest), std::numeric_limits<uint64_t>::max());
-  EXPECT_EQ(zero + one, one);
-  EXPECT_EQ(one + one, two);
-  EXPECT_EQ(big_minus_one + one, big);
-  EXPECT_EQ(one - one, zero);
-  EXPECT_EQ(one - zero, one);
-  EXPECT_EQ(zero - one, biggest);
-  EXPECT_EQ(big - big, zero);
-  EXPECT_EQ(big - one, big_minus_one);
-  EXPECT_EQ(big + std::numeric_limits<uint64_t>::max(), bigger);
-  EXPECT_EQ(biggest + 1, zero);
-  EXPECT_EQ(zero - 1, biggest);
-  EXPECT_EQ(high_low - one, low_high);
-  EXPECT_EQ(low_high + one, high_low);
-  EXPECT_EQ(absl::Uint128High64((absl::uint128(1) << 64) - 1), 0);
-  EXPECT_EQ(absl::Uint128Low64((absl::uint128(1) << 64) - 1),
-            std::numeric_limits<uint64_t>::max());
-  EXPECT_TRUE(!!one);
-  EXPECT_TRUE(!!high_low);
-  EXPECT_FALSE(!!zero);
-  EXPECT_FALSE(!one);
-  EXPECT_FALSE(!high_low);
-  EXPECT_TRUE(!zero);
-  EXPECT_TRUE(zero == 0);       // NOLINT(readability/check)
-  EXPECT_FALSE(zero != 0);      // NOLINT(readability/check)
-  EXPECT_FALSE(one == 0);       // NOLINT(readability/check)
-  EXPECT_TRUE(one != 0);        // NOLINT(readability/check)
-  EXPECT_FALSE(high_low == 0);  // NOLINT(readability/check)
-  EXPECT_TRUE(high_low != 0);   // NOLINT(readability/check)
-
-  absl::uint128 test = zero;
-  EXPECT_EQ(++test, one);
-  EXPECT_EQ(test, one);
-  EXPECT_EQ(test++, one);
-  EXPECT_EQ(test, two);
-  EXPECT_EQ(test -= 2, zero);
-  EXPECT_EQ(test, zero);
-  EXPECT_EQ(test += 2, two);
-  EXPECT_EQ(test, two);
-  EXPECT_EQ(--test, one);
-  EXPECT_EQ(test, one);
-  EXPECT_EQ(test--, one);
-  EXPECT_EQ(test, zero);
-  EXPECT_EQ(test |= three, three);
-  EXPECT_EQ(test &= one, one);
-  EXPECT_EQ(test ^= three, two);
-  EXPECT_EQ(test >>= 1, one);
-  EXPECT_EQ(test <<= 1, two);
-
-  EXPECT_EQ(big, -(-big));
-  EXPECT_EQ(two, -((-one) - 1));
-  EXPECT_EQ(absl::Uint128Max(), -one);
-  EXPECT_EQ(zero, -zero);
-
-  EXPECT_EQ(absl::Uint128Max(), absl::kuint128max);
-}
-
-TEST(Uint128, ConversionTests) {
-  EXPECT_TRUE(absl::MakeUint128(1, 0));
-
-#ifdef ABSL_HAVE_INTRINSIC_INT128
-  unsigned __int128 intrinsic =
-      (static_cast<unsigned __int128>(0x3a5b76c209de76f6) << 64) +
-      0x1f25e1d63a2b46c5;
-  absl::uint128 custom =
-      absl::MakeUint128(0x3a5b76c209de76f6, 0x1f25e1d63a2b46c5);
-
-  EXPECT_EQ(custom, absl::uint128(intrinsic));
-  EXPECT_EQ(custom, absl::uint128(static_cast<__int128>(intrinsic)));
-  EXPECT_EQ(intrinsic, static_cast<unsigned __int128>(custom));
-  EXPECT_EQ(intrinsic, static_cast<__int128>(custom));
-#endif  // ABSL_HAVE_INTRINSIC_INT128
-
-  // verify that an integer greater than 2**64 that can be stored precisely
-  // inside a double is converted to a absl::uint128 without loss of
-  // information.
-  double precise_double = 0x530e * std::pow(2.0, 64.0) + 0xda74000000000000;
-  absl::uint128 from_precise_double(precise_double);
-  absl::uint128 from_precise_ints =
-      absl::MakeUint128(0x530e, 0xda74000000000000);
-  EXPECT_EQ(from_precise_double, from_precise_ints);
-  EXPECT_DOUBLE_EQ(static_cast<double>(from_precise_ints), precise_double);
-
-  double approx_double = 0xffffeeeeddddcccc * std::pow(2.0, 64.0) +
-                         0xbbbbaaaa99998888;
-  absl::uint128 from_approx_double(approx_double);
-  EXPECT_DOUBLE_EQ(static_cast<double>(from_approx_double), approx_double);
-
-  double round_to_zero = 0.7;
-  double round_to_five = 5.8;
-  double round_to_nine = 9.3;
-  EXPECT_EQ(static_cast<absl::uint128>(round_to_zero), 0);
-  EXPECT_EQ(static_cast<absl::uint128>(round_to_five), 5);
-  EXPECT_EQ(static_cast<absl::uint128>(round_to_nine), 9);
-
-  absl::uint128 highest_precision_in_long_double =
-      ~absl::uint128{} >> (128 - std::numeric_limits<long double>::digits);
-  EXPECT_EQ(highest_precision_in_long_double,
-            static_cast<absl::uint128>(
-                static_cast<long double>(highest_precision_in_long_double)));
-  // Apply a mask just to make sure all the bits are the right place.
-  const absl::uint128 arbitrary_mask =
-      absl::MakeUint128(0xa29f622677ded751, 0xf8ca66add076f468);
-  EXPECT_EQ(highest_precision_in_long_double & arbitrary_mask,
-            static_cast<absl::uint128>(static_cast<long double>(
-                highest_precision_in_long_double & arbitrary_mask)));
-
-  EXPECT_EQ(static_cast<absl::uint128>(-0.1L), 0);
-}
-
-TEST(Uint128, OperatorAssignReturnRef) {
-  absl::uint128 v(1);
-  (v += 4) -= 3;
-  EXPECT_EQ(2, v);
-}
-
-TEST(Uint128, Multiply) {
-  absl::uint128 a, b, c;
-
-  // Zero test.
-  a = 0;
-  b = 0;
-  c = a * b;
-  EXPECT_EQ(0, c);
-
-  // Max carries.
-  a = absl::uint128(0) - 1;
-  b = absl::uint128(0) - 1;
-  c = a * b;
-  EXPECT_EQ(1, c);
-
-  // Self-operation with max carries.
-  c = absl::uint128(0) - 1;
-  c *= c;
-  EXPECT_EQ(1, c);
-
-  // 1-bit x 1-bit.
-  for (int i = 0; i < 64; ++i) {
-    for (int j = 0; j < 64; ++j) {
-      a = absl::uint128(1) << i;
-      b = absl::uint128(1) << j;
-      c = a * b;
-      EXPECT_EQ(absl::uint128(1) << (i + j), c);
-    }
-  }
-
-  // Verified with dc.
-  a = absl::MakeUint128(0xffffeeeeddddcccc, 0xbbbbaaaa99998888);
-  b = absl::MakeUint128(0x7777666655554444, 0x3333222211110000);
-  c = a * b;
-  EXPECT_EQ(absl::MakeUint128(0x530EDA741C71D4C3, 0xBF25975319080000), c);
-  EXPECT_EQ(0, c - b * a);
-  EXPECT_EQ(a*a - b*b, (a+b) * (a-b));
-
-  // Verified with dc.
-  a = absl::MakeUint128(0x0123456789abcdef, 0xfedcba9876543210);
-  b = absl::MakeUint128(0x02468ace13579bdf, 0xfdb97531eca86420);
-  c = a * b;
-  EXPECT_EQ(absl::MakeUint128(0x97a87f4f261ba3f2, 0x342d0bbf48948200), c);
-  EXPECT_EQ(0, c - b * a);
-  EXPECT_EQ(a*a - b*b, (a+b) * (a-b));
-}
-
-TEST(Uint128, AliasTests) {
-  absl::uint128 x1 = absl::MakeUint128(1, 2);
-  absl::uint128 x2 = absl::MakeUint128(2, 4);
-  x1 += x1;
-  EXPECT_EQ(x2, x1);
-
-  absl::uint128 x3 = absl::MakeUint128(1, static_cast<uint64_t>(1) << 63);
-  absl::uint128 x4 = absl::MakeUint128(3, 0);
-  x3 += x3;
-  EXPECT_EQ(x4, x3);
-}
-
-TEST(Uint128, DivideAndMod) {
-  using std::swap;
-
-  // a := q * b + r
-  absl::uint128 a, b, q, r;
-
-  // Zero test.
-  a = 0;
-  b = 123;
-  q = a / b;
-  r = a % b;
-  EXPECT_EQ(0, q);
-  EXPECT_EQ(0, r);
-
-  a = absl::MakeUint128(0x530eda741c71d4c3, 0xbf25975319080000);
-  q = absl::MakeUint128(0x4de2cab081, 0x14c34ab4676e4bab);
-  b = absl::uint128(0x1110001);
-  r = absl::uint128(0x3eb455);
-  ASSERT_EQ(a, q * b + r);  // Sanity-check.
-
-  absl::uint128 result_q, result_r;
-  result_q = a / b;
-  result_r = a % b;
-  EXPECT_EQ(q, result_q);
-  EXPECT_EQ(r, result_r);
-
-  // Try the other way around.
-  swap(q, b);
-  result_q = a / b;
-  result_r = a % b;
-  EXPECT_EQ(q, result_q);
-  EXPECT_EQ(r, result_r);
-  // Restore.
-  swap(b, q);
-
-  // Dividend < divisor; result should be q:0 r:<dividend>.
-  swap(a, b);
-  result_q = a / b;
-  result_r = a % b;
-  EXPECT_EQ(0, result_q);
-  EXPECT_EQ(a, result_r);
-  // Try the other way around.
-  swap(a, q);
-  result_q = a / b;
-  result_r = a % b;
-  EXPECT_EQ(0, result_q);
-  EXPECT_EQ(a, result_r);
-  // Restore.
-  swap(q, a);
-  swap(b, a);
-
-  // Try a large remainder.
-  b = a / 2 + 1;
-  absl::uint128 expected_r =
-      absl::MakeUint128(0x29876d3a0e38ea61, 0xdf92cba98c83ffff);
-  // Sanity checks.
-  ASSERT_EQ(a / 2 - 1, expected_r);
-  ASSERT_EQ(a, b + expected_r);
-  result_q = a / b;
-  result_r = a % b;
-  EXPECT_EQ(1, result_q);
-  EXPECT_EQ(expected_r, result_r);
-}
-
-TEST(Uint128, DivideAndModRandomInputs) {
-  const int kNumIters = 1 << 18;
-  std::minstd_rand random(testing::UnitTest::GetInstance()->random_seed());
-  std::uniform_int_distribution<uint64_t> uniform_uint64;
-  for (int i = 0; i < kNumIters; ++i) {
-    const absl::uint128 a =
-        absl::MakeUint128(uniform_uint64(random), uniform_uint64(random));
-    const absl::uint128 b =
-        absl::MakeUint128(uniform_uint64(random), uniform_uint64(random));
-    if (b == 0) {
-      continue;  // Avoid a div-by-zero.
-    }
-    const absl::uint128 q = a / b;
-    const absl::uint128 r = a % b;
-    ASSERT_EQ(a, b * q + r);
-  }
-}
-
-TEST(Uint128, ConstexprTest) {
-  constexpr absl::uint128 zero = absl::uint128();
-  constexpr absl::uint128 one = 1;
-  constexpr absl::uint128 minus_two = -2;
-  EXPECT_EQ(zero, absl::uint128(0));
-  EXPECT_EQ(one, absl::uint128(1));
-  EXPECT_EQ(minus_two, absl::MakeUint128(-1, -2));
-}
-
-TEST(Uint128, NumericLimitsTest) {
-  static_assert(std::numeric_limits<absl::uint128>::is_specialized, "");
-  static_assert(!std::numeric_limits<absl::uint128>::is_signed, "");
-  static_assert(std::numeric_limits<absl::uint128>::is_integer, "");
-  EXPECT_EQ(static_cast<int>(128 * std::log10(2)),
-            std::numeric_limits<absl::uint128>::digits10);
-  EXPECT_EQ(0, std::numeric_limits<absl::uint128>::min());
-  EXPECT_EQ(0, std::numeric_limits<absl::uint128>::lowest());
-  EXPECT_EQ(absl::Uint128Max(), std::numeric_limits<absl::uint128>::max());
-}
-
-TEST(Uint128, Hash) {
-  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly({
-      // Some simple values
-      absl::uint128{0},
-      absl::uint128{1},
-      ~absl::uint128{},
-      // 64 bit limits
-      absl::uint128{std::numeric_limits<int64_t>::max()},
-      absl::uint128{std::numeric_limits<uint64_t>::max()} + 0,
-      absl::uint128{std::numeric_limits<uint64_t>::max()} + 1,
-      absl::uint128{std::numeric_limits<uint64_t>::max()} + 2,
-      // Keeping high same
-      absl::uint128{1} << 62,
-      absl::uint128{1} << 63,
-      // Keeping low same
-      absl::uint128{1} << 64,
-      absl::uint128{1} << 65,
-      // 128 bit limits
-      std::numeric_limits<absl::uint128>::max(),
-      std::numeric_limits<absl::uint128>::max() - 1,
-      std::numeric_limits<absl::uint128>::min() + 1,
-      std::numeric_limits<absl::uint128>::min(),
-  }));
-}
-
-
-TEST(Int128Uint128, ConversionTest) {
-  absl::int128 nonnegative_signed_values[] = {
-      0,
-      1,
-      0xffeeddccbbaa9988,
-      absl::MakeInt128(0x7766554433221100, 0),
-      absl::MakeInt128(0x1234567890abcdef, 0xfedcba0987654321),
-      absl::Int128Max()};
-  for (absl::int128 value : nonnegative_signed_values) {
-    EXPECT_EQ(value, absl::int128(absl::uint128(value)));
-
-    absl::uint128 assigned_value;
-    assigned_value = value;
-    EXPECT_EQ(value, absl::int128(assigned_value));
-  }
-
-  absl::int128 negative_values[] = {
-      -1, -0x1234567890abcdef,
-      absl::MakeInt128(-0x5544332211ffeedd, 0),
-      -absl::MakeInt128(0x76543210fedcba98, 0xabcdef0123456789)};
-  for (absl::int128 value : negative_values) {
-    EXPECT_EQ(absl::uint128(-value), -absl::uint128(value));
-
-    absl::uint128 assigned_value;
-    assigned_value = value;
-    EXPECT_EQ(absl::uint128(-value), -assigned_value);
-  }
-}
-
-template <typename T>
-class Int128IntegerTraitsTest : public ::testing::Test {};
-
-TYPED_TEST_SUITE(Int128IntegerTraitsTest, IntegerTypes);
-
-TYPED_TEST(Int128IntegerTraitsTest, ConstructAssignTest) {
-  static_assert(std::is_constructible<absl::int128, TypeParam>::value,
-                "absl::int128 must be constructible from TypeParam");
-  static_assert(std::is_assignable<absl::int128&, TypeParam>::value,
-                "absl::int128 must be assignable from TypeParam");
-  static_assert(!std::is_assignable<TypeParam&, absl::int128>::value,
-                "TypeParam must not be assignable from absl::int128");
-}
-
-template <typename T>
-class Int128FloatTraitsTest : public ::testing::Test {};
-
-TYPED_TEST_SUITE(Int128FloatTraitsTest, FloatingPointTypes);
-
-TYPED_TEST(Int128FloatTraitsTest, ConstructAssignTest) {
-  static_assert(std::is_constructible<absl::int128, TypeParam>::value,
-                "absl::int128 must be constructible from TypeParam");
-  static_assert(!std::is_assignable<absl::int128&, TypeParam>::value,
-                "absl::int128 must not be assignable from TypeParam");
-  static_assert(!std::is_assignable<TypeParam&, absl::int128>::value,
-                "TypeParam must not be assignable from absl::int128");
-}
-
-#ifdef ABSL_HAVE_INTRINSIC_INT128
-// These type traits done separately as TYPED_TEST requires typeinfo, and not
-// all platforms have this for __int128 even though they define the type.
-TEST(Int128, IntrinsicTypeTraitsTest) {
-  static_assert(std::is_constructible<absl::int128, __int128>::value,
-                "absl::int128 must be constructible from __int128");
-  static_assert(std::is_assignable<absl::int128&, __int128>::value,
-                "absl::int128 must be assignable from __int128");
-  static_assert(!std::is_assignable<__int128&, absl::int128>::value,
-                "__int128 must not be assignable from absl::int128");
-
-  static_assert(std::is_constructible<absl::int128, unsigned __int128>::value,
-                "absl::int128 must be constructible from unsigned __int128");
-  static_assert(!std::is_assignable<absl::int128&, unsigned __int128>::value,
-                "absl::int128 must be assignable from unsigned __int128");
-  static_assert(!std::is_assignable<unsigned __int128&, absl::int128>::value,
-                "unsigned __int128 must not be assignable from absl::int128");
-}
-#endif  // ABSL_HAVE_INTRINSIC_INT128
-
-TEST(Int128, TrivialTraitsTest) {
-  static_assert(absl::is_trivially_default_constructible<absl::int128>::value,
-                "");
-  static_assert(absl::is_trivially_copy_constructible<absl::int128>::value, "");
-  static_assert(absl::is_trivially_copy_assignable<absl::int128>::value, "");
-  static_assert(std::is_trivially_destructible<absl::int128>::value, "");
-}
-
-TEST(Int128, BoolConversionTest) {
-  EXPECT_FALSE(absl::int128(0));
-  for (int i = 0; i < 64; ++i) {
-    EXPECT_TRUE(absl::MakeInt128(0, uint64_t{1} << i));
-  }
-  for (int i = 0; i < 63; ++i) {
-    EXPECT_TRUE(absl::MakeInt128(int64_t{1} << i, 0));
-  }
-  EXPECT_TRUE(absl::Int128Min());
-
-  EXPECT_EQ(absl::int128(1), absl::int128(true));
-  EXPECT_EQ(absl::int128(0), absl::int128(false));
-}
-
-template <typename T>
-class Int128IntegerConversionTest : public ::testing::Test {};
-
-TYPED_TEST_SUITE(Int128IntegerConversionTest, IntegerTypes);
-
-TYPED_TEST(Int128IntegerConversionTest, RoundTripTest) {
-  EXPECT_EQ(TypeParam{0}, static_cast<TypeParam>(absl::int128(0)));
-  EXPECT_EQ(std::numeric_limits<TypeParam>::min(),
-            static_cast<TypeParam>(
-                absl::int128(std::numeric_limits<TypeParam>::min())));
-  EXPECT_EQ(std::numeric_limits<TypeParam>::max(),
-            static_cast<TypeParam>(
-                absl::int128(std::numeric_limits<TypeParam>::max())));
-}
-
-template <typename T>
-class Int128FloatConversionTest : public ::testing::Test {};
-
-TYPED_TEST_SUITE(Int128FloatConversionTest, FloatingPointTypes);
-
-TYPED_TEST(Int128FloatConversionTest, ConstructAndCastTest) {
-  // Conversions where the floating point values should be exactly the same.
-  // 0x9f5b is a randomly chosen small value.
-  for (int i = 0; i < 110; ++i) {  // 110 = 126 - #bits in 0x9f5b
-    SCOPED_TRACE(::testing::Message() << "i = " << i);
-
-    TypeParam float_value = std::ldexp(static_cast<TypeParam>(0x9f5b), i);
-    absl::int128 int_value = absl::int128(0x9f5b) << i;
-
-    EXPECT_EQ(float_value, static_cast<TypeParam>(int_value));
-    EXPECT_EQ(-float_value, static_cast<TypeParam>(-int_value));
-    EXPECT_EQ(int_value, absl::int128(float_value));
-    EXPECT_EQ(-int_value, absl::int128(-float_value));
-  }
-
-  // Round trip conversions with a small sample of randomly generated uint64_t
-  // values (less than int64_t max so that value * 2^64 fits into int128).
-  uint64_t values[] = {0x6d4492c24fb86199, 0x26ead65e4cb359b5,
-                       0x2c43407433ba3fd1, 0x3b574ec668df6b55,
-                       0x1c750e55a29f4f0f};
-  for (uint64_t value : values) {
-    for (int i = 0; i <= 64; ++i) {
-      SCOPED_TRACE(::testing::Message()
-                   << "value = " << value << "; i = " << i);
-
-      TypeParam fvalue = std::ldexp(static_cast<TypeParam>(value), i);
-      EXPECT_DOUBLE_EQ(fvalue, static_cast<TypeParam>(absl::int128(fvalue)));
-      EXPECT_DOUBLE_EQ(-fvalue, static_cast<TypeParam>(-absl::int128(fvalue)));
-      EXPECT_DOUBLE_EQ(-fvalue, static_cast<TypeParam>(absl::int128(-fvalue)));
-      EXPECT_DOUBLE_EQ(fvalue, static_cast<TypeParam>(-absl::int128(-fvalue)));
-    }
-  }
-
-  // Round trip conversions with a small sample of random large positive values.
-  absl::int128 large_values[] = {
-      absl::MakeInt128(0x5b0640d96c7b3d9f, 0xb7a7189e51d18622),
-      absl::MakeInt128(0x34bed042c6f65270, 0x73b236570669a089),
-      absl::MakeInt128(0x43deba9e6da12724, 0xf7f0f83da686797d),
-      absl::MakeInt128(0x71e8d383be4e5589, 0x75c3f96fb00752b6)};
-  for (absl::int128 value : large_values) {
-    // Make value have as many significant bits as can be represented by
-    // the mantissa, also making sure the highest and lowest bit in the range
-    // are set.
-    value >>= (127 - std::numeric_limits<TypeParam>::digits);
-    value |= absl::int128(1) << (std::numeric_limits<TypeParam>::digits - 1);
-    value |= 1;
-    for (int i = 0; i < 127 - std::numeric_limits<TypeParam>::digits; ++i) {
-      absl::int128 int_value = value << i;
-      EXPECT_EQ(int_value,
-                static_cast<absl::int128>(static_cast<TypeParam>(int_value)));
-      EXPECT_EQ(-int_value,
-                static_cast<absl::int128>(static_cast<TypeParam>(-int_value)));
-    }
-  }
-
-  // Small sample of checks that rounding is toward zero
-  EXPECT_EQ(0, absl::int128(TypeParam(0.1)));
-  EXPECT_EQ(17, absl::int128(TypeParam(17.8)));
-  EXPECT_EQ(0, absl::int128(TypeParam(-0.8)));
-  EXPECT_EQ(-53, absl::int128(TypeParam(-53.1)));
-  EXPECT_EQ(0, absl::int128(TypeParam(0.5)));
-  EXPECT_EQ(0, absl::int128(TypeParam(-0.5)));
-  TypeParam just_lt_one = std::nexttoward(TypeParam(1), TypeParam(0));
-  EXPECT_EQ(0, absl::int128(just_lt_one));
-  TypeParam just_gt_minus_one = std::nexttoward(TypeParam(-1), TypeParam(0));
-  EXPECT_EQ(0, absl::int128(just_gt_minus_one));
-
-  // Check limits
-  EXPECT_DOUBLE_EQ(std::ldexp(static_cast<TypeParam>(1), 127),
-                   static_cast<TypeParam>(absl::Int128Max()));
-  EXPECT_DOUBLE_EQ(-std::ldexp(static_cast<TypeParam>(1), 127),
-                   static_cast<TypeParam>(absl::Int128Min()));
-}
-
-TEST(Int128, FactoryTest) {
-  EXPECT_EQ(absl::int128(-1), absl::MakeInt128(-1, -1));
-  EXPECT_EQ(absl::int128(-31), absl::MakeInt128(-1, -31));
-  EXPECT_EQ(absl::int128(std::numeric_limits<int64_t>::min()),
-            absl::MakeInt128(-1, std::numeric_limits<int64_t>::min()));
-  EXPECT_EQ(absl::int128(0), absl::MakeInt128(0, 0));
-  EXPECT_EQ(absl::int128(1), absl::MakeInt128(0, 1));
-  EXPECT_EQ(absl::int128(std::numeric_limits<int64_t>::max()),
-            absl::MakeInt128(0, std::numeric_limits<int64_t>::max()));
-}
-
-TEST(Int128, HighLowTest) {
-  struct HighLowPair {
-    int64_t high;
-    uint64_t low;
-  };
-  HighLowPair values[]{{0, 0}, {0, 1}, {1, 0}, {123, 456}, {-654, 321}};
-  for (const HighLowPair& pair : values) {
-    absl::int128 value = absl::MakeInt128(pair.high, pair.low);
-    EXPECT_EQ(pair.low, absl::Int128Low64(value));
-    EXPECT_EQ(pair.high, absl::Int128High64(value));
-  }
-}
-
-TEST(Int128, LimitsTest) {
-  EXPECT_EQ(absl::MakeInt128(0x7fffffffffffffff, 0xffffffffffffffff),
-            absl::Int128Max());
-  EXPECT_EQ(absl::Int128Max(), ~absl::Int128Min());
-}
-
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
-TEST(Int128, IntrinsicConversionTest) {
-  __int128 intrinsic =
-      (static_cast<__int128>(0x3a5b76c209de76f6) << 64) + 0x1f25e1d63a2b46c5;
-  absl::int128 custom =
-      absl::MakeInt128(0x3a5b76c209de76f6, 0x1f25e1d63a2b46c5);
-
-  EXPECT_EQ(custom, absl::int128(intrinsic));
-  EXPECT_EQ(intrinsic, static_cast<__int128>(custom));
-}
-#endif  // ABSL_HAVE_INTRINSIC_INT128
-
-TEST(Int128, ConstexprTest) {
-  constexpr absl::int128 zero = absl::int128();
-  constexpr absl::int128 one = 1;
-  constexpr absl::int128 minus_two = -2;
-  constexpr absl::int128 min = absl::Int128Min();
-  constexpr absl::int128 max = absl::Int128Max();
-  EXPECT_EQ(zero, absl::int128(0));
-  EXPECT_EQ(one, absl::int128(1));
-  EXPECT_EQ(minus_two, absl::MakeInt128(-1, -2));
-  EXPECT_GT(max, one);
-  EXPECT_LT(min, minus_two);
-}
-
-TEST(Int128, ComparisonTest) {
-  struct TestCase {
-    absl::int128 smaller;
-    absl::int128 larger;
-  };
-  TestCase cases[] = {
-      {absl::int128(0), absl::int128(123)},
-      {absl::MakeInt128(-12, 34), absl::MakeInt128(12, 34)},
-      {absl::MakeInt128(1, 1000), absl::MakeInt128(1000, 1)},
-      {absl::MakeInt128(-1000, 1000), absl::MakeInt128(-1, 1)},
-  };
-  for (const TestCase& pair : cases) {
-    SCOPED_TRACE(::testing::Message() << "pair.smaller = " << pair.smaller
-                                      << "; pair.larger = " << pair.larger);
-
-    EXPECT_TRUE(pair.smaller == pair.smaller);  // NOLINT(readability/check)
-    EXPECT_TRUE(pair.larger == pair.larger);    // NOLINT(readability/check)
-    EXPECT_FALSE(pair.smaller == pair.larger);  // NOLINT(readability/check)
-
-    EXPECT_TRUE(pair.smaller != pair.larger);    // NOLINT(readability/check)
-    EXPECT_FALSE(pair.smaller != pair.smaller);  // NOLINT(readability/check)
-    EXPECT_FALSE(pair.larger != pair.larger);    // NOLINT(readability/check)
-
-    EXPECT_TRUE(pair.smaller < pair.larger);   // NOLINT(readability/check)
-    EXPECT_FALSE(pair.larger < pair.smaller);  // NOLINT(readability/check)
-
-    EXPECT_TRUE(pair.larger > pair.smaller);   // NOLINT(readability/check)
-    EXPECT_FALSE(pair.smaller > pair.larger);  // NOLINT(readability/check)
-
-    EXPECT_TRUE(pair.smaller <= pair.larger);   // NOLINT(readability/check)
-    EXPECT_FALSE(pair.larger <= pair.smaller);  // NOLINT(readability/check)
-    EXPECT_TRUE(pair.smaller <= pair.smaller);  // NOLINT(readability/check)
-    EXPECT_TRUE(pair.larger <= pair.larger);    // NOLINT(readability/check)
-
-    EXPECT_TRUE(pair.larger >= pair.smaller);   // NOLINT(readability/check)
-    EXPECT_FALSE(pair.smaller >= pair.larger);  // NOLINT(readability/check)
-    EXPECT_TRUE(pair.smaller >= pair.smaller);  // NOLINT(readability/check)
-    EXPECT_TRUE(pair.larger >= pair.larger);    // NOLINT(readability/check)
-  }
-}
-
-TEST(Int128, UnaryNegationTest) {
-  int64_t values64[] = {0, 1, 12345, 0x4000000000000000,
-                        std::numeric_limits<int64_t>::max()};
-  for (int64_t value : values64) {
-    SCOPED_TRACE(::testing::Message() << "value = " << value);
-
-    EXPECT_EQ(absl::int128(-value), -absl::int128(value));
-    EXPECT_EQ(absl::int128(value), -absl::int128(-value));
-    EXPECT_EQ(absl::MakeInt128(-value, 0), -absl::MakeInt128(value, 0));
-    EXPECT_EQ(absl::MakeInt128(value, 0), -absl::MakeInt128(-value, 0));
-  }
-}
-
-TEST(Int128, LogicalNotTest) {
-  EXPECT_TRUE(!absl::int128(0));
-  for (int i = 0; i < 64; ++i) {
-    EXPECT_FALSE(!absl::MakeInt128(0, uint64_t{1} << i));
-  }
-  for (int i = 0; i < 63; ++i) {
-    EXPECT_FALSE(!absl::MakeInt128(int64_t{1} << i, 0));
-  }
-}
-
-TEST(Int128, AdditionSubtractionTest) {
-  // 64 bit pairs that will not cause overflow / underflow. These test negative
-  // carry; positive carry must be checked separately.
-  std::pair<int64_t, int64_t> cases[]{
-      {0, 0},                              // 0, 0
-      {0, 2945781290834},                  // 0, +
-      {1908357619234, 0},                  // +, 0
-      {0, -1204895918245},                 // 0, -
-      {-2957928523560, 0},                 // -, 0
-      {89023982312461, 98346012567134},    // +, +
-      {-63454234568239, -23456235230773},  // -, -
-      {98263457263502, -21428561935925},   // +, -
-      {-88235237438467, 15923659234573},   // -, +
-  };
-  for (const auto& pair : cases) {
-    SCOPED_TRACE(::testing::Message()
-                 << "pair = {" << pair.first << ", " << pair.second << '}');
-
-    EXPECT_EQ(absl::int128(pair.first + pair.second),
-              absl::int128(pair.first) + absl::int128(pair.second));
-    EXPECT_EQ(absl::int128(pair.second + pair.first),
-              absl::int128(pair.second) += absl::int128(pair.first));
-
-    EXPECT_EQ(absl::int128(pair.first - pair.second),
-              absl::int128(pair.first) - absl::int128(pair.second));
-    EXPECT_EQ(absl::int128(pair.second - pair.first),
-              absl::int128(pair.second) -= absl::int128(pair.first));
-
-    EXPECT_EQ(
-        absl::MakeInt128(pair.second + pair.first, 0),
-        absl::MakeInt128(pair.second, 0) + absl::MakeInt128(pair.first, 0));
-    EXPECT_EQ(
-        absl::MakeInt128(pair.first + pair.second, 0),
-        absl::MakeInt128(pair.first, 0) += absl::MakeInt128(pair.second, 0));
-
-    EXPECT_EQ(
-        absl::MakeInt128(pair.second - pair.first, 0),
-        absl::MakeInt128(pair.second, 0) - absl::MakeInt128(pair.first, 0));
-    EXPECT_EQ(
-        absl::MakeInt128(pair.first - pair.second, 0),
-        absl::MakeInt128(pair.first, 0) -= absl::MakeInt128(pair.second, 0));
-  }
-
-  // check positive carry
-  EXPECT_EQ(absl::MakeInt128(31, 0),
-            absl::MakeInt128(20, 1) +
-                absl::MakeInt128(10, std::numeric_limits<uint64_t>::max()));
-}
-
-TEST(Int128, IncrementDecrementTest) {
-  absl::int128 value = 0;
-  EXPECT_EQ(0, value++);
-  EXPECT_EQ(1, value);
-  EXPECT_EQ(1, value--);
-  EXPECT_EQ(0, value);
-  EXPECT_EQ(-1, --value);
-  EXPECT_EQ(-1, value);
-  EXPECT_EQ(0, ++value);
-  EXPECT_EQ(0, value);
-}
-
-TEST(Int128, MultiplicationTest) {
-  // 1 bit x 1 bit, and negative combinations
-  for (int i = 0; i < 64; ++i) {
-    for (int j = 0; j < 127 - i; ++j) {
-      SCOPED_TRACE(::testing::Message() << "i = " << i << "; j = " << j);
-      absl::int128 a = absl::int128(1) << i;
-      absl::int128 b = absl::int128(1) << j;
-      absl::int128 c = absl::int128(1) << (i + j);
-
-      EXPECT_EQ(c, a * b);
-      EXPECT_EQ(-c, -a * b);
-      EXPECT_EQ(-c, a * -b);
-      EXPECT_EQ(c, -a * -b);
-
-      EXPECT_EQ(c, absl::int128(a) *= b);
-      EXPECT_EQ(-c, absl::int128(-a) *= b);
-      EXPECT_EQ(-c, absl::int128(a) *= -b);
-      EXPECT_EQ(c, absl::int128(-a) *= -b);
-    }
-  }
-
-  // Pairs of random values that will not overflow signed 64-bit multiplication
-  std::pair<int64_t, int64_t> small_values[] = {
-      {0x5e61, 0xf29f79ca14b4},    // +, +
-      {0x3e033b, -0x612c0ee549},   // +, -
-      {-0x052ce7e8, 0x7c728f0f},   // -, +
-      {-0x3af7054626, -0xfb1e1d},  // -, -
-  };
-  for (const std::pair<int64_t, int64_t>& pair : small_values) {
-    SCOPED_TRACE(::testing::Message()
-                 << "pair = {" << pair.first << ", " << pair.second << '}');
-
-    EXPECT_EQ(absl::int128(pair.first * pair.second),
-              absl::int128(pair.first) * absl::int128(pair.second));
-    EXPECT_EQ(absl::int128(pair.first * pair.second),
-              absl::int128(pair.first) *= absl::int128(pair.second));
-
-    EXPECT_EQ(absl::MakeInt128(pair.first * pair.second, 0),
-              absl::MakeInt128(pair.first, 0) * absl::int128(pair.second));
-    EXPECT_EQ(absl::MakeInt128(pair.first * pair.second, 0),
-              absl::MakeInt128(pair.first, 0) *= absl::int128(pair.second));
-  }
-
-  // Pairs of positive random values that will not overflow 64-bit
-  // multiplication and can be left shifted by 32 without overflow
-  std::pair<int64_t, int64_t> small_values2[] = {
-      {0x1bb0a110, 0x31487671},
-      {0x4792784e, 0x28add7d7},
-      {0x7b66553a, 0x11dff8ef},
-  };
-  for (const std::pair<int64_t, int64_t>& pair : small_values2) {
-    SCOPED_TRACE(::testing::Message()
-                 << "pair = {" << pair.first << ", " << pair.second << '}');
-
-    absl::int128 a = absl::int128(pair.first << 32);
-    absl::int128 b = absl::int128(pair.second << 32);
-    absl::int128 c = absl::MakeInt128(pair.first * pair.second, 0);
-
-    EXPECT_EQ(c, a * b);
-    EXPECT_EQ(-c, -a * b);
-    EXPECT_EQ(-c, a * -b);
-    EXPECT_EQ(c, -a * -b);
-
-    EXPECT_EQ(c, absl::int128(a) *= b);
-    EXPECT_EQ(-c, absl::int128(-a) *= b);
-    EXPECT_EQ(-c, absl::int128(a) *= -b);
-    EXPECT_EQ(c, absl::int128(-a) *= -b);
-  }
-
-  // check 0, 1, and -1 behavior with large values
-  absl::int128 large_values[] = {
-      {absl::MakeInt128(0xd66f061af02d0408, 0x727d2846cb475b53)},
-      {absl::MakeInt128(0x27b8d5ed6104452d, 0x03f8a33b0ee1df4f)},
-      {-absl::MakeInt128(0x621b6626b9e8d042, 0x27311ac99df00938)},
-      {-absl::MakeInt128(0x34e0656f1e95fb60, 0x4281cfd731257a47)},
-  };
-  for (absl::int128 value : large_values) {
-    EXPECT_EQ(0, 0 * value);
-    EXPECT_EQ(0, value * 0);
-    EXPECT_EQ(0, absl::int128(0) *= value);
-    EXPECT_EQ(0, value *= 0);
-
-    EXPECT_EQ(value, 1 * value);
-    EXPECT_EQ(value, value * 1);
-    EXPECT_EQ(value, absl::int128(1) *= value);
-    EXPECT_EQ(value, value *= 1);
-
-    EXPECT_EQ(-value, -1 * value);
-    EXPECT_EQ(-value, value * -1);
-    EXPECT_EQ(-value, absl::int128(-1) *= value);
-    EXPECT_EQ(-value, value *= -1);
-  }
-
-  // Manually calculated random large value cases
-  EXPECT_EQ(absl::MakeInt128(0xcd0efd3442219bb, 0xde47c05bcd9df6e1),
-            absl::MakeInt128(0x7c6448, 0x3bc4285c47a9d253) * 0x1a6037537b);
-  EXPECT_EQ(-absl::MakeInt128(0x1f8f149850b1e5e6, 0x1e50d6b52d272c3e),
-            -absl::MakeInt128(0x23, 0x2e68a513ca1b8859) * 0xe5a434cd14866e);
-  EXPECT_EQ(-absl::MakeInt128(0x55cae732029d1fce, 0xca6474b6423263e4),
-            0xa9b98a8ddf66bc * -absl::MakeInt128(0x81, 0x672e58231e2469d7));
-  EXPECT_EQ(absl::MakeInt128(0x19c8b7620b507dc4, 0xfec042b71a5f29a4),
-            -0x3e39341147 * -absl::MakeInt128(0x6a14b2, 0x5ed34cca42327b3c));
-
-  EXPECT_EQ(absl::MakeInt128(0xcd0efd3442219bb, 0xde47c05bcd9df6e1),
-            absl::MakeInt128(0x7c6448, 0x3bc4285c47a9d253) *= 0x1a6037537b);
-  EXPECT_EQ(-absl::MakeInt128(0x1f8f149850b1e5e6, 0x1e50d6b52d272c3e),
-            -absl::MakeInt128(0x23, 0x2e68a513ca1b8859) *= 0xe5a434cd14866e);
-  EXPECT_EQ(-absl::MakeInt128(0x55cae732029d1fce, 0xca6474b6423263e4),
-            absl::int128(0xa9b98a8ddf66bc) *=
-            -absl::MakeInt128(0x81, 0x672e58231e2469d7));
-  EXPECT_EQ(absl::MakeInt128(0x19c8b7620b507dc4, 0xfec042b71a5f29a4),
-            absl::int128(-0x3e39341147) *=
-            -absl::MakeInt128(0x6a14b2, 0x5ed34cca42327b3c));
-}
-
-TEST(Int128, DivisionAndModuloTest) {
-  // Check against 64 bit division and modulo operators with a sample of
-  // randomly generated pairs.
-  std::pair<int64_t, int64_t> small_pairs[] = {
-      {0x15f2a64138, 0x67da05},    {0x5e56d194af43045f, 0xcf1543fb99},
-      {0x15e61ed052036a, -0xc8e6}, {0x88125a341e85, -0xd23fb77683},
-      {-0xc06e20, 0x5a},           {-0x4f100219aea3e85d, 0xdcc56cb4efe993},
-      {-0x168d629105, -0xa7},      {-0x7b44e92f03ab2375, -0x6516},
-  };
-  for (const std::pair<int64_t, int64_t>& pair : small_pairs) {
-    SCOPED_TRACE(::testing::Message()
-                 << "pair = {" << pair.first << ", " << pair.second << '}');
-
-    absl::int128 dividend = pair.first;
-    absl::int128 divisor = pair.second;
-    int64_t quotient = pair.first / pair.second;
-    int64_t remainder = pair.first % pair.second;
-
-    EXPECT_EQ(quotient, dividend / divisor);
-    EXPECT_EQ(quotient, absl::int128(dividend) /= divisor);
-    EXPECT_EQ(remainder, dividend % divisor);
-    EXPECT_EQ(remainder, absl::int128(dividend) %= divisor);
-  }
-
-  // Test behavior with 0, 1, and -1 with a sample of randomly generated large
-  // values.
-  absl::int128 values[] = {
-      absl::MakeInt128(0x63d26ee688a962b2, 0x9e1411abda5c1d70),
-      absl::MakeInt128(0x152f385159d6f986, 0xbf8d48ef63da395d),
-      -absl::MakeInt128(0x3098d7567030038c, 0x14e7a8a098dc2164),
-      -absl::MakeInt128(0x49a037aca35c809f, 0xa6a87525480ef330),
-  };
-  for (absl::int128 value : values) {
-    SCOPED_TRACE(::testing::Message() << "value = " << value);
-
-    EXPECT_EQ(0, 0 / value);
-    EXPECT_EQ(0, absl::int128(0) /= value);
-    EXPECT_EQ(0, 0 % value);
-    EXPECT_EQ(0, absl::int128(0) %= value);
-
-    EXPECT_EQ(value, value / 1);
-    EXPECT_EQ(value, absl::int128(value) /= 1);
-    EXPECT_EQ(0, value % 1);
-    EXPECT_EQ(0, absl::int128(value) %= 1);
-
-    EXPECT_EQ(-value, value / -1);
-    EXPECT_EQ(-value, absl::int128(value) /= -1);
-    EXPECT_EQ(0, value % -1);
-    EXPECT_EQ(0, absl::int128(value) %= -1);
-  }
-
-  // Min and max values
-  EXPECT_EQ(0, absl::Int128Max() / absl::Int128Min());
-  EXPECT_EQ(absl::Int128Max(), absl::Int128Max() % absl::Int128Min());
-  EXPECT_EQ(-1, absl::Int128Min() / absl::Int128Max());
-  EXPECT_EQ(-1, absl::Int128Min() % absl::Int128Max());
-
-  // Power of two division and modulo of random large dividends
-  absl::int128 positive_values[] = {
-      absl::MakeInt128(0x21e1a1cc69574620, 0xe7ac447fab2fc869),
-      absl::MakeInt128(0x32c2ff3ab89e66e8, 0x03379a613fd1ce74),
-      absl::MakeInt128(0x6f32ca786184dcaf, 0x046f9c9ecb3a9ce1),
-      absl::MakeInt128(0x1aeb469dd990e0ee, 0xda2740f243cd37eb),
-  };
-  for (absl::int128 value : positive_values) {
-    for (int i = 0; i < 127; ++i) {
-      SCOPED_TRACE(::testing::Message()
-                   << "value = " << value << "; i = " << i);
-      absl::int128 power_of_two = absl::int128(1) << i;
-
-      EXPECT_EQ(value >> i, value / power_of_two);
-      EXPECT_EQ(value >> i, absl::int128(value) /= power_of_two);
-      EXPECT_EQ(value & (power_of_two - 1), value % power_of_two);
-      EXPECT_EQ(value & (power_of_two - 1),
-                absl::int128(value) %= power_of_two);
-    }
-  }
-
-  // Manually calculated cases with random large dividends
-  struct DivisionModCase {
-    absl::int128 dividend;
-    absl::int128 divisor;
-    absl::int128 quotient;
-    absl::int128 remainder;
-  };
-  DivisionModCase manual_cases[] = {
-      {absl::MakeInt128(0x6ada48d489007966, 0x3c9c5c98150d5d69),
-       absl::MakeInt128(0x8bc308fb, 0x8cb9cc9a3b803344), 0xc3b87e08,
-       absl::MakeInt128(0x1b7db5e1, 0xd9eca34b7af04b49)},
-      {absl::MakeInt128(0xd6946511b5b, 0x4886c5c96546bf5f),
-       -absl::MakeInt128(0x263b, 0xfd516279efcfe2dc), -0x59cbabf0,
-       absl::MakeInt128(0x622, 0xf462909155651d1f)},
-      {-absl::MakeInt128(0x33db734f9e8d1399, 0x8447ac92482bca4d), 0x37495078240,
-       -absl::MakeInt128(0xf01f1, 0xbc0368bf9a77eae8), -0x21a508f404d},
-      {-absl::MakeInt128(0x13f837b409a07e7d, 0x7fc8e248a7d73560), -0x1b9f,
-       absl::MakeInt128(0xb9157556d724, 0xb14f635714d7563e), -0x1ade},
-  };
-  for (const DivisionModCase test_case : manual_cases) {
-    EXPECT_EQ(test_case.quotient, test_case.dividend / test_case.divisor);
-    EXPECT_EQ(test_case.quotient,
-              absl::int128(test_case.dividend) /= test_case.divisor);
-    EXPECT_EQ(test_case.remainder, test_case.dividend % test_case.divisor);
-    EXPECT_EQ(test_case.remainder,
-              absl::int128(test_case.dividend) %= test_case.divisor);
-  }
-}
-
-TEST(Int128, BitwiseLogicTest) {
-  EXPECT_EQ(absl::int128(-1), ~absl::int128(0));
-
-  absl::int128 values[]{
-      0, -1, 0xde400bee05c3ff6b, absl::MakeInt128(0x7f32178dd81d634a, 0),
-      absl::MakeInt128(0xaf539057055613a9, 0x7d104d7d946c2e4d)};
-  for (absl::int128 value : values) {
-    EXPECT_EQ(value, ~~value);
-
-    EXPECT_EQ(value, value | value);
-    EXPECT_EQ(value, value & value);
-    EXPECT_EQ(0, value ^ value);
-
-    EXPECT_EQ(value, absl::int128(value) |= value);
-    EXPECT_EQ(value, absl::int128(value) &= value);
-    EXPECT_EQ(0, absl::int128(value) ^= value);
-
-    EXPECT_EQ(value, value | 0);
-    EXPECT_EQ(0, value & 0);
-    EXPECT_EQ(value, value ^ 0);
-
-    EXPECT_EQ(absl::int128(-1), value | absl::int128(-1));
-    EXPECT_EQ(value, value & absl::int128(-1));
-    EXPECT_EQ(~value, value ^ absl::int128(-1));
-  }
-
-  // small sample of randomly generated int64_t's
-  std::pair<int64_t, int64_t> pairs64[]{
-      {0x7f86797f5e991af4, 0x1ee30494fb007c97},
-      {0x0b278282bacf01af, 0x58780e0a57a49e86},
-      {0x059f266ccb93a666, 0x3d5b731bae9286f5},
-      {0x63c0c4820f12108c, 0x58166713c12e1c3a},
-      {0x381488bb2ed2a66e, 0x2220a3eb76a3698c},
-      {0x2a0a0dfb81e06f21, 0x4b60585927f5523c},
-      {0x555b1c3a03698537, 0x25478cd19d8e53cb},
-      {0x4750f6f27d779225, 0x16397553c6ff05fc},
-  };
-  for (const std::pair<int64_t, int64_t>& pair : pairs64) {
-    SCOPED_TRACE(::testing::Message()
-                 << "pair = {" << pair.first << ", " << pair.second << '}');
-
-    EXPECT_EQ(absl::MakeInt128(~pair.first, ~pair.second),
-              ~absl::MakeInt128(pair.first, pair.second));
-
-    EXPECT_EQ(absl::int128(pair.first & pair.second),
-              absl::int128(pair.first) & absl::int128(pair.second));
-    EXPECT_EQ(absl::int128(pair.first | pair.second),
-              absl::int128(pair.first) | absl::int128(pair.second));
-    EXPECT_EQ(absl::int128(pair.first ^ pair.second),
-              absl::int128(pair.first) ^ absl::int128(pair.second));
-
-    EXPECT_EQ(absl::int128(pair.first & pair.second),
-              absl::int128(pair.first) &= absl::int128(pair.second));
-    EXPECT_EQ(absl::int128(pair.first | pair.second),
-              absl::int128(pair.first) |= absl::int128(pair.second));
-    EXPECT_EQ(absl::int128(pair.first ^ pair.second),
-              absl::int128(pair.first) ^= absl::int128(pair.second));
-
-    EXPECT_EQ(
-        absl::MakeInt128(pair.first & pair.second, 0),
-        absl::MakeInt128(pair.first, 0) & absl::MakeInt128(pair.second, 0));
-    EXPECT_EQ(
-        absl::MakeInt128(pair.first | pair.second, 0),
-        absl::MakeInt128(pair.first, 0) | absl::MakeInt128(pair.second, 0));
-    EXPECT_EQ(
-        absl::MakeInt128(pair.first ^ pair.second, 0),
-        absl::MakeInt128(pair.first, 0) ^ absl::MakeInt128(pair.second, 0));
-
-    EXPECT_EQ(
-        absl::MakeInt128(pair.first & pair.second, 0),
-        absl::MakeInt128(pair.first, 0) &= absl::MakeInt128(pair.second, 0));
-    EXPECT_EQ(
-        absl::MakeInt128(pair.first | pair.second, 0),
-        absl::MakeInt128(pair.first, 0) |= absl::MakeInt128(pair.second, 0));
-    EXPECT_EQ(
-        absl::MakeInt128(pair.first ^ pair.second, 0),
-        absl::MakeInt128(pair.first, 0) ^= absl::MakeInt128(pair.second, 0));
-  }
-}
-
-TEST(Int128, BitwiseShiftTest) {
-  for (int i = 0; i < 64; ++i) {
-    for (int j = 0; j <= i; ++j) {
-      // Left shift from j-th bit to i-th bit.
-      SCOPED_TRACE(::testing::Message() << "i = " << i << "; j = " << j);
-      EXPECT_EQ(uint64_t{1} << i, absl::int128(uint64_t{1} << j) << (i - j));
-      EXPECT_EQ(uint64_t{1} << i, absl::int128(uint64_t{1} << j) <<= (i - j));
-    }
-  }
-  for (int i = 0; i < 63; ++i) {
-    for (int j = 0; j < 64; ++j) {
-      // Left shift from j-th bit to (i + 64)-th bit.
-      SCOPED_TRACE(::testing::Message() << "i = " << i << "; j = " << j);
-      EXPECT_EQ(absl::MakeInt128(uint64_t{1} << i, 0),
-                absl::int128(uint64_t{1} << j) << (i + 64 - j));
-      EXPECT_EQ(absl::MakeInt128(uint64_t{1} << i, 0),
-                absl::int128(uint64_t{1} << j) <<= (i + 64 - j));
-    }
-    for (int j = 0; j <= i; ++j) {
-      // Left shift from (j + 64)-th bit to (i + 64)-th bit.
-      SCOPED_TRACE(::testing::Message() << "i = " << i << "; j = " << j);
-      EXPECT_EQ(absl::MakeInt128(uint64_t{1} << i, 0),
-                absl::MakeInt128(uint64_t{1} << j, 0) << (i - j));
-      EXPECT_EQ(absl::MakeInt128(uint64_t{1} << i, 0),
-                absl::MakeInt128(uint64_t{1} << j, 0) <<= (i - j));
-    }
-  }
-
-  for (int i = 0; i < 64; ++i) {
-    for (int j = i; j < 64; ++j) {
-      // Right shift from j-th bit to i-th bit.
-      SCOPED_TRACE(::testing::Message() << "i = " << i << "; j = " << j);
-      EXPECT_EQ(uint64_t{1} << i, absl::int128(uint64_t{1} << j) >> (j - i));
-      EXPECT_EQ(uint64_t{1} << i, absl::int128(uint64_t{1} << j) >>= (j - i));
-    }
-    for (int j = 0; j < 63; ++j) {
-      // Right shift from (j + 64)-th bit to i-th bit.
-      SCOPED_TRACE(::testing::Message() << "i = " << i << "; j = " << j);
-      EXPECT_EQ(uint64_t{1} << i,
-                absl::MakeInt128(uint64_t{1} << j, 0) >> (j + 64 - i));
-      EXPECT_EQ(uint64_t{1} << i,
-                absl::MakeInt128(uint64_t{1} << j, 0) >>= (j + 64 - i));
-    }
-  }
-  for (int i = 0; i < 63; ++i) {
-    for (int j = i; j < 63; ++j) {
-      // Right shift from (j + 64)-th bit to (i + 64)-th bit.
-      SCOPED_TRACE(::testing::Message() << "i = " << i << "; j = " << j);
-      EXPECT_EQ(absl::MakeInt128(uint64_t{1} << i, 0),
-                absl::MakeInt128(uint64_t{1} << j, 0) >> (j - i));
-      EXPECT_EQ(absl::MakeInt128(uint64_t{1} << i, 0),
-                absl::MakeInt128(uint64_t{1} << j, 0) >>= (j - i));
-    }
-  }
-}
-
-TEST(Int128, NumericLimitsTest) {
-  static_assert(std::numeric_limits<absl::int128>::is_specialized, "");
-  static_assert(std::numeric_limits<absl::int128>::is_signed, "");
-  static_assert(std::numeric_limits<absl::int128>::is_integer, "");
-  EXPECT_EQ(static_cast<int>(127 * std::log10(2)),
-            std::numeric_limits<absl::int128>::digits10);
-  EXPECT_EQ(absl::Int128Min(), std::numeric_limits<absl::int128>::min());
-  EXPECT_EQ(absl::Int128Min(), std::numeric_limits<absl::int128>::lowest());
-  EXPECT_EQ(absl::Int128Max(), std::numeric_limits<absl::int128>::max());
-}
-
-}  // namespace