Roll chromium_revision e1ef7d4b6b..b47e7752c6 (568794:569173)

Change log: https://chromium.googlesource.com/chromium/src/+log/e1ef7d4b6b..b47e7752c6
Full diff: https://chromium.googlesource.com/chromium/src/+/e1ef7d4b6b..b47e7752c6

Roll chromium third_party ab9fbe29c9..630af48a96
Change log: https://chromium.googlesource.com/chromium/src/third_party/+log/ab9fbe29c9..630af48a96

Changed dependencies:
* src/base: https://chromium.googlesource.com/chromium/src/base/+log/03e1bc561f..6070b24b9f
* src/build: https://chromium.googlesource.com/chromium/src/build/+log/bb306be407..511e258eee
* src/ios: https://chromium.googlesource.com/chromium/src/ios/+log/48697bf3a1..ce1db7deb1
* src/testing: https://chromium.googlesource.com/chromium/src/testing/+log/6440c4ea3a..80a4cfaab7
* src/third_party/catapult: https://chromium.googlesource.com/catapult.git/+log/f153b902be..f3c454475a
* src/third_party/depot_tools: https://chromium.googlesource.com/chromium/tools/depot_tools.git/+log/1cabdc4643..a28b14f122
* src/tools: https://chromium.googlesource.com/chromium/src/tools/+log/66f1089d0c..f6bb2a6fb4
DEPS diff: https://chromium.googlesource.com/chromium/src/+/e1ef7d4b6b..b47e7752c6/DEPS

No update to Clang.

TBR=buildbot@webrtc.org,
BUG=None
CQ_INCLUDE_TRYBOTS=master.internal.tryserver.corp.webrtc:linux_internal
NO_AUTOIMPORT_DEPS_CHECK=true

Change-Id: I7553549111225f2c5bc769dec114cd058ae699d5
Reviewed-on: https://webrtc-review.googlesource.com/84600
Reviewed-by: WebRTC Buildbot <buildbot@webrtc.org>
Commit-Queue: WebRTC Buildbot <buildbot@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23692}

48 files changed, 4823 insertions, 458 deletions

diff --git a/third_party/abseil-cpp/README.chromium b/third_party/abseil-cpp/README.chromium
index 1de41c34d0..03bd420d55 100644
--- a/third_party/abseil-cpp/README.chromium
+++ b/third_party/abseil-cpp/README.chromium
@@ -4,7 +4,7 @@ URL: https://github.com/abseil/abseil-cpp
 License: Apache 2.0
 License File: LICENSE
 Version: 0
-Revision: e5be80532b5d998813f9db952d2cc5401b1532df
+Revision: bd40a41cc142b36c73b881099d08a9d83f7f4780
 Security Critical: yes
 
 Description:
diff --git a/third_party/abseil-cpp/WORKSPACE b/third_party/abseil-cpp/WORKSPACE
index 9c95065087..89a80bbf42 100644
--- a/third_party/abseil-cpp/WORKSPACE
+++ b/third_party/abseil-cpp/WORKSPACE
@@ -1,13 +1,13 @@
 workspace(name = "com_google_absl")
 # Bazel toolchains
 http_archive(
-    name = "bazel_toolchains",
-    urls = [
-        "https://mirror.bazel.build/github.com/bazelbuild/bazel-toolchains/archive/f8847f64e6950e8ab9fde1c0aba768550b0d9ab2.tar.gz",
-        "https://github.com/bazelbuild/bazel-toolchains/archive/f8847f64e6950e8ab9fde1c0aba768550b0d9ab2.tar.gz",
-    ],
-    strip_prefix = "bazel-toolchains-f8847f64e6950e8ab9fde1c0aba768550b0d9ab2",
-    sha256 = "794366f51fea224b3656a0b0f8f1518e739748646523a572fcd3d68614a0e670",
+  name = "bazel_toolchains",
+  urls = [
+    "https://mirror.bazel.build/github.com/bazelbuild/bazel-toolchains/archive/2cec6c9f6d12224e93d9b3f337b24e41602de3ba.tar.gz",
+    "https://github.com/bazelbuild/bazel-toolchains/archive/2cec6c9f6d12224e93d9b3f337b24e41602de3ba.tar.gz",
+  ],
+  strip_prefix = "bazel-toolchains-2cec6c9f6d12224e93d9b3f337b24e41602de3ba",
+  sha256 = "9b8d85b61d8945422e86ac31e4d4d2d967542c080d1da1b45364da7fd6bdd638",
 )
 
 # GoogleTest/GoogleMock framework. Used by most unit-tests.
@@ -15,6 +15,7 @@ http_archive(
      name = "com_google_googletest",
      urls = ["https://github.com/google/googletest/archive/4e4df226fc197c0dda6e37f5c8c3845ca1e73a49.zip"],
      strip_prefix = "googletest-4e4df226fc197c0dda6e37f5c8c3845ca1e73a49",
+     sha256 = "d4179caf54410968d1fff0b869e7d74803dd30209ee6645ccf1ca65ab6cf5e5a",
 )
 
 # Google benchmark.
@@ -22,6 +23,7 @@ http_archive(
     name = "com_github_google_benchmark",
     urls = ["https://github.com/google/benchmark/archive/16703ff83c1ae6d53e5155df3bb3ab0bc96083be.zip"],
     strip_prefix = "benchmark-16703ff83c1ae6d53e5155df3bb3ab0bc96083be",
+    sha256 = "59f918c8ccd4d74b6ac43484467b500f1d64b40cc1010daa055375b322a43ba3",
 )
 
 # RE2 regular-expression framework. Used by some unit-tests.
@@ -29,4 +31,5 @@ http_archive(
     name = "com_googlesource_code_re2",
     urls = ["https://github.com/google/re2/archive/6cf8ccd82dbaab2668e9b13596c68183c9ecd13f.zip"],
     strip_prefix = "re2-6cf8ccd82dbaab2668e9b13596c68183c9ecd13f",
+    sha256 = "279a852219dbfc504501775596089d30e9c0b29664ce4128b0ac4c841471a16a",
 )
diff --git a/third_party/abseil-cpp/absl/LTS.md b/third_party/abseil-cpp/absl/LTS.md
new file mode 100644
index 0000000000..f7be0997c4
--- /dev/null
+++ b/third_party/abseil-cpp/absl/LTS.md
@@ -0,0 +1,13 @@
+# Long Term Support (LTS) Branches
+
+This repository contains periodic snapshots of the Abseil codebase that are
+Long Term Support (LTS) branches. An LTS branch allows you to use a known
+version of Abseil without interfering with other projects which may also, in
+turn, use Abseil. (For more information about our releases, see the
+[Abseil Release Management](https://abseil.io/about/releases) guide.
+
+## LTS Branches
+
+The following lists LTS branches and the date they have been released:
+
+* [LTS Branch June 18, 2018](https://github.com/abseil/abseil-cpp/tree/lts_2018_06_18/)
diff --git a/third_party/abseil-cpp/absl/base/BUILD.bazel b/third_party/abseil-cpp/absl/base/BUILD.bazel
index 1e93d97ebd..d117a4fea8 100644
--- a/third_party/abseil-cpp/absl/base/BUILD.bazel
+++ b/third_party/abseil-cpp/absl/base/BUILD.bazel
@@ -371,11 +371,6 @@ cc_test(
     size = "small",
     srcs = ["internal/sysinfo_test.cc"],
     copts = ABSL_TEST_COPTS,
-    tags = [
-        "no_test_android_arm",
-        "no_test_android_arm64",
-        "no_test_android_x86",
-    ],
     deps = [
         ":base",
         "//absl/synchronization",
diff --git a/third_party/abseil-cpp/absl/base/internal/identity.h b/third_party/abseil-cpp/absl/base/internal/identity.h
index a6734b4d35..a1a5d70a84 100644
--- a/third_party/abseil-cpp/absl/base/internal/identity.h
+++ b/third_party/abseil-cpp/absl/base/internal/identity.h
@@ -27,7 +27,7 @@ struct identity {
 template <typename T>
 using identity_t = typename identity<T>::type;
 
-}  //  namespace internal
-}  //  namespace absl
+}  // namespace internal
+}  // namespace absl
 
 #endif  // ABSL_BASE_INTERNAL_IDENTITY_H_
diff --git a/third_party/abseil-cpp/absl/base/internal/spinlock_wait.h b/third_party/abseil-cpp/absl/base/internal/spinlock_wait.h
index 5f658211cc..5c6cc7fdba 100644
--- a/third_party/abseil-cpp/absl/base/internal/spinlock_wait.h
+++ b/third_party/abseil-cpp/absl/base/internal/spinlock_wait.h
@@ -84,7 +84,7 @@ inline void absl::base_internal::SpinLockWake(std::atomic<uint32_t> *w,
 
 inline void absl::base_internal::SpinLockDelay(
     std::atomic<uint32_t> *w, uint32_t value, int loop,
-    base_internal::SchedulingMode scheduling_mode) {
+    absl::base_internal::SchedulingMode scheduling_mode) {
   AbslInternalSpinLockDelay(w, value, loop, scheduling_mode);
 }
 
diff --git a/third_party/abseil-cpp/absl/base/macros.h b/third_party/abseil-cpp/absl/base/macros.h
index afa30300bc..ca3d5edb65 100644
--- a/third_party/abseil-cpp/absl/base/macros.h
+++ b/third_party/abseil-cpp/absl/base/macros.h
@@ -194,8 +194,9 @@ enum LinkerInitialized {
 #if defined(NDEBUG)
 #define ABSL_ASSERT(expr) (false ? (void)(expr) : (void)0)
 #else
-#define ABSL_ASSERT(expr) \
-  (ABSL_PREDICT_TRUE((expr)) ? (void)0 : [] { assert(false && #expr); }())
+#define ABSL_ASSERT(expr)              \
+  (ABSL_PREDICT_TRUE((expr)) ? (void)0 \
+                             : [] { assert(false && #expr); }())  // NOLINT
 #endif
 
 #endif  // ABSL_BASE_MACROS_H_
diff --git a/third_party/abseil-cpp/absl/container/inlined_vector_benchmark.cc b/third_party/abseil-cpp/absl/container/inlined_vector_benchmark.cc
index 5977bc934f..24f2174928 100644
--- a/third_party/abseil-cpp/absl/container/inlined_vector_benchmark.cc
+++ b/third_party/abseil-cpp/absl/container/inlined_vector_benchmark.cc
@@ -63,18 +63,34 @@ void BM_StdVectorFill(benchmark::State& state) {
 }
 BENCHMARK(BM_StdVectorFill)->Range(0, 1024);
 
+// The purpose of the next two benchmarks is to verify that
+// absl::InlinedVector is efficient when moving is more efficent than
+// copying. To do so, we use strings that are larger than the short
+// std::string optimization.
 bool StringRepresentedInline(std::string s) {
   const char* chars = s.data();
   std::string s1 = std::move(s);
   return s1.data() != chars;
 }
 
+int GetNonShortStringOptimizationSize() {
+  for (int i = 24; i <= 192; i *= 2) {
+    if (!StringRepresentedInline(std::string(i, 'A'))) {
+      return i;
+    }
+  }
+  ABSL_RAW_LOG(
+      FATAL,
+      "Failed to find a std::string larger than the short std::string optimization");
+  return -1;
+}
+
 void BM_InlinedVectorFillString(benchmark::State& state) {
   const int len = state.range(0);
-  std::string strings[4] = {"a quite long string",
-                       "another long string",
-                       "012345678901234567",
-                       "to cause allocation"};
+  const int no_sso = GetNonShortStringOptimizationSize();
+  std::string strings[4] = {std::string(no_sso, 'A'), std::string(no_sso, 'B'),
+                       std::string(no_sso, 'C'), std::string(no_sso, 'D')};
+
   for (auto _ : state) {
     absl::InlinedVector<std::string, 8> v;
     for (int i = 0; i < len; i++) {
@@ -87,10 +103,10 @@ BENCHMARK(BM_InlinedVectorFillString)->Range(0, 1024);
 
 void BM_StdVectorFillString(benchmark::State& state) {
   const int len = state.range(0);
-  std::string strings[4] = {"a quite long string",
-                       "another long string",
-                       "012345678901234567",
-                       "to cause allocation"};
+  const int no_sso = GetNonShortStringOptimizationSize();
+  std::string strings[4] = {std::string(no_sso, 'A'), std::string(no_sso, 'B'),
+                       std::string(no_sso, 'C'), std::string(no_sso, 'D')};
+
   for (auto _ : state) {
     std::vector<std::string> v;
     for (int i = 0; i < len; i++) {
@@ -98,11 +114,6 @@ void BM_StdVectorFillString(benchmark::State& state) {
     }
   }
   state.SetItemsProcessed(static_cast<int64_t>(state.iterations()) * len);
-  // The purpose of the benchmark is to verify that inlined vector is
-  // efficient when moving is more efficent than copying. To do so, we
-  // use strings that are larger than the small std::string optimization.
-  ABSL_RAW_CHECK(!StringRepresentedInline(strings[0]),
-                 "benchmarked with strings that are too small");
 }
 BENCHMARK(BM_StdVectorFillString)->Range(0, 1024);
 
diff --git a/third_party/abseil-cpp/absl/memory/BUILD.bazel b/third_party/abseil-cpp/absl/memory/BUILD.bazel
index d5c62265a8..46f47b12bb 100644
--- a/third_party/abseil-cpp/absl/memory/BUILD.bazel
+++ b/third_party/abseil-cpp/absl/memory/BUILD.bazel
@@ -18,6 +18,7 @@ load(
     "//absl:copts.bzl",
     "ABSL_DEFAULT_COPTS",
     "ABSL_TEST_COPTS",
+    "ABSL_EXCEPTIONS_FLAG",
 )
 
 package(default_visibility = ["//visibility:public"])
@@ -45,3 +46,16 @@ cc_test(
         "@com_google_googletest//:gtest_main",
     ],
 )
+
+cc_test(
+    name = "memory_exception_safety_test",
+    srcs = [
+        "memory_exception_safety_test.cc",
+    ],
+    copts = ABSL_TEST_COPTS + ABSL_EXCEPTIONS_FLAG,
+    deps = [
+        ":memory",
+        "//absl/base:exception_safety_testing",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
diff --git a/third_party/abseil-cpp/absl/memory/CMakeLists.txt b/third_party/abseil-cpp/absl/memory/CMakeLists.txt
index 21bfc87ed6..5958f5c52b 100644
--- a/third_party/abseil-cpp/absl/memory/CMakeLists.txt
+++ b/third_party/abseil-cpp/absl/memory/CMakeLists.txt
@@ -49,4 +49,23 @@ absl_test(
 )
 
 
+# test memory_exception_safety_test
+set(MEMORY_EXCEPTION_SAFETY_TEST_SRC "memory_exception_safety_test.cc")
+set(MEMORY_EXCEPTION_SAFETY_TEST_PUBLIC_LIBRARIES
+  absl::memory
+  absl_base_internal_exception_safety_testing
+)
+
+absl_test(
+  TARGET
+    memory_exception_safety_test
+  SOURCES
+    ${MEMORY_EXCEPTION_SAFETY_TEST_SRC}
+  PUBLIC_LIBRARIES
+    ${MEMORY_EXCEPTION_SAFETY_TEST_PUBLIC_LIBRARIES}
+  PRIVATE_COMPILE_FLAGS
+    ${ABSL_EXCEPTIONS_FLAG}
+)
+
+
 
diff --git a/third_party/abseil-cpp/absl/memory/memory_exception_safety_test.cc b/third_party/abseil-cpp/absl/memory/memory_exception_safety_test.cc
new file mode 100644
index 0000000000..55e8f36f2f
--- /dev/null
+++ b/third_party/abseil-cpp/absl/memory/memory_exception_safety_test.cc
@@ -0,0 +1,49 @@
+// 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
+//
+//      http://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/memory/memory.h"
+
+#include "gtest/gtest.h"
+#include "absl/base/internal/exception_safety_testing.h"
+
+namespace absl {
+namespace {
+
+using Thrower = ::testing::ThrowingValue<>;
+
+TEST(MakeUnique, CheckForLeaks) {
+  constexpr int kValue = 321;
+  constexpr size_t kLength = 10;
+  auto tester = testing::MakeExceptionSafetyTester()
+                    .WithInitialValue(Thrower(kValue))
+                    // Ensures make_unique does not modify the input. The real
+                    // test, though, is ConstructorTracker checking for leaks.
+                    .WithInvariants(testing::strong_guarantee);
+
+  EXPECT_TRUE(tester.Test([](Thrower* thrower) {
+    static_cast<void>(absl::make_unique<Thrower>(*thrower));
+  }));
+
+  EXPECT_TRUE(tester.Test([](Thrower* thrower) {
+    static_cast<void>(absl::make_unique<Thrower>(std::move(*thrower)));
+  }));
+
+  // Test T[n] overload
+  EXPECT_TRUE(tester.Test([&](Thrower*) {
+    static_cast<void>(absl::make_unique<Thrower[]>(kLength));
+  }));
+}
+
+}  // namespace
+}  // namespace absl
diff --git a/third_party/abseil-cpp/absl/strings/BUILD.bazel b/third_party/abseil-cpp/absl/strings/BUILD.bazel
index f06bdc0d01..328f52f33d 100644
--- a/third_party/abseil-cpp/absl/strings/BUILD.bazel
+++ b/third_party/abseil-cpp/absl/strings/BUILD.bazel
@@ -32,7 +32,12 @@ cc_library(
     name = "strings",
     srcs = [
         "ascii.cc",
+        "charconv.cc",
         "escaping.cc",
+        "internal/charconv_bigint.cc",
+        "internal/charconv_bigint.h",
+        "internal/charconv_parse.cc",
+        "internal/charconv_parse.h",
         "internal/memutil.cc",
         "internal/memutil.h",
         "internal/stl_type_traits.h",
@@ -48,6 +53,7 @@ cc_library(
     ],
     hdrs = [
         "ascii.h",
+        "charconv.h",
         "escaping.h",
         "match.h",
         "numbers.h",
@@ -144,11 +150,6 @@ cc_test(
     size = "small",
     srcs = ["ascii_test.cc"],
     copts = ABSL_TEST_COPTS,
-    tags = [
-        "no_test_android_arm",
-        "no_test_android_arm64",
-        "no_test_android_x86",
-    ],
     visibility = ["//visibility:private"],
     deps = [
         ":strings",
@@ -398,12 +399,6 @@ cc_test(
         "numbers_test.cc",
     ],
     copts = ABSL_TEST_COPTS,
-    tags = [
-        "no_test_android_arm",
-        "no_test_android_arm64",
-        "no_test_android_x86",
-        "no_test_loonix",
-    ],
     visibility = ["//visibility:private"],
     deps = [
         ":strings",
@@ -429,11 +424,6 @@ cc_test(
     name = "char_map_test",
     srcs = ["internal/char_map_test.cc"],
     copts = ABSL_TEST_COPTS,
-    tags = [
-        "no_test_android_arm",
-        "no_test_android_arm64",
-        "no_test_android_x86",
-    ],
     deps = [
         ":internal",
         "@com_google_googletest//:gtest_main",
@@ -450,3 +440,55 @@ cc_test(
         "@com_github_google_benchmark//:benchmark_main",
     ],
 )
+
+cc_test(
+    name = "charconv_test",
+    srcs = ["charconv_test.cc"],
+    copts = ABSL_TEST_COPTS,
+    deps = [
+        ":strings",
+        "//absl/base",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+cc_test(
+    name = "charconv_parse_test",
+    srcs = [
+        "internal/charconv_parse.h",
+        "internal/charconv_parse_test.cc",
+    ],
+    copts = ABSL_TEST_COPTS,
+    deps = [
+        ":strings",
+        "//absl/base",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+cc_test(
+    name = "charconv_bigint_test",
+    srcs = [
+        "internal/charconv_bigint.h",
+        "internal/charconv_bigint_test.cc",
+        "internal/charconv_parse.h",
+    ],
+    copts = ABSL_TEST_COPTS,
+    deps = [
+        ":strings",
+        "//absl/base",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+cc_test(
+    name = "charconv_benchmark",
+    srcs = [
+        "charconv_benchmark.cc",
+    ],
+    deps = [
+        ":strings",
+        "//absl/base",
+        "@com_github_google_benchmark//:benchmark_main",
+    ],
+)
diff --git a/third_party/abseil-cpp/absl/strings/BUILD.gn b/third_party/abseil-cpp/absl/strings/BUILD.gn
index 7434eb23cd..117570c29c 100644
--- a/third_party/abseil-cpp/absl/strings/BUILD.gn
+++ b/third_party/abseil-cpp/absl/strings/BUILD.gn
@@ -22,7 +22,12 @@ source_set("strings") {
   public_configs = [ "//third_party/abseil-cpp:absl_include_config" ]
   sources = [
     "ascii.cc",
+    "charconv.cc",
     "escaping.cc",
+    "internal/charconv_bigint.cc",
+    "internal/charconv_bigint.h",
+    "internal/charconv_parse.cc",
+    "internal/charconv_parse.h",
     "internal/memutil.cc",
     "internal/memutil.h",
     "internal/stl_type_traits.h",
@@ -38,6 +43,7 @@ source_set("strings") {
   ]
   public = [
     "ascii.h",
+    "charconv.h",
     "escaping.h",
     "match.h",
     "numbers.h",
diff --git a/third_party/abseil-cpp/absl/strings/CMakeLists.txt b/third_party/abseil-cpp/absl/strings/CMakeLists.txt
index 9dc47328c7..cab2c4561e 100644
--- a/third_party/abseil-cpp/absl/strings/CMakeLists.txt
+++ b/third_party/abseil-cpp/absl/strings/CMakeLists.txt
@@ -17,6 +17,7 @@
 
 list(APPEND STRINGS_PUBLIC_HEADERS
   "ascii.h"
+  "charconv.h"
   "escaping.h"
   "match.h"
   "numbers.h"
@@ -33,6 +34,8 @@ list(APPEND STRINGS_PUBLIC_HEADERS
 list(APPEND STRINGS_INTERNAL_HEADERS
   "internal/bits.h"
   "internal/char_map.h"
+  "internal/charconv_bigint.h"
+  "internal/charconv_parse.h"
   "internal/memutil.h"
   "internal/ostringstream.h"
   "internal/resize_uninitialized.h"
@@ -47,7 +50,10 @@ list(APPEND STRINGS_INTERNAL_HEADERS
 # add string library
 list(APPEND STRINGS_SRC
   "ascii.cc"
+  "charconv.cc"
   "escaping.cc"
+  "internal/charconv_bigint.cc"
+  "internal/charconv_parse.cc"
   "internal/memutil.cc"
   "internal/memutil.h"
   "internal/utf8.cc"
@@ -301,5 +307,43 @@ absl_test(
 )
 
 
+# test charconv_test
+set(CHARCONV_TEST_SRC "charconv_test.cc")
+set(CHARCONV_TEST_PUBLIC_LIBRARIES absl::strings)
 
+absl_test(
+  TARGET
+    charconv_test
+  SOURCES
+    ${CHARCONV_TEST_SRC}
+  PUBLIC_LIBRARIES
+    ${CHARCONV_TEST_PUBLIC_LIBRARIES}
+)
+
+
+# test charconv_parse_test
+set(CHARCONV_PARSE_TEST_SRC "internal/charconv_parse_test.cc")
+set(CHARCONV_PARSE_TEST_PUBLIC_LIBRARIES absl::strings)
+
+absl_test(
+  TARGET
+    charconv_parse_test
+  SOURCES
+    ${CHARCONV_PARSE_TEST_SRC}
+  PUBLIC_LIBRARIES
+    ${CHARCONV_PARSE_TEST_PUBLIC_LIBRARIES}
+)
+
+
+# test charconv_bigint_test
+set(CHARCONV_BIGINT_TEST_SRC "internal/charconv_bigint_test.cc")
+set(CHARCONV_BIGINT_TEST_PUBLIC_LIBRARIES absl::strings)
 
+absl_test(
+  TARGET
+    charconv_bigint_test
+  SOURCES
+    ${CHARCONV_BIGINT_TEST_SRC}
+  PUBLIC_LIBRARIES
+    ${CHARCONV_BIGINT_TEST_PUBLIC_LIBRARIES}
+)
diff --git a/third_party/abseil-cpp/absl/strings/charconv.cc b/third_party/abseil-cpp/absl/strings/charconv.cc
new file mode 100644
index 0000000000..08c3947ecc
--- /dev/null
+++ b/third_party/abseil-cpp/absl/strings/charconv.cc
@@ -0,0 +1,982 @@
+// 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
+//
+//      http://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/strings/charconv.h"
+
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <cstring>
+
+#include "absl/base/casts.h"
+#include "absl/numeric/int128.h"
+#include "absl/strings/internal/bits.h"
+#include "absl/strings/internal/charconv_bigint.h"
+#include "absl/strings/internal/charconv_parse.h"
+
+// The macro ABSL_BIT_PACK_FLOATS is defined on x86-64, where IEEE floating
+// point numbers have the same endianness in memory as a bitfield struct
+// containing the corresponding parts.
+//
+// When set, we replace calls to ldexp() with manual bit packing, which is
+// faster and is unaffected by floating point environment.
+#ifdef ABSL_BIT_PACK_FLOATS
+#error ABSL_BIT_PACK_FLOATS cannot be directly set
+#elif defined(__x86_64__) || defined(_M_X64)
+#define ABSL_BIT_PACK_FLOATS 1
+#endif
+
+// A note about subnormals:
+//
+// The code below talks about "normals" and "subnormals".  A normal IEEE float
+// has a fixed-width mantissa and power of two exponent.  For example, a normal
+// `double` has a 53-bit mantissa.  Because the high bit is always 1, it is not
+// stored in the representation.  The implicit bit buys an extra bit of
+// resolution in the datatype.
+//
+// The downside of this scheme is that there is a large gap between DBL_MIN and
+// zero.  (Large, at least, relative to the different between DBL_MIN and the
+// next representable number).  This gap is softened by the "subnormal" numbers,
+// which have the same power-of-two exponent as DBL_MIN, but no implicit 53rd
+// bit.  An all-bits-zero exponent in the encoding represents subnormals.  (Zero
+// is represented as a subnormal with an all-bits-zero mantissa.)
+//
+// The code below, in calculations, represents the mantissa as a uint64_t.  The
+// end result normally has the 53rd bit set.  It represents subnormals by using
+// narrower mantissas.
+
+namespace absl {
+namespace {
+
+template <typename FloatType>
+struct FloatTraits;
+
+template <>
+struct FloatTraits<double> {
+  // The number of mantissa bits in the given float type.  This includes the
+  // implied high bit.
+  static constexpr int kTargetMantissaBits = 53;
+
+  // The largest supported IEEE exponent, in our integral mantissa
+  // representation.
+  //
+  // If `m` is the largest possible int kTargetMantissaBits bits wide, then
+  // m * 2**kMaxExponent is exactly equal to DBL_MAX.
+  static constexpr int kMaxExponent = 971;
+
+  // The smallest supported IEEE normal exponent, in our integral mantissa
+  // representation.
+  //
+  // If `m` is the smallest possible int kTargetMantissaBits bits wide, then
+  // m * 2**kMinNormalExponent is exactly equal to DBL_MIN.
+  static constexpr int kMinNormalExponent = -1074;
+
+  static double MakeNan(const char* tagp) {
+    // Support nan no matter which namespace it's in.  Some platforms
+    // incorrectly don't put it in namespace std.
+    using namespace std;  // NOLINT
+    return nan(tagp);
+  }
+
+  // Builds a nonzero floating point number out of the provided parts.
+  //
+  // This is intended to do the same operation as ldexp(mantissa, exponent),
+  // but using purely integer math, to avoid -ffastmath and floating
+  // point environment issues.  Using type punning is also faster. We fall back
+  // to ldexp on a per-platform basis for portability.
+  //
+  // `exponent` must be between kMinNormalExponent and kMaxExponent.
+  //
+  // `mantissa` must either be exactly kTargetMantissaBits wide, in which case
+  // a normal value is made, or it must be less narrow than that, in which case
+  // `exponent` must be exactly kMinNormalExponent, and a subnormal value is
+  // made.
+  static double Make(uint64_t mantissa, int exponent, bool sign) {
+#ifndef ABSL_BIT_PACK_FLOATS
+    // Support ldexp no matter which namespace it's in.  Some platforms
+    // incorrectly don't put it in namespace std.
+    using namespace std;  // NOLINT
+    return sign ? -ldexp(mantissa, exponent) : ldexp(mantissa, exponent);
+#else
+    constexpr uint64_t kMantissaMask =
+        (uint64_t(1) << (kTargetMantissaBits - 1)) - 1;
+    uint64_t dbl = static_cast<uint64_t>(sign) << 63;
+    if (mantissa > kMantissaMask) {
+      // Normal value.
+      // Adjust by 1023 for the exponent representation bias, and an additional
+      // 52 due to the implied decimal point in the IEEE mantissa represenation.
+      dbl += uint64_t{exponent + 1023u + kTargetMantissaBits - 1} << 52;
+      mantissa &= kMantissaMask;
+    } else {
+      // subnormal value
+      assert(exponent == kMinNormalExponent);
+    }
+    dbl += mantissa;
+    return absl::bit_cast<double>(dbl);
+#endif  // ABSL_BIT_PACK_FLOATS
+  }
+};
+
+// Specialization of floating point traits for the `float` type.  See the
+// FloatTraits<double> specialization above for meaning of each of the following
+// members and methods.
+template <>
+struct FloatTraits<float> {
+  static constexpr int kTargetMantissaBits = 24;
+  static constexpr int kMaxExponent = 104;
+  static constexpr int kMinNormalExponent = -149;
+  static float MakeNan(const char* tagp) {
+    // Support nanf no matter which namespace it's in.  Some platforms
+    // incorrectly don't put it in namespace std.
+    using namespace std;  // NOLINT
+    return nanf(tagp);
+  }
+  static float Make(uint32_t mantissa, int exponent, bool sign) {
+#ifndef ABSL_BIT_PACK_FLOATS
+    // Support ldexpf no matter which namespace it's in.  Some platforms
+    // incorrectly don't put it in namespace std.
+    using namespace std;  // NOLINT
+    return sign ? -ldexpf(mantissa, exponent) : ldexpf(mantissa, exponent);
+#else
+    constexpr uint32_t kMantissaMask =
+        (uint32_t(1) << (kTargetMantissaBits - 1)) - 1;
+    uint32_t flt = static_cast<uint32_t>(sign) << 31;
+    if (mantissa > kMantissaMask) {
+      // Normal value.
+      // Adjust by 127 for the exponent representation bias, and an additional
+      // 23 due to the implied decimal point in the IEEE mantissa represenation.
+      flt += uint32_t{exponent + 127u + kTargetMantissaBits - 1} << 23;
+      mantissa &= kMantissaMask;
+    } else {
+      // subnormal value
+      assert(exponent == kMinNormalExponent);
+    }
+    flt += mantissa;
+    return absl::bit_cast<float>(flt);
+#endif  // ABSL_BIT_PACK_FLOATS
+  }
+};
+
+// Decimal-to-binary conversions require coercing powers of 10 into a mantissa
+// and a power of 2.  The two helper functions Power10Mantissa(n) and
+// Power10Exponent(n) perform this task.  Together, these represent a hand-
+// rolled floating point value which is equal to or just less than 10**n.
+//
+// The return values satisfy two range guarantees:
+//
+//   Power10Mantissa(n) * 2**Power10Exponent(n) <= 10**n
+//     < (Power10Mantissa(n) + 1) * 2**Power10Exponent(n)
+//
+//   2**63 <= Power10Mantissa(n) < 2**64.
+//
+// Lookups into the power-of-10 table must first check the Power10Overflow() and
+// Power10Underflow() functions, to avoid out-of-bounds table access.
+//
+// Indexes into these tables are biased by -kPower10TableMin, and the table has
+// values in the range [kPower10TableMin, kPower10TableMax].
+extern const uint64_t kPower10MantissaTable[];
+extern const int16_t kPower10ExponentTable[];
+
+// The smallest allowed value for use with the Power10Mantissa() and
+// Power10Exponent() functions below.  (If a smaller exponent is needed in
+// calculations, the end result is guaranteed to underflow.)
+constexpr int kPower10TableMin = -342;
+
+// The largest allowed value for use with the Power10Mantissa() and
+// Power10Exponent() functions below.  (If a smaller exponent is needed in
+// calculations, the end result is guaranteed to overflow.)
+constexpr int kPower10TableMax = 308;
+
+uint64_t Power10Mantissa(int n) {
+  return kPower10MantissaTable[n - kPower10TableMin];
+}
+
+int Power10Exponent(int n) {
+  return kPower10ExponentTable[n - kPower10TableMin];
+}
+
+// Returns true if n is large enough that 10**n always results in an IEEE
+// overflow.
+bool Power10Overflow(int n) { return n > kPower10TableMax; }
+
+// Returns true if n is small enough that 10**n times a ParsedFloat mantissa
+// always results in an IEEE underflow.
+bool Power10Underflow(int n) { return n < kPower10TableMin; }
+
+// Returns true if Power10Mantissa(n) * 2**Power10Exponent(n) is exactly equal
+// to 10**n numerically.  Put another way, this returns true if there is no
+// truncation error in Power10Mantissa(n).
+bool Power10Exact(int n) { return n >= 0 && n <= 27; }
+
+// Sentinel exponent values for representing numbers too large or too close to
+// zero to represent in a double.
+constexpr int kOverflow = 99999;
+constexpr int kUnderflow = -99999;
+
+// Struct representing the calculated conversion result of a positive (nonzero)
+// floating point number.
+//
+// The calculated number is mantissa * 2**exponent (mantissa is treated as an
+// integer.)  `mantissa` is chosen to be the correct width for the IEEE float
+// representation being calculated.  (`mantissa` will always have the same bit
+// width for normal values, and narrower bit widths for subnormals.)
+//
+// If the result of conversion was an underflow or overflow, exponent is set
+// to kUnderflow or kOverflow.
+struct CalculatedFloat {
+  uint64_t mantissa = 0;
+  int exponent = 0;
+};
+
+// Returns the bit width of the given uint128.  (Equivalently, returns 128
+// minus the number of leading zero bits.)
+int BitWidth(uint128 value) {
+  if (Uint128High64(value) == 0) {
+    return 64 - strings_internal::CountLeadingZeros64(Uint128Low64(value));
+  }
+  return 128 - strings_internal::CountLeadingZeros64(Uint128High64(value));
+}
+
+// Calculates how far to the right a mantissa needs to be shifted to create a
+// properly adjusted mantissa for an IEEE floating point number.
+//
+// `mantissa_width` is the bit width of the mantissa to be shifted, and
+// `binary_exponent` is the exponent of the number before the shift.
+//
+// This accounts for subnormal values, and will return a larger-than-normal
+// shift if binary_exponent would otherwise be too low.
+template <typename FloatType>
+int NormalizedShiftSize(int mantissa_width, int binary_exponent) {
+  const int normal_shift =
+      mantissa_width - FloatTraits<FloatType>::kTargetMantissaBits;
+  const int minimum_shift =
+      FloatTraits<FloatType>::kMinNormalExponent - binary_exponent;
+  return std::max(normal_shift, minimum_shift);
+}
+
+// Right shifts a uint128 so that it has the requested bit width.  (The
+// resulting value will have 128 - bit_width leading zeroes.)  The initial
+// `value` must be wider than the requested bit width.
+//
+// Returns the number of bits shifted.
+int TruncateToBitWidth(int bit_width, uint128* value) {
+  const int current_bit_width = BitWidth(*value);
+  const int shift = current_bit_width - bit_width;
+  *value >>= shift;
+  return shift;
+}
+
+// Checks if the given ParsedFloat represents one of the edge cases that are
+// not dependent on number base: zero, infinity, or NaN.  If so, sets *value
+// the appropriate double, and returns true.
+template <typename FloatType>
+bool HandleEdgeCase(const strings_internal::ParsedFloat& input, bool negative,
+                    FloatType* value) {
+  if (input.type == strings_internal::FloatType::kNan) {
+    // A bug in both clang and gcc would cause the compiler to optimize away the
+    // buffer we are building below.  Declaring the buffer volatile avoids the
+    // issue, and has no measurable performance impact in microbenchmarks.
+    //
+    // https://bugs.llvm.org/show_bug.cgi?id=37778
+    // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=86113
+    constexpr ptrdiff_t kNanBufferSize = 128;
+    volatile char n_char_sequence[kNanBufferSize];
+    if (input.subrange_begin == nullptr) {
+      n_char_sequence[0] = '\0';
+    } else {
+      ptrdiff_t nan_size = input.subrange_end - input.subrange_begin;
+      nan_size = std::min(nan_size, kNanBufferSize - 1);
+      std::copy_n(input.subrange_begin, nan_size, n_char_sequence);
+      n_char_sequence[nan_size] = '\0';
+    }
+    char* nan_argument = const_cast<char*>(n_char_sequence);
+    *value = negative ? -FloatTraits<FloatType>::MakeNan(nan_argument)
+                      : FloatTraits<FloatType>::MakeNan(nan_argument);
+    return true;
+  }
+  if (input.type == strings_internal::FloatType::kInfinity) {
+    *value = negative ? -std::numeric_limits<FloatType>::infinity()
+                      : std::numeric_limits<FloatType>::infinity();
+    return true;
+  }
+  if (input.mantissa == 0) {
+    *value = negative ? -0.0 : 0.0;
+    return true;
+  }
+  return false;
+}
+
+// Given a CalculatedFloat result of a from_chars conversion, generate the
+// correct output values.
+//
+// CalculatedFloat can represent an underflow or overflow, in which case the
+// error code in *result is set.  Otherwise, the calculated floating point
+// number is stored in *value.
+template <typename FloatType>
+void EncodeResult(const CalculatedFloat& calculated, bool negative,
+                  absl::from_chars_result* result, FloatType* value) {
+  if (calculated.exponent == kOverflow) {
+    result->ec = std::errc::result_out_of_range;
+    *value = negative ? -std::numeric_limits<FloatType>::max()
+                      : std::numeric_limits<FloatType>::max();
+    return;
+  } else if (calculated.mantissa == 0 || calculated.exponent == kUnderflow) {
+    result->ec = std::errc::result_out_of_range;
+    *value = negative ? -0.0 : 0.0;
+    return;
+  }
+  *value = FloatTraits<FloatType>::Make(calculated.mantissa,
+                                        calculated.exponent, negative);
+}
+
+// Returns the given uint128 shifted to the right by `shift` bits, and rounds
+// the remaining bits using round_to_nearest logic.  The value is returned as a
+// uint64_t, since this is the type used by this library for storing calculated
+// floating point mantissas.
+//
+// It is expected that the width of the input value shifted by `shift` will
+// be the correct bit-width for the target mantissa, which is strictly narrower
+// than a uint64_t.
+//
+// If `input_exact` is false, then a nonzero error epsilon is assumed.  For
+// rounding purposes, the true value being rounded is strictly greater than the
+// input value.  The error may represent a single lost carry bit.
+//
+// When input_exact, shifted bits of the form 1000000... represent a tie, which
+// is broken by rounding to even -- the rounding direction is chosen so the low
+// bit of the returned value is 0.
+//
+// When !input_exact, shifted bits of the form 10000000... represent a value
+// strictly greater than one half (due to the error epsilon), and so ties are
+// always broken by rounding up.
+//
+// When !input_exact, shifted bits of the form 01111111... are uncertain;
+// the true value may or may not be greater than 10000000..., due to the
+// possible lost carry bit.  The correct rounding direction is unknown.  In this
+// case, the result is rounded down, and `output_exact` is set to false.
+//
+// Zero and negative values of `shift` are accepted, in which case the word is
+// shifted left, as necessary.
+uint64_t ShiftRightAndRound(uint128 value, int shift, bool input_exact,
+                            bool* output_exact) {
+  if (shift <= 0) {
+    *output_exact = input_exact;
+    return static_cast<uint64_t>(value << -shift);
+  }
+  if (shift >= 128) {
+    // Exponent is so small that we are shifting away all significant bits.
+    // Answer will not be representable, even as a subnormal, so return a zero
+    // mantissa (which represents underflow).
+    *output_exact = true;
+    return 0;
+  }
+
+  *output_exact = true;
+  const uint128 shift_mask = (uint128(1) << shift) - 1;
+  const uint128 halfway_point = uint128(1) << (shift - 1);
+
+  const uint128 shifted_bits = value & shift_mask;
+  value >>= shift;
+  if (shifted_bits > halfway_point) {
+    // Shifted bits greater than 10000... require rounding up.
+    return static_cast<uint64_t>(value + 1);
+  }
+  if (shifted_bits == halfway_point) {
+    // In exact mode, shifted bits of 10000... mean we're exactly halfway
+    // between two numbers, and we must round to even.  So only round up if
+    // the low bit of `value` is set.
+    //
+    // In inexact mode, the nonzero error means the actual value is greater
+    // than the halfway point and we must alway round up.
+    if ((value & 1) == 1 || !input_exact) {
+      ++value;
+    }
+    return static_cast<uint64_t>(value);
+  }
+  if (!input_exact && shifted_bits == halfway_point - 1) {
+    // Rounding direction is unclear, due to error.
+    *output_exact = false;
+  }
+  // Otherwise, round down.
+  return static_cast<uint64_t>(value);
+}
+
+// Checks if a floating point guess needs to be rounded up, using high precision
+// math.
+//
+// `guess_mantissa` and `guess_exponent` represent a candidate guess for the
+// number represented by `parsed_decimal`.
+//
+// The exact number represented by `parsed_decimal` must lie between the two
+// numbers:
+//   A = `guess_mantissa * 2**guess_exponent`
+//   B = `(guess_mantissa + 1) * 2**guess_exponent`
+//
+// This function returns false if `A` is the better guess, and true if `B` is
+// the better guess, with rounding ties broken by rounding to even.
+bool MustRoundUp(uint64_t guess_mantissa, int guess_exponent,
+                 const strings_internal::ParsedFloat& parsed_decimal) {
+  // 768 is the number of digits needed in the worst case.  We could determine a
+  // better limit dynamically based on the value of parsed_decimal.exponent.
+  // This would optimize pathological input cases only.  (Sane inputs won't have
+  // hundreds of digits of mantissa.)
+  absl::strings_internal::BigUnsigned<84> exact_mantissa;
+  int exact_exponent = exact_mantissa.ReadFloatMantissa(parsed_decimal, 768);
+
+  // Adjust the `guess` arguments to be halfway between A and B.
+  guess_mantissa = guess_mantissa * 2 + 1;
+  guess_exponent -= 1;
+
+  // In our comparison:
+  // lhs = exact = exact_mantissa * 10**exact_exponent
+  //             = exact_mantissa * 5**exact_exponent * 2**exact_exponent
+  // rhs = guess = guess_mantissa * 2**guess_exponent
+  //
+  // Because we are doing integer math, we can't directly deal with negative
+  // exponents.  We instead move these to the other side of the inequality.
+  absl::strings_internal::BigUnsigned<84>& lhs = exact_mantissa;
+  int comparison;
+  if (exact_exponent >= 0) {
+    lhs.MultiplyByFiveToTheNth(exact_exponent);
+    absl::strings_internal::BigUnsigned<84> rhs(guess_mantissa);
+    // There are powers of 2 on both sides of the inequality; reduce this to
+    // a single bit-shift.
+    if (exact_exponent > guess_exponent) {
+      lhs.ShiftLeft(exact_exponent - guess_exponent);
+    } else {
+      rhs.ShiftLeft(guess_exponent - exact_exponent);
+    }
+    comparison = Compare(lhs, rhs);
+  } else {
+    // Move the power of 5 to the other side of the equation, giving us:
+    // lhs = exact_mantissa * 2**exact_exponent
+    // rhs = guess_mantissa * 5**(-exact_exponent) * 2**guess_exponent
+    absl::strings_internal::BigUnsigned<84> rhs =
+        absl::strings_internal::BigUnsigned<84>::FiveToTheNth(-exact_exponent);
+    rhs.MultiplyBy(guess_mantissa);
+    if (exact_exponent > guess_exponent) {
+      lhs.ShiftLeft(exact_exponent - guess_exponent);
+    } else {
+      rhs.ShiftLeft(guess_exponent - exact_exponent);
+    }
+    comparison = Compare(lhs, rhs);
+  }
+  if (comparison < 0) {
+    return false;
+  } else if (comparison > 0) {
+    return true;
+  } else {
+    // When lhs == rhs, the decimal input is exactly between A and B.
+    // Round towards even -- round up only if the low bit of the initial
+    // `guess_mantissa` was a 1.  We shifted guess_mantissa left 1 bit at
+    // the beginning of this function, so test the 2nd bit here.
+    return (guess_mantissa & 2) == 2;
+  }
+}
+
+// Constructs a CalculatedFloat from a given mantissa and exponent, but
+// with the following normalizations applied:
+//
+// If rounding has caused mantissa to increase just past the allowed bit
+// width, shift and adjust exponent.
+//
+// If exponent is too high, sets kOverflow.
+//
+// If mantissa is zero (representing a non-zero value not representable, even
+// as a subnormal), sets kUnderflow.
+template <typename FloatType>
+CalculatedFloat CalculatedFloatFromRawValues(uint64_t mantissa, int exponent) {
+  CalculatedFloat result;
+  if (mantissa == uint64_t(1) << FloatTraits<FloatType>::kTargetMantissaBits) {
+    mantissa >>= 1;
+    exponent += 1;
+  }
+  if (exponent > FloatTraits<FloatType>::kMaxExponent) {
+    result.exponent = kOverflow;
+  } else if (mantissa == 0) {
+    result.exponent = kUnderflow;
+  } else {
+    result.exponent = exponent;
+    result.mantissa = mantissa;
+  }
+  return result;
+}
+
+template <typename FloatType>
+CalculatedFloat CalculateFromParsedHexadecimal(
+    const strings_internal::ParsedFloat& parsed_hex) {
+  uint64_t mantissa = parsed_hex.mantissa;
+  int exponent = parsed_hex.exponent;
+  int mantissa_width = 64 - strings_internal::CountLeadingZeros64(mantissa);
+  const int shift = NormalizedShiftSize<FloatType>(mantissa_width, exponent);
+  bool result_exact;
+  exponent += shift;
+  mantissa = ShiftRightAndRound(mantissa, shift,
+                                /* input exact= */ true, &result_exact);
+  // ParseFloat handles rounding in the hexadecimal case, so we don't have to
+  // check `result_exact` here.
+  return CalculatedFloatFromRawValues<FloatType>(mantissa, exponent);
+}
+
+template <typename FloatType>
+CalculatedFloat CalculateFromParsedDecimal(
+    const strings_internal::ParsedFloat& parsed_decimal) {
+  CalculatedFloat result;
+
+  // Large or small enough decimal exponents will always result in overflow
+  // or underflow.
+  if (Power10Underflow(parsed_decimal.exponent)) {
+    result.exponent = kUnderflow;
+    return result;
+  } else if (Power10Overflow(parsed_decimal.exponent)) {
+    result.exponent = kOverflow;
+    return result;
+  }
+
+  // Otherwise convert our power of 10 into a power of 2 times an integer
+  // mantissa, and multiply this by our parsed decimal mantissa.
+  uint128 wide_binary_mantissa = parsed_decimal.mantissa;
+  wide_binary_mantissa *= Power10Mantissa(parsed_decimal.exponent);
+  int binary_exponent = Power10Exponent(parsed_decimal.exponent);
+
+  // Discard bits that are inaccurate due to truncation error.  The magic
+  // `mantissa_width` constants below are justified in charconv_algorithm.md.
+  // They represent the number of bits in `wide_binary_mantissa` that are
+  // guaranteed to be unaffected by error propagation.
+  bool mantissa_exact;
+  int mantissa_width;
+  if (parsed_decimal.subrange_begin) {
+    // Truncated mantissa
+    mantissa_width = 58;
+    mantissa_exact = false;
+    binary_exponent +=
+        TruncateToBitWidth(mantissa_width, &wide_binary_mantissa);
+  } else if (!Power10Exact(parsed_decimal.exponent)) {
+    // Exact mantissa, truncated power of ten
+    mantissa_width = 63;
+    mantissa_exact = false;
+    binary_exponent +=
+        TruncateToBitWidth(mantissa_width, &wide_binary_mantissa);
+  } else {
+    // Product is exact
+    mantissa_width = BitWidth(wide_binary_mantissa);
+    mantissa_exact = true;
+  }
+
+  // Shift into an FloatType-sized mantissa, and round to nearest.
+  const int shift =
+      NormalizedShiftSize<FloatType>(mantissa_width, binary_exponent);
+  bool result_exact;
+  binary_exponent += shift;
+  uint64_t binary_mantissa = ShiftRightAndRound(wide_binary_mantissa, shift,
+                                                mantissa_exact, &result_exact);
+  if (!result_exact) {
+    // We could not determine the rounding direction using int128 math.  Use
+    // full resolution math instead.
+    if (MustRoundUp(binary_mantissa, binary_exponent, parsed_decimal)) {
+      binary_mantissa += 1;
+    }
+  }
+
+  return CalculatedFloatFromRawValues<FloatType>(binary_mantissa,
+                                                 binary_exponent);
+}
+
+template <typename FloatType>
+from_chars_result FromCharsImpl(const char* first, const char* last,
+                                FloatType& value, chars_format fmt_flags) {
+  from_chars_result result;
+  result.ptr = first;  // overwritten on successful parse
+  result.ec = std::errc();
+
+  bool negative = false;
+  if (first != last && *first == '-') {
+    ++first;
+    negative = true;
+  }
+  // If the `hex` flag is *not* set, then we will accept a 0x prefix and try
+  // to parse a hexadecimal float.
+  if ((fmt_flags & chars_format::hex) == chars_format{} && last - first >= 2 &&
+      *first == '0' && (first[1] == 'x' || first[1] == 'X')) {
+    const char* hex_first = first + 2;
+    strings_internal::ParsedFloat hex_parse =
+        strings_internal::ParseFloat<16>(hex_first, last, fmt_flags);
+    if (hex_parse.end == nullptr ||
+        hex_parse.type != strings_internal::FloatType::kNumber) {
+      // Either we failed to parse a hex float after the "0x", or we read
+      // "0xinf" or "0xnan" which we don't want to match.
+      //
+      // However, a std::string that begins with "0x" also begins with "0", which
+      // is normally a valid match for the number zero.  So we want these
+      // strings to match zero unless fmt_flags is `scientific`.  (This flag
+      // means an exponent is required, which the std::string "0" does not have.)
+      if (fmt_flags == chars_format::scientific) {
+        result.ec = std::errc::invalid_argument;
+      } else {
+        result.ptr = first + 1;
+        value = negative ? -0.0 : 0.0;
+      }
+      return result;
+    }
+    // We matched a value.
+    result.ptr = hex_parse.end;
+    if (HandleEdgeCase(hex_parse, negative, &value)) {
+      return result;
+    }
+    CalculatedFloat calculated =
+        CalculateFromParsedHexadecimal<FloatType>(hex_parse);
+    EncodeResult(calculated, negative, &result, &value);
+    return result;
+  }
+  // Otherwise, we choose the number base based on the flags.
+  if ((fmt_flags & chars_format::hex) == chars_format::hex) {
+    strings_internal::ParsedFloat hex_parse =
+        strings_internal::ParseFloat<16>(first, last, fmt_flags);
+    if (hex_parse.end == nullptr) {
+      result.ec = std::errc::invalid_argument;
+      return result;
+    }
+    result.ptr = hex_parse.end;
+    if (HandleEdgeCase(hex_parse, negative, &value)) {
+      return result;
+    }
+    CalculatedFloat calculated =
+        CalculateFromParsedHexadecimal<FloatType>(hex_parse);
+    EncodeResult(calculated, negative, &result, &value);
+    return result;
+  } else {
+    strings_internal::ParsedFloat decimal_parse =
+        strings_internal::ParseFloat<10>(first, last, fmt_flags);
+    if (decimal_parse.end == nullptr) {
+      result.ec = std::errc::invalid_argument;
+      return result;
+    }
+    result.ptr = decimal_parse.end;
+    if (HandleEdgeCase(decimal_parse, negative, &value)) {
+      return result;
+    }
+    CalculatedFloat calculated =
+        CalculateFromParsedDecimal<FloatType>(decimal_parse);
+    EncodeResult(calculated, negative, &result, &value);
+    return result;
+  }
+  return result;
+}
+}  // namespace
+
+from_chars_result from_chars(const char* first, const char* last, double& value,
+                             chars_format fmt) {
+  return FromCharsImpl(first, last, value, fmt);
+}
+
+from_chars_result from_chars(const char* first, const char* last, float& value,
+                             chars_format fmt) {
+  return FromCharsImpl(first, last, value, fmt);
+}
+
+namespace {
+
+// Table of powers of 10, from kPower10TableMin to kPower10TableMax.
+//
+// kPower10MantissaTable[i - kPower10TableMin] stores the 64-bit mantissa (high
+// bit always on), and kPower10ExponentTable[i - kPower10TableMin] stores the
+// power-of-two exponent.  For a given number i, this gives the unique mantissa
+// and exponent such that mantissa * 2**exponent <= 10**i < (mantissa + 1) *
+// 2**exponent.
+
+const uint64_t kPower10MantissaTable[] = {
+    0xeef453d6923bd65aU, 0x9558b4661b6565f8U, 0xbaaee17fa23ebf76U,
+    0xe95a99df8ace6f53U, 0x91d8a02bb6c10594U, 0xb64ec836a47146f9U,
+    0xe3e27a444d8d98b7U, 0x8e6d8c6ab0787f72U, 0xb208ef855c969f4fU,
+    0xde8b2b66b3bc4723U, 0x8b16fb203055ac76U, 0xaddcb9e83c6b1793U,
+    0xd953e8624b85dd78U, 0x87d4713d6f33aa6bU, 0xa9c98d8ccb009506U,
+    0xd43bf0effdc0ba48U, 0x84a57695fe98746dU, 0xa5ced43b7e3e9188U,
+    0xcf42894a5dce35eaU, 0x818995ce7aa0e1b2U, 0xa1ebfb4219491a1fU,
+    0xca66fa129f9b60a6U, 0xfd00b897478238d0U, 0x9e20735e8cb16382U,
+    0xc5a890362fddbc62U, 0xf712b443bbd52b7bU, 0x9a6bb0aa55653b2dU,
+    0xc1069cd4eabe89f8U, 0xf148440a256e2c76U, 0x96cd2a865764dbcaU,
+    0xbc807527ed3e12bcU, 0xeba09271e88d976bU, 0x93445b8731587ea3U,
+    0xb8157268fdae9e4cU, 0xe61acf033d1a45dfU, 0x8fd0c16206306babU,
+    0xb3c4f1ba87bc8696U, 0xe0b62e2929aba83cU, 0x8c71dcd9ba0b4925U,
+    0xaf8e5410288e1b6fU, 0xdb71e91432b1a24aU, 0x892731ac9faf056eU,
+    0xab70fe17c79ac6caU, 0xd64d3d9db981787dU, 0x85f0468293f0eb4eU,
+    0xa76c582338ed2621U, 0xd1476e2c07286faaU, 0x82cca4db847945caU,
+    0xa37fce126597973cU, 0xcc5fc196fefd7d0cU, 0xff77b1fcbebcdc4fU,
+    0x9faacf3df73609b1U, 0xc795830d75038c1dU, 0xf97ae3d0d2446f25U,
+    0x9becce62836ac577U, 0xc2e801fb244576d5U, 0xf3a20279ed56d48aU,
+    0x9845418c345644d6U, 0xbe5691ef416bd60cU, 0xedec366b11c6cb8fU,
+    0x94b3a202eb1c3f39U, 0xb9e08a83a5e34f07U, 0xe858ad248f5c22c9U,
+    0x91376c36d99995beU, 0xb58547448ffffb2dU, 0xe2e69915b3fff9f9U,
+    0x8dd01fad907ffc3bU, 0xb1442798f49ffb4aU, 0xdd95317f31c7fa1dU,
+    0x8a7d3eef7f1cfc52U, 0xad1c8eab5ee43b66U, 0xd863b256369d4a40U,
+    0x873e4f75e2224e68U, 0xa90de3535aaae202U, 0xd3515c2831559a83U,
+    0x8412d9991ed58091U, 0xa5178fff668ae0b6U, 0xce5d73ff402d98e3U,
+    0x80fa687f881c7f8eU, 0xa139029f6a239f72U, 0xc987434744ac874eU,
+    0xfbe9141915d7a922U, 0x9d71ac8fada6c9b5U, 0xc4ce17b399107c22U,
+    0xf6019da07f549b2bU, 0x99c102844f94e0fbU, 0xc0314325637a1939U,
+    0xf03d93eebc589f88U, 0x96267c7535b763b5U, 0xbbb01b9283253ca2U,
+    0xea9c227723ee8bcbU, 0x92a1958a7675175fU, 0xb749faed14125d36U,
+    0xe51c79a85916f484U, 0x8f31cc0937ae58d2U, 0xb2fe3f0b8599ef07U,
+    0xdfbdcece67006ac9U, 0x8bd6a141006042bdU, 0xaecc49914078536dU,
+    0xda7f5bf590966848U, 0x888f99797a5e012dU, 0xaab37fd7d8f58178U,
+    0xd5605fcdcf32e1d6U, 0x855c3be0a17fcd26U, 0xa6b34ad8c9dfc06fU,
+    0xd0601d8efc57b08bU, 0x823c12795db6ce57U, 0xa2cb1717b52481edU,
+    0xcb7ddcdda26da268U, 0xfe5d54150b090b02U, 0x9efa548d26e5a6e1U,
+    0xc6b8e9b0709f109aU, 0xf867241c8cc6d4c0U, 0x9b407691d7fc44f8U,
+    0xc21094364dfb5636U, 0xf294b943e17a2bc4U, 0x979cf3ca6cec5b5aU,
+    0xbd8430bd08277231U, 0xece53cec4a314ebdU, 0x940f4613ae5ed136U,
+    0xb913179899f68584U, 0xe757dd7ec07426e5U, 0x9096ea6f3848984fU,
+    0xb4bca50b065abe63U, 0xe1ebce4dc7f16dfbU, 0x8d3360f09cf6e4bdU,
+    0xb080392cc4349decU, 0xdca04777f541c567U, 0x89e42caaf9491b60U,
+    0xac5d37d5b79b6239U, 0xd77485cb25823ac7U, 0x86a8d39ef77164bcU,
+    0xa8530886b54dbdebU, 0xd267caa862a12d66U, 0x8380dea93da4bc60U,
+    0xa46116538d0deb78U, 0xcd795be870516656U, 0x806bd9714632dff6U,
+    0xa086cfcd97bf97f3U, 0xc8a883c0fdaf7df0U, 0xfad2a4b13d1b5d6cU,
+    0x9cc3a6eec6311a63U, 0xc3f490aa77bd60fcU, 0xf4f1b4d515acb93bU,
+    0x991711052d8bf3c5U, 0xbf5cd54678eef0b6U, 0xef340a98172aace4U,
+    0x9580869f0e7aac0eU, 0xbae0a846d2195712U, 0xe998d258869facd7U,
+    0x91ff83775423cc06U, 0xb67f6455292cbf08U, 0xe41f3d6a7377eecaU,
+    0x8e938662882af53eU, 0xb23867fb2a35b28dU, 0xdec681f9f4c31f31U,
+    0x8b3c113c38f9f37eU, 0xae0b158b4738705eU, 0xd98ddaee19068c76U,
+    0x87f8a8d4cfa417c9U, 0xa9f6d30a038d1dbcU, 0xd47487cc8470652bU,
+    0x84c8d4dfd2c63f3bU, 0xa5fb0a17c777cf09U, 0xcf79cc9db955c2ccU,
+    0x81ac1fe293d599bfU, 0xa21727db38cb002fU, 0xca9cf1d206fdc03bU,
+    0xfd442e4688bd304aU, 0x9e4a9cec15763e2eU, 0xc5dd44271ad3cdbaU,
+    0xf7549530e188c128U, 0x9a94dd3e8cf578b9U, 0xc13a148e3032d6e7U,
+    0xf18899b1bc3f8ca1U, 0x96f5600f15a7b7e5U, 0xbcb2b812db11a5deU,
+    0xebdf661791d60f56U, 0x936b9fcebb25c995U, 0xb84687c269ef3bfbU,
+    0xe65829b3046b0afaU, 0x8ff71a0fe2c2e6dcU, 0xb3f4e093db73a093U,
+    0xe0f218b8d25088b8U, 0x8c974f7383725573U, 0xafbd2350644eeacfU,
+    0xdbac6c247d62a583U, 0x894bc396ce5da772U, 0xab9eb47c81f5114fU,
+    0xd686619ba27255a2U, 0x8613fd0145877585U, 0xa798fc4196e952e7U,
+    0xd17f3b51fca3a7a0U, 0x82ef85133de648c4U, 0xa3ab66580d5fdaf5U,
+    0xcc963fee10b7d1b3U, 0xffbbcfe994e5c61fU, 0x9fd561f1fd0f9bd3U,
+    0xc7caba6e7c5382c8U, 0xf9bd690a1b68637bU, 0x9c1661a651213e2dU,
+    0xc31bfa0fe5698db8U, 0xf3e2f893dec3f126U, 0x986ddb5c6b3a76b7U,
+    0xbe89523386091465U, 0xee2ba6c0678b597fU, 0x94db483840b717efU,
+    0xba121a4650e4ddebU, 0xe896a0d7e51e1566U, 0x915e2486ef32cd60U,
+    0xb5b5ada8aaff80b8U, 0xe3231912d5bf60e6U, 0x8df5efabc5979c8fU,
+    0xb1736b96b6fd83b3U, 0xddd0467c64bce4a0U, 0x8aa22c0dbef60ee4U,
+    0xad4ab7112eb3929dU, 0xd89d64d57a607744U, 0x87625f056c7c4a8bU,
+    0xa93af6c6c79b5d2dU, 0xd389b47879823479U, 0x843610cb4bf160cbU,
+    0xa54394fe1eedb8feU, 0xce947a3da6a9273eU, 0x811ccc668829b887U,
+    0xa163ff802a3426a8U, 0xc9bcff6034c13052U, 0xfc2c3f3841f17c67U,
+    0x9d9ba7832936edc0U, 0xc5029163f384a931U, 0xf64335bcf065d37dU,
+    0x99ea0196163fa42eU, 0xc06481fb9bcf8d39U, 0xf07da27a82c37088U,
+    0x964e858c91ba2655U, 0xbbe226efb628afeaU, 0xeadab0aba3b2dbe5U,
+    0x92c8ae6b464fc96fU, 0xb77ada0617e3bbcbU, 0xe55990879ddcaabdU,
+    0x8f57fa54c2a9eab6U, 0xb32df8e9f3546564U, 0xdff9772470297ebdU,
+    0x8bfbea76c619ef36U, 0xaefae51477a06b03U, 0xdab99e59958885c4U,
+    0x88b402f7fd75539bU, 0xaae103b5fcd2a881U, 0xd59944a37c0752a2U,
+    0x857fcae62d8493a5U, 0xa6dfbd9fb8e5b88eU, 0xd097ad07a71f26b2U,
+    0x825ecc24c873782fU, 0xa2f67f2dfa90563bU, 0xcbb41ef979346bcaU,
+    0xfea126b7d78186bcU, 0x9f24b832e6b0f436U, 0xc6ede63fa05d3143U,
+    0xf8a95fcf88747d94U, 0x9b69dbe1b548ce7cU, 0xc24452da229b021bU,
+    0xf2d56790ab41c2a2U, 0x97c560ba6b0919a5U, 0xbdb6b8e905cb600fU,
+    0xed246723473e3813U, 0x9436c0760c86e30bU, 0xb94470938fa89bceU,
+    0xe7958cb87392c2c2U, 0x90bd77f3483bb9b9U, 0xb4ecd5f01a4aa828U,
+    0xe2280b6c20dd5232U, 0x8d590723948a535fU, 0xb0af48ec79ace837U,
+    0xdcdb1b2798182244U, 0x8a08f0f8bf0f156bU, 0xac8b2d36eed2dac5U,
+    0xd7adf884aa879177U, 0x86ccbb52ea94baeaU, 0xa87fea27a539e9a5U,
+    0xd29fe4b18e88640eU, 0x83a3eeeef9153e89U, 0xa48ceaaab75a8e2bU,
+    0xcdb02555653131b6U, 0x808e17555f3ebf11U, 0xa0b19d2ab70e6ed6U,
+    0xc8de047564d20a8bU, 0xfb158592be068d2eU, 0x9ced737bb6c4183dU,
+    0xc428d05aa4751e4cU, 0xf53304714d9265dfU, 0x993fe2c6d07b7fabU,
+    0xbf8fdb78849a5f96U, 0xef73d256a5c0f77cU, 0x95a8637627989aadU,
+    0xbb127c53b17ec159U, 0xe9d71b689dde71afU, 0x9226712162ab070dU,
+    0xb6b00d69bb55c8d1U, 0xe45c10c42a2b3b05U, 0x8eb98a7a9a5b04e3U,
+    0xb267ed1940f1c61cU, 0xdf01e85f912e37a3U, 0x8b61313bbabce2c6U,
+    0xae397d8aa96c1b77U, 0xd9c7dced53c72255U, 0x881cea14545c7575U,
+    0xaa242499697392d2U, 0xd4ad2dbfc3d07787U, 0x84ec3c97da624ab4U,
+    0xa6274bbdd0fadd61U, 0xcfb11ead453994baU, 0x81ceb32c4b43fcf4U,
+    0xa2425ff75e14fc31U, 0xcad2f7f5359a3b3eU, 0xfd87b5f28300ca0dU,
+    0x9e74d1b791e07e48U, 0xc612062576589ddaU, 0xf79687aed3eec551U,
+    0x9abe14cd44753b52U, 0xc16d9a0095928a27U, 0xf1c90080baf72cb1U,
+    0x971da05074da7beeU, 0xbce5086492111aeaU, 0xec1e4a7db69561a5U,
+    0x9392ee8e921d5d07U, 0xb877aa3236a4b449U, 0xe69594bec44de15bU,
+    0x901d7cf73ab0acd9U, 0xb424dc35095cd80fU, 0xe12e13424bb40e13U,
+    0x8cbccc096f5088cbU, 0xafebff0bcb24aafeU, 0xdbe6fecebdedd5beU,
+    0x89705f4136b4a597U, 0xabcc77118461cefcU, 0xd6bf94d5e57a42bcU,
+    0x8637bd05af6c69b5U, 0xa7c5ac471b478423U, 0xd1b71758e219652bU,
+    0x83126e978d4fdf3bU, 0xa3d70a3d70a3d70aU, 0xccccccccccccccccU,
+    0x8000000000000000U, 0xa000000000000000U, 0xc800000000000000U,
+    0xfa00000000000000U, 0x9c40000000000000U, 0xc350000000000000U,
+    0xf424000000000000U, 0x9896800000000000U, 0xbebc200000000000U,
+    0xee6b280000000000U, 0x9502f90000000000U, 0xba43b74000000000U,
+    0xe8d4a51000000000U, 0x9184e72a00000000U, 0xb5e620f480000000U,
+    0xe35fa931a0000000U, 0x8e1bc9bf04000000U, 0xb1a2bc2ec5000000U,
+    0xde0b6b3a76400000U, 0x8ac7230489e80000U, 0xad78ebc5ac620000U,
+    0xd8d726b7177a8000U, 0x878678326eac9000U, 0xa968163f0a57b400U,
+    0xd3c21bcecceda100U, 0x84595161401484a0U, 0xa56fa5b99019a5c8U,
+    0xcecb8f27f4200f3aU, 0x813f3978f8940984U, 0xa18f07d736b90be5U,
+    0xc9f2c9cd04674edeU, 0xfc6f7c4045812296U, 0x9dc5ada82b70b59dU,
+    0xc5371912364ce305U, 0xf684df56c3e01bc6U, 0x9a130b963a6c115cU,
+    0xc097ce7bc90715b3U, 0xf0bdc21abb48db20U, 0x96769950b50d88f4U,
+    0xbc143fa4e250eb31U, 0xeb194f8e1ae525fdU, 0x92efd1b8d0cf37beU,
+    0xb7abc627050305adU, 0xe596b7b0c643c719U, 0x8f7e32ce7bea5c6fU,
+    0xb35dbf821ae4f38bU, 0xe0352f62a19e306eU, 0x8c213d9da502de45U,
+    0xaf298d050e4395d6U, 0xdaf3f04651d47b4cU, 0x88d8762bf324cd0fU,
+    0xab0e93b6efee0053U, 0xd5d238a4abe98068U, 0x85a36366eb71f041U,
+    0xa70c3c40a64e6c51U, 0xd0cf4b50cfe20765U, 0x82818f1281ed449fU,
+    0xa321f2d7226895c7U, 0xcbea6f8ceb02bb39U, 0xfee50b7025c36a08U,
+    0x9f4f2726179a2245U, 0xc722f0ef9d80aad6U, 0xf8ebad2b84e0d58bU,
+    0x9b934c3b330c8577U, 0xc2781f49ffcfa6d5U, 0xf316271c7fc3908aU,
+    0x97edd871cfda3a56U, 0xbde94e8e43d0c8ecU, 0xed63a231d4c4fb27U,
+    0x945e455f24fb1cf8U, 0xb975d6b6ee39e436U, 0xe7d34c64a9c85d44U,
+    0x90e40fbeea1d3a4aU, 0xb51d13aea4a488ddU, 0xe264589a4dcdab14U,
+    0x8d7eb76070a08aecU, 0xb0de65388cc8ada8U, 0xdd15fe86affad912U,
+    0x8a2dbf142dfcc7abU, 0xacb92ed9397bf996U, 0xd7e77a8f87daf7fbU,
+    0x86f0ac99b4e8dafdU, 0xa8acd7c0222311bcU, 0xd2d80db02aabd62bU,
+    0x83c7088e1aab65dbU, 0xa4b8cab1a1563f52U, 0xcde6fd5e09abcf26U,
+    0x80b05e5ac60b6178U, 0xa0dc75f1778e39d6U, 0xc913936dd571c84cU,
+    0xfb5878494ace3a5fU, 0x9d174b2dcec0e47bU, 0xc45d1df942711d9aU,
+    0xf5746577930d6500U, 0x9968bf6abbe85f20U, 0xbfc2ef456ae276e8U,
+    0xefb3ab16c59b14a2U, 0x95d04aee3b80ece5U, 0xbb445da9ca61281fU,
+    0xea1575143cf97226U, 0x924d692ca61be758U, 0xb6e0c377cfa2e12eU,
+    0xe498f455c38b997aU, 0x8edf98b59a373fecU, 0xb2977ee300c50fe7U,
+    0xdf3d5e9bc0f653e1U, 0x8b865b215899f46cU, 0xae67f1e9aec07187U,
+    0xda01ee641a708de9U, 0x884134fe908658b2U, 0xaa51823e34a7eedeU,
+    0xd4e5e2cdc1d1ea96U, 0x850fadc09923329eU, 0xa6539930bf6bff45U,
+    0xcfe87f7cef46ff16U, 0x81f14fae158c5f6eU, 0xa26da3999aef7749U,
+    0xcb090c8001ab551cU, 0xfdcb4fa002162a63U, 0x9e9f11c4014dda7eU,
+    0xc646d63501a1511dU, 0xf7d88bc24209a565U, 0x9ae757596946075fU,
+    0xc1a12d2fc3978937U, 0xf209787bb47d6b84U, 0x9745eb4d50ce6332U,
+    0xbd176620a501fbffU, 0xec5d3fa8ce427affU, 0x93ba47c980e98cdfU,
+    0xb8a8d9bbe123f017U, 0xe6d3102ad96cec1dU, 0x9043ea1ac7e41392U,
+    0xb454e4a179dd1877U, 0xe16a1dc9d8545e94U, 0x8ce2529e2734bb1dU,
+    0xb01ae745b101e9e4U, 0xdc21a1171d42645dU, 0x899504ae72497ebaU,
+    0xabfa45da0edbde69U, 0xd6f8d7509292d603U, 0x865b86925b9bc5c2U,
+    0xa7f26836f282b732U, 0xd1ef0244af2364ffU, 0x8335616aed761f1fU,
+    0xa402b9c5a8d3a6e7U, 0xcd036837130890a1U, 0x802221226be55a64U,
+    0xa02aa96b06deb0fdU, 0xc83553c5c8965d3dU, 0xfa42a8b73abbf48cU,
+    0x9c69a97284b578d7U, 0xc38413cf25e2d70dU, 0xf46518c2ef5b8cd1U,
+    0x98bf2f79d5993802U, 0xbeeefb584aff8603U, 0xeeaaba2e5dbf6784U,
+    0x952ab45cfa97a0b2U, 0xba756174393d88dfU, 0xe912b9d1478ceb17U,
+    0x91abb422ccb812eeU, 0xb616a12b7fe617aaU, 0xe39c49765fdf9d94U,
+    0x8e41ade9fbebc27dU, 0xb1d219647ae6b31cU, 0xde469fbd99a05fe3U,
+    0x8aec23d680043beeU, 0xada72ccc20054ae9U, 0xd910f7ff28069da4U,
+    0x87aa9aff79042286U, 0xa99541bf57452b28U, 0xd3fa922f2d1675f2U,
+    0x847c9b5d7c2e09b7U, 0xa59bc234db398c25U, 0xcf02b2c21207ef2eU,
+    0x8161afb94b44f57dU, 0xa1ba1ba79e1632dcU, 0xca28a291859bbf93U,
+    0xfcb2cb35e702af78U, 0x9defbf01b061adabU, 0xc56baec21c7a1916U,
+    0xf6c69a72a3989f5bU, 0x9a3c2087a63f6399U, 0xc0cb28a98fcf3c7fU,
+    0xf0fdf2d3f3c30b9fU, 0x969eb7c47859e743U, 0xbc4665b596706114U,
+    0xeb57ff22fc0c7959U, 0x9316ff75dd87cbd8U, 0xb7dcbf5354e9beceU,
+    0xe5d3ef282a242e81U, 0x8fa475791a569d10U, 0xb38d92d760ec4455U,
+    0xe070f78d3927556aU, 0x8c469ab843b89562U, 0xaf58416654a6babbU,
+    0xdb2e51bfe9d0696aU, 0x88fcf317f22241e2U, 0xab3c2fddeeaad25aU,
+    0xd60b3bd56a5586f1U, 0x85c7056562757456U, 0xa738c6bebb12d16cU,
+    0xd106f86e69d785c7U, 0x82a45b450226b39cU, 0xa34d721642b06084U,
+    0xcc20ce9bd35c78a5U, 0xff290242c83396ceU, 0x9f79a169bd203e41U,
+    0xc75809c42c684dd1U, 0xf92e0c3537826145U, 0x9bbcc7a142b17ccbU,
+    0xc2abf989935ddbfeU, 0xf356f7ebf83552feU, 0x98165af37b2153deU,
+    0xbe1bf1b059e9a8d6U, 0xeda2ee1c7064130cU, 0x9485d4d1c63e8be7U,
+    0xb9a74a0637ce2ee1U, 0xe8111c87c5c1ba99U, 0x910ab1d4db9914a0U,
+    0xb54d5e4a127f59c8U, 0xe2a0b5dc971f303aU, 0x8da471a9de737e24U,
+    0xb10d8e1456105dadU, 0xdd50f1996b947518U, 0x8a5296ffe33cc92fU,
+    0xace73cbfdc0bfb7bU, 0xd8210befd30efa5aU, 0x8714a775e3e95c78U,
+    0xa8d9d1535ce3b396U, 0xd31045a8341ca07cU, 0x83ea2b892091e44dU,
+    0xa4e4b66b68b65d60U, 0xce1de40642e3f4b9U, 0x80d2ae83e9ce78f3U,
+    0xa1075a24e4421730U, 0xc94930ae1d529cfcU, 0xfb9b7cd9a4a7443cU,
+    0x9d412e0806e88aa5U, 0xc491798a08a2ad4eU, 0xf5b5d7ec8acb58a2U,
+    0x9991a6f3d6bf1765U, 0xbff610b0cc6edd3fU, 0xeff394dcff8a948eU,
+    0x95f83d0a1fb69cd9U, 0xbb764c4ca7a4440fU, 0xea53df5fd18d5513U,
+    0x92746b9be2f8552cU, 0xb7118682dbb66a77U, 0xe4d5e82392a40515U,
+    0x8f05b1163ba6832dU, 0xb2c71d5bca9023f8U, 0xdf78e4b2bd342cf6U,
+    0x8bab8eefb6409c1aU, 0xae9672aba3d0c320U, 0xda3c0f568cc4f3e8U,
+    0x8865899617fb1871U, 0xaa7eebfb9df9de8dU, 0xd51ea6fa85785631U,
+    0x8533285c936b35deU, 0xa67ff273b8460356U, 0xd01fef10a657842cU,
+    0x8213f56a67f6b29bU, 0xa298f2c501f45f42U, 0xcb3f2f7642717713U,
+    0xfe0efb53d30dd4d7U, 0x9ec95d1463e8a506U, 0xc67bb4597ce2ce48U,
+    0xf81aa16fdc1b81daU, 0x9b10a4e5e9913128U, 0xc1d4ce1f63f57d72U,
+    0xf24a01a73cf2dccfU, 0x976e41088617ca01U, 0xbd49d14aa79dbc82U,
+    0xec9c459d51852ba2U, 0x93e1ab8252f33b45U, 0xb8da1662e7b00a17U,
+    0xe7109bfba19c0c9dU, 0x906a617d450187e2U, 0xb484f9dc9641e9daU,
+    0xe1a63853bbd26451U, 0x8d07e33455637eb2U, 0xb049dc016abc5e5fU,
+    0xdc5c5301c56b75f7U, 0x89b9b3e11b6329baU, 0xac2820d9623bf429U,
+    0xd732290fbacaf133U, 0x867f59a9d4bed6c0U, 0xa81f301449ee8c70U,
+    0xd226fc195c6a2f8cU, 0x83585d8fd9c25db7U, 0xa42e74f3d032f525U,
+    0xcd3a1230c43fb26fU, 0x80444b5e7aa7cf85U, 0xa0555e361951c366U,
+    0xc86ab5c39fa63440U, 0xfa856334878fc150U, 0x9c935e00d4b9d8d2U,
+    0xc3b8358109e84f07U, 0xf4a642e14c6262c8U, 0x98e7e9cccfbd7dbdU,
+    0xbf21e44003acdd2cU, 0xeeea5d5004981478U, 0x95527a5202df0ccbU,
+    0xbaa718e68396cffdU, 0xe950df20247c83fdU, 0x91d28b7416cdd27eU,
+    0xb6472e511c81471dU, 0xe3d8f9e563a198e5U, 0x8e679c2f5e44ff8fU,
+};
+
+const int16_t kPower10ExponentTable[] = {
+    -1200, -1196, -1193, -1190, -1186, -1183, -1180, -1176, -1173, -1170, -1166,
+    -1163, -1160, -1156, -1153, -1150, -1146, -1143, -1140, -1136, -1133, -1130,
+    -1127, -1123, -1120, -1117, -1113, -1110, -1107, -1103, -1100, -1097, -1093,
+    -1090, -1087, -1083, -1080, -1077, -1073, -1070, -1067, -1063, -1060, -1057,
+    -1053, -1050, -1047, -1043, -1040, -1037, -1034, -1030, -1027, -1024, -1020,
+    -1017, -1014, -1010, -1007, -1004, -1000, -997,  -994,  -990,  -987,  -984,
+    -980,  -977,  -974,  -970,  -967,  -964,  -960,  -957,  -954,  -950,  -947,
+    -944,  -940,  -937,  -934,  -931,  -927,  -924,  -921,  -917,  -914,  -911,
+    -907,  -904,  -901,  -897,  -894,  -891,  -887,  -884,  -881,  -877,  -874,
+    -871,  -867,  -864,  -861,  -857,  -854,  -851,  -847,  -844,  -841,  -838,
+    -834,  -831,  -828,  -824,  -821,  -818,  -814,  -811,  -808,  -804,  -801,
+    -798,  -794,  -791,  -788,  -784,  -781,  -778,  -774,  -771,  -768,  -764,
+    -761,  -758,  -754,  -751,  -748,  -744,  -741,  -738,  -735,  -731,  -728,
+    -725,  -721,  -718,  -715,  -711,  -708,  -705,  -701,  -698,  -695,  -691,
+    -688,  -685,  -681,  -678,  -675,  -671,  -668,  -665,  -661,  -658,  -655,
+    -651,  -648,  -645,  -642,  -638,  -635,  -632,  -628,  -625,  -622,  -618,
+    -615,  -612,  -608,  -605,  -602,  -598,  -595,  -592,  -588,  -585,  -582,
+    -578,  -575,  -572,  -568,  -565,  -562,  -558,  -555,  -552,  -549,  -545,
+    -542,  -539,  -535,  -532,  -529,  -525,  -522,  -519,  -515,  -512,  -509,
+    -505,  -502,  -499,  -495,  -492,  -489,  -485,  -482,  -479,  -475,  -472,
+    -469,  -465,  -462,  -459,  -455,  -452,  -449,  -446,  -442,  -439,  -436,
+    -432,  -429,  -426,  -422,  -419,  -416,  -412,  -409,  -406,  -402,  -399,
+    -396,  -392,  -389,  -386,  -382,  -379,  -376,  -372,  -369,  -366,  -362,
+    -359,  -356,  -353,  -349,  -346,  -343,  -339,  -336,  -333,  -329,  -326,
+    -323,  -319,  -316,  -313,  -309,  -306,  -303,  -299,  -296,  -293,  -289,
+    -286,  -283,  -279,  -276,  -273,  -269,  -266,  -263,  -259,  -256,  -253,
+    -250,  -246,  -243,  -240,  -236,  -233,  -230,  -226,  -223,  -220,  -216,
+    -213,  -210,  -206,  -203,  -200,  -196,  -193,  -190,  -186,  -183,  -180,
+    -176,  -173,  -170,  -166,  -163,  -160,  -157,  -153,  -150,  -147,  -143,
+    -140,  -137,  -133,  -130,  -127,  -123,  -120,  -117,  -113,  -110,  -107,
+    -103,  -100,  -97,   -93,   -90,   -87,   -83,   -80,   -77,   -73,   -70,
+    -67,   -63,   -60,   -57,   -54,   -50,   -47,   -44,   -40,   -37,   -34,
+    -30,   -27,   -24,   -20,   -17,   -14,   -10,   -7,    -4,    0,     3,
+    6,     10,    13,    16,    20,    23,    26,    30,    33,    36,    39,
+    43,    46,    49,    53,    56,    59,    63,    66,    69,    73,    76,
+    79,    83,    86,    89,    93,    96,    99,    103,   106,   109,   113,
+    116,   119,   123,   126,   129,   132,   136,   139,   142,   146,   149,
+    152,   156,   159,   162,   166,   169,   172,   176,   179,   182,   186,
+    189,   192,   196,   199,   202,   206,   209,   212,   216,   219,   222,
+    226,   229,   232,   235,   239,   242,   245,   249,   252,   255,   259,
+    262,   265,   269,   272,   275,   279,   282,   285,   289,   292,   295,
+    299,   302,   305,   309,   312,   315,   319,   322,   325,   328,   332,
+    335,   338,   342,   345,   348,   352,   355,   358,   362,   365,   368,
+    372,   375,   378,   382,   385,   388,   392,   395,   398,   402,   405,
+    408,   412,   415,   418,   422,   425,   428,   431,   435,   438,   441,
+    445,   448,   451,   455,   458,   461,   465,   468,   471,   475,   478,
+    481,   485,   488,   491,   495,   498,   501,   505,   508,   511,   515,
+    518,   521,   524,   528,   531,   534,   538,   541,   544,   548,   551,
+    554,   558,   561,   564,   568,   571,   574,   578,   581,   584,   588,
+    591,   594,   598,   601,   604,   608,   611,   614,   617,   621,   624,
+    627,   631,   634,   637,   641,   644,   647,   651,   654,   657,   661,
+    664,   667,   671,   674,   677,   681,   684,   687,   691,   694,   697,
+    701,   704,   707,   711,   714,   717,   720,   724,   727,   730,   734,
+    737,   740,   744,   747,   750,   754,   757,   760,   764,   767,   770,
+    774,   777,   780,   784,   787,   790,   794,   797,   800,   804,   807,
+    810,   813,   817,   820,   823,   827,   830,   833,   837,   840,   843,
+    847,   850,   853,   857,   860,   863,   867,   870,   873,   877,   880,
+    883,   887,   890,   893,   897,   900,   903,   907,   910,   913,   916,
+    920,   923,   926,   930,   933,   936,   940,   943,   946,   950,   953,
+    956,   960,
+};
+
+}  // namespace
+}  // namespace absl
diff --git a/third_party/abseil-cpp/absl/strings/charconv.h b/third_party/abseil-cpp/absl/strings/charconv.h
new file mode 100644
index 0000000000..3e313679c9
--- /dev/null
+++ b/third_party/abseil-cpp/absl/strings/charconv.h
@@ -0,0 +1,115 @@
+// 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
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_STRINGS_CHARCONV_H_
+#define ABSL_STRINGS_CHARCONV_H_
+
+#include <system_error>  // NOLINT(build/c++11)
+
+namespace absl {
+
+// Workalike compatibilty version of std::chars_format from C++17.
+//
+// This is an bitfield enumerator which can be passed to absl::from_chars to
+// configure the std::string-to-float conversion.
+enum class chars_format {
+  scientific = 1,
+  fixed = 2,
+  hex = 4,
+  general = fixed | scientific,
+};
+
+// The return result of a std::string-to-number conversion.
+//
+// `ec` will be set to `invalid_argument` if a well-formed number was not found
+// at the start of the input range, `result_out_of_range` if a well-formed
+// number was found, but it was out of the representable range of the requested
+// type, or to std::errc() otherwise.
+//
+// If a well-formed number was found, `ptr` is set to one past the sequence of
+// characters that were successfully parsed.  If none was found, `ptr` is set
+// to the `first` argument to from_chars.
+struct from_chars_result {
+  const char* ptr;
+  std::errc ec;
+};
+
+// Workalike compatibilty version of std::from_chars from C++17.  Currently
+// this only supports the `double` and `float` types.
+//
+// This interface incorporates the proposed resolutions for library issues
+// DR 3800 and DR 3801.  If these are adopted with different wording,
+// Abseil's behavior will change to match the standard.  (The behavior most
+// likely to change is for DR 3801, which says what `value` will be set to in
+// the case of overflow and underflow.  Code that wants to avoid possible
+// breaking changes in this area should not depend on `value` when the returned
+// from_chars_result indicates a range error.)
+//
+// Searches the range [first, last) for the longest matching pattern beginning
+// at `first` that represents a floating point number.  If one is found, store
+// the result in `value`.
+//
+// The matching pattern format is almost the same as that of strtod(), except
+// that C locale is not respected, and an initial '+' character in the input
+// range will never be matched.
+//
+// If `fmt` is set, it must be one of the enumerator values of the chars_format.
+// (This is despite the fact that chars_format is a bitmask type.)  If set to
+// `scientific`, a matching number must contain an exponent.  If set to `fixed`,
+// then an exponent will never match.  (For example, the std::string "1e5" will be
+// parsed as "1".)  If set to `hex`, then a hexadecimal float is parsed in the
+// format that strtod() accepts, except that a "0x" prefix is NOT matched.
+// (In particular, in `hex` mode, the input "0xff" results in the largest
+// matching pattern "0".)
+absl::from_chars_result from_chars(const char* first, const char* last,
+                                   double& value,  // NOLINT
+                                   chars_format fmt = chars_format::general);
+
+absl::from_chars_result from_chars(const char* first, const char* last,
+                                   float& value,  // NOLINT
+                                   chars_format fmt = chars_format::general);
+
+// std::chars_format is specified as a bitmask type, which means the following
+// operations must be provided:
+inline constexpr chars_format operator&(chars_format lhs, chars_format rhs) {
+  return static_cast<chars_format>(static_cast<int>(lhs) &
+                                   static_cast<int>(rhs));
+}
+inline constexpr chars_format operator|(chars_format lhs, chars_format rhs) {
+  return static_cast<chars_format>(static_cast<int>(lhs) |
+                                   static_cast<int>(rhs));
+}
+inline constexpr chars_format operator^(chars_format lhs, chars_format rhs) {
+  return static_cast<chars_format>(static_cast<int>(lhs) ^
+                                   static_cast<int>(rhs));
+}
+inline constexpr chars_format operator~(chars_format arg) {
+  return static_cast<chars_format>(~static_cast<int>(arg));
+}
+inline chars_format& operator&=(chars_format& lhs, chars_format rhs) {
+  lhs = lhs & rhs;
+  return lhs;
+}
+inline chars_format& operator|=(chars_format& lhs, chars_format rhs) {
+  lhs = lhs | rhs;
+  return lhs;
+}
+inline chars_format& operator^=(chars_format& lhs, chars_format rhs) {
+  lhs = lhs ^ rhs;
+  return lhs;
+}
+
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_CHARCONV_H_
diff --git a/third_party/abseil-cpp/absl/strings/charconv_benchmark.cc b/third_party/abseil-cpp/absl/strings/charconv_benchmark.cc
new file mode 100644
index 0000000000..fd83f44e3d
--- /dev/null
+++ b/third_party/abseil-cpp/absl/strings/charconv_benchmark.cc
@@ -0,0 +1,204 @@
+// 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
+//
+//      http://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/strings/charconv.h"
+
+#include <cstdlib>
+#include <cstring>
+#include <string>
+
+#include "benchmark/benchmark.h"
+
+namespace {
+
+void BM_Strtod_Pi(benchmark::State& state) {
+  const char* pi = "3.14159";
+  for (auto s : state) {
+    benchmark::DoNotOptimize(pi);
+    benchmark::DoNotOptimize(strtod(pi, nullptr));
+  }
+}
+BENCHMARK(BM_Strtod_Pi);
+
+void BM_Absl_Pi(benchmark::State& state) {
+  const char* pi = "3.14159";
+  const char* pi_end = pi + strlen(pi);
+  for (auto s : state) {
+    benchmark::DoNotOptimize(pi);
+    double v;
+    absl::from_chars(pi, pi_end, v);
+    benchmark::DoNotOptimize(v);
+  }
+}
+BENCHMARK(BM_Absl_Pi);
+
+void BM_Strtod_Pi_float(benchmark::State& state) {
+  const char* pi = "3.14159";
+  for (auto s : state) {
+    benchmark::DoNotOptimize(pi);
+    benchmark::DoNotOptimize(strtof(pi, nullptr));
+  }
+}
+BENCHMARK(BM_Strtod_Pi_float);
+
+void BM_Absl_Pi_float(benchmark::State& state) {
+  const char* pi = "3.14159";
+  const char* pi_end = pi + strlen(pi);
+  for (auto s : state) {
+    benchmark::DoNotOptimize(pi);
+    float v;
+    absl::from_chars(pi, pi_end, v);
+    benchmark::DoNotOptimize(v);
+  }
+}
+BENCHMARK(BM_Absl_Pi_float);
+
+void BM_Strtod_HardLarge(benchmark::State& state) {
+  const char* num = "272104041512242479.e200";
+  for (auto s : state) {
+    benchmark::DoNotOptimize(num);
+    benchmark::DoNotOptimize(strtod(num, nullptr));
+  }
+}
+BENCHMARK(BM_Strtod_HardLarge);
+
+void BM_Absl_HardLarge(benchmark::State& state) {
+  const char* numstr = "272104041512242479.e200";
+  const char* numstr_end = numstr + strlen(numstr);
+  for (auto s : state) {
+    benchmark::DoNotOptimize(numstr);
+    double v;
+    absl::from_chars(numstr, numstr_end, v);
+    benchmark::DoNotOptimize(v);
+  }
+}
+BENCHMARK(BM_Absl_HardLarge);
+
+void BM_Strtod_HardSmall(benchmark::State& state) {
+  const char* num = "94080055902682397.e-242";
+  for (auto s : state) {
+    benchmark::DoNotOptimize(num);
+    benchmark::DoNotOptimize(strtod(num, nullptr));
+  }
+}
+BENCHMARK(BM_Strtod_HardSmall);
+
+void BM_Absl_HardSmall(benchmark::State& state) {
+  const char* numstr = "94080055902682397.e-242";
+  const char* numstr_end = numstr + strlen(numstr);
+  for (auto s : state) {
+    benchmark::DoNotOptimize(numstr);
+    double v;
+    absl::from_chars(numstr, numstr_end, v);
+    benchmark::DoNotOptimize(v);
+  }
+}
+BENCHMARK(BM_Absl_HardSmall);
+
+void BM_Strtod_HugeMantissa(benchmark::State& state) {
+  std::string huge(200, '3');
+  const char* num = huge.c_str();
+  for (auto s : state) {
+    benchmark::DoNotOptimize(num);
+    benchmark::DoNotOptimize(strtod(num, nullptr));
+  }
+}
+BENCHMARK(BM_Strtod_HugeMantissa);
+
+void BM_Absl_HugeMantissa(benchmark::State& state) {
+  std::string huge(200, '3');
+  const char* num = huge.c_str();
+  const char* num_end = num + 200;
+  for (auto s : state) {
+    benchmark::DoNotOptimize(num);
+    double v;
+    absl::from_chars(num, num_end, v);
+    benchmark::DoNotOptimize(v);
+  }
+}
+BENCHMARK(BM_Absl_HugeMantissa);
+
+std::string MakeHardCase(int length) {
+  // The number 1.1521...e-297 is exactly halfway between 12345 * 2**-1000 and
+  // the next larger representable number.  The digits of this number are in
+  // the std::string below.
+  const std::string digits =
+      "1."
+      "152113937042223790993097181572444900347587985074226836242307364987727724"
+      "831384300183638649152607195040591791364113930628852279348613864894524591"
+      "272746490313676832900762939595690019745859128071117417798540258114233761"
+      "012939937017879509401007964861774960297319002612457273148497158989073482"
+      "171377406078223015359818300988676687994537274548940612510414856761641652"
+      "513434981938564294004070500716200446656421722229202383105446378511678258"
+      "370570631774499359748259931676320916632111681001853983492795053244971606"
+      "922718923011680846577744433974087653954904214152517799883551075537146316"
+      "168973685866425605046988661997658648354773076621610279716804960009043764"
+      "038392994055171112475093876476783502487512538082706095923790634572014823"
+      "78877699375152587890625" +
+      std::string(5000, '0');
+  // generate the hard cases on either side for the given length.
+  // Lengths between 3 and 1000 are reasonable.
+  return digits.substr(0, length) + "1e-297";
+}
+
+void BM_Strtod_Big_And_Difficult(benchmark::State& state) {
+  std::string testcase = MakeHardCase(state.range(0));
+  const char* begin = testcase.c_str();
+  for (auto s : state) {
+    benchmark::DoNotOptimize(begin);
+    benchmark::DoNotOptimize(strtod(begin, nullptr));
+  }
+}
+BENCHMARK(BM_Strtod_Big_And_Difficult)->Range(3, 5000);
+
+void BM_Absl_Big_And_Difficult(benchmark::State& state) {
+  std::string testcase = MakeHardCase(state.range(0));
+  const char* begin = testcase.c_str();
+  const char* end = begin + testcase.size();
+  for (auto s : state) {
+    benchmark::DoNotOptimize(begin);
+    double v;
+    absl::from_chars(begin, end, v);
+    benchmark::DoNotOptimize(v);
+  }
+}
+BENCHMARK(BM_Absl_Big_And_Difficult)->Range(3, 5000);
+
+}  // namespace
+
+// ------------------------------------------------------------------------
+// Benchmark                                 Time           CPU Iterations
+// ------------------------------------------------------------------------
+// BM_Strtod_Pi                             96 ns         96 ns    6337454
+// BM_Absl_Pi                               35 ns         35 ns   20031996
+// BM_Strtod_Pi_float                       91 ns         91 ns    7745851
+// BM_Absl_Pi_float                         35 ns         35 ns   20430298
+// BM_Strtod_HardLarge                     133 ns        133 ns    5288341
+// BM_Absl_HardLarge                       181 ns        181 ns    3855615
+// BM_Strtod_HardSmall                     279 ns        279 ns    2517243
+// BM_Absl_HardSmall                       287 ns        287 ns    2458744
+// BM_Strtod_HugeMantissa                  433 ns        433 ns    1604293
+// BM_Absl_HugeMantissa                    160 ns        160 ns    4403671
+// BM_Strtod_Big_And_Difficult/3           236 ns        236 ns    2942496
+// BM_Strtod_Big_And_Difficult/8           232 ns        232 ns    2983796
+// BM_Strtod_Big_And_Difficult/64          437 ns        437 ns    1591951
+// BM_Strtod_Big_And_Difficult/512        1738 ns       1738 ns     402519
+// BM_Strtod_Big_And_Difficult/4096       3943 ns       3943 ns     176128
+// BM_Strtod_Big_And_Difficult/5000       4397 ns       4397 ns     157878
+// BM_Absl_Big_And_Difficult/3              39 ns         39 ns   17799583
+// BM_Absl_Big_And_Difficult/8              43 ns         43 ns   16096859
+// BM_Absl_Big_And_Difficult/64            550 ns        550 ns    1259717
+// BM_Absl_Big_And_Difficult/512          4167 ns       4167 ns     171414
+// BM_Absl_Big_And_Difficult/4096         9160 ns       9159 ns      76297
+// BM_Absl_Big_And_Difficult/5000         9738 ns       9738 ns      70140
diff --git a/third_party/abseil-cpp/absl/strings/charconv_test.cc b/third_party/abseil-cpp/absl/strings/charconv_test.cc
new file mode 100644
index 0000000000..f8d71cc6c4
--- /dev/null
+++ b/third_party/abseil-cpp/absl/strings/charconv_test.cc
@@ -0,0 +1,766 @@
+// 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
+//
+//      http://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/strings/charconv.h"
+
+#include <cstdlib>
+#include <string>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/strings/str_cat.h"
+
+#ifdef _MSC_FULL_VER
+#define ABSL_COMPILER_DOES_EXACT_ROUNDING 0
+#define ABSL_STRTOD_HANDLES_NAN_CORRECTLY 0
+#else
+#define ABSL_COMPILER_DOES_EXACT_ROUNDING 1
+#define ABSL_STRTOD_HANDLES_NAN_CORRECTLY 1
+#endif
+
+namespace {
+
+#if ABSL_COMPILER_DOES_EXACT_ROUNDING
+
+// Tests that the given std::string is accepted by absl::from_chars, and that it
+// converts exactly equal to the given number.
+void TestDoubleParse(absl::string_view str, double expected_number) {
+  SCOPED_TRACE(str);
+  double actual_number = 0.0;
+  absl::from_chars_result result =
+      absl::from_chars(str.data(), str.data() + str.length(), actual_number);
+  EXPECT_EQ(result.ec, std::errc());
+  EXPECT_EQ(result.ptr, str.data() + str.length());
+  EXPECT_EQ(actual_number, expected_number);
+}
+
+void TestFloatParse(absl::string_view str, float expected_number) {
+  SCOPED_TRACE(str);
+  float actual_number = 0.0;
+  absl::from_chars_result result =
+      absl::from_chars(str.data(), str.data() + str.length(), actual_number);
+  EXPECT_EQ(result.ec, std::errc());
+  EXPECT_EQ(result.ptr, str.data() + str.length());
+  EXPECT_EQ(actual_number, expected_number);
+}
+
+// Tests that the given double or single precision floating point literal is
+// parsed correctly by absl::from_chars.
+//
+// These convenience macros assume that the C++ compiler being used also does
+// fully correct decimal-to-binary conversions.
+#define FROM_CHARS_TEST_DOUBLE(number)     \
+  {                                        \
+    TestDoubleParse(#number, number);      \
+    TestDoubleParse("-" #number, -number); \
+  }
+
+#define FROM_CHARS_TEST_FLOAT(number)        \
+  {                                          \
+    TestFloatParse(#number, number##f);      \
+    TestFloatParse("-" #number, -number##f); \
+  }
+
+TEST(FromChars, NearRoundingCases) {
+  // Cases from "A Program for Testing IEEE Decimal-Binary Conversion"
+  // by Vern Paxson.
+
+  // Forms that should round towards zero.  (These are the hardest cases for
+  // each decimal mantissa size.)
+  FROM_CHARS_TEST_DOUBLE(5.e125);
+  FROM_CHARS_TEST_DOUBLE(69.e267);
+  FROM_CHARS_TEST_DOUBLE(999.e-026);
+  FROM_CHARS_TEST_DOUBLE(7861.e-034);
+  FROM_CHARS_TEST_DOUBLE(75569.e-254);
+  FROM_CHARS_TEST_DOUBLE(928609.e-261);
+  FROM_CHARS_TEST_DOUBLE(9210917.e080);
+  FROM_CHARS_TEST_DOUBLE(84863171.e114);
+  FROM_CHARS_TEST_DOUBLE(653777767.e273);
+  FROM_CHARS_TEST_DOUBLE(5232604057.e-298);
+  FROM_CHARS_TEST_DOUBLE(27235667517.e-109);
+  FROM_CHARS_TEST_DOUBLE(653532977297.e-123);
+  FROM_CHARS_TEST_DOUBLE(3142213164987.e-294);
+  FROM_CHARS_TEST_DOUBLE(46202199371337.e-072);
+  FROM_CHARS_TEST_DOUBLE(231010996856685.e-073);
+  FROM_CHARS_TEST_DOUBLE(9324754620109615.e212);
+  FROM_CHARS_TEST_DOUBLE(78459735791271921.e049);
+  FROM_CHARS_TEST_DOUBLE(272104041512242479.e200);
+  FROM_CHARS_TEST_DOUBLE(6802601037806061975.e198);
+  FROM_CHARS_TEST_DOUBLE(20505426358836677347.e-221);
+  FROM_CHARS_TEST_DOUBLE(836168422905420598437.e-234);
+  FROM_CHARS_TEST_DOUBLE(4891559871276714924261.e222);
+  FROM_CHARS_TEST_FLOAT(5.e-20);
+  FROM_CHARS_TEST_FLOAT(67.e14);
+  FROM_CHARS_TEST_FLOAT(985.e15);
+  FROM_CHARS_TEST_FLOAT(7693.e-42);
+  FROM_CHARS_TEST_FLOAT(55895.e-16);
+  FROM_CHARS_TEST_FLOAT(996622.e-44);
+  FROM_CHARS_TEST_FLOAT(7038531.e-32);
+  FROM_CHARS_TEST_FLOAT(60419369.e-46);
+  FROM_CHARS_TEST_FLOAT(702990899.e-20);
+  FROM_CHARS_TEST_FLOAT(6930161142.e-48);
+  FROM_CHARS_TEST_FLOAT(25933168707.e-13);
+  FROM_CHARS_TEST_FLOAT(596428896559.e20);
+
+  // Similarly, forms that should round away from zero.
+  FROM_CHARS_TEST_DOUBLE(9.e-265);
+  FROM_CHARS_TEST_DOUBLE(85.e-037);
+  FROM_CHARS_TEST_DOUBLE(623.e100);
+  FROM_CHARS_TEST_DOUBLE(3571.e263);
+  FROM_CHARS_TEST_DOUBLE(81661.e153);
+  FROM_CHARS_TEST_DOUBLE(920657.e-023);
+  FROM_CHARS_TEST_DOUBLE(4603285.e-024);
+  FROM_CHARS_TEST_DOUBLE(87575437.e-309);
+  FROM_CHARS_TEST_DOUBLE(245540327.e122);
+  FROM_CHARS_TEST_DOUBLE(6138508175.e120);
+  FROM_CHARS_TEST_DOUBLE(83356057653.e193);
+  FROM_CHARS_TEST_DOUBLE(619534293513.e124);
+  FROM_CHARS_TEST_DOUBLE(2335141086879.e218);
+  FROM_CHARS_TEST_DOUBLE(36167929443327.e-159);
+  FROM_CHARS_TEST_DOUBLE(609610927149051.e-255);
+  FROM_CHARS_TEST_DOUBLE(3743626360493413.e-165);
+  FROM_CHARS_TEST_DOUBLE(94080055902682397.e-242);
+  FROM_CHARS_TEST_DOUBLE(899810892172646163.e283);
+  FROM_CHARS_TEST_DOUBLE(7120190517612959703.e120);
+  FROM_CHARS_TEST_DOUBLE(25188282901709339043.e-252);
+  FROM_CHARS_TEST_DOUBLE(308984926168550152811.e-052);
+  FROM_CHARS_TEST_DOUBLE(6372891218502368041059.e064);
+  FROM_CHARS_TEST_FLOAT(3.e-23);
+  FROM_CHARS_TEST_FLOAT(57.e18);
+  FROM_CHARS_TEST_FLOAT(789.e-35);
+  FROM_CHARS_TEST_FLOAT(2539.e-18);
+  FROM_CHARS_TEST_FLOAT(76173.e28);
+  FROM_CHARS_TEST_FLOAT(887745.e-11);
+  FROM_CHARS_TEST_FLOAT(5382571.e-37);
+  FROM_CHARS_TEST_FLOAT(82381273.e-35);
+  FROM_CHARS_TEST_FLOAT(750486563.e-38);
+  FROM_CHARS_TEST_FLOAT(3752432815.e-39);
+  FROM_CHARS_TEST_FLOAT(75224575729.e-45);
+  FROM_CHARS_TEST_FLOAT(459926601011.e15);
+}
+
+#undef FROM_CHARS_TEST_DOUBLE
+#undef FROM_CHARS_TEST_FLOAT
+#endif
+
+float ToFloat(absl::string_view s) {
+  float f;
+  absl::from_chars(s.data(), s.data() + s.size(), f);
+  return f;
+}
+
+double ToDouble(absl::string_view s) {
+  double d;
+  absl::from_chars(s.data(), s.data() + s.size(), d);
+  return d;
+}
+
+// A duplication of the test cases in "NearRoundingCases" above, but with
+// expected values expressed with integers, using ldexp/ldexpf.  These test
+// cases will work even on compilers that do not accurately round floating point
+// literals.
+TEST(FromChars, NearRoundingCasesExplicit) {
+  EXPECT_EQ(ToDouble("5.e125"), ldexp(6653062250012735, 365));
+  EXPECT_EQ(ToDouble("69.e267"), ldexp(4705683757438170, 841));
+  EXPECT_EQ(ToDouble("999.e-026"), ldexp(6798841691080350, -129));
+  EXPECT_EQ(ToDouble("7861.e-034"), ldexp(8975675289889240, -153));
+  EXPECT_EQ(ToDouble("75569.e-254"), ldexp(6091718967192243, -880));
+  EXPECT_EQ(ToDouble("928609.e-261"), ldexp(7849264900213743, -900));
+  EXPECT_EQ(ToDouble("9210917.e080"), ldexp(8341110837370930, 236));
+  EXPECT_EQ(ToDouble("84863171.e114"), ldexp(4625202867375927, 353));
+  EXPECT_EQ(ToDouble("653777767.e273"), ldexp(5068902999763073, 884));
+  EXPECT_EQ(ToDouble("5232604057.e-298"), ldexp(5741343011915040, -1010));
+  EXPECT_EQ(ToDouble("27235667517.e-109"), ldexp(6707124626673586, -380));
+  EXPECT_EQ(ToDouble("653532977297.e-123"), ldexp(7078246407265384, -422));
+  EXPECT_EQ(ToDouble("3142213164987.e-294"), ldexp(8219991337640559, -988));
+  EXPECT_EQ(ToDouble("46202199371337.e-072"), ldexp(5224462102115359, -246));
+  EXPECT_EQ(ToDouble("231010996856685.e-073"), ldexp(5224462102115359, -247));
+  EXPECT_EQ(ToDouble("9324754620109615.e212"), ldexp(5539753864394442, 705));
+  EXPECT_EQ(ToDouble("78459735791271921.e049"), ldexp(8388176519442766, 166));
+  EXPECT_EQ(ToDouble("272104041512242479.e200"), ldexp(5554409530847367, 670));
+  EXPECT_EQ(ToDouble("6802601037806061975.e198"), ldexp(5554409530847367, 668));
+  EXPECT_EQ(ToDouble("20505426358836677347.e-221"),
+            ldexp(4524032052079546, -722));
+  EXPECT_EQ(ToDouble("836168422905420598437.e-234"),
+            ldexp(5070963299887562, -760));
+  EXPECT_EQ(ToDouble("4891559871276714924261.e222"),
+            ldexp(6452687840519111, 757));
+  EXPECT_EQ(ToFloat("5.e-20"), ldexpf(15474250, -88));
+  EXPECT_EQ(ToFloat("67.e14"), ldexpf(12479722, 29));
+  EXPECT_EQ(ToFloat("985.e15"), ldexpf(14333636, 36));
+  EXPECT_EQ(ToFloat("7693.e-42"), ldexpf(10979816, -150));
+  EXPECT_EQ(ToFloat("55895.e-16"), ldexpf(12888509, -61));
+  EXPECT_EQ(ToFloat("996622.e-44"), ldexpf(14224264, -150));
+  EXPECT_EQ(ToFloat("7038531.e-32"), ldexpf(11420669, -107));
+  EXPECT_EQ(ToFloat("60419369.e-46"), ldexpf(8623340, -150));
+  EXPECT_EQ(ToFloat("702990899.e-20"), ldexpf(16209866, -61));
+  EXPECT_EQ(ToFloat("6930161142.e-48"), ldexpf(9891056, -150));
+  EXPECT_EQ(ToFloat("25933168707.e-13"), ldexpf(11138211, -32));
+  EXPECT_EQ(ToFloat("596428896559.e20"), ldexpf(12333860, 82));
+
+
+  EXPECT_EQ(ToDouble("9.e-265"), ldexp(8168427841980010, -930));
+  EXPECT_EQ(ToDouble("85.e-037"), ldexp(6360455125664090, -169));
+  EXPECT_EQ(ToDouble("623.e100"), ldexp(6263531988747231, 289));
+  EXPECT_EQ(ToDouble("3571.e263"), ldexp(6234526311072170, 833));
+  EXPECT_EQ(ToDouble("81661.e153"), ldexp(6696636728760206, 472));
+  EXPECT_EQ(ToDouble("920657.e-023"), ldexp(5975405561110124, -109));
+  EXPECT_EQ(ToDouble("4603285.e-024"), ldexp(5975405561110124, -110));
+  EXPECT_EQ(ToDouble("87575437.e-309"), ldexp(8452160731874668, -1053));
+  EXPECT_EQ(ToDouble("245540327.e122"), ldexp(4985336549131723, 381));
+  EXPECT_EQ(ToDouble("6138508175.e120"), ldexp(4985336549131723, 379));
+  EXPECT_EQ(ToDouble("83356057653.e193"), ldexp(5986732817132056, 625));
+  EXPECT_EQ(ToDouble("619534293513.e124"), ldexp(4798406992060657, 399));
+  EXPECT_EQ(ToDouble("2335141086879.e218"), ldexp(5419088166961646, 713));
+  EXPECT_EQ(ToDouble("36167929443327.e-159"), ldexp(8135819834632444, -536));
+  EXPECT_EQ(ToDouble("609610927149051.e-255"), ldexp(4576664294594737, -850));
+  EXPECT_EQ(ToDouble("3743626360493413.e-165"), ldexp(6898586531774201, -549));
+  EXPECT_EQ(ToDouble("94080055902682397.e-242"), ldexp(6273271706052298, -800));
+  EXPECT_EQ(ToDouble("899810892172646163.e283"), ldexp(7563892574477827, 947));
+  EXPECT_EQ(ToDouble("7120190517612959703.e120"), ldexp(5385467232557565, 409));
+  EXPECT_EQ(ToDouble("25188282901709339043.e-252"),
+            ldexp(5635662608542340, -825));
+  EXPECT_EQ(ToDouble("308984926168550152811.e-052"),
+            ldexp(5644774693823803, -157));
+  EXPECT_EQ(ToDouble("6372891218502368041059.e064"),
+            ldexp(4616868614322430, 233));
+
+  EXPECT_EQ(ToFloat("3.e-23"), ldexpf(9507380, -98));
+  EXPECT_EQ(ToFloat("57.e18"), ldexpf(12960300, 42));
+  EXPECT_EQ(ToFloat("789.e-35"), ldexpf(10739312, -130));
+  EXPECT_EQ(ToFloat("2539.e-18"), ldexpf(11990089, -72));
+  EXPECT_EQ(ToFloat("76173.e28"), ldexpf(9845130, 86));
+  EXPECT_EQ(ToFloat("887745.e-11"), ldexpf(9760860, -40));
+  EXPECT_EQ(ToFloat("5382571.e-37"), ldexpf(11447463, -124));
+  EXPECT_EQ(ToFloat("82381273.e-35"), ldexpf(8554961, -113));
+  EXPECT_EQ(ToFloat("750486563.e-38"), ldexpf(9975678, -120));
+  EXPECT_EQ(ToFloat("3752432815.e-39"), ldexpf(9975678, -121));
+  EXPECT_EQ(ToFloat("75224575729.e-45"), ldexpf(13105970, -137));
+  EXPECT_EQ(ToFloat("459926601011.e15"), ldexpf(12466336, 65));
+}
+
+// Common test logic for converting a std::string which lies exactly halfway between
+// two target floats.
+//
+// mantissa and exponent represent the precise value between two floating point
+// numbers, `expected_low` and `expected_high`.  The floating point
+// representation to parse in `StrCat(mantissa, "e", exponent)`.
+//
+// This function checks that an input just slightly less than the exact value
+// is rounded down to `expected_low`, and an input just slightly greater than
+// the exact value is rounded up to `expected_high`.
+//
+// The exact value should round to `expected_half`, which must be either
+// `expected_low` or `expected_high`.
+template <typename FloatType>
+void TestHalfwayValue(const std::string& mantissa, int exponent,
+                      FloatType expected_low, FloatType expected_high,
+                      FloatType expected_half) {
+  std::string low_rep = mantissa;
+  low_rep[low_rep.size() - 1] -= 1;
+  absl::StrAppend(&low_rep, std::string(1000, '9'), "e", exponent);
+
+  FloatType actual_low = 0;
+  absl::from_chars(low_rep.data(), low_rep.data() + low_rep.size(), actual_low);
+  EXPECT_EQ(expected_low, actual_low);
+
+  std::string high_rep = absl::StrCat(mantissa, std::string(1000, '0'), "1e", exponent);
+  FloatType actual_high = 0;
+  absl::from_chars(high_rep.data(), high_rep.data() + high_rep.size(),
+                   actual_high);
+  EXPECT_EQ(expected_high, actual_high);
+
+  std::string halfway_rep = absl::StrCat(mantissa, "e", exponent);
+  FloatType actual_half = 0;
+  absl::from_chars(halfway_rep.data(), halfway_rep.data() + halfway_rep.size(),
+                   actual_half);
+  EXPECT_EQ(expected_half, actual_half);
+}
+
+TEST(FromChars, DoubleRounding) {
+  const double zero = 0.0;
+  const double first_subnormal = nextafter(zero, 1.0);
+  const double second_subnormal = nextafter(first_subnormal, 1.0);
+
+  const double first_normal = DBL_MIN;
+  const double last_subnormal = nextafter(first_normal, 0.0);
+  const double second_normal = nextafter(first_normal, 1.0);
+
+  const double last_normal = DBL_MAX;
+  const double penultimate_normal = nextafter(last_normal, 0.0);
+
+  // Various test cases for numbers between two representable floats.  Each
+  // call to TestHalfwayValue tests a number just below and just above the
+  // halfway point, as well as the number exactly between them.
+
+  // Test between zero and first_subnormal.  Round-to-even tie rounds down.
+  TestHalfwayValue(
+      "2."
+      "470328229206232720882843964341106861825299013071623822127928412503377536"
+      "351043759326499181808179961898982823477228588654633283551779698981993873"
+      "980053909390631503565951557022639229085839244910518443593180284993653615"
+      "250031937045767824921936562366986365848075700158576926990370631192827955"
+      "855133292783433840935197801553124659726357957462276646527282722005637400"
+      "648549997709659947045402082816622623785739345073633900796776193057750674"
+      "017632467360096895134053553745851666113422376667860416215968046191446729"
+      "184030053005753084904876539171138659164623952491262365388187963623937328"
+      "042389101867234849766823508986338858792562830275599565752445550725518931"
+      "369083625477918694866799496832404970582102851318545139621383772282614543"
+      "7693412532098591327667236328125",
+      -324, zero, first_subnormal, zero);
+
+  // first_subnormal and second_subnormal.  Round-to-even tie rounds up.
+  TestHalfwayValue(
+      "7."
+      "410984687618698162648531893023320585475897039214871466383785237510132609"
+      "053131277979497545424539885696948470431685765963899850655339096945981621"
+      "940161728171894510697854671067917687257517734731555330779540854980960845"
+      "750095811137303474765809687100959097544227100475730780971111893578483867"
+      "565399878350301522805593404659373979179073872386829939581848166016912201"
+      "945649993128979841136206248449867871357218035220901702390328579173252022"
+      "052897402080290685402160661237554998340267130003581248647904138574340187"
+      "552090159017259254714629617513415977493871857473787096164563890871811984"
+      "127167305601704549300470526959016576377688490826798697257336652176556794"
+      "107250876433756084600398490497214911746308553955635418864151316847843631"
+      "3080237596295773983001708984375",
+      -324, first_subnormal, second_subnormal, second_subnormal);
+
+  // last_subnormal and first_normal.  Round-to-even tie rounds up.
+  TestHalfwayValue(
+      "2."
+      "225073858507201136057409796709131975934819546351645648023426109724822222"
+      "021076945516529523908135087914149158913039621106870086438694594645527657"
+      "207407820621743379988141063267329253552286881372149012981122451451889849"
+      "057222307285255133155755015914397476397983411801999323962548289017107081"
+      "850690630666655994938275772572015763062690663332647565300009245888316433"
+      "037779791869612049497390377829704905051080609940730262937128958950003583"
+      "799967207254304360284078895771796150945516748243471030702609144621572289"
+      "880258182545180325707018860872113128079512233426288368622321503775666622"
+      "503982534335974568884423900265498198385487948292206894721689831099698365"
+      "846814022854243330660339850886445804001034933970427567186443383770486037"
+      "86162277173854562306587467901408672332763671875",
+      -308, last_subnormal, first_normal, first_normal);
+
+  // first_normal and second_normal.  Round-to-even tie rounds down.
+  TestHalfwayValue(
+      "2."
+      "225073858507201630123055637955676152503612414573018013083228724049586647"
+      "606759446192036794116886953213985520549032000903434781884412325572184367"
+      "563347617020518175998922941393629966742598285899994830148971433555578567"
+      "693279306015978183162142425067962460785295885199272493577688320732492479"
+      "924816869232247165964934329258783950102250973957579510571600738343645738"
+      "494324192997092179207389919761694314131497173265255020084997973676783743"
+      "155205818804439163810572367791175177756227497413804253387084478193655533"
+      "073867420834526162513029462022730109054820067654020201547112002028139700"
+      "141575259123440177362244273712468151750189745559978653234255886219611516"
+      "335924167958029604477064946470184777360934300451421683607013647479513962"
+      "13837722826145437693412532098591327667236328125",
+      -308, first_normal, second_normal, first_normal);
+
+  // penultimate_normal and last_normal.  Round-to-even rounds down.
+  TestHalfwayValue(
+      "1."
+      "797693134862315608353258760581052985162070023416521662616611746258695532"
+      "672923265745300992879465492467506314903358770175220871059269879629062776"
+      "047355692132901909191523941804762171253349609463563872612866401980290377"
+      "995141836029815117562837277714038305214839639239356331336428021390916694"
+      "57927874464075218944",
+      308, penultimate_normal, last_normal, penultimate_normal);
+}
+
+// Same test cases as DoubleRounding, now with new and improved Much Smaller
+// Precision!
+TEST(FromChars, FloatRounding) {
+  const float zero = 0.0;
+  const float first_subnormal = nextafterf(zero, 1.0);
+  const float second_subnormal = nextafterf(first_subnormal, 1.0);
+
+  const float first_normal = FLT_MIN;
+  const float last_subnormal = nextafterf(first_normal, 0.0);
+  const float second_normal = nextafterf(first_normal, 1.0);
+
+  const float last_normal = FLT_MAX;
+  const float penultimate_normal = nextafterf(last_normal, 0.0);
+
+  // Test between zero and first_subnormal.  Round-to-even tie rounds down.
+  TestHalfwayValue(
+      "7."
+      "006492321624085354618647916449580656401309709382578858785341419448955413"
+      "42930300743319094181060791015625",
+      -46, zero, first_subnormal, zero);
+
+  // first_subnormal and second_subnormal.  Round-to-even tie rounds up.
+  TestHalfwayValue(
+      "2."
+      "101947696487225606385594374934874196920392912814773657635602425834686624"
+      "028790902229957282543182373046875",
+      -45, first_subnormal, second_subnormal, second_subnormal);
+
+  // last_subnormal and first_normal.  Round-to-even tie rounds up.
+  TestHalfwayValue(
+      "1."
+      "175494280757364291727882991035766513322858992758990427682963118425003064"
+      "9651730385585324256680905818939208984375",
+      -38, last_subnormal, first_normal, first_normal);
+
+  // first_normal and second_normal.  Round-to-even tie rounds down.
+  TestHalfwayValue(
+      "1."
+      "175494420887210724209590083408724842314472120785184615334540294131831453"
+      "9442813071445925743319094181060791015625",
+      -38, first_normal, second_normal, first_normal);
+
+  // penultimate_normal and last_normal.  Round-to-even rounds down.
+  TestHalfwayValue("3.40282336497324057985868971510891282432", 38,
+                   penultimate_normal, last_normal, penultimate_normal);
+}
+
+TEST(FromChars, Underflow) {
+  // Check that underflow is handled correctly, according to the specification
+  // in DR 3081.
+  double d;
+  float f;
+  absl::from_chars_result result;
+
+  std::string negative_underflow = "-1e-1000";
+  const char* begin = negative_underflow.data();
+  const char* end = begin + negative_underflow.size();
+  d = 100.0;
+  result = absl::from_chars(begin, end, d);
+  EXPECT_EQ(result.ptr, end);
+  EXPECT_EQ(result.ec, std::errc::result_out_of_range);
+  EXPECT_TRUE(std::signbit(d));  // negative
+  EXPECT_GE(d, -std::numeric_limits<double>::min());
+  f = 100.0;
+  result = absl::from_chars(begin, end, f);
+  EXPECT_EQ(result.ptr, end);
+  EXPECT_EQ(result.ec, std::errc::result_out_of_range);
+  EXPECT_TRUE(std::signbit(f));  // negative
+  EXPECT_GE(f, -std::numeric_limits<float>::min());
+
+  std::string positive_underflow = "1e-1000";
+  begin = positive_underflow.data();
+  end = begin + positive_underflow.size();
+  d = -100.0;
+  result = absl::from_chars(begin, end, d);
+  EXPECT_EQ(result.ptr, end);
+  EXPECT_EQ(result.ec, std::errc::result_out_of_range);
+  EXPECT_FALSE(std::signbit(d));  // positive
+  EXPECT_LE(d, std::numeric_limits<double>::min());
+  f = -100.0;
+  result = absl::from_chars(begin, end, f);
+  EXPECT_EQ(result.ptr, end);
+  EXPECT_EQ(result.ec, std::errc::result_out_of_range);
+  EXPECT_FALSE(std::signbit(f));  // positive
+  EXPECT_LE(f, std::numeric_limits<float>::min());
+}
+
+TEST(FromChars, Overflow) {
+  // Check that overflow is handled correctly, according to the specification
+  // in DR 3081.
+  double d;
+  float f;
+  absl::from_chars_result result;
+
+  std::string negative_overflow = "-1e1000";
+  const char* begin = negative_overflow.data();
+  const char* end = begin + negative_overflow.size();
+  d = 100.0;
+  result = absl::from_chars(begin, end, d);
+  EXPECT_EQ(result.ptr, end);
+  EXPECT_EQ(result.ec, std::errc::result_out_of_range);
+  EXPECT_TRUE(std::signbit(d));  // negative
+  EXPECT_EQ(d, -std::numeric_limits<double>::max());
+  f = 100.0;
+  result = absl::from_chars(begin, end, f);
+  EXPECT_EQ(result.ptr, end);
+  EXPECT_EQ(result.ec, std::errc::result_out_of_range);
+  EXPECT_TRUE(std::signbit(f));  // negative
+  EXPECT_EQ(f, -std::numeric_limits<float>::max());
+
+  std::string positive_overflow = "1e1000";
+  begin = positive_overflow.data();
+  end = begin + positive_overflow.size();
+  d = -100.0;
+  result = absl::from_chars(begin, end, d);
+  EXPECT_EQ(result.ptr, end);
+  EXPECT_EQ(result.ec, std::errc::result_out_of_range);
+  EXPECT_FALSE(std::signbit(d));  // positive
+  EXPECT_EQ(d, std::numeric_limits<double>::max());
+  f = -100.0;
+  result = absl::from_chars(begin, end, f);
+  EXPECT_EQ(result.ptr, end);
+  EXPECT_EQ(result.ec, std::errc::result_out_of_range);
+  EXPECT_FALSE(std::signbit(f));  // positive
+  EXPECT_EQ(f, std::numeric_limits<float>::max());
+}
+
+TEST(FromChars, ReturnValuePtr) {
+  // Check that `ptr` points one past the number scanned, even if that number
+  // is not representable.
+  double d;
+  absl::from_chars_result result;
+
+  std::string normal = "3.14@#$%@#$%";
+  result = absl::from_chars(normal.data(), normal.data() + normal.size(), d);
+  EXPECT_EQ(result.ec, std::errc());
+  EXPECT_EQ(result.ptr - normal.data(), 4);
+
+  std::string overflow = "1e1000@#$%@#$%";
+  result = absl::from_chars(overflow.data(),
+                            overflow.data() + overflow.size(), d);
+  EXPECT_EQ(result.ec, std::errc::result_out_of_range);
+  EXPECT_EQ(result.ptr - overflow.data(), 6);
+
+  std::string garbage = "#$%@#$%";
+  result = absl::from_chars(garbage.data(),
+                            garbage.data() + garbage.size(), d);
+  EXPECT_EQ(result.ec, std::errc::invalid_argument);
+  EXPECT_EQ(result.ptr - garbage.data(), 0);
+}
+
+// Check for a wide range of inputs that strtod() and absl::from_chars() exactly
+// agree on the conversion amount.
+//
+// This test assumes the platform's strtod() uses perfect round_to_nearest
+// rounding.
+TEST(FromChars, TestVersusStrtod) {
+  for (int mantissa = 1000000; mantissa <= 9999999; mantissa += 501) {
+    for (int exponent = -300; exponent < 300; ++exponent) {
+      std::string candidate = absl::StrCat(mantissa, "e", exponent);
+      double strtod_value = strtod(candidate.c_str(), nullptr);
+      double absl_value = 0;
+      absl::from_chars(candidate.data(), candidate.data() + candidate.size(),
+                       absl_value);
+      ASSERT_EQ(strtod_value, absl_value) << candidate;
+    }
+  }
+}
+
+// Check for a wide range of inputs that strtof() and absl::from_chars() exactly
+// agree on the conversion amount.
+//
+// This test assumes the platform's strtof() uses perfect round_to_nearest
+// rounding.
+TEST(FromChars, TestVersusStrtof) {
+  for (int mantissa = 1000000; mantissa <= 9999999; mantissa += 501) {
+    for (int exponent = -43; exponent < 32; ++exponent) {
+      std::string candidate = absl::StrCat(mantissa, "e", exponent);
+      float strtod_value = strtof(candidate.c_str(), nullptr);
+      float absl_value = 0;
+      absl::from_chars(candidate.data(), candidate.data() + candidate.size(),
+                       absl_value);
+      ASSERT_EQ(strtod_value, absl_value) << candidate;
+    }
+  }
+}
+
+// Tests if two floating point values have identical bit layouts.  (EXPECT_EQ
+// is not suitable for NaN testing, since NaNs are never equal.)
+template <typename Float>
+bool Identical(Float a, Float b) {
+  return 0 == memcmp(&a, &b, sizeof(Float));
+}
+
+// Check that NaNs are parsed correctly.  The spec requires that
+// std::from_chars on "NaN(123abc)" return the same value as std::nan("123abc").
+// How such an n-char-sequence affects the generated NaN is unspecified, so we
+// just test for symmetry with std::nan and strtod here.
+//
+// (In Linux, this parses the value as a number and stuffs that number into the
+// free bits of a quiet NaN.)
+TEST(FromChars, NaNDoubles) {
+  for (std::string n_char_sequence :
+       {"", "1", "2", "3", "fff", "FFF", "200000", "400000", "4000000000000",
+        "8000000000000", "abc123", "legal_but_unexpected",
+        "99999999999999999999999", "_"}) {
+    std::string input = absl::StrCat("nan(", n_char_sequence, ")");
+    SCOPED_TRACE(input);
+    double from_chars_double;
+    absl::from_chars(input.data(), input.data() + input.size(),
+                     from_chars_double);
+    double std_nan_double = std::nan(n_char_sequence.c_str());
+    EXPECT_TRUE(Identical(from_chars_double, std_nan_double));
+
+    // Also check that we match strtod()'s behavior.  This test assumes that the
+    // platform has a compliant strtod().
+#if ABSL_STRTOD_HANDLES_NAN_CORRECTLY
+    double strtod_double = strtod(input.c_str(), nullptr);
+    EXPECT_TRUE(Identical(from_chars_double, strtod_double));
+#endif  // ABSL_STRTOD_HANDLES_NAN_CORRECTLY
+
+    // Check that we can parse a negative NaN
+    std::string negative_input = "-" + input;
+    double negative_from_chars_double;
+    absl::from_chars(negative_input.data(),
+                     negative_input.data() + negative_input.size(),
+                     negative_from_chars_double);
+    EXPECT_TRUE(std::signbit(negative_from_chars_double));
+    EXPECT_FALSE(Identical(negative_from_chars_double, from_chars_double));
+    from_chars_double = std::copysign(from_chars_double, -1.0);
+    EXPECT_TRUE(Identical(negative_from_chars_double, from_chars_double));
+  }
+}
+
+TEST(FromChars, NaNFloats) {
+  for (std::string n_char_sequence :
+       {"", "1", "2", "3", "fff", "FFF", "200000", "400000", "4000000000000",
+        "8000000000000", "abc123", "legal_but_unexpected",
+        "99999999999999999999999", "_"}) {
+    std::string input = absl::StrCat("nan(", n_char_sequence, ")");
+    SCOPED_TRACE(input);
+    float from_chars_float;
+    absl::from_chars(input.data(), input.data() + input.size(),
+                     from_chars_float);
+    float std_nan_float = std::nanf(n_char_sequence.c_str());
+    EXPECT_TRUE(Identical(from_chars_float, std_nan_float));
+
+    // Also check that we match strtof()'s behavior.  This test assumes that the
+    // platform has a compliant strtof().
+#if ABSL_STRTOD_HANDLES_NAN_CORRECTLY
+    float strtof_float = strtof(input.c_str(), nullptr);
+    EXPECT_TRUE(Identical(from_chars_float, strtof_float));
+#endif  // ABSL_STRTOD_HANDLES_NAN_CORRECTLY
+
+    // Check that we can parse a negative NaN
+    std::string negative_input = "-" + input;
+    float negative_from_chars_float;
+    absl::from_chars(negative_input.data(),
+                     negative_input.data() + negative_input.size(),
+                     negative_from_chars_float);
+    EXPECT_TRUE(std::signbit(negative_from_chars_float));
+    EXPECT_FALSE(Identical(negative_from_chars_float, from_chars_float));
+    from_chars_float = std::copysign(from_chars_float, -1.0);
+    EXPECT_TRUE(Identical(negative_from_chars_float, from_chars_float));
+  }
+}
+
+// Returns an integer larger than step.  The values grow exponentially.
+int NextStep(int step) {
+  return step + (step >> 2) + 1;
+}
+
+// Test a conversion on a family of input strings, checking that the calculation
+// is correct for in-bounds values, and that overflow and underflow are done
+// correctly for out-of-bounds values.
+//
+// input_generator maps from an integer index to a std::string to test.
+// expected_generator maps from an integer index to an expected Float value.
+// from_chars conversion of input_generator(i) should result in
+// expected_generator(i).
+//
+// lower_bound and upper_bound denote the smallest and largest values for which
+// the conversion is expected to succeed.
+template <typename Float>
+void TestOverflowAndUnderflow(
+    const std::function<std::string(int)>& input_generator,
+    const std::function<Float(int)>& expected_generator, int lower_bound,
+    int upper_bound) {
+  // test legal values near lower_bound
+  int index, step;
+  for (index = lower_bound, step = 1; index < upper_bound;
+       index += step, step = NextStep(step)) {
+    std::string input = input_generator(index);
+    SCOPED_TRACE(input);
+    Float expected = expected_generator(index);
+    Float actual;
+    auto result =
+        absl::from_chars(input.data(), input.data() + input.size(), actual);
+    EXPECT_EQ(result.ec, std::errc());
+    EXPECT_EQ(expected, actual);
+  }
+  // test legal values near upper_bound
+  for (index = upper_bound, step = 1; index > lower_bound;
+       index -= step, step = NextStep(step)) {
+    std::string input = input_generator(index);
+    SCOPED_TRACE(input);
+    Float expected = expected_generator(index);
+    Float actual;
+    auto result =
+        absl::from_chars(input.data(), input.data() + input.size(), actual);
+    EXPECT_EQ(result.ec, std::errc());
+    EXPECT_EQ(expected, actual);
+  }
+  // Test underflow values below lower_bound
+  for (index = lower_bound - 1, step = 1; index > -1000000;
+       index -= step, step = NextStep(step)) {
+    std::string input = input_generator(index);
+    SCOPED_TRACE(input);
+    Float actual;
+    auto result =
+        absl::from_chars(input.data(), input.data() + input.size(), actual);
+    EXPECT_EQ(result.ec, std::errc::result_out_of_range);
+    EXPECT_LT(actual, 1.0);  // check for underflow
+  }
+  // Test overflow values above upper_bound
+  for (index = upper_bound + 1, step = 1; index < 1000000;
+       index += step, step = NextStep(step)) {
+    std::string input = input_generator(index);
+    SCOPED_TRACE(input);
+    Float actual;
+    auto result =
+        absl::from_chars(input.data(), input.data() + input.size(), actual);
+    EXPECT_EQ(result.ec, std::errc::result_out_of_range);
+    EXPECT_GT(actual, 1.0);  // check for overflow
+  }
+}
+
+// Check that overflow and underflow are caught correctly for hex doubles.
+//
+// The largest representable double is 0x1.fffffffffffffp+1023, and the
+// smallest representable subnormal is 0x0.0000000000001p-1022, which equals
+// 0x1p-1074.  Therefore 1023 and -1074 are the limits of acceptable exponents
+// in this test.
+TEST(FromChars, HexdecimalDoubleLimits) {
+  auto input_gen = [](int index) { return absl::StrCat("0x1.0p", index); };
+  auto expected_gen = [](int index) { return std::ldexp(1.0, index); };
+  TestOverflowAndUnderflow<double>(input_gen, expected_gen, -1074, 1023);
+}
+
+// Check that overflow and underflow are caught correctly for hex floats.
+//
+// The largest representable float is 0x1.fffffep+127, and the smallest
+// representable subnormal is 0x0.000002p-126, which equals 0x1p-149.
+// Therefore 127 and -149 are the limits of acceptable exponents in this test.
+TEST(FromChars, HexdecimalFloatLimits) {
+  auto input_gen = [](int index) { return absl::StrCat("0x1.0p", index); };
+  auto expected_gen = [](int index) { return std::ldexp(1.0f, index); };
+  TestOverflowAndUnderflow<float>(input_gen, expected_gen, -149, 127);
+}
+
+// Check that overflow and underflow are caught correctly for decimal doubles.
+//
+// The largest representable double is about 1.8e308, and the smallest
+// representable subnormal is about 5e-324.  '1e-324' therefore rounds away from
+// the smallest representable positive value.  -323 and 308 are the limits of
+// acceptable exponents in this test.
+TEST(FromChars, DecimalDoubleLimits) {
+  auto input_gen = [](int index) { return absl::StrCat("1.0e", index); };
+  auto expected_gen = [](int index) { return std::pow(10.0, index); };
+  TestOverflowAndUnderflow<double>(input_gen, expected_gen, -323, 308);
+}
+
+// Check that overflow and underflow are caught correctly for decimal floats.
+//
+// The largest representable float is about 3.4e38, and the smallest
+// representable subnormal is about 1.45e-45.  '1e-45' therefore rounds towards
+// the smallest representable positive value.  -45 and 38 are the limits of
+// acceptable exponents in this test.
+TEST(FromChars, DecimalFloatLimits) {
+  auto input_gen = [](int index) { return absl::StrCat("1.0e", index); };
+  auto expected_gen = [](int index) { return std::pow(10.0, index); };
+  TestOverflowAndUnderflow<float>(input_gen, expected_gen, -45, 38);
+}
+
+}  // namespace
diff --git a/third_party/abseil-cpp/absl/strings/internal/charconv_bigint.cc b/third_party/abseil-cpp/absl/strings/internal/charconv_bigint.cc
new file mode 100644
index 0000000000..3e7296e706
--- /dev/null
+++ b/third_party/abseil-cpp/absl/strings/internal/charconv_bigint.cc
@@ -0,0 +1,357 @@
+// 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
+//
+//      http://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/strings/internal/charconv_bigint.h"
+
+#include <algorithm>
+#include <cassert>
+#include <string>
+
+namespace absl {
+namespace strings_internal {
+
+namespace {
+
+// Table containing some large powers of 5, for fast computation.
+
+// Constant step size for entries in the kLargePowersOfFive table.  Each entry
+// is larger than the previous entry by a factor of 5**kLargePowerOfFiveStep
+// (or 5**27).
+//
+// In other words, the Nth entry in the table is 5**(27*N).
+//
+// 5**27 is the largest power of 5 that fits in 64 bits.
+constexpr int kLargePowerOfFiveStep = 27;
+
+// The largest legal index into the kLargePowersOfFive table.
+//
+// In other words, the largest precomputed power of 5 is 5**(27*20).
+constexpr int kLargestPowerOfFiveIndex = 20;
+
+// Table of powers of (5**27), up to (5**27)**20 == 5**540.
+//
+// Used to generate large powers of 5 while limiting the number of repeated
+// multiplications required.
+//
+// clang-format off
+const uint32_t kLargePowersOfFive[] = {
+// 5**27 (i=1), start=0, end=2
+  0xfa10079dU, 0x6765c793U,
+// 5**54 (i=2), start=2, end=6
+  0x97d9f649U, 0x6664242dU, 0x29939b14U, 0x29c30f10U,
+// 5**81 (i=3), start=6, end=12
+  0xc4f809c5U, 0x7bf3f22aU, 0x67bdae34U, 0xad340517U, 0x369d1b5fU, 0x10de1593U,
+// 5**108 (i=4), start=12, end=20
+  0x92b260d1U, 0x9efff7c7U, 0x81de0ec6U, 0xaeba5d56U, 0x410664a4U, 0x4f40737aU,
+  0x20d3846fU, 0x06d00f73U,
+// 5**135 (i=5), start=20, end=30
+  0xff1b172dU, 0x13a1d71cU, 0xefa07617U, 0x7f682d3dU, 0xff8c90c0U, 0x3f0131e7U,
+  0x3fdcb9feU, 0x917b0177U, 0x16c407a7U, 0x02c06b9dU,
+// 5**162 (i=6), start=30, end=42
+  0x960f7199U, 0x056667ecU, 0xe07aefd8U, 0x80f2b9ccU, 0x8273f5e3U, 0xeb9a214aU,
+  0x40b38005U, 0x0e477ad4U, 0x277d08e6U, 0xfa28b11eU, 0xd3f7d784U, 0x011c835bU,
+// 5**189 (i=7), start=42, end=56
+  0xf723d9d5U, 0x3282d3f3U, 0xe00857d1U, 0x69659d25U, 0x2cf117cfU, 0x24da6d07U,
+  0x954d1417U, 0x3e5d8cedU, 0x7a8bb766U, 0xfd785ae6U, 0x645436d2U, 0x40c78b34U,
+  0x94151217U, 0x0072e9f7U,
+// 5**216 (i=8), start=56, end=72
+  0x2b416aa1U, 0x7893c5a7U, 0xe37dc6d4U, 0x2bad2beaU, 0xf0fc846cU, 0x7575ae4bU,
+  0x62587b14U, 0x83b67a34U, 0x02110cdbU, 0xf7992f55U, 0x00deb022U, 0xa4a23becU,
+  0x8af5c5cdU, 0xb85b654fU, 0x818df38bU, 0x002e69d2U,
+// 5**243 (i=9), start=72, end=90
+  0x3518cbbdU, 0x20b0c15fU, 0x38756c2fU, 0xfb5dc3ddU, 0x22ad2d94U, 0xbf35a952U,
+  0xa699192aU, 0x9a613326U, 0xad2a9cedU, 0xd7f48968U, 0xe87dfb54U, 0xc8f05db6U,
+  0x5ef67531U, 0x31c1ab49U, 0xe202ac9fU, 0x9b2957b5U, 0xa143f6d3U, 0x0012bf07U,
+// 5**270 (i=10), start=90, end=110
+  0x8b971de9U, 0x21aba2e1U, 0x63944362U, 0x57172336U, 0xd9544225U, 0xfb534166U,
+  0x08c563eeU, 0x14640ee2U, 0x24e40d31U, 0x02b06537U, 0x03887f14U, 0x0285e533U,
+  0xb744ef26U, 0x8be3a6c4U, 0x266979b4U, 0x6761ece2U, 0xd9cb39e4U, 0xe67de319U,
+  0x0d39e796U, 0x00079250U,
+// 5**297 (i=11), start=110, end=132
+  0x260eb6e5U, 0xf414a796U, 0xee1a7491U, 0xdb9368ebU, 0xf50c105bU, 0x59157750U,
+  0x9ed2fb5cU, 0xf6e56d8bU, 0xeaee8d23U, 0x0f319f75U, 0x2aa134d6U, 0xac2908e9U,
+  0xd4413298U, 0x02f02a55U, 0x989d5a7aU, 0x70dde184U, 0xba8040a7U, 0x03200981U,
+  0xbe03b11cU, 0x3c1c2a18U, 0xd60427a1U, 0x00030ee0U,
+// 5**324 (i=12), start=132, end=156
+  0xce566d71U, 0xf1c4aa25U, 0x4e93ca53U, 0xa72283d0U, 0x551a73eaU, 0x3d0538e2U,
+  0x8da4303fU, 0x6a58de60U, 0x0e660221U, 0x49cf61a6U, 0x8d058fc1U, 0xb9d1a14cU,
+  0x4bab157dU, 0xc85c6932U, 0x518c8b9eU, 0x9b92b8d0U, 0x0d8a0e21U, 0xbd855df9U,
+  0xb3ea59a1U, 0x8da29289U, 0x4584d506U, 0x3752d80fU, 0xb72569c6U, 0x00013c33U,
+// 5**351 (i=13), start=156, end=182
+  0x190f354dU, 0x83695cfeU, 0xe5a4d0c7U, 0xb60fb7e8U, 0xee5bbcc4U, 0xb922054cU,
+  0xbb4f0d85U, 0x48394028U, 0x1d8957dbU, 0x0d7edb14U, 0x4ecc7587U, 0x505e9e02U,
+  0x4c87f36bU, 0x99e66bd6U, 0x44b9ed35U, 0x753037d4U, 0xe5fe5f27U, 0x2742c203U,
+  0x13b2ed2bU, 0xdc525d2cU, 0xe6fde59aU, 0x77ffb18fU, 0x13c5752cU, 0x08a84bccU,
+  0x859a4940U, 0x00007fb6U,
+// 5**378 (i=14), start=182, end=210
+  0x4f98cb39U, 0xa60edbbcU, 0x83b5872eU, 0xa501acffU, 0x9cc76f78U, 0xbadd4c73U,
+  0x43e989faU, 0xca7acf80U, 0x2e0c824fU, 0xb19f4ffcU, 0x092fd81cU, 0xe4eb645bU,
+  0xa1ff84c2U, 0x8a5a83baU, 0xa8a1fae9U, 0x1db43609U, 0xb0fed50bU, 0x0dd7d2bdU,
+  0x7d7accd8U, 0x91fa640fU, 0x37dcc6c5U, 0x1c417fd5U, 0xe4d462adU, 0xe8a43399U,
+  0x131bf9a5U, 0x8df54d29U, 0x36547dc1U, 0x00003395U,
+// 5**405 (i=15), start=210, end=240
+  0x5bd330f5U, 0x77d21967U, 0x1ac481b7U, 0x6be2f7ceU, 0x7f4792a9U, 0xe84c2c52U,
+  0x84592228U, 0x9dcaf829U, 0xdab44ce1U, 0x3d0c311bU, 0x532e297dU, 0x4704e8b4U,
+  0x9cdc32beU, 0x41e64d9dU, 0x7717bea1U, 0xa824c00dU, 0x08f50b27U, 0x0f198d77U,
+  0x49bbfdf0U, 0x025c6c69U, 0xd4e55cd3U, 0xf083602bU, 0xb9f0fecdU, 0xc0864aeaU,
+  0x9cb98681U, 0xaaf620e9U, 0xacb6df30U, 0x4faafe66U, 0x8af13c3bU, 0x000014d5U,
+// 5**432 (i=16), start=240, end=272
+  0x682bb941U, 0x89a9f297U, 0xcba75d7bU, 0x404217b1U, 0xb4e519e9U, 0xa1bc162bU,
+  0xf7f5910aU, 0x98715af5U, 0x2ff53e57U, 0xe3ef118cU, 0x490c4543U, 0xbc9b1734U,
+  0x2affbe4dU, 0x4cedcb4cU, 0xfb14e99eU, 0x35e34212U, 0xece39c24U, 0x07673ab3U,
+  0xe73115ddU, 0xd15d38e7U, 0x093eed3bU, 0xf8e7eac5U, 0x78a8cc80U, 0x25227aacU,
+  0x3f590551U, 0x413da1cbU, 0xdf643a55U, 0xab65ad44U, 0xd70b23d7U, 0xc672cd76U,
+  0x3364ea62U, 0x0000086aU,
+// 5**459 (i=17), start=272, end=306
+  0x22f163ddU, 0x23cf07acU, 0xbe2af6c2U, 0xf412f6f6U, 0xc3ff541eU, 0x6eeaf7deU,
+  0xa47047e0U, 0x408cda92U, 0x0f0eeb08U, 0x56deba9dU, 0xcfc6b090U, 0x8bbbdf04U,
+  0x3933cdb3U, 0x9e7bb67dU, 0x9f297035U, 0x38946244U, 0xee1d37bbU, 0xde898174U,
+  0x63f3559dU, 0x705b72fbU, 0x138d27d9U, 0xf8603a78U, 0x735eec44U, 0xe30987d5U,
+  0xc6d38070U, 0x9cfe548eU, 0x9ff01422U, 0x7c564aa8U, 0x91cc60baU, 0xcbc3565dU,
+  0x7550a50bU, 0x6909aeadU, 0x13234c45U, 0x00000366U,
+// 5**486 (i=18), start=306, end=342
+  0x17954989U, 0x3a7d7709U, 0x98042de5U, 0xa9011443U, 0x45e723c2U, 0x269ffd6fU,
+  0x58852a46U, 0xaaa1042aU, 0x2eee8153U, 0xb2b6c39eU, 0xaf845b65U, 0xf6c365d7U,
+  0xe4cffb2bU, 0xc840e90cU, 0xabea8abbU, 0x5c58f8d2U, 0x5c19fa3aU, 0x4670910aU,
+  0x4449f21cU, 0xefa645b3U, 0xcc427decU, 0x083c3d73U, 0x467cb413U, 0x6fe10ae4U,
+  0x3caffc72U, 0x9f8da55eU, 0x5e5c8ea7U, 0x490594bbU, 0xf0871b0bU, 0xdd89816cU,
+  0x8e931df8U, 0xe85ce1c9U, 0xcca090a5U, 0x575fa16bU, 0x6b9f106cU, 0x0000015fU,
+// 5**513 (i=19), start=342, end=380
+  0xee20d805U, 0x57bc3c07U, 0xcdea624eU, 0xd3f0f52dU, 0x9924b4f4U, 0xcf968640U,
+  0x61d41962U, 0xe87fb464U, 0xeaaf51c7U, 0x564c8b60U, 0xccda4028U, 0x529428bbU,
+  0x313a1fa8U, 0x96bd0f94U, 0x7a82ebaaU, 0xad99e7e9U, 0xf2668cd4U, 0xbe33a45eU,
+  0xfd0db669U, 0x87ee369fU, 0xd3ec20edU, 0x9c4d7db7U, 0xdedcf0d8U, 0x7cd2ca64U,
+  0xe25a6577U, 0x61003fd4U, 0xe56f54ccU, 0x10b7c748U, 0x40526e5eU, 0x7300ae87U,
+  0x5c439261U, 0x2c0ff469U, 0xbf723f12U, 0xb2379b61U, 0xbf59b4f5U, 0xc91b1c3fU,
+  0xf0046d27U, 0x0000008dU,
+// 5**540 (i=20), start=380, end=420
+  0x525c9e11U, 0xf4e0eb41U, 0xebb2895dU, 0x5da512f9U, 0x7d9b29d4U, 0x452f4edcU,
+  0x0b90bc37U, 0x341777cbU, 0x63d269afU, 0x1da77929U, 0x0a5c1826U, 0x77991898U,
+  0x5aeddf86U, 0xf853a877U, 0x538c31ccU, 0xe84896daU, 0xb7a0010bU, 0x17ef4de5U,
+  0xa52a2adeU, 0x029fd81cU, 0x987ce701U, 0x27fefd77U, 0xdb46c66fU, 0x5d301900U,
+  0x496998c0U, 0xbb6598b9U, 0x5eebb607U, 0xe547354aU, 0xdf4a2f7eU, 0xf06c4955U,
+  0x96242ffaU, 0x1775fb27U, 0xbecc58ceU, 0xebf2a53bU, 0x3eaad82aU, 0xf41137baU,
+  0x573e6fbaU, 0xfb4866b8U, 0x54002148U, 0x00000039U,
+};
+// clang-format on
+
+// Returns a pointer to the big integer data for (5**27)**i.  i must be
+// between 1 and 20, inclusive.
+const uint32_t* LargePowerOfFiveData(int i) {
+  return kLargePowersOfFive + i * (i - 1);
+}
+
+// Returns the size of the big integer data for (5**27)**i, in words.  i must be
+// between 1 and 20, inclusive.
+int LargePowerOfFiveSize(int i) { return 2 * i; }
+}  // namespace
+
+const uint32_t kFiveToNth[14] = {
+    1,     5,      25,      125,     625,      3125,      15625,
+    78125, 390625, 1953125, 9765625, 48828125, 244140625, 1220703125,
+};
+
+const uint32_t kTenToNth[10] = {
+    1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000,
+};
+
+template <int max_words>
+int BigUnsigned<max_words>::ReadFloatMantissa(const ParsedFloat& fp,
+                                              int significant_digits) {
+  SetToZero();
+  assert(fp.type == FloatType::kNumber);
+
+  if (fp.subrange_begin == nullptr) {
+    // We already exactly parsed the mantissa, so no more work is necessary.
+    words_[0] = fp.mantissa & 0xffffffffu;
+    words_[1] = fp.mantissa >> 32;
+    if (words_[1]) {
+      size_ = 2;
+    } else if (words_[0]) {
+      size_ = 1;
+    }
+    return fp.exponent;
+  }
+  int exponent_adjust =
+      ReadDigits(fp.subrange_begin, fp.subrange_end, significant_digits);
+  return fp.literal_exponent + exponent_adjust;
+}
+
+template <int max_words>
+int BigUnsigned<max_words>::ReadDigits(const char* begin, const char* end,
+                                       int significant_digits) {
+  assert(significant_digits <= Digits10() + 1);
+  SetToZero();
+
+  bool after_decimal_point = false;
+  // Discard any leading zeroes before the decimal point
+  while (begin < end && *begin == '0') {
+    ++begin;
+  }
+  int dropped_digits = 0;
+  // Discard any trailing zeroes.  These may or may not be after the decimal
+  // point.
+  while (begin < end && *std::prev(end) == '0') {
+    --end;
+    ++dropped_digits;
+  }
+  if (begin < end && *std::prev(end) == '.') {
+    // If the std::string ends in '.', either before or after dropping zeroes, then
+    // drop the decimal point and look for more digits to drop.
+    dropped_digits = 0;
+    --end;
+    while (begin < end && *std::prev(end) == '0') {
+      --end;
+      ++dropped_digits;
+    }
+  } else if (dropped_digits) {
+    // We dropped digits, and aren't sure if they're before or after the decimal
+    // point.  Figure that out now.
+    const char* dp = std::find(begin, end, '.');
+    if (dp != end) {
+      // The dropped trailing digits were after the decimal point, so don't
+      // count them.
+      dropped_digits = 0;
+    }
+  }
+  // Any non-fraction digits we dropped need to be accounted for in our exponent
+  // adjustment.
+  int exponent_adjust = dropped_digits;
+
+  uint32_t queued = 0;
+  int digits_queued = 0;
+  for (; begin != end && significant_digits > 0; ++begin) {
+    if (*begin == '.') {
+      after_decimal_point = true;
+      continue;
+    }
+    if (after_decimal_point) {
+      // For each fractional digit we emit in our parsed integer, adjust our
+      // decimal exponent to compensate.
+      --exponent_adjust;
+    }
+    int digit = (*begin - '0');
+    --significant_digits;
+    if (significant_digits == 0 && std::next(begin) != end &&
+        (digit == 0 || digit == 5)) {
+      // If this is the very last significant digit, but insignificant digits
+      // remain, we know that the last of those remaining significant digits is
+      // nonzero.  (If it wasn't, we would have stripped it before we got here.)
+      // So if this final digit is a 0 or 5, adjust it upward by 1.
+      //
+      // This adjustment is what allows incredibly large mantissas ending in
+      // 500000...000000000001 to correctly round up, rather than to nearest.
+      ++digit;
+    }
+    queued = 10 * queued + digit;
+    ++digits_queued;
+    if (digits_queued == kMaxSmallPowerOfTen) {
+      MultiplyBy(kTenToNth[kMaxSmallPowerOfTen]);
+      AddWithCarry(0, queued);
+      queued = digits_queued = 0;
+    }
+  }
+  // Encode any remaining digits.
+  if (digits_queued) {
+    MultiplyBy(kTenToNth[digits_queued]);
+    AddWithCarry(0, queued);
+  }
+
+  // If any insignificant digits remain, we will drop them.  But if we have not
+  // yet read the decimal point, then we have to adjust the exponent to account
+  // for the dropped digits.
+  if (begin < end && !after_decimal_point) {
+    // This call to std::find will result in a pointer either to the decimal
+    // point, or to the end of our buffer if there was none.
+    //
+    // Either way, [begin, decimal_point) will contain the set of dropped digits
+    // that require an exponent adjustment.
+    const char* decimal_point = std::find(begin, end, '.');
+    exponent_adjust += (decimal_point - begin);
+  }
+  return exponent_adjust;
+}
+
+template <int max_words>
+/* static */ BigUnsigned<max_words> BigUnsigned<max_words>::FiveToTheNth(
+    int n) {
+  BigUnsigned answer(1u);
+
+  // Seed from the table of large powers, if possible.
+  bool first_pass = true;
+  while (n >= kLargePowerOfFiveStep) {
+    int big_power =
+        std::min(n / kLargePowerOfFiveStep, kLargestPowerOfFiveIndex);
+    if (first_pass) {
+      // just copy, rather than multiplying by 1
+      std::copy(
+          LargePowerOfFiveData(big_power),
+          LargePowerOfFiveData(big_power) + LargePowerOfFiveSize(big_power),
+          answer.words_);
+      answer.size_ = LargePowerOfFiveSize(big_power);
+      first_pass = false;
+    } else {
+      answer.MultiplyBy(LargePowerOfFiveSize(big_power),
+                        LargePowerOfFiveData(big_power));
+    }
+    n -= kLargePowerOfFiveStep * big_power;
+  }
+  answer.MultiplyByFiveToTheNth(n);
+  return answer;
+}
+
+template <int max_words>
+void BigUnsigned<max_words>::MultiplyStep(int original_size,
+                                          const uint32_t* other_words,
+                                          int other_size, int step) {
+  int this_i = std::min(original_size - 1, step);
+  int other_i = step - this_i;
+
+  uint64_t this_word = 0;
+  uint64_t carry = 0;
+  for (; this_i >= 0 && other_i < other_size; --this_i, ++other_i) {
+    uint64_t product = words_[this_i];
+    product *= other_words[other_i];
+    this_word += product;
+    carry += (this_word >> 32);
+    this_word &= 0xffffffff;
+  }
+  AddWithCarry(step + 1, carry);
+  words_[step] = this_word & 0xffffffff;
+  if (this_word > 0 && size_ <= step) {
+    size_ = step + 1;
+  }
+}
+
+template <int max_words>
+std::string BigUnsigned<max_words>::ToString() const {
+  BigUnsigned<max_words> copy = *this;
+  std::string result;
+  // Build result in reverse order
+  while (copy.size() > 0) {
+    int next_digit = copy.DivMod<10>();
+    result.push_back('0' + next_digit);
+  }
+  if (result.empty()) {
+    result.push_back('0');
+  }
+  std::reverse(result.begin(), result.end());
+  return result;
+}
+
+template class BigUnsigned<4>;
+template class BigUnsigned<84>;
+
+}  // namespace strings_internal
+}  // namespace absl
diff --git a/third_party/abseil-cpp/absl/strings/internal/charconv_bigint.h b/third_party/abseil-cpp/absl/strings/internal/charconv_bigint.h
new file mode 100644
index 0000000000..aa70af2c28
--- /dev/null
+++ b/third_party/abseil-cpp/absl/strings/internal/charconv_bigint.h
@@ -0,0 +1,426 @@
+// 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
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_STRINGS_INTERNAL_CHARCONV_BIGINT_H_
+#define ABSL_STRINGS_INTERNAL_CHARCONV_BIGINT_H_
+
+#include <algorithm>
+#include <cstdint>
+#include <iostream>
+#include <string>
+
+#include "absl/strings/ascii.h"
+#include "absl/strings/internal/charconv_parse.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+namespace strings_internal {
+
+// The largest power that 5 that can be raised to, and still fit in a uint32_t.
+constexpr int kMaxSmallPowerOfFive = 13;
+// The largest power that 10 that can be raised to, and still fit in a uint32_t.
+constexpr int kMaxSmallPowerOfTen = 9;
+
+extern const uint32_t kFiveToNth[kMaxSmallPowerOfFive + 1];
+extern const uint32_t kTenToNth[kMaxSmallPowerOfTen + 1];
+
+// Large, fixed-width unsigned integer.
+//
+// Exact rounding for decimal-to-binary floating point conversion requires very
+// large integer math, but a design goal of absl::from_chars is to avoid
+// allocating memory.  The integer precision needed for decimal-to-binary
+// conversions is large but bounded, so a huge fixed-width integer class
+// suffices.
+//
+// This is an intentionally limited big integer class.  Only needed operations
+// are implemented.  All storage lives in an array data member, and all
+// arithmetic is done in-place, to avoid requiring separate storage for operand
+// and result.
+//
+// This is an internal class.  Some methods live in the .cc file, and are
+// instantiated only for the values of max_words we need.
+template <int max_words>
+class BigUnsigned {
+ public:
+  static_assert(max_words == 4 || max_words == 84,
+                "unsupported max_words value");
+
+  BigUnsigned() : size_(0), words_{} {}
+  explicit BigUnsigned(uint32_t v) : size_(v > 0 ? 1 : 0), words_{v} {}
+  explicit BigUnsigned(uint64_t v)
+      : size_(0),
+        words_{static_cast<uint32_t>(v & 0xffffffff),
+               static_cast<uint32_t>(v >> 32)} {
+    if (words_[1]) {
+      size_ = 2;
+    } else if (words_[0]) {
+      size_ = 1;
+    }
+  }
+
+  // Constructs a BigUnsigned from the given string_view containing a decimal
+  // value.  If the input std::string is not a decimal integer, constructs a 0
+  // instead.
+  explicit BigUnsigned(absl::string_view sv) : size_(0), words_{} {
+    // Check for valid input, returning a 0 otherwise.  This is reasonable
+    // behavior only because this constructor is for unit tests.
+    if (std::find_if_not(sv.begin(), sv.end(), ascii_isdigit) != sv.end() ||
+        sv.empty()) {
+      return;
+    }
+    int exponent_adjust =
+        ReadDigits(sv.data(), sv.data() + sv.size(), Digits10() + 1);
+    if (exponent_adjust > 0) {
+      MultiplyByTenToTheNth(exponent_adjust);
+    }
+  }
+
+  // Loads the mantissa value of a previously-parsed float.
+  //
+  // Returns the associated decimal exponent.  The value of the parsed float is
+  // exactly *this * 10**exponent.
+  int ReadFloatMantissa(const ParsedFloat& fp, int significant_digits);
+
+  // Returns the number of decimal digits of precision this type provides.  All
+  // numbers with this many decimal digits or fewer are representable by this
+  // type.
+  //
+  // Analagous to std::numeric_limits<BigUnsigned>::digits10.
+  static constexpr int Digits10() {
+    // 9975007/1035508 is very slightly less than log10(2**32).
+    return static_cast<uint64_t>(max_words) * 9975007 / 1035508;
+  }
+
+  // Shifts left by the given number of bits.
+  void ShiftLeft(int count) {
+    if (count > 0) {
+      const int word_shift = count / 32;
+      if (word_shift >= max_words) {
+        SetToZero();
+        return;
+      }
+      size_ = std::min(size_ + word_shift, max_words);
+      count %= 32;
+      if (count == 0) {
+        std::copy_backward(words_, words_ + size_ - word_shift, words_ + size_);
+      } else {
+        for (int i = std::min(size_, max_words - 1); i > word_shift; --i) {
+          words_[i] = (words_[i - word_shift] << count) |
+                      (words_[i - word_shift - 1] >> (32 - count));
+        }
+        words_[word_shift] = words_[0] << count;
+        // Grow size_ if necessary.
+        if (size_ < max_words && words_[size_]) {
+          ++size_;
+        }
+      }
+      std::fill(words_, words_ + word_shift, 0u);
+    }
+  }
+
+
+  // Multiplies by v in-place.
+  void MultiplyBy(uint32_t v) {
+    if (size_ == 0 || v == 1) {
+      return;
+    }
+    if (v == 0) {
+      SetToZero();
+      return;
+    }
+    const uint64_t factor = v;
+    uint64_t window = 0;
+    for (int i = 0; i < size_; ++i) {
+      window += factor * words_[i];
+      words_[i] = window & 0xffffffff;
+      window >>= 32;
+    }
+    // If carry bits remain and there's space for them, grow size_.
+    if (window && size_ < max_words) {
+      words_[size_] = window & 0xffffffff;
+      ++size_;
+    }
+  }
+
+  void MultiplyBy(uint64_t v) {
+    uint32_t words[2];
+    words[0] = static_cast<uint32_t>(v);
+    words[1] = static_cast<uint32_t>(v >> 32);
+    if (words[1] == 0) {
+      MultiplyBy(words[0]);
+    } else {
+      MultiplyBy(2, words);
+    }
+  }
+
+  // Multiplies in place by 5 to the power of n.  n must be non-negative.
+  void MultiplyByFiveToTheNth(int n) {
+    while (n >= kMaxSmallPowerOfFive) {
+      MultiplyBy(kFiveToNth[kMaxSmallPowerOfFive]);
+      n -= kMaxSmallPowerOfFive;
+    }
+    if (n > 0) {
+      MultiplyBy(kFiveToNth[n]);
+    }
+  }
+
+  // Multiplies in place by 10 to the power of n.  n must be non-negative.
+  void MultiplyByTenToTheNth(int n) {
+    if (n > kMaxSmallPowerOfTen) {
+      // For large n, raise to a power of 5, then shift left by the same amount.
+      // (10**n == 5**n * 2**n.)  This requires fewer multiplications overall.
+      MultiplyByFiveToTheNth(n);
+      ShiftLeft(n);
+    } else if (n > 0) {
+      // We can do this more quickly for very small N by using a single
+      // multiplication.
+      MultiplyBy(kTenToNth[n]);
+    }
+  }
+
+  // Returns the value of 5**n, for non-negative n.  This implementation uses
+  // a lookup table, and is faster then seeding a BigUnsigned with 1 and calling
+  // MultiplyByFiveToTheNth().
+  static BigUnsigned FiveToTheNth(int n);
+
+  // Multiplies by another BigUnsigned, in-place.
+  template <int M>
+  void MultiplyBy(const BigUnsigned<M>& other) {
+    MultiplyBy(other.size(), other.words());
+  }
+
+  void SetToZero() {
+    std::fill(words_, words_ + size_, 0u);
+    size_ = 0;
+  }
+
+  // Returns the value of the nth word of this BigUnsigned.  This is
+  // range-checked, and returns 0 on out-of-bounds accesses.
+  uint32_t GetWord(int index) const {
+    if (index < 0 || index >= size_) {
+      return 0;
+    }
+    return words_[index];
+  }
+
+  // Returns this integer as a decimal std::string.  This is not used in the decimal-
+  // to-binary conversion; it is intended to aid in testing.
+  std::string ToString() const;
+
+  int size() const { return size_; }
+  const uint32_t* words() const { return words_; }
+
+ private:
+  // Reads the number between [begin, end), possibly containing a decimal point,
+  // into this BigUnsigned.
+  //
+  // Callers are required to ensure [begin, end) contains a valid number, with
+  // one or more decimal digits and at most one decimal point.  This routine
+  // will behave unpredictably if these preconditions are not met.
+  //
+  // Only the first `significant_digits` digits are read.  Digits beyond this
+  // limit are "sticky": If the final significant digit is 0 or 5, and if any
+  // dropped digit is nonzero, then that final significant digit is adjusted up
+  // to 1 or 6.  This adjustment allows for precise rounding.
+  //
+  // Returns `exponent_adjustment`, a power-of-ten exponent adjustment to
+  // account for the decimal point and for dropped significant digits.  After
+  // this function returns,
+  //   actual_value_of_parsed_string ~= *this * 10**exponent_adjustment.
+  int ReadDigits(const char* begin, const char* end, int significant_digits);
+
+  // Performs a step of big integer multiplication.  This computes the full
+  // (64-bit-wide) values that should be added at the given index (step), and
+  // adds to that location in-place.
+  //
+  // Because our math all occurs in place, we must multiply starting from the
+  // highest word working downward.  (This is a bit more expensive due to the
+  // extra carries involved.)
+  //
+  // This must be called in steps, for each word to be calculated, starting from
+  // the high end and working down to 0.  The first value of `step` should be
+  //   `std::min(original_size + other.size_ - 2, max_words - 1)`.
+  // The reason for this expression is that multiplying the i'th word from one
+  // multiplicand and the j'th word of another multiplicand creates a
+  // two-word-wide value to be stored at the (i+j)'th element.  The highest
+  // word indices we will access are `original_size - 1` from this object, and
+  // `other.size_ - 1` from our operand.  Therefore,
+  // `original_size + other.size_ - 2` is the first step we should calculate,
+  // but limited on an upper bound by max_words.
+
+  // Working from high-to-low ensures that we do not overwrite the portions of
+  // the initial value of *this which are still needed for later steps.
+  //
+  // Once called with step == 0, *this contains the result of the
+  // multiplication.
+  //
+  // `original_size` is the size_ of *this before the first call to
+  // MultiplyStep().  `other_words` and `other_size` are the contents of our
+  // operand.  `step` is the step to perform, as described above.
+  void MultiplyStep(int original_size, const uint32_t* other_words,
+                    int other_size, int step);
+
+  void MultiplyBy(int other_size, const uint32_t* other_words) {
+    const int original_size = size_;
+    const int first_step =
+        std::min(original_size + other_size - 2, max_words - 1);
+    for (int step = first_step; step >= 0; --step) {
+      MultiplyStep(original_size, other_words, other_size, step);
+    }
+  }
+
+  // Adds a 32-bit value to the index'th word, with carry.
+  void AddWithCarry(int index, uint32_t value) {
+    if (value) {
+      while (index < max_words && value > 0) {
+        words_[index] += value;
+        // carry if we overflowed in this word:
+        if (value > words_[index]) {
+          value = 1;
+          ++index;
+        } else {
+          value = 0;
+        }
+      }
+      size_ = std::min(max_words, std::max(index + 1, size_));
+    }
+  }
+
+  void AddWithCarry(int index, uint64_t value) {
+    if (value && index < max_words) {
+      uint32_t high = value >> 32;
+      uint32_t low = value & 0xffffffff;
+      words_[index] += low;
+      if (words_[index] < low) {
+        ++high;
+        if (high == 0) {
+          // Carry from the low word caused our high word to overflow.
+          // Short circuit here to do the right thing.
+          AddWithCarry(index + 2, static_cast<uint32_t>(1));
+          return;
+        }
+      }
+      if (high > 0) {
+        AddWithCarry(index + 1, high);
+      } else {
+        // Normally 32-bit AddWithCarry() sets size_, but since we don't call
+        // it when `high` is 0, do it ourselves here.
+        size_ = std::min(max_words, std::max(index + 1, size_));
+      }
+    }
+  }
+
+  // Divide this in place by a constant divisor.  Returns the remainder of the
+  // division.
+  template <uint32_t divisor>
+  uint32_t DivMod() {
+    uint64_t accumulator = 0;
+    for (int i = size_ - 1; i >= 0; --i) {
+      accumulator <<= 32;
+      accumulator += words_[i];
+      // accumulator / divisor will never overflow an int32_t in this loop
+      words_[i] = static_cast<uint32_t>(accumulator / divisor);
+      accumulator = accumulator % divisor;
+    }
+    while (size_ > 0 && words_[size_ - 1] == 0) {
+      --size_;
+    }
+    return static_cast<uint32_t>(accumulator);
+  }
+
+  // The number of elements in words_ that may carry significant values.
+  // All elements beyond this point are 0.
+  //
+  // When size_ is 0, this BigUnsigned stores the value 0.
+  // When size_ is nonzero, is *not* guaranteed that words_[size_ - 1] is
+  // nonzero.  This can occur due to overflow truncation.
+  // In particular, x.size_ != y.size_ does *not* imply x != y.
+  int size_;
+  uint32_t words_[max_words];
+};
+
+// Compares two big integer instances.
+//
+// Returns -1 if lhs < rhs, 0 if lhs == rhs, and 1 if lhs > rhs.
+template <int N, int M>
+int Compare(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
+  int limit = std::max(lhs.size(), rhs.size());
+  for (int i = limit - 1; i >= 0; --i) {
+    const uint32_t lhs_word = lhs.GetWord(i);
+    const uint32_t rhs_word = rhs.GetWord(i);
+    if (lhs_word < rhs_word) {
+      return -1;
+    } else if (lhs_word > rhs_word) {
+      return 1;
+    }
+  }
+  return 0;
+}
+
+template <int N, int M>
+bool operator==(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
+  int limit = std::max(lhs.size(), rhs.size());
+  for (int i = 0; i < limit; ++i) {
+    if (lhs.GetWord(i) != rhs.GetWord(i)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+template <int N, int M>
+bool operator!=(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
+  return !(lhs == rhs);
+}
+
+template <int N, int M>
+bool operator<(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
+  return Compare(lhs, rhs) == -1;
+}
+
+template <int N, int M>
+bool operator>(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
+  return rhs < lhs;
+}
+template <int N, int M>
+bool operator<=(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
+  return !(rhs < lhs);
+}
+template <int N, int M>
+bool operator>=(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
+  return !(lhs < rhs);
+}
+
+// Output operator for BigUnsigned, for testing purposes only.
+template <int N>
+std::ostream& operator<<(std::ostream& os, const BigUnsigned<N>& num) {
+  return os << num.ToString();
+}
+
+// Explicit instantiation declarations for the sizes of BigUnsigned that we
+// are using.
+//
+// For now, the choices of 4 and 84 are arbitrary; 4 is a small value that is
+// still bigger than an int128, and 84 is a large value we will want to use
+// in the from_chars implementation.
+//
+// Comments justifying the use of 84 belong in the from_chars implementation,
+// and will be added in a follow-up CL.
+extern template class BigUnsigned<4>;
+extern template class BigUnsigned<84>;
+
+}  // namespace strings_internal
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_CHARCONV_BIGINT_H_
diff --git a/third_party/abseil-cpp/absl/strings/internal/charconv_bigint_test.cc b/third_party/abseil-cpp/absl/strings/internal/charconv_bigint_test.cc
new file mode 100644
index 0000000000..9b6357888f
--- /dev/null
+++ b/third_party/abseil-cpp/absl/strings/internal/charconv_bigint_test.cc
@@ -0,0 +1,203 @@
+// 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
+//
+//      http://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/strings/internal/charconv_bigint.h"
+
+#include <string>
+
+#include "gtest/gtest.h"
+
+namespace absl {
+namespace strings_internal {
+
+TEST(BigUnsigned, ShiftLeft) {
+  {
+    // Check that 3 * 2**100 is calculated correctly
+    BigUnsigned<4> num(3u);
+    num.ShiftLeft(100);
+    EXPECT_EQ(num, BigUnsigned<4>("3802951800684688204490109616128"));
+  }
+  {
+    // Test that overflow is truncated properly.
+    // 15 is 4 bits long, and BigUnsigned<4> is a 128-bit bigint.
+    // Shifting left by 125 bits should truncate off the high bit, so that
+    //   15 << 125 == 7 << 125
+    // after truncation.
+    BigUnsigned<4> a(15u);
+    BigUnsigned<4> b(7u);
+    BigUnsigned<4> c(3u);
+    a.ShiftLeft(125);
+    b.ShiftLeft(125);
+    c.ShiftLeft(125);
+    EXPECT_EQ(a, b);
+    EXPECT_NE(a, c);
+  }
+  {
+    // Same test, larger bigint:
+    BigUnsigned<84> a(15u);
+    BigUnsigned<84> b(7u);
+    BigUnsigned<84> c(3u);
+    a.ShiftLeft(84 * 32 - 3);
+    b.ShiftLeft(84 * 32 - 3);
+    c.ShiftLeft(84 * 32 - 3);
+    EXPECT_EQ(a, b);
+    EXPECT_NE(a, c);
+  }
+  {
+    // Check that incrementally shifting has the same result as doing it all at
+    // once (attempting to capture corner cases.)
+    const std::string seed = "1234567890123456789012345678901234567890";
+    BigUnsigned<84> a(seed);
+    for (int i = 1; i <= 84 * 32; ++i) {
+      a.ShiftLeft(1);
+      BigUnsigned<84> b(seed);
+      b.ShiftLeft(i);
+      EXPECT_EQ(a, b);
+    }
+    // And we should have fully rotated all bits off by now:
+    EXPECT_EQ(a, BigUnsigned<84>(0u));
+  }
+}
+
+TEST(BigUnsigned, MultiplyByUint32) {
+  const BigUnsigned<84> factorial_100(
+      "933262154439441526816992388562667004907159682643816214685929638952175999"
+      "932299156089414639761565182862536979208272237582511852109168640000000000"
+      "00000000000000");
+  BigUnsigned<84> a(1u);
+  for (uint32_t i = 1; i <= 100; ++i) {
+    a.MultiplyBy(i);
+  }
+  EXPECT_EQ(a, BigUnsigned<84>(factorial_100));
+}
+
+TEST(BigUnsigned, MultiplyByBigUnsigned) {
+  {
+    // Put the terms of factorial_200 into two bigints, and multiply them
+    // together.
+    const BigUnsigned<84> factorial_200(
+        "7886578673647905035523632139321850622951359776871732632947425332443594"
+        "4996340334292030428401198462390417721213891963883025764279024263710506"
+        "1926624952829931113462857270763317237396988943922445621451664240254033"
+        "2918641312274282948532775242424075739032403212574055795686602260319041"
+        "7032406235170085879617892222278962370389737472000000000000000000000000"
+        "0000000000000000000000000");
+    BigUnsigned<84> evens(1u);
+    BigUnsigned<84> odds(1u);
+    for (uint32_t i = 1; i < 200; i += 2) {
+      odds.MultiplyBy(i);
+      evens.MultiplyBy(i + 1);
+    }
+    evens.MultiplyBy(odds);
+    EXPECT_EQ(evens, factorial_200);
+  }
+  {
+    // Multiply various powers of 10 together.
+    for (int a = 0 ; a < 700; a += 25) {
+      SCOPED_TRACE(a);
+      BigUnsigned<84> a_value("3" + std::string(a, '0'));
+      for (int b = 0; b < (700 - a); b += 25) {
+        SCOPED_TRACE(b);
+        BigUnsigned<84> b_value("2" + std::string(b, '0'));
+        BigUnsigned<84> expected_product("6" + std::string(a + b, '0'));
+        b_value.MultiplyBy(a_value);
+        EXPECT_EQ(b_value, expected_product);
+      }
+    }
+  }
+}
+
+TEST(BigUnsigned, MultiplyByOverflow) {
+  {
+    // Check that multiplcation overflow predictably truncates.
+
+    // A big int with all bits on.
+    BigUnsigned<4> all_bits_on("340282366920938463463374607431768211455");
+    // Modulo 2**128, this is equal to -1.  Therefore the square of this,
+    // modulo 2**128, should be 1.
+    all_bits_on.MultiplyBy(all_bits_on);
+    EXPECT_EQ(all_bits_on, BigUnsigned<4>(1u));
+  }
+  {
+    // Try multiplying a large bigint by 2**50, and compare the result to
+    // shifting.
+    BigUnsigned<4> value_1("12345678901234567890123456789012345678");
+    BigUnsigned<4> value_2("12345678901234567890123456789012345678");
+    BigUnsigned<4> two_to_fiftieth(1u);
+    two_to_fiftieth.ShiftLeft(50);
+
+    value_1.ShiftLeft(50);
+    value_2.MultiplyBy(two_to_fiftieth);
+    EXPECT_EQ(value_1, value_2);
+  }
+}
+
+TEST(BigUnsigned, FiveToTheNth) {
+  {
+    // Sanity check that MultiplyByFiveToTheNth gives consistent answers, up to
+    // and including overflow.
+    for (int i = 0; i < 1160; ++i) {
+      SCOPED_TRACE(i);
+      BigUnsigned<84> value_1(123u);
+      BigUnsigned<84> value_2(123u);
+      value_1.MultiplyByFiveToTheNth(i);
+      for (int j = 0; j < i; j++) {
+        value_2.MultiplyBy(5u);
+      }
+      EXPECT_EQ(value_1, value_2);
+    }
+  }
+  {
+    // Check that the faster, table-lookup-based static method returns the same
+    // result that multiplying in-place would return, up to and including
+    // overflow.
+    for (int i = 0; i < 1160; ++i) {
+      SCOPED_TRACE(i);
+      BigUnsigned<84> value_1(1u);
+      value_1.MultiplyByFiveToTheNth(i);
+      BigUnsigned<84> value_2 = BigUnsigned<84>::FiveToTheNth(i);
+      EXPECT_EQ(value_1, value_2);
+    }
+  }
+}
+
+TEST(BigUnsigned, TenToTheNth) {
+  {
+    // Sanity check MultiplyByTenToTheNth.
+    for (int i = 0; i < 800; ++i) {
+      SCOPED_TRACE(i);
+      BigUnsigned<84> value_1(123u);
+      BigUnsigned<84> value_2(123u);
+      value_1.MultiplyByTenToTheNth(i);
+      for (int j = 0; j < i; j++) {
+        value_2.MultiplyBy(10u);
+      }
+      EXPECT_EQ(value_1, value_2);
+    }
+  }
+  {
+    // Alternate testing approach, taking advantage of the decimal parser.
+    for (int i = 0; i < 200; ++i) {
+      SCOPED_TRACE(i);
+      BigUnsigned<84> value_1(135u);
+      value_1.MultiplyByTenToTheNth(i);
+      BigUnsigned<84> value_2("135" + std::string(i, '0'));
+      EXPECT_EQ(value_1, value_2);
+    }
+  }
+}
+
+
+}  // namespace strings_internal
+}  // namespace absl
diff --git a/third_party/abseil-cpp/absl/strings/internal/charconv_parse.cc b/third_party/abseil-cpp/absl/strings/internal/charconv_parse.cc
new file mode 100644
index 0000000000..a04cc67669
--- /dev/null
+++ b/third_party/abseil-cpp/absl/strings/internal/charconv_parse.cc
@@ -0,0 +1,496 @@
+// 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
+//
+//      http://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/strings/internal/charconv_parse.h"
+#include "absl/strings/charconv.h"
+
+#include <cassert>
+#include <cstdint>
+#include <limits>
+
+#include "absl/strings/internal/memutil.h"
+
+namespace absl {
+namespace {
+
+// ParseFloat<10> will read the first 19 significant digits of the mantissa.
+// This number was chosen for multiple reasons.
+//
+// (a) First, for whatever integer type we choose to represent the mantissa, we
+// want to choose the largest possible number of decimal digits for that integer
+// type.  We are using uint64_t, which can express any 19-digit unsigned
+// integer.
+//
+// (b) Second, we need to parse enough digits that the binary value of any
+// mantissa we capture has more bits of resolution than the mantissa
+// representation in the target float.  Our algorithm requires at least 3 bits
+// of headway, but 19 decimal digits give a little more than that.
+//
+// The following static assertions verify the above comments:
+constexpr int kDecimalMantissaDigitsMax = 19;
+
+static_assert(std::numeric_limits<uint64_t>::digits10 ==
+                  kDecimalMantissaDigitsMax,
+              "(a) above");
+
+// IEEE doubles, which we assume in Abseil, have 53 binary bits of mantissa.
+static_assert(std::numeric_limits<double>::is_iec559, "IEEE double assumed");
+static_assert(std::numeric_limits<double>::radix == 2, "IEEE double fact");
+static_assert(std::numeric_limits<double>::digits == 53, "IEEE double fact");
+
+// The lowest valued 19-digit decimal mantissa we can read still contains
+// sufficient information to reconstruct a binary mantissa.
+static_assert(1000000000000000000u > (uint64_t(1) << (53 + 3)), "(b) above");
+
+// ParseFloat<16> will read the first 15 significant digits of the mantissa.
+//
+// Because a base-16-to-base-2 conversion can be done exactly, we do not need
+// to maximize the number of scanned hex digits to improve our conversion.  What
+// is required is to scan two more bits than the mantissa can represent, so that
+// we always round correctly.
+//
+// (One extra bit does not suffice to perform correct rounding, since a number
+// exactly halfway between two representable floats has unique rounding rules,
+// so we need to differentiate between a "halfway between" number and a "closer
+// to the larger value" number.)
+constexpr int kHexadecimalMantissaDigitsMax = 15;
+
+// The minimum number of significant bits that will be read from
+// kHexadecimalMantissaDigitsMax hex digits.  We must subtract by three, since
+// the most significant digit can be a "1", which only contributes a single
+// significant bit.
+constexpr int kGuaranteedHexadecimalMantissaBitPrecision =
+    4 * kHexadecimalMantissaDigitsMax - 3;
+
+static_assert(kGuaranteedHexadecimalMantissaBitPrecision >
+                  std::numeric_limits<double>::digits + 2,
+              "kHexadecimalMantissaDigitsMax too small");
+
+// We also impose a limit on the number of significant digits we will read from
+// an exponent, to avoid having to deal with integer overflow.  We use 9 for
+// this purpose.
+//
+// If we read a 9 digit exponent, the end result of the conversion will
+// necessarily be infinity or zero, depending on the sign of the exponent.
+// Therefore we can just drop extra digits on the floor without any extra
+// logic.
+constexpr int kDecimalExponentDigitsMax = 9;
+static_assert(std::numeric_limits<int>::digits10 >= kDecimalExponentDigitsMax,
+              "int type too small");
+
+// To avoid incredibly large inputs causing integer overflow for our exponent,
+// we impose an arbitrary but very large limit on the number of significant
+// digits we will accept.  The implementation refuses to match a std::string with
+// more consecutive significant mantissa digits than this.
+constexpr int kDecimalDigitLimit = 50000000;
+
+// Corresponding limit for hexadecimal digit inputs.  This is one fourth the
+// amount of kDecimalDigitLimit, since each dropped hexadecimal digit requires
+// a binary exponent adjustment of 4.
+constexpr int kHexadecimalDigitLimit = kDecimalDigitLimit / 4;
+
+// The largest exponent we can read is 999999999 (per
+// kDecimalExponentDigitsMax), and the largest exponent adjustment we can get
+// from dropped mantissa digits is 2 * kDecimalDigitLimit, and the sum of these
+// comfortably fits in an integer.
+//
+// We count kDecimalDigitLimit twice because there are independent limits for
+// numbers before and after the decimal point.  (In the case where there are no
+// significant digits before the decimal point, there are independent limits for
+// post-decimal-point leading zeroes and for significant digits.)
+static_assert(999999999 + 2 * kDecimalDigitLimit <
+                  std::numeric_limits<int>::max(),
+              "int type too small");
+static_assert(999999999 + 2 * (4 * kHexadecimalDigitLimit) <
+                  std::numeric_limits<int>::max(),
+              "int type too small");
+
+// Returns true if the provided bitfield allows parsing an exponent value
+// (e.g., "1.5e100").
+bool AllowExponent(chars_format flags) {
+  bool fixed = (flags & chars_format::fixed) == chars_format::fixed;
+  bool scientific =
+      (flags & chars_format::scientific) == chars_format::scientific;
+  return scientific || !fixed;
+}
+
+// Returns true if the provided bitfield requires an exponent value be present.
+bool RequireExponent(chars_format flags) {
+  bool fixed = (flags & chars_format::fixed) == chars_format::fixed;
+  bool scientific =
+      (flags & chars_format::scientific) == chars_format::scientific;
+  return scientific && !fixed;
+}
+
+const int8_t kAsciiToInt[256] = {
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0,  1,  2,  3,  4,  5,  6,  7,  8,
+    9,  -1, -1, -1, -1, -1, -1, -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1};
+
+// Returns true if `ch` is a digit in the given base
+template <int base>
+bool IsDigit(char ch);
+
+// Converts a valid `ch` to its digit value in the given base.
+template <int base>
+unsigned ToDigit(char ch);
+
+// Returns true if `ch` is the exponent delimiter for the given base.
+template <int base>
+bool IsExponentCharacter(char ch);
+
+// Returns the maximum number of significant digits we will read for a float
+// in the given base.
+template <int base>
+constexpr int MantissaDigitsMax();
+
+// Returns the largest consecutive run of digits we will accept when parsing a
+// number in the given base.
+template <int base>
+constexpr int DigitLimit();
+
+// Returns the amount the exponent must be adjusted by for each dropped digit.
+// (For decimal this is 1, since the digits are in base 10 and the exponent base
+// is also 10, but for hexadecimal this is 4, since the digits are base 16 but
+// the exponent base is 2.)
+template <int base>
+constexpr int DigitMagnitude();
+
+template <>
+bool IsDigit<10>(char ch) {
+  return ch >= '0' && ch <= '9';
+}
+template <>
+bool IsDigit<16>(char ch) {
+  return kAsciiToInt[static_cast<unsigned char>(ch)] >= 0;
+}
+
+template <>
+unsigned ToDigit<10>(char ch) {
+  return ch - '0';
+}
+template <>
+unsigned ToDigit<16>(char ch) {
+  return kAsciiToInt[static_cast<unsigned char>(ch)];
+}
+
+template <>
+bool IsExponentCharacter<10>(char ch) {
+  return ch == 'e' || ch == 'E';
+}
+
+template <>
+bool IsExponentCharacter<16>(char ch) {
+  return ch == 'p' || ch == 'P';
+}
+
+template <>
+constexpr int MantissaDigitsMax<10>() {
+  return kDecimalMantissaDigitsMax;
+}
+template <>
+constexpr int MantissaDigitsMax<16>() {
+  return kHexadecimalMantissaDigitsMax;
+}
+
+template <>
+constexpr int DigitLimit<10>() {
+  return kDecimalDigitLimit;
+}
+template <>
+constexpr int DigitLimit<16>() {
+  return kHexadecimalDigitLimit;
+}
+
+template <>
+constexpr int DigitMagnitude<10>() {
+  return 1;
+}
+template <>
+constexpr int DigitMagnitude<16>() {
+  return 4;
+}
+
+// Reads decimal digits from [begin, end) into *out.  Returns the number of
+// digits consumed.
+//
+// After max_digits has been read, keeps consuming characters, but no longer
+// adjusts *out.  If a nonzero digit is dropped this way, *dropped_nonzero_digit
+// is set; otherwise, it is left unmodified.
+//
+// If no digits are matched, returns 0 and leaves *out unchanged.
+//
+// ConsumeDigits does not protect against overflow on *out; max_digits must
+// be chosen with respect to type T to avoid the possibility of overflow.
+template <int base, typename T>
+std::size_t ConsumeDigits(const char* begin, const char* end, int max_digits,
+                          T* out, bool* dropped_nonzero_digit) {
+  if (base == 10) {
+    assert(max_digits <= std::numeric_limits<T>::digits10);
+  } else if (base == 16) {
+    assert(max_digits * 4 <= std::numeric_limits<T>::digits);
+  }
+  const char* const original_begin = begin;
+  T accumulator = *out;
+  const char* significant_digits_end =
+      (end - begin > max_digits) ? begin + max_digits : end;
+  while (begin < significant_digits_end && IsDigit<base>(*begin)) {
+    // Do not guard against *out overflow; max_digits was chosen to avoid this.
+    // Do assert against it, to detect problems in debug builds.
+    auto digit = static_cast<T>(ToDigit<base>(*begin));
+    assert(accumulator * base >= accumulator);
+    accumulator *= base;
+    assert(accumulator + digit >= accumulator);
+    accumulator += digit;
+    ++begin;
+  }
+  bool dropped_nonzero = false;
+  while (begin < end && IsDigit<base>(*begin)) {
+    dropped_nonzero = dropped_nonzero || (*begin != '0');
+    ++begin;
+  }
+  if (dropped_nonzero && dropped_nonzero_digit != nullptr) {
+    *dropped_nonzero_digit = true;
+  }
+  *out = accumulator;
+  return begin - original_begin;
+}
+
+// Returns true if `v` is one of the chars allowed inside parentheses following
+// a NaN.
+bool IsNanChar(char v) {
+  return (v == '_') || (v >= '0' && v <= '9') || (v >= 'a' && v <= 'z') ||
+         (v >= 'A' && v <= 'Z');
+}
+
+// Checks the range [begin, end) for a strtod()-formatted infinity or NaN.  If
+// one is found, sets `out` appropriately and returns true.
+bool ParseInfinityOrNan(const char* begin, const char* end,
+                        strings_internal::ParsedFloat* out) {
+  if (end - begin < 3) {
+    return false;
+  }
+  switch (*begin) {
+    case 'i':
+    case 'I': {
+      // An infinity std::string consists of the characters "inf" or "infinity",
+      // case insensitive.
+      if (strings_internal::memcasecmp(begin + 1, "nf", 2) != 0) {
+        return false;
+      }
+      out->type = strings_internal::FloatType::kInfinity;
+      if (end - begin >= 8 &&
+          strings_internal::memcasecmp(begin + 3, "inity", 5) == 0) {
+        out->end = begin + 8;
+      } else {
+        out->end = begin + 3;
+      }
+      return true;
+    }
+    case 'n':
+    case 'N': {
+      // A NaN consists of the characters "nan", case insensitive, optionally
+      // followed by a parenthesized sequence of zero or more alphanumeric
+      // characters and/or underscores.
+      if (strings_internal::memcasecmp(begin + 1, "an", 2) != 0) {
+        return false;
+      }
+      out->type = strings_internal::FloatType::kNan;
+      out->end = begin + 3;
+      // NaN is allowed to be followed by a parenthesized std::string, consisting of
+      // only the characters [a-zA-Z0-9_].  Match that if it's present.
+      begin += 3;
+      if (begin < end && *begin == '(') {
+        const char* nan_begin = begin + 1;
+        while (nan_begin < end && IsNanChar(*nan_begin)) {
+          ++nan_begin;
+        }
+        if (nan_begin < end && *nan_begin == ')') {
+          // We found an extra NaN specifier range
+          out->subrange_begin = begin + 1;
+          out->subrange_end = nan_begin;
+          out->end = nan_begin + 1;
+        }
+      }
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+}  // namespace
+
+namespace strings_internal {
+
+template <int base>
+strings_internal::ParsedFloat ParseFloat(const char* begin, const char* end,
+                                         chars_format format_flags) {
+  strings_internal::ParsedFloat result;
+
+  // Exit early if we're given an empty range.
+  if (begin == end) return result;
+
+  // Handle the infinity and NaN cases.
+  if (ParseInfinityOrNan(begin, end, &result)) {
+    return result;
+  }
+
+  const char* const mantissa_begin = begin;
+  while (begin < end && *begin == '0') {
+    ++begin;  // skip leading zeros
+  }
+  uint64_t mantissa = 0;
+
+  int exponent_adjustment = 0;
+  bool mantissa_is_inexact = false;
+  std::size_t pre_decimal_digits = ConsumeDigits<base>(
+      begin, end, MantissaDigitsMax<base>(), &mantissa, &mantissa_is_inexact);
+  begin += pre_decimal_digits;
+  int digits_left;
+  if (pre_decimal_digits >= DigitLimit<base>()) {
+    // refuse to parse pathological inputs
+    return result;
+  } else if (pre_decimal_digits > MantissaDigitsMax<base>()) {
+    // We dropped some non-fraction digits on the floor.  Adjust our exponent
+    // to compensate.
+    exponent_adjustment =
+        static_cast<int>(pre_decimal_digits - MantissaDigitsMax<base>());
+    digits_left = 0;
+  } else {
+    digits_left =
+        static_cast<int>(MantissaDigitsMax<base>() - pre_decimal_digits);
+  }
+  if (begin < end && *begin == '.') {
+    ++begin;
+    if (mantissa == 0) {
+      // If we haven't seen any nonzero digits yet, keep skipping zeros.  We
+      // have to adjust the exponent to reflect the changed place value.
+      const char* begin_zeros = begin;
+      while (begin < end && *begin == '0') {
+        ++begin;
+      }
+      std::size_t zeros_skipped = begin - begin_zeros;
+      if (zeros_skipped >= DigitLimit<base>()) {
+        // refuse to parse pathological inputs
+        return result;
+      }
+      exponent_adjustment -= static_cast<int>(zeros_skipped);
+    }
+    std::size_t post_decimal_digits = ConsumeDigits<base>(
+        begin, end, digits_left, &mantissa, &mantissa_is_inexact);
+    begin += post_decimal_digits;
+
+    // Since `mantissa` is an integer, each significant digit we read after
+    // the decimal point requires an adjustment to the exponent. "1.23e0" will
+    // be stored as `mantissa` == 123 and `exponent` == -2 (that is,
+    // "123e-2").
+    if (post_decimal_digits >= DigitLimit<base>()) {
+      // refuse to parse pathological inputs
+      return result;
+    } else if (post_decimal_digits > digits_left) {
+      exponent_adjustment -= digits_left;
+    } else {
+      exponent_adjustment -= post_decimal_digits;
+    }
+  }
+  // If we've found no mantissa whatsoever, this isn't a number.
+  if (mantissa_begin == begin) {
+    return result;
+  }
+  // A bare "." doesn't count as a mantissa either.
+  if (begin - mantissa_begin == 1 && *mantissa_begin == '.') {
+    return result;
+  }
+
+  if (mantissa_is_inexact) {
+    // We dropped significant digits on the floor.  Handle this appropriately.
+    if (base == 10) {
+      // If we truncated significant decimal digits, store the full range of the
+      // mantissa for future big integer math for exact rounding.
+      result.subrange_begin = mantissa_begin;
+      result.subrange_end = begin;
+    } else if (base == 16) {
+      // If we truncated hex digits, reflect this fact by setting the low
+      // ("sticky") bit.  This allows for correct rounding in all cases.
+      mantissa |= 1;
+    }
+  }
+  result.mantissa = mantissa;
+
+  const char* const exponent_begin = begin;
+  result.literal_exponent = 0;
+  bool found_exponent = false;
+  if (AllowExponent(format_flags) && begin < end &&
+      IsExponentCharacter<base>(*begin)) {
+    bool negative_exponent = false;
+    ++begin;
+    if (begin < end && *begin == '-') {
+      negative_exponent = true;
+      ++begin;
+    } else if (begin < end && *begin == '+') {
+      ++begin;
+    }
+    const char* const exponent_digits_begin = begin;
+    // Exponent is always expressed in decimal, even for hexadecimal floats.
+    begin += ConsumeDigits<10>(begin, end, kDecimalExponentDigitsMax,
+                               &result.literal_exponent, nullptr);
+    if (begin == exponent_digits_begin) {
+      // there were no digits where we expected an exponent.  We failed to read
+      // an exponent and should not consume the 'e' after all.  Rewind 'begin'.
+      found_exponent = false;
+      begin = exponent_begin;
+    } else {
+      found_exponent = true;
+      if (negative_exponent) {
+        result.literal_exponent = -result.literal_exponent;
+      }
+    }
+  }
+
+  if (!found_exponent && RequireExponent(format_flags)) {
+    // Provided flags required an exponent, but none was found.  This results
+    // in a failure to scan.
+    return result;
+  }
+
+  // Success!
+  result.type = strings_internal::FloatType::kNumber;
+  if (result.mantissa > 0) {
+    result.exponent = result.literal_exponent +
+                      (DigitMagnitude<base>() * exponent_adjustment);
+  } else {
+    result.exponent = 0;
+  }
+  result.end = begin;
+  return result;
+}
+
+template ParsedFloat ParseFloat<10>(const char* begin, const char* end,
+                                    chars_format format_flags);
+template ParsedFloat ParseFloat<16>(const char* begin, const char* end,
+                                    chars_format format_flags);
+
+}  // namespace strings_internal
+}  // namespace absl
diff --git a/third_party/abseil-cpp/absl/strings/internal/charconv_parse.h b/third_party/abseil-cpp/absl/strings/internal/charconv_parse.h
new file mode 100644
index 0000000000..7a5c0874b8
--- /dev/null
+++ b/third_party/abseil-cpp/absl/strings/internal/charconv_parse.h
@@ -0,0 +1,96 @@
+// 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
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_
+#define ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_
+
+#include <cstdint>
+
+#include "absl/strings/charconv.h"
+
+namespace absl {
+namespace strings_internal {
+
+// Enum indicating whether a parsed float is a number or special value.
+enum class FloatType { kNumber, kInfinity, kNan };
+
+// The decomposed parts of a parsed `float` or `double`.
+struct ParsedFloat {
+  // Representation of the parsed mantissa, with the decimal point adjusted to
+  // make it an integer.
+  //
+  // During decimal scanning, this contains 19 significant digits worth of
+  // mantissa value.  If digits beyond this point are found, they
+  // are truncated, and if any of these dropped digits are nonzero, then
+  // `mantissa` is inexact, and the full mantissa is stored in [subrange_begin,
+  // subrange_end).
+  //
+  // During hexadecimal scanning, this contains 15 significant hex digits worth
+  // of mantissa value.  Digits beyond this point are sticky -- they are
+  // truncated, but if any dropped digits are nonzero, the low bit of mantissa
+  // will be set.  (This allows for precise rounding, and avoids the need
+  // to store the full mantissa in [subrange_begin, subrange_end).)
+  uint64_t mantissa = 0;
+
+  // Floating point expontent.  This reflects any decimal point adjustments and
+  // any truncated digits from the mantissa.  The absolute value of the parsed
+  // number is represented by mantissa * (base ** exponent), where base==10 for
+  // decimal floats, and base==2 for hexadecimal floats.
+  int exponent = 0;
+
+  // The literal exponent value scanned from the input, or 0 if none was
+  // present.  This does not reflect any adjustments applied to mantissa.
+  int literal_exponent = 0;
+
+  // The type of number scanned.
+  FloatType type = FloatType::kNumber;
+
+  // When non-null, [subrange_begin, subrange_end) marks a range of characters
+  // that require further processing.  The meaning is dependent on float type.
+  // If type == kNumber and this is set, this is a "wide input": the input
+  // mantissa contained more than 19 digits.  The range contains the full
+  // mantissa.  It plus `literal_exponent` need to be examined to find the best
+  // floating point match.
+  // If type == kNan and this is set, the range marks the contents of a
+  // matched parenthesized character region after the NaN.
+  const char* subrange_begin = nullptr;
+  const char* subrange_end = nullptr;
+
+  // One-past-the-end of the successfully parsed region, or nullptr if no
+  // matching pattern was found.
+  const char* end = nullptr;
+};
+
+// Read the floating point number in the provided range, and populate
+// ParsedFloat accordingly.
+//
+// format_flags is a bitmask value specifying what patterns this API will match.
+// `scientific` and `fixed`  are honored per std::from_chars rules
+// ([utility.from.chars], C++17): if exactly one of these bits is set, then an
+// exponent is required, or dislallowed, respectively.
+//
+// Template parameter `base` must be either 10 or 16.  For base 16, a "0x" is
+// *not* consumed.  The `hex` bit from format_flags is ignored by ParseFloat.
+template <int base>
+ParsedFloat ParseFloat(const char* begin, const char* end,
+                       absl::chars_format format_flags);
+
+extern template ParsedFloat ParseFloat<10>(const char* begin, const char* end,
+                                           absl::chars_format format_flags);
+extern template ParsedFloat ParseFloat<16>(const char* begin, const char* end,
+                                           absl::chars_format format_flags);
+
+}  // namespace strings_internal
+}  // namespace absl
+#endif  // ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_
diff --git a/third_party/abseil-cpp/absl/strings/internal/charconv_parse_test.cc b/third_party/abseil-cpp/absl/strings/internal/charconv_parse_test.cc
new file mode 100644
index 0000000000..1ff8600497
--- /dev/null
+++ b/third_party/abseil-cpp/absl/strings/internal/charconv_parse_test.cc
@@ -0,0 +1,357 @@
+// 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
+//
+//      http://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/strings/internal/charconv_parse.h"
+
+#include <string>
+#include <utility>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/strings/str_cat.h"
+
+using absl::chars_format;
+using absl::strings_internal::FloatType;
+using absl::strings_internal::ParsedFloat;
+using absl::strings_internal::ParseFloat;
+
+namespace {
+
+// Check that a given std::string input is parsed to the expected mantissa and
+// exponent.
+//
+// Input std::string `s` must contain a '$' character.  It marks the end of the
+// characters that should be consumed by the match.  It is stripped from the
+// input to ParseFloat.
+//
+// If input std::string `s` contains '[' and ']' characters, these mark the region
+// of characters that should be marked as the "subrange".  For NaNs, this is
+// the location of the extended NaN std::string.  For numbers, this is the location
+// of the full, over-large mantissa.
+template <int base>
+void ExpectParsedFloat(std::string s, absl::chars_format format_flags,
+                       FloatType expected_type, uint64_t expected_mantissa,
+                       int expected_exponent,
+                       int expected_literal_exponent = -999) {
+  SCOPED_TRACE(s);
+
+  int begin_subrange = -1;
+  int end_subrange = -1;
+  // If s contains '[' and ']', then strip these characters and set the subrange
+  // indices appropriately.
+  std::string::size_type open_bracket_pos = s.find('[');
+  if (open_bracket_pos != std::string::npos) {
+    begin_subrange = static_cast<int>(open_bracket_pos);
+    s.replace(open_bracket_pos, 1, "");
+    std::string::size_type close_bracket_pos = s.find(']');
+    ABSL_RAW_CHECK(close_bracket_pos != absl::string_view::npos,
+                   "Test input contains [ without matching ]");
+    end_subrange = static_cast<int>(close_bracket_pos);
+    s.replace(close_bracket_pos, 1, "");
+  }
+  const std::string::size_type expected_characters_matched = s.find('$');
+  ABSL_RAW_CHECK(expected_characters_matched != std::string::npos,
+                 "Input std::string must contain $");
+  s.replace(expected_characters_matched, 1, "");
+
+  ParsedFloat parsed =
+      ParseFloat<base>(s.data(), s.data() + s.size(), format_flags);
+
+  EXPECT_NE(parsed.end, nullptr);
+  if (parsed.end == nullptr) {
+    return;  // The following tests are not useful if we fully failed to parse
+  }
+  EXPECT_EQ(parsed.type, expected_type);
+  if (begin_subrange == -1) {
+    EXPECT_EQ(parsed.subrange_begin, nullptr);
+    EXPECT_EQ(parsed.subrange_end, nullptr);
+  } else {
+    EXPECT_EQ(parsed.subrange_begin, s.data() + begin_subrange);
+    EXPECT_EQ(parsed.subrange_end, s.data() + end_subrange);
+  }
+  if (parsed.type == FloatType::kNumber) {
+    EXPECT_EQ(parsed.mantissa, expected_mantissa);
+    EXPECT_EQ(parsed.exponent, expected_exponent);
+    if (expected_literal_exponent != -999) {
+      EXPECT_EQ(parsed.literal_exponent, expected_literal_exponent);
+    }
+  }
+  auto characters_matched = static_cast<int>(parsed.end - s.data());
+  EXPECT_EQ(characters_matched, expected_characters_matched);
+}
+
+// Check that a given std::string input is parsed to the expected mantissa and
+// exponent.
+//
+// Input std::string `s` must contain a '$' character.  It marks the end of the
+// characters that were consumed by the match.
+template <int base>
+void ExpectNumber(std::string s, absl::chars_format format_flags,
+                  uint64_t expected_mantissa, int expected_exponent,
+                  int expected_literal_exponent = -999) {
+  ExpectParsedFloat<base>(std::move(s), format_flags, FloatType::kNumber,
+                          expected_mantissa, expected_exponent,
+                          expected_literal_exponent);
+}
+
+// Check that a given std::string input is parsed to the given special value.
+//
+// This tests against both number bases, since infinities and NaNs have
+// identical representations in both modes.
+void ExpectSpecial(const std::string& s, absl::chars_format format_flags,
+                   FloatType type) {
+  ExpectParsedFloat<10>(s, format_flags, type, 0, 0);
+  ExpectParsedFloat<16>(s, format_flags, type, 0, 0);
+}
+
+// Check that a given input std::string is not matched by Float.
+template <int base>
+void ExpectFailedParse(absl::string_view s, absl::chars_format format_flags) {
+  ParsedFloat parsed =
+      ParseFloat<base>(s.data(), s.data() + s.size(), format_flags);
+  EXPECT_EQ(parsed.end, nullptr);
+}
+
+TEST(ParseFloat, SimpleValue) {
+  // Test that various forms of floating point numbers all parse correctly.
+  ExpectNumber<10>("1.23456789e5$", chars_format::general, 123456789, -3);
+  ExpectNumber<10>("1.23456789e+5$", chars_format::general, 123456789, -3);
+  ExpectNumber<10>("1.23456789E5$", chars_format::general, 123456789, -3);
+  ExpectNumber<10>("1.23456789e05$", chars_format::general, 123456789, -3);
+  ExpectNumber<10>("123.456789e3$", chars_format::general, 123456789, -3);
+  ExpectNumber<10>("0.000123456789e9$", chars_format::general, 123456789, -3);
+  ExpectNumber<10>("123456.789$", chars_format::general, 123456789, -3);
+  ExpectNumber<10>("123456789e-3$", chars_format::general, 123456789, -3);
+
+  ExpectNumber<16>("1.234abcdefp28$", chars_format::general, 0x1234abcdef, -8);
+  ExpectNumber<16>("1.234abcdefp+28$", chars_format::general, 0x1234abcdef, -8);
+  ExpectNumber<16>("1.234ABCDEFp28$", chars_format::general, 0x1234abcdef, -8);
+  ExpectNumber<16>("1.234AbCdEfP0028$", chars_format::general, 0x1234abcdef,
+                   -8);
+  ExpectNumber<16>("123.4abcdefp20$", chars_format::general, 0x1234abcdef, -8);
+  ExpectNumber<16>("0.0001234abcdefp44$", chars_format::general, 0x1234abcdef,
+                   -8);
+  ExpectNumber<16>("1234abcd.ef$", chars_format::general, 0x1234abcdef, -8);
+  ExpectNumber<16>("1234abcdefp-8$", chars_format::general, 0x1234abcdef, -8);
+
+  // ExpectNumber does not attempt to drop trailing zeroes.
+  ExpectNumber<10>("0001.2345678900e005$", chars_format::general, 12345678900,
+                   -5);
+  ExpectNumber<16>("0001.234abcdef000p28$", chars_format::general,
+                   0x1234abcdef000, -20);
+
+  // Ensure non-matching characters after a number are ignored, even when they
+  // look like potentially matching characters.
+  ExpectNumber<10>("1.23456789e5$   ", chars_format::general, 123456789, -3);
+  ExpectNumber<10>("1.23456789e5$e5e5", chars_format::general, 123456789, -3);
+  ExpectNumber<10>("1.23456789e5$.25", chars_format::general, 123456789, -3);
+  ExpectNumber<10>("1.23456789e5$-", chars_format::general, 123456789, -3);
+  ExpectNumber<10>("1.23456789e5$PUPPERS!!!", chars_format::general, 123456789,
+                   -3);
+  ExpectNumber<10>("123456.789$efghij", chars_format::general, 123456789, -3);
+  ExpectNumber<10>("123456.789$e", chars_format::general, 123456789, -3);
+  ExpectNumber<10>("123456.789$p5", chars_format::general, 123456789, -3);
+  ExpectNumber<10>("123456.789$.10", chars_format::general, 123456789, -3);
+
+  ExpectNumber<16>("1.234abcdefp28$   ", chars_format::general, 0x1234abcdef,
+                   -8);
+  ExpectNumber<16>("1.234abcdefp28$p28", chars_format::general, 0x1234abcdef,
+                   -8);
+  ExpectNumber<16>("1.234abcdefp28$.125", chars_format::general, 0x1234abcdef,
+                   -8);
+  ExpectNumber<16>("1.234abcdefp28$-", chars_format::general, 0x1234abcdef, -8);
+  ExpectNumber<16>("1.234abcdefp28$KITTEHS!!!", chars_format::general,
+                   0x1234abcdef, -8);
+  ExpectNumber<16>("1234abcd.ef$ghijk", chars_format::general, 0x1234abcdef,
+                   -8);
+  ExpectNumber<16>("1234abcd.ef$p", chars_format::general, 0x1234abcdef, -8);
+  ExpectNumber<16>("1234abcd.ef$.10", chars_format::general, 0x1234abcdef, -8);
+
+  // Ensure we can read a full resolution mantissa without overflow.
+  ExpectNumber<10>("9999999999999999999$", chars_format::general,
+                   9999999999999999999u, 0);
+  ExpectNumber<16>("fffffffffffffff$", chars_format::general,
+                   0xfffffffffffffffu, 0);
+
+  // Check that zero is consistently read.
+  ExpectNumber<10>("0$", chars_format::general, 0, 0);
+  ExpectNumber<16>("0$", chars_format::general, 0, 0);
+  ExpectNumber<10>("000000000000000000000000000000000000000$",
+                   chars_format::general, 0, 0);
+  ExpectNumber<16>("000000000000000000000000000000000000000$",
+                   chars_format::general, 0, 0);
+  ExpectNumber<10>("0000000000000000000000.000000000000000000$",
+                   chars_format::general, 0, 0);
+  ExpectNumber<16>("0000000000000000000000.000000000000000000$",
+                   chars_format::general, 0, 0);
+  ExpectNumber<10>("0.00000000000000000000000000000000e123456$",
+                   chars_format::general, 0, 0);
+  ExpectNumber<16>("0.00000000000000000000000000000000p123456$",
+                   chars_format::general, 0, 0);
+}
+
+TEST(ParseFloat, LargeDecimalMantissa) {
+  // After 19 significant decimal digits in the mantissa, ParsedFloat will
+  // truncate additional digits.  We need to test that:
+  //   1) the truncation to 19 digits happens
+  //   2) the returned exponent reflects the dropped significant digits
+  //   3) a correct literal_exponent is set
+  //
+  // If and only if a significant digit is found after 19 digits, then the
+  // entirety of the mantissa in case the exact value is needed to make a
+  // rounding decision.  The [ and ] characters below denote where such a
+  // subregion was marked by by ParseFloat.  They are not part of the input.
+
+  // Mark a capture group only if a dropped digit is significant (nonzero).
+  ExpectNumber<10>("100000000000000000000000000$", chars_format::general,
+                   1000000000000000000,
+                   /* adjusted exponent */ 8);
+
+  ExpectNumber<10>("123456789123456789100000000$", chars_format::general,
+                   1234567891234567891,
+                   /* adjusted exponent */ 8);
+
+  ExpectNumber<10>("[123456789123456789123456789]$", chars_format::general,
+                   1234567891234567891,
+                   /* adjusted exponent */ 8,
+                   /* literal exponent */ 0);
+
+  ExpectNumber<10>("[123456789123456789100000009]$", chars_format::general,
+                   1234567891234567891,
+                   /* adjusted exponent */ 8,
+                   /* literal exponent */ 0);
+
+  ExpectNumber<10>("[123456789123456789120000000]$", chars_format::general,
+                   1234567891234567891,
+                   /* adjusted exponent */ 8,
+                   /* literal exponent */ 0);
+
+  // Leading zeroes should not count towards the 19 significant digit limit
+  ExpectNumber<10>("[00000000123456789123456789123456789]$",
+                   chars_format::general, 1234567891234567891,
+                   /* adjusted exponent */ 8,
+                   /* literal exponent */ 0);
+
+  ExpectNumber<10>("00000000123456789123456789100000000$",
+                   chars_format::general, 1234567891234567891,
+                   /* adjusted exponent */ 8);
+
+  // Truncated digits after the decimal point should not cause a further
+  // exponent adjustment.
+  ExpectNumber<10>("1.234567891234567891e123$", chars_format::general,
+                   1234567891234567891, 105);
+  ExpectNumber<10>("[1.23456789123456789123456789]e123$", chars_format::general,
+                   1234567891234567891,
+                   /* adjusted exponent */ 105,
+                   /* literal exponent */ 123);
+
+  // Ensure we truncate, and not round.  (The from_chars algorithm we use
+  // depends on our guess missing low, if it misses, so we need the rounding
+  // error to be downward.)
+  ExpectNumber<10>("[1999999999999999999999]$", chars_format::general,
+                   1999999999999999999,
+                   /* adjusted exponent */ 3,
+                   /* literal exponent */ 0);
+}
+
+TEST(ParseFloat, LargeHexadecimalMantissa) {
+  // After 15 significant hex digits in the mantissa, ParsedFloat will treat
+  // additional digits as sticky,  We need to test that:
+  //   1) The truncation to 15 digits happens
+  //   2) The returned exponent reflects the dropped significant digits
+  //   3) If a nonzero digit is dropped, the low bit of mantissa is set.
+
+  ExpectNumber<16>("123456789abcdef123456789abcdef$", chars_format::general,
+                   0x123456789abcdef, 60);
+
+  // Leading zeroes should not count towards the 15 significant digit limit
+  ExpectNumber<16>("000000123456789abcdef123456789abcdef$",
+                   chars_format::general, 0x123456789abcdef, 60);
+
+  // Truncated digits after the radix point should not cause a further
+  // exponent adjustment.
+  ExpectNumber<16>("1.23456789abcdefp100$", chars_format::general,
+                   0x123456789abcdef, 44);
+  ExpectNumber<16>("1.23456789abcdef123456789abcdefp100$",
+                   chars_format::general, 0x123456789abcdef, 44);
+
+  // test sticky digit behavior.  The low bit should be set iff any dropped
+  // digit is nonzero.
+  ExpectNumber<16>("123456789abcdee123456789abcdee$", chars_format::general,
+                   0x123456789abcdef, 60);
+  ExpectNumber<16>("123456789abcdee000000000000001$", chars_format::general,
+                   0x123456789abcdef, 60);
+  ExpectNumber<16>("123456789abcdee000000000000000$", chars_format::general,
+                   0x123456789abcdee, 60);
+}
+
+TEST(ParseFloat, ScientificVsFixed) {
+  // In fixed mode, an exponent is never matched (but the remainder of the
+  // number will be matched.)
+  ExpectNumber<10>("1.23456789$e5", chars_format::fixed, 123456789, -8);
+  ExpectNumber<10>("123456.789$", chars_format::fixed, 123456789, -3);
+  ExpectNumber<16>("1.234abcdef$p28", chars_format::fixed, 0x1234abcdef, -36);
+  ExpectNumber<16>("1234abcd.ef$", chars_format::fixed, 0x1234abcdef, -8);
+
+  // In scientific mode, numbers don't match *unless* they have an exponent.
+  ExpectNumber<10>("1.23456789e5$", chars_format::scientific, 123456789, -3);
+  ExpectFailedParse<10>("-123456.789$", chars_format::scientific);
+  ExpectNumber<16>("1.234abcdefp28$", chars_format::scientific, 0x1234abcdef,
+                   -8);
+  ExpectFailedParse<16>("1234abcd.ef$", chars_format::scientific);
+}
+
+TEST(ParseFloat, Infinity) {
+  ExpectFailedParse<10>("in", chars_format::general);
+  ExpectFailedParse<16>("in", chars_format::general);
+  ExpectFailedParse<10>("inx", chars_format::general);
+  ExpectFailedParse<16>("inx", chars_format::general);
+  ExpectSpecial("inf$", chars_format::general, FloatType::kInfinity);
+  ExpectSpecial("Inf$", chars_format::general, FloatType::kInfinity);
+  ExpectSpecial("INF$", chars_format::general, FloatType::kInfinity);
+  ExpectSpecial("inf$inite", chars_format::general, FloatType::kInfinity);
+  ExpectSpecial("iNfInItY$", chars_format::general, FloatType::kInfinity);
+  ExpectSpecial("infinity$!!!", chars_format::general, FloatType::kInfinity);
+}
+
+TEST(ParseFloat, NaN) {
+  ExpectFailedParse<10>("na", chars_format::general);
+  ExpectFailedParse<16>("na", chars_format::general);
+  ExpectFailedParse<10>("nah", chars_format::general);
+  ExpectFailedParse<16>("nah", chars_format::general);
+  ExpectSpecial("nan$", chars_format::general, FloatType::kNan);
+  ExpectSpecial("NaN$", chars_format::general, FloatType::kNan);
+  ExpectSpecial("nAn$", chars_format::general, FloatType::kNan);
+  ExpectSpecial("NAN$", chars_format::general, FloatType::kNan);
+  ExpectSpecial("NaN$aNaNaNaNaBatman!", chars_format::general, FloatType::kNan);
+
+  // A parenthesized sequence of the characters [a-zA-Z0-9_] is allowed to
+  // appear after an NaN.  Check that this is allowed, and that the correct
+  // characters are grouped.
+  //
+  // (The characters [ and ] in the pattern below delimit the expected matched
+  // subgroup; they are not part of the input passed to ParseFloat.)
+  ExpectSpecial("nan([0xabcdef])$", chars_format::general, FloatType::kNan);
+  ExpectSpecial("nan([0xabcdef])$...", chars_format::general, FloatType::kNan);
+  ExpectSpecial("nan([0xabcdef])$)...", chars_format::general, FloatType::kNan);
+  ExpectSpecial("nan([])$", chars_format::general, FloatType::kNan);
+  ExpectSpecial("nan([aAzZ09_])$", chars_format::general, FloatType::kNan);
+  // If the subgroup contains illegal characters, don't match it at all.
+  ExpectSpecial("nan$(bad-char)", chars_format::general, FloatType::kNan);
+  // Also cope with a missing close paren.
+  ExpectSpecial("nan$(0xabcdef", chars_format::general, FloatType::kNan);
+}
+
+}  // namespace
diff --git a/third_party/abseil-cpp/absl/strings/numbers.cc b/third_party/abseil-cpp/absl/strings/numbers.cc
index 68ef7999a9..f842ed85e9 100644
--- a/third_party/abseil-cpp/absl/strings/numbers.cc
+++ b/third_party/abseil-cpp/absl/strings/numbers.cc
@@ -32,6 +32,7 @@
 
 #include "absl/base/internal/raw_logging.h"
 #include "absl/strings/ascii.h"
+#include "absl/strings/charconv.h"
 #include "absl/strings/internal/bits.h"
 #include "absl/strings/internal/memutil.h"
 #include "absl/strings/str_cat.h"
@@ -40,51 +41,54 @@ namespace absl {
 
 bool SimpleAtof(absl::string_view str, float* value) {
   *value = 0.0;
-  if (str.empty()) return false;
-  char buf[32];
-  std::unique_ptr<char[]> bigbuf;
-  char* ptr = buf;
-  if (str.size() > sizeof(buf) - 1) {
-    bigbuf.reset(new char[str.size() + 1]);
-    ptr = bigbuf.get();
-  }
-  memcpy(ptr, str.data(), str.size());
-  ptr[str.size()] = '\0';
-
-  char* endptr;
-  *value = strtof(ptr, &endptr);
-  if (endptr != ptr) {
-    while (absl::ascii_isspace(*endptr)) ++endptr;
-  }
-  // Ignore range errors from strtod/strtof.
-  // The values it returns on underflow and
-  // overflow are the right fallback in a
-  // robust setting.
-  return *ptr != '\0' && *endptr == '\0';
+  str = StripAsciiWhitespace(str);
+  if (!str.empty() && str[0] == '+') {
+    str.remove_prefix(1);
+  }
+  auto result = absl::from_chars(str.data(), str.data() + str.size(), *value);
+  if (result.ec == std::errc::invalid_argument) {
+    return false;
+  }
+  if (result.ptr != str.data() + str.size()) {
+    // not all non-whitespace characters consumed
+    return false;
+  }
+  // from_chars() with DR 3801's current wording will return max() on
+  // overflow.  SimpleAtof returns infinity instead.
+  if (result.ec == std::errc::result_out_of_range) {
+    if (*value > 1.0) {
+      *value = std::numeric_limits<float>::infinity();
+    } else if (*value < -1.0) {
+      *value = -std::numeric_limits<float>::infinity();
+    }
+  }
+  return true;
 }
 
 bool SimpleAtod(absl::string_view str, double* value) {
   *value = 0.0;
-  if (str.empty()) return false;
-  char buf[32];
-  std::unique_ptr<char[]> bigbuf;
-  char* ptr = buf;
-  if (str.size() > sizeof(buf) - 1) {
-    bigbuf.reset(new char[str.size() + 1]);
-    ptr = bigbuf.get();
-  }
-  memcpy(ptr, str.data(), str.size());
-  ptr[str.size()] = '\0';
-
-  char* endptr;
-  *value = strtod(ptr, &endptr);
-  if (endptr != ptr) {
-    while (absl::ascii_isspace(*endptr)) ++endptr;
-  }
-  // Ignore range errors from strtod.  The values it
-  // returns on underflow and overflow are the right
-  // fallback in a robust setting.
-  return *ptr != '\0' && *endptr == '\0';
+  str = StripAsciiWhitespace(str);
+  if (!str.empty() && str[0] == '+') {
+    str.remove_prefix(1);
+  }
+  auto result = absl::from_chars(str.data(), str.data() + str.size(), *value);
+  if (result.ec == std::errc::invalid_argument) {
+    return false;
+  }
+  if (result.ptr != str.data() + str.size()) {
+    // not all non-whitespace characters consumed
+    return false;
+  }
+  // from_chars() with DR 3801's current wording will return max() on
+  // overflow.  SimpleAtod returns infinity instead.
+  if (result.ec == std::errc::result_out_of_range) {
+    if (*value > 1.0) {
+      *value = std::numeric_limits<double>::infinity();
+    } else if (*value < -1.0) {
+      *value = -std::numeric_limits<double>::infinity();
+    }
+  }
+  return true;
 }
 
 namespace {
diff --git a/third_party/abseil-cpp/absl/synchronization/BUILD.bazel b/third_party/abseil-cpp/absl/synchronization/BUILD.bazel
index 123536ea4d..372874e110 100644
--- a/third_party/abseil-cpp/absl/synchronization/BUILD.bazel
+++ b/third_party/abseil-cpp/absl/synchronization/BUILD.bazel
@@ -149,12 +149,6 @@ cc_test(
     size = "large",
     srcs = ["mutex_test.cc"],
     copts = ABSL_TEST_COPTS,
-    tags = [
-        "no_test_android_arm",
-        "no_test_android_arm64",
-        "no_test_android_x86",
-        "no_test_loonix",  # Too slow.
-    ],
     deps = [
         ":synchronization",
         ":thread_pool",
diff --git a/third_party/abseil-cpp/absl/time/BUILD.bazel b/third_party/abseil-cpp/absl/time/BUILD.bazel
index fe55fe1f9b..e793da87d1 100644
--- a/third_party/abseil-cpp/absl/time/BUILD.bazel
+++ b/third_party/abseil-cpp/absl/time/BUILD.bazel
@@ -44,6 +44,7 @@ cc_library(
         "//absl/base",
         "//absl/base:core_headers",
         "//absl/numeric:int128",
+        "//absl/strings",
         "//absl/time/internal/cctz:civil_time",
         "//absl/time/internal/cctz:time_zone",
     ],
@@ -80,9 +81,6 @@ cc_test(
         "time_zone_test.cc",
     ],
     copts = ABSL_TEST_COPTS,
-    tags = [
-        "no_test_loonix",
-    ],
     deps = [
         ":test_util",
         ":time",
diff --git a/third_party/abseil-cpp/absl/time/BUILD.gn b/third_party/abseil-cpp/absl/time/BUILD.gn
index 1cc3276f8f..3ed4655bcf 100644
--- a/third_party/abseil-cpp/absl/time/BUILD.gn
+++ b/third_party/abseil-cpp/absl/time/BUILD.gn
@@ -37,6 +37,7 @@ source_set("time") {
     "../base",
     "../base:core_headers",
     "../numeric:int128",
+    "../strings",
     "../time/internal/cctz:civil_time",
     "../time/internal/cctz:time_zone",
   ]
diff --git a/third_party/abseil-cpp/absl/time/CMakeLists.txt b/third_party/abseil-cpp/absl/time/CMakeLists.txt
index 72bb4d25b5..06272364f1 100644
--- a/third_party/abseil-cpp/absl/time/CMakeLists.txt
+++ b/third_party/abseil-cpp/absl/time/CMakeLists.txt
@@ -53,7 +53,7 @@ list(APPEND TIME_SRC
   ${TIME_PUBLIC_HEADERS}
   ${TIME_INTERNAL_HEADERS}
 )
-set(TIME_PUBLIC_LIBRARIES absl::base absl::stacktrace absl::int128)
+set(TIME_PUBLIC_LIBRARIES absl::base absl::stacktrace absl::int128 absl::strings)
 
 absl_library(
   TARGET
diff --git a/third_party/abseil-cpp/absl/time/duration.cc b/third_party/abseil-cpp/absl/time/duration.cc
index 82b4d9892c..c13fa79b7f 100644
--- a/third_party/abseil-cpp/absl/time/duration.cc
+++ b/third_party/abseil-cpp/absl/time/duration.cc
@@ -896,8 +896,7 @@ bool ParseDuration(const std::string& dur_string, Duration* d) {
   return true;
 }
 
-// TODO(absl-team): Remove once dependencies are removed.
-bool ParseFlag(const std::string& text, Duration* dst, std::string* /* err */) {
+bool ParseFlag(const std::string& text, Duration* dst, std::string* ) {
   return ParseDuration(text, dst);
 }
 
diff --git a/third_party/abseil-cpp/absl/time/format.cc b/third_party/abseil-cpp/absl/time/format.cc
index 5dc01bda15..6edf2b5f03 100644
--- a/third_party/abseil-cpp/absl/time/format.cc
+++ b/third_party/abseil-cpp/absl/time/format.cc
@@ -129,7 +129,6 @@ bool ParseTime(const std::string& format, const std::string& input, absl::TimeZo
   return b;
 }
 
-// TODO(absl-team): Remove once dependencies are removed.
 // Functions required to support absl::Time flags.
 bool ParseFlag(const std::string& text, absl::Time* t, std::string* error) {
   return absl::ParseTime(RFC3339_full, text, absl::UTCTimeZone(), t, error);
diff --git a/third_party/abseil-cpp/absl/time/time.h b/third_party/abseil-cpp/absl/time/time.h
index 99c12bbd87..ceec2de7cd 100644
--- a/third_party/abseil-cpp/absl/time/time.h
+++ b/third_party/abseil-cpp/absl/time/time.h
@@ -64,6 +64,7 @@
 #include <utility>
 
 #include "absl/base/port.h"  // Needed for string vs std::string
+#include "absl/strings/string_view.h"
 #include "absl/time/internal/cctz/include/cctz/time_zone.h"
 
 namespace absl {
@@ -491,9 +492,6 @@ inline std::ostream& operator<<(std::ostream& os, Duration d) {
 // `ZeroDuration()`.  Parses "inf" and "-inf" as +/- `InfiniteDuration()`.
 bool ParseDuration(const std::string& dur_string, Duration* d);
 
-// Flag Support
-// TODO(absl-team): Remove once dependencies are removed.
-
 // ParseFlag()
 //
 bool ParseFlag(const std::string& text, Duration* dst, std::string* error);
@@ -993,8 +991,6 @@ bool ParseTime(const std::string& format, const std::string& input, Time* time,
 bool ParseTime(const std::string& format, const std::string& input, TimeZone tz,
                Time* time, std::string* err);
 
-// TODO(absl-team): Remove once dependencies are removed.
-
 // ParseFlag()
 // UnparseFlag()
 //
diff --git a/third_party/abseil-cpp/absl/types/BUILD.bazel b/third_party/abseil-cpp/absl/types/BUILD.bazel
index 1fc4c098e9..c50ec425ae 100644
--- a/third_party/abseil-cpp/absl/types/BUILD.bazel
+++ b/third_party/abseil-cpp/absl/types/BUILD.bazel
@@ -248,6 +248,19 @@ cc_test(
 )
 
 cc_test(
+    name = "variant_benchmark",
+    srcs = [
+        "variant_benchmark.cc",
+    ],
+    copts = ABSL_TEST_COPTS,
+    deps = [
+        ":variant",
+        "//absl/utility",
+        "@com_github_google_benchmark//:benchmark_main",
+    ],
+)
+
+cc_test(
     name = "variant_exception_safety_test",
     size = "small",
     srcs = [
diff --git a/third_party/abseil-cpp/absl/types/internal/variant.h b/third_party/abseil-cpp/absl/types/internal/variant.h
index 61c56ddf4e..94c2ddab6f 100644
--- a/third_party/abseil-cpp/absl/types/internal/variant.h
+++ b/third_party/abseil-cpp/absl/types/internal/variant.h
@@ -19,15 +19,19 @@
 #ifndef ABSL_TYPES_variant_internal_H_
 #define ABSL_TYPES_variant_internal_H_
 
+#include <cassert>
 #include <cstddef>
+#include <cstdlib>
 #include <memory>
 #include <stdexcept>
 #include <tuple>
 #include <type_traits>
 
+#include "absl/base/config.h"
 #include "absl/base/internal/identity.h"
 #include "absl/base/internal/inline_variable.h"
 #include "absl/base/internal/invoke.h"
+#include "absl/base/macros.h"
 #include "absl/base/optimization.h"
 #include "absl/meta/type_traits.h"
 #include "absl/types/bad_variant_access.h"
@@ -119,6 +123,8 @@ using GiveQualsToT = typename GiveQualsTo<T, U>::type;
 template <std::size_t I>
 using SizeT = std::integral_constant<std::size_t, I>;
 
+using NPos = SizeT<variant_npos>;
+
 template <class Variant, class T, class = void>
 struct IndexOfConstructedType {};
 
@@ -248,19 +254,270 @@ struct MakeVisitationMatrix<ReturnType, FunctionObject,
           ReturnType, FunctionObject, index_sequence<TailEndIndices...>,
           absl::make_index_sequence<HeadEndIndex>, BoundIndices...> {};
 
-template <std::size_t... EndIndices, class Op, class... SizeT>
-VisitIndicesResultT<Op, SizeT...> visit_indices(Op&& op, SizeT... indices) {
-  return AccessSimpleArray(
-      MakeVisitationMatrix<VisitIndicesResultT<Op, SizeT...>, Op,
-                           index_sequence<(EndIndices + 1)...>>::Run(),
-      (indices + 1)...)(absl::forward<Op>(op));
-}
+struct UnreachableSwitchCase {
+  template <class Op>
+  [[noreturn]] static VisitIndicesResultT<Op, std::size_t> Run(
+      Op&& /*ignored*/) {
+#if ABSL_HAVE_BUILTIN(__builtin_unreachable) || \
+    (defined(__GNUC__) && !defined(__clang__))
+    __builtin_unreachable();
+#elif defined(_MSC_VER)
+    __assume(false);
+#else
+    // Try to use assert of false being identified as an unreachable intrinsic.
+    // NOTE: We use assert directly to increase chances of exploiting an assume
+    //       intrinsic.
+    assert(false);  // NOLINT
+
+    // Hack to silence potential no return warning -- cause an infinite loop.
+    return Run(absl::forward<Op>(op));
+#endif  // Checks for __builtin_unreachable
+  }
+};
+
+template <class Op, std::size_t I>
+struct ReachableSwitchCase {
+  static VisitIndicesResultT<Op, std::size_t> Run(Op&& op) {
+    return absl::base_internal::Invoke(absl::forward<Op>(op), SizeT<I>());
+  }
+};
+
+// The number 33 is just a guess at a reasonable maximum to our switch. It is
+// not based on any analysis. The reason it is a power of 2 plus 1 instead of a
+// power of 2 is because the number was picked to correspond to a power of 2
+// amount of "normal" alternatives, plus one for the possibility of the user
+// providing "monostate" in addition to the more natural alternatives.
+ABSL_INTERNAL_INLINE_CONSTEXPR(std::size_t, MaxUnrolledVisitCases, 33);
+
+// Note: The default-definition is for unreachable cases.
+template <bool IsReachable>
+struct PickCaseImpl {
+  template <class Op, std::size_t I>
+  using Apply = UnreachableSwitchCase;
+};
+
+template <>
+struct PickCaseImpl</*IsReachable =*/true> {
+  template <class Op, std::size_t I>
+  using Apply = ReachableSwitchCase<Op, I>;
+};
+
+// Note: This form of dance with template aliases is to make sure that we
+//       instantiate a number of templates proportional to the number of variant
+//       alternatives rather than a number of templates proportional to our
+//       maximum unrolled amount of visitation cases (aliases are effectively
+//       "free" whereas other template instantiations are costly).
+template <class Op, std::size_t I, std::size_t EndIndex>
+using PickCase = typename PickCaseImpl<(I < EndIndex)>::template Apply<Op, I>;
 
 template <class ReturnType>
 [[noreturn]] ReturnType TypedThrowBadVariantAccess() {
   absl::variant_internal::ThrowBadVariantAccess();
 }
 
+// Given N variant sizes, determine the number of cases there would need to be
+// in a single switch-statement that would cover every possibility in the
+// corresponding N-ary visit operation.
+template <std::size_t... NumAlternatives>
+struct NumCasesOfSwitch;
+
+template <std::size_t HeadNumAlternatives, std::size_t... TailNumAlternatives>
+struct NumCasesOfSwitch<HeadNumAlternatives, TailNumAlternatives...> {
+  static constexpr std::size_t value =
+      (HeadNumAlternatives + 1) *
+      NumCasesOfSwitch<TailNumAlternatives...>::value;
+};
+
+template <>
+struct NumCasesOfSwitch<> {
+  static constexpr std::size_t value = 1;
+};
+
+// A switch statement optimizes better than the table of function pointers.
+template <std::size_t EndIndex>
+struct VisitIndicesSwitch {
+  static_assert(EndIndex <= MaxUnrolledVisitCases,
+                "Maximum unrolled switch size exceeded.");
+
+  template <class Op>
+  static VisitIndicesResultT<Op, std::size_t> Run(Op&& op, std::size_t i) {
+    switch (i) {
+      case 0:
+        return PickCase<Op, 0, EndIndex>::Run(absl::forward<Op>(op));
+      case 1:
+        return PickCase<Op, 1, EndIndex>::Run(absl::forward<Op>(op));
+      case 2:
+        return PickCase<Op, 2, EndIndex>::Run(absl::forward<Op>(op));
+      case 3:
+        return PickCase<Op, 3, EndIndex>::Run(absl::forward<Op>(op));
+      case 4:
+        return PickCase<Op, 4, EndIndex>::Run(absl::forward<Op>(op));
+      case 5:
+        return PickCase<Op, 5, EndIndex>::Run(absl::forward<Op>(op));
+      case 6:
+        return PickCase<Op, 6, EndIndex>::Run(absl::forward<Op>(op));
+      case 7:
+        return PickCase<Op, 7, EndIndex>::Run(absl::forward<Op>(op));
+      case 8:
+        return PickCase<Op, 8, EndIndex>::Run(absl::forward<Op>(op));
+      case 9:
+        return PickCase<Op, 9, EndIndex>::Run(absl::forward<Op>(op));
+      case 10:
+        return PickCase<Op, 10, EndIndex>::Run(absl::forward<Op>(op));
+      case 11:
+        return PickCase<Op, 11, EndIndex>::Run(absl::forward<Op>(op));
+      case 12:
+        return PickCase<Op, 12, EndIndex>::Run(absl::forward<Op>(op));
+      case 13:
+        return PickCase<Op, 13, EndIndex>::Run(absl::forward<Op>(op));
+      case 14:
+        return PickCase<Op, 14, EndIndex>::Run(absl::forward<Op>(op));
+      case 15:
+        return PickCase<Op, 15, EndIndex>::Run(absl::forward<Op>(op));
+      case 16:
+        return PickCase<Op, 16, EndIndex>::Run(absl::forward<Op>(op));
+      case 17:
+        return PickCase<Op, 17, EndIndex>::Run(absl::forward<Op>(op));
+      case 18:
+        return PickCase<Op, 18, EndIndex>::Run(absl::forward<Op>(op));
+      case 19:
+        return PickCase<Op, 19, EndIndex>::Run(absl::forward<Op>(op));
+      case 20:
+        return PickCase<Op, 20, EndIndex>::Run(absl::forward<Op>(op));
+      case 21:
+        return PickCase<Op, 21, EndIndex>::Run(absl::forward<Op>(op));
+      case 22:
+        return PickCase<Op, 22, EndIndex>::Run(absl::forward<Op>(op));
+      case 23:
+        return PickCase<Op, 23, EndIndex>::Run(absl::forward<Op>(op));
+      case 24:
+        return PickCase<Op, 24, EndIndex>::Run(absl::forward<Op>(op));
+      case 25:
+        return PickCase<Op, 25, EndIndex>::Run(absl::forward<Op>(op));
+      case 26:
+        return PickCase<Op, 26, EndIndex>::Run(absl::forward<Op>(op));
+      case 27:
+        return PickCase<Op, 27, EndIndex>::Run(absl::forward<Op>(op));
+      case 28:
+        return PickCase<Op, 28, EndIndex>::Run(absl::forward<Op>(op));
+      case 29:
+        return PickCase<Op, 29, EndIndex>::Run(absl::forward<Op>(op));
+      case 30:
+        return PickCase<Op, 30, EndIndex>::Run(absl::forward<Op>(op));
+      case 31:
+        return PickCase<Op, 31, EndIndex>::Run(absl::forward<Op>(op));
+      case 32:
+        return PickCase<Op, 32, EndIndex>::Run(absl::forward<Op>(op));
+      default:
+        ABSL_ASSERT(i == variant_npos);
+        return absl::base_internal::Invoke(absl::forward<Op>(op), NPos());
+    }
+  }
+};
+
+template <std::size_t... EndIndices>
+struct VisitIndicesFallback {
+  template <class Op, class... SizeT>
+  static VisitIndicesResultT<Op, SizeT...> Run(Op&& op, SizeT... indices) {
+    return AccessSimpleArray(
+        MakeVisitationMatrix<VisitIndicesResultT<Op, SizeT...>, Op,
+                             index_sequence<(EndIndices + 1)...>>::Run(),
+        (indices + 1)...)(absl::forward<Op>(op));
+  }
+};
+
+// Take an N-dimensional series of indices and convert them into a single index
+// without loss of information. The purpose of this is to be able to convert an
+// N-ary visit operation into a single switch statement.
+template <std::size_t...>
+struct FlattenIndices;
+
+template <std::size_t HeadSize, std::size_t... TailSize>
+struct FlattenIndices<HeadSize, TailSize...> {
+  template<class... SizeType>
+  static constexpr std::size_t Run(std::size_t head, SizeType... tail) {
+    return head + HeadSize * FlattenIndices<TailSize...>::Run(tail...);
+  }
+};
+
+template <>
+struct FlattenIndices<> {
+  static constexpr std::size_t Run() { return 0; }
+};
+
+// Take a single "flattened" index (flattened by FlattenIndices) and determine
+// the value of the index of one of the logically represented dimensions.
+template <std::size_t I, std::size_t IndexToGet, std::size_t HeadSize,
+          std::size_t... TailSize>
+struct UnflattenIndex {
+  static constexpr std::size_t value =
+      UnflattenIndex<I / HeadSize, IndexToGet - 1, TailSize...>::value;
+};
+
+template <std::size_t I, std::size_t HeadSize, std::size_t... TailSize>
+struct UnflattenIndex<I, 0, HeadSize, TailSize...> {
+  static constexpr std::size_t value = (I % HeadSize);
+};
+
+// The backend for converting an N-ary visit operation into a unary visit.
+template <class IndexSequence, std::size_t... EndIndices>
+struct VisitIndicesVariadicImpl;
+
+template <std::size_t... N, std::size_t... EndIndices>
+struct VisitIndicesVariadicImpl<absl::index_sequence<N...>, EndIndices...> {
+  // A type that can take an N-ary function object and converts it to a unary
+  // function object that takes a single, flattened index, and "unflattens" it
+  // into its individual dimensions when forwarding to the wrapped object.
+  template <class Op>
+  struct FlattenedOp {
+    template <std::size_t I>
+    VisitIndicesResultT<Op, decltype(EndIndices)...> operator()(
+        SizeT<I> /*index*/) && {
+      return base_internal::Invoke(
+          absl::forward<Op>(op),
+          SizeT<UnflattenIndex<I, N, (EndIndices + 1)...>::value -
+                std::size_t{1}>()...);
+    }
+
+    Op&& op;
+  };
+
+  template <class Op, class... SizeType>
+  static VisitIndicesResultT<Op, decltype(EndIndices)...> Run(
+      Op&& op, SizeType... i) {
+    return VisitIndicesSwitch<NumCasesOfSwitch<EndIndices...>::value>::Run(
+        FlattenedOp<Op>{absl::forward<Op>(op)},
+        FlattenIndices<(EndIndices + std::size_t{1})...>::Run(
+            (i + std::size_t{1})...));
+  }
+};
+
+template <std::size_t... EndIndices>
+struct VisitIndicesVariadic
+    : VisitIndicesVariadicImpl<absl::make_index_sequence<sizeof...(EndIndices)>,
+                               EndIndices...> {};
+
+// This implementation will flatten N-ary visit operations into a single switch
+// statement when the number of cases would be less than our maximum specified
+// switch-statement size.
+// TODO(calabrese)
+//   Based on benchmarks, determine whether the function table approach actually
+//   does optimize better than a chain of switch statements and possibly update
+//   the implementation accordingly. Also consider increasing the maximum switch
+//   size.
+template <std::size_t... EndIndices>
+struct VisitIndices
+    : absl::conditional_t<(NumCasesOfSwitch<EndIndices...>::value <=
+                           MaxUnrolledVisitCases),
+                          VisitIndicesVariadic<EndIndices...>,
+                          VisitIndicesFallback<EndIndices...>> {};
+
+template <std::size_t EndIndex>
+struct VisitIndices<EndIndex>
+    : absl::conditional_t<(EndIndex <= MaxUnrolledVisitCases),
+                          VisitIndicesSwitch<EndIndex>,
+                          VisitIndicesFallback<EndIndex>> {};
+
 // Suppress bogus warning on MSVC: MSVC complains that the `reinterpret_cast`
 // below is returning the address of a temporary or local object.
 #ifdef _MSC_VER
@@ -270,8 +527,10 @@ template <class ReturnType>
 
 // TODO(calabrese) std::launder
 // TODO(calabrese) constexpr
+// NOTE: DO NOT REMOVE the `inline` keyword as it is necessary to work around a
+// MSVC bug. See https://github.com/abseil/abseil-cpp/issues/129 for details.
 template <class Self, std::size_t I>
-VariantAccessResult<I, Self> AccessUnion(Self&& self, SizeT<I> /*i*/) {
+inline VariantAccessResult<I, Self> AccessUnion(Self&& self, SizeT<I> /*i*/) {
   return reinterpret_cast<VariantAccessResult<I, Self>>(self);
 }
 
@@ -313,7 +572,7 @@ struct VariantCoreAccess {
 
   template <class Variant>
   static void InitFrom(Variant& self, Variant&& other) {  // NOLINT
-    variant_internal::visit_indices<absl::variant_size<Variant>::value>(
+    VisitIndices<absl::variant_size<Variant>::value>::Run(
         InitFromVisitor<Variant, Variant&&>{&self,
                                             std::forward<Variant>(other)},
         other.index());
@@ -1049,9 +1308,7 @@ class VariantStateBaseDestructorNontrivial : protected VariantStateBase<T...> {
     VariantStateBaseDestructorNontrivial* self;
   };
 
-  void destroy() {
-    variant_internal::visit_indices<sizeof...(T)>(Destroyer{this}, index_);
-  }
+  void destroy() { VisitIndices<sizeof...(T)>::Run(Destroyer{this}, index_); }
 
   ~VariantStateBaseDestructorNontrivial() { destroy(); }
 
@@ -1087,8 +1344,7 @@ class VariantMoveBaseNontrivial : protected VariantStateBaseDestructor<T...> {
   VariantMoveBaseNontrivial(VariantMoveBaseNontrivial&& other) noexcept(
       absl::conjunction<std::is_nothrow_move_constructible<T>...>::value)
       : Base(NoopConstructorTag()) {
-    variant_internal::visit_indices<sizeof...(T)>(Construct{this, &other},
-                                                  other.index_);
+    VisitIndices<sizeof...(T)>::Run(Construct{this, &other}, other.index_);
     index_ = other.index_;
   }
 
@@ -1131,8 +1387,7 @@ class VariantCopyBaseNontrivial : protected VariantMoveBase<T...> {
 
   VariantCopyBaseNontrivial(VariantCopyBaseNontrivial const& other)
       : Base(NoopConstructorTag()) {
-    variant_internal::visit_indices<sizeof...(T)>(Construct{this, &other},
-                                                  other.index_);
+    VisitIndices<sizeof...(T)>::Run(Construct{this, &other}, other.index_);
     index_ = other.index_;
   }
 
@@ -1166,7 +1421,7 @@ class VariantMoveAssignBaseNontrivial : protected VariantCopyBase<T...> {
     operator=(VariantMoveAssignBaseNontrivial&& other) noexcept(
         absl::conjunction<std::is_nothrow_move_constructible<T>...,
                           std::is_nothrow_move_assignable<T>...>::value) {
-      variant_internal::visit_indices<sizeof...(T)>(
+      VisitIndices<sizeof...(T)>::Run(
           VariantCoreAccess::MakeMoveAssignVisitor(this, &other), other.index_);
       return *this;
     }
@@ -1195,7 +1450,7 @@ class VariantCopyAssignBaseNontrivial : protected VariantMoveAssignBase<T...> {
 
     VariantCopyAssignBaseNontrivial& operator=(
         const VariantCopyAssignBaseNontrivial& other) {
-      variant_internal::visit_indices<sizeof...(T)>(
+      VisitIndices<sizeof...(T)>::Run(
           VariantCoreAccess::MakeCopyAssignVisitor(this, other), other.index_);
       return *this;
     }
@@ -1336,7 +1591,7 @@ struct Swap {
   template <std::size_t Wi>
   void operator()(SizeT<Wi> /*w_i*/) {
     if (v->index() == Wi) {
-      visit_indices<sizeof...(Types)>(SwapSameIndex<Types...>{v, w}, Wi);
+      VisitIndices<sizeof...(Types)>::Run(SwapSameIndex<Types...>{v, w}, Wi);
     } else {
       generic_swap();
     }
@@ -1370,11 +1625,10 @@ struct VariantHashBase<Variant,
     if (var.valueless_by_exception()) {
       return 239799884;
     }
-    size_t result =
-        variant_internal::visit_indices<variant_size<Variant>::value>(
-            PerformVisitation<VariantHashVisitor, const Variant&>{
-                std::forward_as_tuple(var), VariantHashVisitor{}},
-            var.index());
+    size_t result = VisitIndices<variant_size<Variant>::value>::Run(
+        PerformVisitation<VariantHashVisitor, const Variant&>{
+            std::forward_as_tuple(var), VariantHashVisitor{}},
+        var.index());
     // Combine the index and the hash result in order to distinguish
     // std::variant<int, int> holding the same value as different alternative.
     return result ^ var.index();
diff --git a/third_party/abseil-cpp/absl/types/optional.h b/third_party/abseil-cpp/absl/types/optional.h
index 80a2d149fc..c837cddeef 100644
--- a/third_party/abseil-cpp/absl/types/optional.h
+++ b/third_party/abseil-cpp/absl/types/optional.h
@@ -48,7 +48,7 @@ using std::optional;
 using std::make_optional;
 using std::nullopt_t;
 using std::nullopt;
-}
+}  // namespace absl
 
 #else  // ABSL_HAVE_STD_OPTIONAL
 
diff --git a/third_party/abseil-cpp/absl/types/variant.h b/third_party/abseil-cpp/absl/types/variant.h
index 7ae65abe0e..5837a1be21 100644
--- a/third_party/abseil-cpp/absl/types/variant.h
+++ b/third_party/abseil-cpp/absl/types/variant.h
@@ -416,12 +416,12 @@ constexpr absl::add_pointer_t<const T> get_if(
 template <typename Visitor, typename... Variants>
 variant_internal::VisitResult<Visitor, Variants...> visit(Visitor&& vis,
                                                           Variants&&... vars) {
-  return variant_internal::visit_indices<
-      variant_size<absl::decay_t<Variants>>::value...>(
-      variant_internal::PerformVisitation<Visitor, Variants...>{
-          std::forward_as_tuple(absl::forward<Variants>(vars)...),
-          absl::forward<Visitor>(vis)},
-      vars.index()...);
+  return variant_internal::
+      VisitIndices<variant_size<absl::decay_t<Variants> >::value...>::Run(
+          variant_internal::PerformVisitation<Visitor, Variants...>{
+              std::forward_as_tuple(absl::forward<Variants>(vars)...),
+              absl::forward<Visitor>(vis)},
+          vars.index()...);
 }
 
 // monostate
@@ -573,7 +573,7 @@ class variant<T0, Tn...> : private variant_internal::VariantBase<T0, Tn...> {
   variant& operator=(T&& t) noexcept(
       std::is_nothrow_assignable<Tj&, T>::value&&
           std::is_nothrow_constructible<Tj, T>::value) {
-    variant_internal::visit_indices<sizeof...(Tn) + 1>(
+    variant_internal::VisitIndices<sizeof...(Tn) + 1>::Run(
         variant_internal::VariantCoreAccess::MakeConversionAssignVisitor(
             this, absl::forward<T>(t)),
         index());
@@ -682,7 +682,7 @@ class variant<T0, Tn...> : private variant_internal::VariantBase<T0, Tn...> {
   //   true and `is_nothrow_swappable()` is same as `std::is_trivial()`.
   void swap(variant& rhs) noexcept(
       absl::conjunction<std::is_trivial<T0>, std::is_trivial<Tn>...>::value) {
-    return variant_internal::visit_indices<sizeof...(Tn) + 1>(
+    return variant_internal::VisitIndices<sizeof...(Tn) + 1>::Run(
         variant_internal::Swap<T0, Tn...>{this, &rhs}, rhs.index());
   }
 };
@@ -722,7 +722,7 @@ template <typename... Types>
 constexpr variant_internal::RequireAllHaveEqualT<Types...> operator==(
     const variant<Types...>& a, const variant<Types...>& b) {
   return (a.index() == b.index()) &&
-         variant_internal::visit_indices<sizeof...(Types)>(
+         variant_internal::VisitIndices<sizeof...(Types)>::Run(
              variant_internal::EqualsOp<Types...>{&a, &b}, a.index());
 }
 
@@ -731,7 +731,7 @@ template <typename... Types>
 constexpr variant_internal::RequireAllHaveNotEqualT<Types...> operator!=(
     const variant<Types...>& a, const variant<Types...>& b) {
   return (a.index() != b.index()) ||
-         variant_internal::visit_indices<sizeof...(Types)>(
+         variant_internal::VisitIndices<sizeof...(Types)>::Run(
              variant_internal::NotEqualsOp<Types...>{&a, &b}, a.index());
 }
 
@@ -741,7 +741,7 @@ constexpr variant_internal::RequireAllHaveLessThanT<Types...> operator<(
     const variant<Types...>& a, const variant<Types...>& b) {
   return (a.index() != b.index())
              ? (a.index() + 1) < (b.index() + 1)
-             : variant_internal::visit_indices<sizeof...(Types)>(
+             : variant_internal::VisitIndices<sizeof...(Types)>::Run(
                    variant_internal::LessThanOp<Types...>{&a, &b}, a.index());
 }
 
@@ -751,7 +751,7 @@ constexpr variant_internal::RequireAllHaveGreaterThanT<Types...> operator>(
     const variant<Types...>& a, const variant<Types...>& b) {
   return (a.index() != b.index())
              ? (a.index() + 1) > (b.index() + 1)
-             : variant_internal::visit_indices<sizeof...(Types)>(
+             : variant_internal::VisitIndices<sizeof...(Types)>::Run(
                    variant_internal::GreaterThanOp<Types...>{&a, &b},
                    a.index());
 }
@@ -762,7 +762,7 @@ constexpr variant_internal::RequireAllHaveLessThanOrEqualT<Types...> operator<=(
     const variant<Types...>& a, const variant<Types...>& b) {
   return (a.index() != b.index())
              ? (a.index() + 1) < (b.index() + 1)
-             : variant_internal::visit_indices<sizeof...(Types)>(
+             : variant_internal::VisitIndices<sizeof...(Types)>::Run(
                    variant_internal::LessThanOrEqualsOp<Types...>{&a, &b},
                    a.index());
 }
@@ -773,7 +773,7 @@ constexpr variant_internal::RequireAllHaveGreaterThanOrEqualT<Types...>
 operator>=(const variant<Types...>& a, const variant<Types...>& b) {
   return (a.index() != b.index())
              ? (a.index() + 1) > (b.index() + 1)
-             : variant_internal::visit_indices<sizeof...(Types)>(
+             : variant_internal::VisitIndices<sizeof...(Types)>::Run(
                    variant_internal::GreaterThanOrEqualsOp<Types...>{&a, &b},
                    a.index());
 }
diff --git a/third_party/abseil-cpp/absl/types/variant_benchmark.cc b/third_party/abseil-cpp/absl/types/variant_benchmark.cc
new file mode 100644
index 0000000000..99658ac70c
--- /dev/null
+++ b/third_party/abseil-cpp/absl/types/variant_benchmark.cc
@@ -0,0 +1,220 @@
+// 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
+//
+//      http://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.
+
+// Unit tests for the variant template. The 'is' and 'IsEmpty' methods
+// of variant are not explicitly tested because they are used repeatedly
+// in building other tests. All other public variant methods should have
+// explicit tests.
+
+#include "absl/types/variant.h"
+
+#include <cstddef>
+#include <cstdlib>
+#include <string>
+#include <tuple>
+
+#include "benchmark/benchmark.h"
+#include "absl/utility/utility.h"
+
+namespace absl {
+namespace {
+
+template <std::size_t I>
+struct VariantAlternative {
+  char member;
+};
+
+template <class Indices>
+struct VariantOfAlternativesImpl;
+
+template <std::size_t... Indices>
+struct VariantOfAlternativesImpl<absl::index_sequence<Indices...>> {
+  using type = absl::variant<VariantAlternative<Indices>...>;
+};
+
+template <std::size_t NumAlternatives>
+using VariantOfAlternatives = typename VariantOfAlternativesImpl<
+    absl::make_index_sequence<NumAlternatives>>::type;
+
+struct Empty {};
+
+template <class... T>
+void Ignore(T...) noexcept {}
+
+template <class T>
+Empty DoNotOptimizeAndReturnEmpty(T&& arg) noexcept {
+  benchmark::DoNotOptimize(arg);
+  return {};
+}
+
+struct VisitorApplier {
+  struct Visitor {
+    template <class... T>
+    void operator()(T&&... args) const noexcept {
+      Ignore(DoNotOptimizeAndReturnEmpty(args)...);
+    }
+  };
+
+  template <class... Vars>
+  void operator()(const Vars&... vars) const noexcept {
+    absl::visit(Visitor(), vars...);
+  }
+};
+
+template <std::size_t NumIndices, std::size_t CurrIndex = NumIndices - 1>
+struct MakeWithIndex {
+  using Variant = VariantOfAlternatives<NumIndices>;
+
+  static Variant Run(std::size_t index) {
+    return index == CurrIndex
+               ? Variant(absl::in_place_index_t<CurrIndex>())
+               : MakeWithIndex<NumIndices, CurrIndex - 1>::Run(index);
+  }
+};
+
+template <std::size_t NumIndices>
+struct MakeWithIndex<NumIndices, 0> {
+  using Variant = VariantOfAlternatives<NumIndices>;
+
+  static Variant Run(std::size_t /*index*/) { return Variant(); }
+};
+
+template <std::size_t NumIndices, class Dimensions>
+struct MakeVariantTuple;
+
+template <class T, std::size_t /*I*/>
+using always_t = T;
+
+template <std::size_t NumIndices>
+VariantOfAlternatives<NumIndices> MakeVariant(std::size_t dimension,
+                                              std::size_t index) {
+  return dimension == 0
+             ? MakeWithIndex<NumIndices>::Run(index % NumIndices)
+             : MakeVariant<NumIndices>(dimension - 1, index / NumIndices);
+}
+
+template <std::size_t NumIndices, std::size_t... Dimensions>
+struct MakeVariantTuple<NumIndices, absl::index_sequence<Dimensions...>> {
+  using VariantTuple =
+      std::tuple<always_t<VariantOfAlternatives<NumIndices>, Dimensions>...>;
+
+  static VariantTuple Run(int index) {
+    return std::make_tuple(MakeVariant<NumIndices>(Dimensions, index)...);
+  }
+};
+
+constexpr std::size_t integral_pow(std::size_t base, std::size_t power) {
+  return power == 0 ? 1 : base * integral_pow(base, power - 1);
+}
+
+template <std::size_t End, std::size_t I = 0>
+struct VisitTestBody {
+  template <class Vars, class State>
+  static bool Run(Vars& vars, State& state) {
+    if (state.KeepRunning()) {
+      absl::apply(VisitorApplier(), vars[I]);
+      return VisitTestBody<End, I + 1>::Run(vars, state);
+    }
+    return false;
+  }
+};
+
+template <std::size_t End>
+struct VisitTestBody<End, End> {
+  template <class Vars, class State>
+  static bool Run(Vars& /*vars*/, State& /*state*/) {
+    return true;
+  }
+};
+
+// Visit operations where branch prediction is likely to give a boost.
+template <std::size_t NumIndices, std::size_t NumDimensions = 1>
+void BM_RedundantVisit(benchmark::State& state) {
+  auto vars =
+      MakeVariantTuple<NumIndices, absl::make_index_sequence<NumDimensions>>::
+          Run(static_cast<std::size_t>(state.range(0)));
+
+  for (auto _ : state) {  // NOLINT
+    benchmark::DoNotOptimize(vars);
+    absl::apply(VisitorApplier(), vars);
+  }
+}
+
+// Visit operations where branch prediction is unlikely to give a boost.
+template <std::size_t NumIndices, std::size_t NumDimensions = 1>
+void BM_Visit(benchmark::State& state) {
+  constexpr std::size_t num_possibilities =
+      integral_pow(NumIndices, NumDimensions);
+
+  using VariantTupleMaker =
+      MakeVariantTuple<NumIndices, absl::make_index_sequence<NumDimensions>>;
+  using Tuple = typename VariantTupleMaker::VariantTuple;
+
+  Tuple vars[num_possibilities];
+  for (std::size_t i = 0; i < num_possibilities; ++i)
+    vars[i] = VariantTupleMaker::Run(i);
+
+  while (VisitTestBody<num_possibilities>::Run(vars, state)) {
+  }
+}
+
+// Visitation
+//   Each visit is on a different variant with a different active alternative)
+
+// Unary visit
+BENCHMARK_TEMPLATE(BM_Visit, 1);
+BENCHMARK_TEMPLATE(BM_Visit, 2);
+BENCHMARK_TEMPLATE(BM_Visit, 3);
+BENCHMARK_TEMPLATE(BM_Visit, 4);
+BENCHMARK_TEMPLATE(BM_Visit, 5);
+BENCHMARK_TEMPLATE(BM_Visit, 6);
+BENCHMARK_TEMPLATE(BM_Visit, 7);
+BENCHMARK_TEMPLATE(BM_Visit, 8);
+BENCHMARK_TEMPLATE(BM_Visit, 16);
+BENCHMARK_TEMPLATE(BM_Visit, 32);
+BENCHMARK_TEMPLATE(BM_Visit, 64);
+
+// Binary visit
+BENCHMARK_TEMPLATE(BM_Visit, 1, 2);
+BENCHMARK_TEMPLATE(BM_Visit, 2, 2);
+BENCHMARK_TEMPLATE(BM_Visit, 3, 2);
+BENCHMARK_TEMPLATE(BM_Visit, 4, 2);
+BENCHMARK_TEMPLATE(BM_Visit, 5, 2);
+
+// Ternary visit
+BENCHMARK_TEMPLATE(BM_Visit, 1, 3);
+BENCHMARK_TEMPLATE(BM_Visit, 2, 3);
+BENCHMARK_TEMPLATE(BM_Visit, 3, 3);
+
+// Quaternary visit
+BENCHMARK_TEMPLATE(BM_Visit, 1, 4);
+BENCHMARK_TEMPLATE(BM_Visit, 2, 4);
+
+// Redundant Visitation
+//   Each visit consistently has the same alternative active
+
+// Unary visit
+BENCHMARK_TEMPLATE(BM_RedundantVisit, 1)->Arg(0);
+BENCHMARK_TEMPLATE(BM_RedundantVisit, 2)->DenseRange(0, 1);
+BENCHMARK_TEMPLATE(BM_RedundantVisit, 8)->DenseRange(0, 7);
+
+// Binary visit
+BENCHMARK_TEMPLATE(BM_RedundantVisit, 1, 2)->Arg(0);
+BENCHMARK_TEMPLATE(BM_RedundantVisit, 2, 2)
+    ->DenseRange(0, integral_pow(2, 2) - 1);
+BENCHMARK_TEMPLATE(BM_RedundantVisit, 4, 2)
+    ->DenseRange(0, integral_pow(4, 2) - 1);
+
+}  // namespace
+}  // namespace absl
diff --git a/third_party/closure_compiler/externs/bluetooth_private.js b/third_party/closure_compiler/externs/bluetooth_private.js
index 76ef861a35..cfcfbbcb5e 100644
--- a/third_party/closure_compiler/externs/bluetooth_private.js
+++ b/third_party/closure_compiler/externs/bluetooth_private.js
@@ -21,7 +21,6 @@ chrome.bluetoothPrivate = {};
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/bluetoothPrivate#type-PairingEventType
  */
 chrome.bluetoothPrivate.PairingEventType = {
   REQUEST_PINCODE: 'requestPincode',
@@ -36,7 +35,6 @@ chrome.bluetoothPrivate.PairingEventType = {
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/bluetoothPrivate#type-ConnectResultType
  */
 chrome.bluetoothPrivate.ConnectResultType = {
   ALREADY_CONNECTED: 'alreadyConnected',
@@ -53,7 +51,6 @@ chrome.bluetoothPrivate.ConnectResultType = {
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/bluetoothPrivate#type-PairingResponse
  */
 chrome.bluetoothPrivate.PairingResponse = {
   CONFIRM: 'confirm',
@@ -63,7 +60,6 @@ chrome.bluetoothPrivate.PairingResponse = {
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/bluetoothPrivate#type-TransportType
  */
 chrome.bluetoothPrivate.TransportType = {
   LE: 'le',
@@ -79,7 +75,6 @@ chrome.bluetoothPrivate.TransportType = {
  *   passkey: (number|undefined),
  *   enteredKey: (number|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/bluetoothPrivate#type-PairingEvent
  */
 chrome.bluetoothPrivate.PairingEvent;
 
@@ -89,7 +84,6 @@ chrome.bluetoothPrivate.PairingEvent;
  *   powered: (boolean|undefined),
  *   discoverable: (boolean|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/bluetoothPrivate#type-NewAdapterState
  */
 chrome.bluetoothPrivate.NewAdapterState;
 
@@ -100,7 +94,6 @@ chrome.bluetoothPrivate.NewAdapterState;
  *   pincode: (string|undefined),
  *   passkey: (number|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/bluetoothPrivate#type-SetPairingResponseOptions
  */
 chrome.bluetoothPrivate.SetPairingResponseOptions;
 
@@ -111,7 +104,6 @@ chrome.bluetoothPrivate.SetPairingResponseOptions;
  *   rssi: (number|undefined),
  *   pathloss: (number|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/bluetoothPrivate#type-DiscoveryFilter
  */
 chrome.bluetoothPrivate.DiscoveryFilter;
 
@@ -119,14 +111,12 @@ chrome.bluetoothPrivate.DiscoveryFilter;
  * Changes the state of the Bluetooth adapter.
  * @param {!chrome.bluetoothPrivate.NewAdapterState} adapterState
  * @param {function():void=} callback
- * @see https://developer.chrome.com/extensions/bluetoothPrivate#method-setAdapterState
  */
 chrome.bluetoothPrivate.setAdapterState = function(adapterState, callback) {};
 
 /**
  * @param {!chrome.bluetoothPrivate.SetPairingResponseOptions} options
  * @param {function():void=} callback
- * @see https://developer.chrome.com/extensions/bluetoothPrivate#method-setPairingResponse
  */
 chrome.bluetoothPrivate.setPairingResponse = function(options, callback) {};
 
@@ -134,7 +124,6 @@ chrome.bluetoothPrivate.setPairingResponse = function(options, callback) {};
  * Tears down all connections to the given device.
  * @param {string} deviceAddress
  * @param {function():void=} callback
- * @see https://developer.chrome.com/extensions/bluetoothPrivate#method-disconnectAll
  */
 chrome.bluetoothPrivate.disconnectAll = function(deviceAddress, callback) {};
 
@@ -142,7 +131,6 @@ chrome.bluetoothPrivate.disconnectAll = function(deviceAddress, callback) {};
  * Forgets the given device.
  * @param {string} deviceAddress
  * @param {function():void=} callback
- * @see https://developer.chrome.com/extensions/bluetoothPrivate#method-forgetDevice
  */
 chrome.bluetoothPrivate.forgetDevice = function(deviceAddress, callback) {};
 
@@ -150,7 +138,6 @@ chrome.bluetoothPrivate.forgetDevice = function(deviceAddress, callback) {};
  * Set or clear discovery filter.
  * @param {!chrome.bluetoothPrivate.DiscoveryFilter} discoveryFilter
  * @param {function():void=} callback
- * @see https://developer.chrome.com/extensions/bluetoothPrivate#method-setDiscoveryFilter
  */
 chrome.bluetoothPrivate.setDiscoveryFilter = function(discoveryFilter, callback) {};
 
@@ -160,7 +147,6 @@ chrome.bluetoothPrivate.setDiscoveryFilter = function(discoveryFilter, callback)
  * succeed and invoke |callback| with ConnectResultType.
  * @param {string} deviceAddress
  * @param {function(!chrome.bluetoothPrivate.ConnectResultType):void=} callback
- * @see https://developer.chrome.com/extensions/bluetoothPrivate#method-connect
  */
 chrome.bluetoothPrivate.connect = function(deviceAddress, callback) {};
 
@@ -168,13 +154,11 @@ chrome.bluetoothPrivate.connect = function(deviceAddress, callback) {};
  * Pairs the given device.
  * @param {string} deviceAddress
  * @param {function():void=} callback
- * @see https://developer.chrome.com/extensions/bluetoothPrivate#method-pair
  */
 chrome.bluetoothPrivate.pair = function(deviceAddress, callback) {};
 
 /**
  * Fired when a pairing event occurs.
  * @type {!ChromeEvent}
- * @see https://developer.chrome.com/extensions/bluetoothPrivate#event-onPairing
  */
 chrome.bluetoothPrivate.onPairing;
diff --git a/third_party/closure_compiler/externs/developer_private.js b/third_party/closure_compiler/externs/developer_private.js
index a4b21dcde1..212e30c3cd 100644
--- a/third_party/closure_compiler/externs/developer_private.js
+++ b/third_party/closure_compiler/externs/developer_private.js
@@ -18,7 +18,6 @@ chrome.developerPrivate = {};
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-ItemType
  */
 chrome.developerPrivate.ItemType = {
   HOSTED_APP: 'hosted_app',
@@ -36,7 +35,6 @@ chrome.developerPrivate.ItemType = {
  *   incognito: boolean,
  *   generatedBackgroundPage: boolean
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-ItemInspectView
  */
 chrome.developerPrivate.ItemInspectView;
 
@@ -47,7 +45,6 @@ chrome.developerPrivate.ItemInspectView;
  *   render_view_id: (string|number),
  *   incognito: boolean
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-InspectOptions
  */
 chrome.developerPrivate.InspectOptions;
 
@@ -55,13 +52,11 @@ chrome.developerPrivate.InspectOptions;
  * @typedef {{
  *   message: string
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-InstallWarning
  */
 chrome.developerPrivate.InstallWarning;
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-ExtensionType
  */
 chrome.developerPrivate.ExtensionType = {
   HOSTED_APP: 'HOSTED_APP',
@@ -74,7 +69,6 @@ chrome.developerPrivate.ExtensionType = {
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-Location
  */
 chrome.developerPrivate.Location = {
   FROM_STORE: 'FROM_STORE',
@@ -85,7 +79,6 @@ chrome.developerPrivate.Location = {
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-ViewType
  */
 chrome.developerPrivate.ViewType = {
   APP_WINDOW: 'APP_WINDOW',
@@ -100,7 +93,6 @@ chrome.developerPrivate.ViewType = {
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-ErrorType
  */
 chrome.developerPrivate.ErrorType = {
   MANIFEST: 'MANIFEST',
@@ -109,7 +101,6 @@ chrome.developerPrivate.ErrorType = {
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-ErrorLevel
  */
 chrome.developerPrivate.ErrorLevel = {
   LOG: 'LOG',
@@ -119,7 +110,6 @@ chrome.developerPrivate.ErrorLevel = {
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-ExtensionState
  */
 chrome.developerPrivate.ExtensionState = {
   ENABLED: 'ENABLED',
@@ -130,7 +120,6 @@ chrome.developerPrivate.ExtensionState = {
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-CommandScope
  */
 chrome.developerPrivate.CommandScope = {
   GLOBAL: 'GLOBAL',
@@ -142,7 +131,6 @@ chrome.developerPrivate.CommandScope = {
  *   isEnabled: boolean,
  *   isActive: boolean
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-AccessModifier
  */
 chrome.developerPrivate.AccessModifier;
 
@@ -153,7 +141,6 @@ chrome.developerPrivate.AccessModifier;
  *   url: string,
  *   functionName: string
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-StackFrame
  */
 chrome.developerPrivate.StackFrame;
 
@@ -168,7 +155,6 @@ chrome.developerPrivate.StackFrame;
  *   manifestKey: string,
  *   manifestSpecific: (string|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-ManifestError
  */
 chrome.developerPrivate.ManifestError;
 
@@ -188,7 +174,6 @@ chrome.developerPrivate.ManifestError;
  *   canInspect: boolean,
  *   stackTrace: !Array<!chrome.developerPrivate.StackFrame>
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-RuntimeError
  */
 chrome.developerPrivate.RuntimeError;
 
@@ -198,7 +183,6 @@ chrome.developerPrivate.RuntimeError;
  *   corruptInstall: boolean,
  *   updateRequired: boolean
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-DisableReasons
  */
 chrome.developerPrivate.DisableReasons;
 
@@ -207,7 +191,6 @@ chrome.developerPrivate.DisableReasons;
  *   openInTab: boolean,
  *   url: string
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-OptionsPage
  */
 chrome.developerPrivate.OptionsPage;
 
@@ -216,7 +199,6 @@ chrome.developerPrivate.OptionsPage;
  *   url: string,
  *   specified: boolean
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-HomePage
  */
 chrome.developerPrivate.HomePage;
 
@@ -229,13 +211,11 @@ chrome.developerPrivate.HomePage;
  *   isIframe: boolean,
  *   type: !chrome.developerPrivate.ViewType
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-ExtensionView
  */
 chrome.developerPrivate.ExtensionView;
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-ControllerType
  */
 chrome.developerPrivate.ControllerType = {
   POLICY: 'POLICY',
@@ -248,7 +228,6 @@ chrome.developerPrivate.ControllerType = {
  *   type: !chrome.developerPrivate.ControllerType,
  *   text: string
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-ControlledInfo
  */
 chrome.developerPrivate.ControlledInfo;
 
@@ -261,7 +240,6 @@ chrome.developerPrivate.ControlledInfo;
  *   scope: !chrome.developerPrivate.CommandScope,
  *   isExtensionAction: boolean
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-Command
  */
 chrome.developerPrivate.Command;
 
@@ -270,7 +248,6 @@ chrome.developerPrivate.Command;
  *   id: string,
  *   name: string
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-DependentExtension
  */
 chrome.developerPrivate.DependentExtension;
 
@@ -279,7 +256,6 @@ chrome.developerPrivate.DependentExtension;
  *   message: string,
  *   submessages: !Array<string>
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-Permission
  */
 chrome.developerPrivate.Permission;
 
@@ -321,7 +297,6 @@ chrome.developerPrivate.Permission;
  *   views: !Array<!chrome.developerPrivate.ExtensionView>,
  *   webStoreUrl: string
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-ExtensionInfo
  */
 chrome.developerPrivate.ExtensionInfo;
 
@@ -334,7 +309,6 @@ chrome.developerPrivate.ExtensionInfo;
  *   isIncognitoAvailable: boolean,
  *   isSupervised: boolean
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-ProfileInfo
  */
 chrome.developerPrivate.ProfileInfo;
 
@@ -368,7 +342,6 @@ chrome.developerPrivate.ProfileInfo;
  *   offline_enabled: boolean,
  *   views: !Array<!chrome.developerPrivate.ItemInspectView>
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-ItemInfo
  */
 chrome.developerPrivate.ItemInfo;
 
@@ -377,7 +350,6 @@ chrome.developerPrivate.ItemInfo;
  *   includeDisabled: (boolean|undefined),
  *   includeTerminated: (boolean|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-GetExtensionsInfoOptions
  */
 chrome.developerPrivate.GetExtensionsInfoOptions;
 
@@ -389,7 +361,6 @@ chrome.developerPrivate.GetExtensionsInfoOptions;
  *   errorCollection: (boolean|undefined),
  *   runOnAllUrls: (boolean|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-ExtensionConfigurationUpdate
  */
 chrome.developerPrivate.ExtensionConfigurationUpdate;
 
@@ -397,7 +368,6 @@ chrome.developerPrivate.ExtensionConfigurationUpdate;
  * @typedef {{
  *   inDeveloperMode: (boolean|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-ProfileConfigurationUpdate
  */
 chrome.developerPrivate.ProfileConfigurationUpdate;
 
@@ -408,7 +378,6 @@ chrome.developerPrivate.ProfileConfigurationUpdate;
  *   scope: (!chrome.developerPrivate.CommandScope|undefined),
  *   keybinding: (string|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-ExtensionCommandUpdate
  */
 chrome.developerPrivate.ExtensionCommandUpdate;
 
@@ -417,7 +386,6 @@ chrome.developerPrivate.ExtensionCommandUpdate;
  *   failQuietly: (boolean|undefined),
  *   populateErrorForUnpacked: (boolean|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-ReloadOptions
  */
 chrome.developerPrivate.ReloadOptions;
 
@@ -428,13 +396,11 @@ chrome.developerPrivate.ReloadOptions;
  *   retryGuid: (string|undefined),
  *   useDraggedPath: (boolean|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-LoadUnpackedOptions
  */
 chrome.developerPrivate.LoadUnpackedOptions;
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-PackStatus
  */
 chrome.developerPrivate.PackStatus = {
   SUCCESS: 'SUCCESS',
@@ -444,7 +410,6 @@ chrome.developerPrivate.PackStatus = {
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-FileType
  */
 chrome.developerPrivate.FileType = {
   LOAD: 'LOAD',
@@ -453,7 +418,6 @@ chrome.developerPrivate.FileType = {
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-SelectType
  */
 chrome.developerPrivate.SelectType = {
   FILE: 'FILE',
@@ -462,7 +426,6 @@ chrome.developerPrivate.SelectType = {
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-EventType
  */
 chrome.developerPrivate.EventType = {
   INSTALLED: 'INSTALLED',
@@ -487,7 +450,6 @@ chrome.developerPrivate.EventType = {
  *   override_flags: number,
  *   status: !chrome.developerPrivate.PackStatus
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-PackDirectoryResponse
  */
 chrome.developerPrivate.PackDirectoryResponse;
 
@@ -495,7 +457,6 @@ chrome.developerPrivate.PackDirectoryResponse;
  * @typedef {{
  *   name: string
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-ProjectInfo
  */
 chrome.developerPrivate.ProjectInfo;
 
@@ -505,7 +466,6 @@ chrome.developerPrivate.ProjectInfo;
  *   item_id: string,
  *   extensionInfo: (!chrome.developerPrivate.ExtensionInfo|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-EventData
  */
 chrome.developerPrivate.EventData;
 
@@ -515,7 +475,6 @@ chrome.developerPrivate.EventData;
  *   highlight: string,
  *   afterHighlight: string
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-ErrorFileSource
  */
 chrome.developerPrivate.ErrorFileSource;
 
@@ -526,7 +485,6 @@ chrome.developerPrivate.ErrorFileSource;
  *   source: (!chrome.developerPrivate.ErrorFileSource|undefined),
  *   retryGuid: string
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-LoadError
  */
 chrome.developerPrivate.LoadError;
 
@@ -539,7 +497,6 @@ chrome.developerPrivate.LoadError;
  *   manifestSpecific: (string|undefined),
  *   lineNumber: (number|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-RequestFileSourceProperties
  */
 chrome.developerPrivate.RequestFileSourceProperties;
 
@@ -551,7 +508,6 @@ chrome.developerPrivate.RequestFileSourceProperties;
  *   title: string,
  *   message: string
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-RequestFileSourceResponse
  */
 chrome.developerPrivate.RequestFileSourceResponse;
 
@@ -565,7 +521,6 @@ chrome.developerPrivate.RequestFileSourceResponse;
  *   lineNumber: (number|undefined),
  *   columnNumber: (number|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-OpenDevToolsProperties
  */
 chrome.developerPrivate.OpenDevToolsProperties;
 
@@ -575,14 +530,12 @@ chrome.developerPrivate.OpenDevToolsProperties;
  *   errorIds: (!Array<number>|undefined),
  *   type: (!chrome.developerPrivate.ErrorType|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/developerPrivate#type-DeleteExtensionErrorsProperties
  */
 chrome.developerPrivate.DeleteExtensionErrorsProperties;
 
 /**
  * Runs auto update for extensions and apps immediately.
  * @param {function():void=} callback Called after update check completes.
- * @see https://developer.chrome.com/extensions/developerPrivate#method-autoUpdate
  */
 chrome.developerPrivate.autoUpdate = function(callback) {};
 
@@ -592,7 +545,6 @@ chrome.developerPrivate.autoUpdate = function(callback) {};
  *     to restrict the items returned.
  * @param {function(!Array<!chrome.developerPrivate.ExtensionInfo>):void=}
  *     callback Called with extensions info.
- * @see https://developer.chrome.com/extensions/developerPrivate#method-getExtensionsInfo
  */
 chrome.developerPrivate.getExtensionsInfo = function(options, callback) {};
 
@@ -601,7 +553,6 @@ chrome.developerPrivate.getExtensionsInfo = function(options, callback) {};
  * @param {string} id The id of the extension.
  * @param {function(!chrome.developerPrivate.ExtensionInfo):void=} callback
  *     Called with the result.
- * @see https://developer.chrome.com/extensions/developerPrivate#method-getExtensionInfo
  */
 chrome.developerPrivate.getExtensionInfo = function(id, callback) {};
 
@@ -609,7 +560,6 @@ chrome.developerPrivate.getExtensionInfo = function(id, callback) {};
  * Returns the size of a particular extension on disk (already formatted).
  * @param {string} id The id of the extension.
  * @param {function(string):void} callback Called with the result.
- * @see https://developer.chrome.com/extensions/developerPrivate#method-getExtensionSize
  */
 chrome.developerPrivate.getExtensionSize = function(id, callback) {};
 
@@ -620,14 +570,12 @@ chrome.developerPrivate.getExtensionSize = function(id, callback) {};
  * @param {function(!Array<!chrome.developerPrivate.ItemInfo>):void} callback
  *     Called with items info.
  * @deprecated Use getExtensionsInfo
- * @see https://developer.chrome.com/extensions/developerPrivate#method-getItemsInfo
  */
 chrome.developerPrivate.getItemsInfo = function(includeDisabled, includeTerminated, callback) {};
 
 /**
  * Returns the current profile's configuration.
  * @param {function(!chrome.developerPrivate.ProfileInfo):void} callback
- * @see https://developer.chrome.com/extensions/developerPrivate#method-getProfileConfiguration
  */
 chrome.developerPrivate.getProfileConfiguration = function(callback) {};
 
@@ -637,7 +585,6 @@ chrome.developerPrivate.getProfileConfiguration = function(callback) {};
  *     parameters for updating the profile's configuration.  Any     properties
  *     omitted from |update| will not be changed.
  * @param {function():void=} callback
- * @see https://developer.chrome.com/extensions/developerPrivate#method-updateProfileConfiguration
  */
 chrome.developerPrivate.updateProfileConfiguration = function(update, callback) {};
 
@@ -645,7 +592,6 @@ chrome.developerPrivate.updateProfileConfiguration = function(update, callback)
  * Opens a permissions dialog.
  * @param {string} extensionId The id of the extension to show permissions for.
  * @param {function():void=} callback
- * @see https://developer.chrome.com/extensions/developerPrivate#method-showPermissionsDialog
  */
 chrome.developerPrivate.showPermissionsDialog = function(extensionId, callback) {};
 
@@ -656,7 +602,6 @@ chrome.developerPrivate.showPermissionsDialog = function(extensionId, callback)
  *     configuration parameters.
  * @param {function((!chrome.developerPrivate.LoadError|undefined)):void=}
  *     callback
- * @see https://developer.chrome.com/extensions/developerPrivate#method-reload
  */
 chrome.developerPrivate.reload = function(extensionId, options, callback) {};
 
@@ -666,7 +611,6 @@ chrome.developerPrivate.reload = function(extensionId, options, callback) {};
  *     parameters for updating the extension's configuration.     Any properties
  *     omitted from |update| will not be changed.
  * @param {function():void=} callback
- * @see https://developer.chrome.com/extensions/developerPrivate#method-updateExtensionConfiguration
  */
 chrome.developerPrivate.updateExtensionConfiguration = function(update, callback) {};
 
@@ -676,21 +620,18 @@ chrome.developerPrivate.updateExtensionConfiguration = function(update, callback
  *     configuration parameters.
  * @param {function((!chrome.developerPrivate.LoadError|undefined)):void=}
  *     callback
- * @see https://developer.chrome.com/extensions/developerPrivate#method-loadUnpacked
  */
 chrome.developerPrivate.loadUnpacked = function(options, callback) {};
 
 /**
  * Installs the file that was dragged and dropped onto the associated page.
  * @param {function():void=} callback
- * @see https://developer.chrome.com/extensions/developerPrivate#method-installDroppedFile
  */
 chrome.developerPrivate.installDroppedFile = function(callback) {};
 
 /**
  * Notifies the browser that a user began a drag in order to install an
  * extension.
- * @see https://developer.chrome.com/extensions/developerPrivate#method-notifyDragInstallInProgress
  */
 chrome.developerPrivate.notifyDragInstallInProgress = function() {};
 
@@ -698,7 +639,6 @@ chrome.developerPrivate.notifyDragInstallInProgress = function() {};
  * Loads an extension / app.
  * @param {Object} directory The directory to load the extension from.
  * @param {function(string):void} callback
- * @see https://developer.chrome.com/extensions/developerPrivate#method-loadDirectory
  */
 chrome.developerPrivate.loadDirectory = function(directory, callback) {};
 
@@ -710,7 +650,6 @@ chrome.developerPrivate.loadDirectory = function(directory, callback) {};
  *     example, pem type is for private key and load type is for an unpacked
  *     item.
  * @param {function(string):void} callback called with selected item's path.
- * @see https://developer.chrome.com/extensions/developerPrivate#method-choosePath
  */
 chrome.developerPrivate.choosePath = function(selectType, fileType, callback) {};
 
@@ -721,14 +660,12 @@ chrome.developerPrivate.choosePath = function(selectType, fileType, callback) {}
  * @param {number=} flags Special flags to apply to the loading process, if any.
  * @param {function(!chrome.developerPrivate.PackDirectoryResponse):void=}
  *     callback called with the success result string.
- * @see https://developer.chrome.com/extensions/developerPrivate#method-packDirectory
  */
 chrome.developerPrivate.packDirectory = function(path, privateKeyPath, flags, callback) {};
 
 /**
  * Returns true if the profile is managed.
  * @param {function(boolean):void} callback
- * @see https://developer.chrome.com/extensions/developerPrivate#method-isProfileManaged
  */
 chrome.developerPrivate.isProfileManaged = function(callback) {};
 
@@ -738,7 +675,6 @@ chrome.developerPrivate.isProfileManaged = function(callback) {};
  * @param {!chrome.developerPrivate.RequestFileSourceProperties} properties
  * @param {function(!chrome.developerPrivate.RequestFileSourceResponse):void}
  *     callback
- * @see https://developer.chrome.com/extensions/developerPrivate#method-requestFileSource
  */
 chrome.developerPrivate.requestFileSource = function(properties, callback) {};
 
@@ -746,7 +682,6 @@ chrome.developerPrivate.requestFileSource = function(properties, callback) {};
  * Open the developer tools to focus on a particular error.
  * @param {!chrome.developerPrivate.OpenDevToolsProperties} properties
  * @param {function():void=} callback
- * @see https://developer.chrome.com/extensions/developerPrivate#method-openDevTools
  */
 chrome.developerPrivate.openDevTools = function(properties, callback) {};
 
@@ -755,7 +690,6 @@ chrome.developerPrivate.openDevTools = function(properties, callback) {};
  * @param {!chrome.developerPrivate.DeleteExtensionErrorsProperties} properties
  *     The properties specifying the errors to remove.
  * @param {function():void=} callback
- * @see https://developer.chrome.com/extensions/developerPrivate#method-deleteExtensionErrors
  */
 chrome.developerPrivate.deleteExtensionErrors = function(properties, callback) {};
 
@@ -763,7 +697,6 @@ chrome.developerPrivate.deleteExtensionErrors = function(properties, callback) {
  * Repairs the extension specified.
  * @param {string} extensionId The id of the extension to repair.
  * @param {function():void=} callback
- * @see https://developer.chrome.com/extensions/developerPrivate#method-repairExtension
  */
 chrome.developerPrivate.repairExtension = function(extensionId, callback) {};
 
@@ -772,7 +705,6 @@ chrome.developerPrivate.repairExtension = function(extensionId, callback) {};
  * @param {string} extensionId The id of the extension to show the options page
  *     for.
  * @param {function():void=} callback
- * @see https://developer.chrome.com/extensions/developerPrivate#method-showOptions
  */
 chrome.developerPrivate.showOptions = function(extensionId, callback) {};
 
@@ -780,7 +712,6 @@ chrome.developerPrivate.showOptions = function(extensionId, callback) {};
  * Shows the path of the extension specified.
  * @param {string} extensionId The id of the extension to show the path for.
  * @param {function():void=} callback
- * @see https://developer.chrome.com/extensions/developerPrivate#method-showPath
  */
 chrome.developerPrivate.showPath = function(extensionId, callback) {};
 
@@ -789,7 +720,6 @@ chrome.developerPrivate.showPath = function(extensionId, callback) {};
  * @param {boolean} isSuspended Whether or not shortcut handling should be
  *     suspended.
  * @param {function():void=} callback
- * @see https://developer.chrome.com/extensions/developerPrivate#method-setShortcutHandlingSuspended
  */
 chrome.developerPrivate.setShortcutHandlingSuspended = function(isSuspended, callback) {};
 
@@ -798,7 +728,6 @@ chrome.developerPrivate.setShortcutHandlingSuspended = function(isSuspended, cal
  * @param {!chrome.developerPrivate.ExtensionCommandUpdate} update The
  *     parameters for updating the extension command.
  * @param {function():void=} callback
- * @see https://developer.chrome.com/extensions/developerPrivate#method-updateExtensionCommand
  */
 chrome.developerPrivate.updateExtensionCommand = function(update, callback) {};
 
@@ -808,7 +737,6 @@ chrome.developerPrivate.updateExtensionCommand = function(update, callback) {};
  * @param {string} extensionId The id of the extension to modify.
  * @param {string} host The host to add.
  * @param {function():void=} callback
- * @see https://developer.chrome.com/extensions/developerPrivate#method-addHostPermission
  */
 chrome.developerPrivate.addHostPermission = function(extensionId, host, callback) {};
 
@@ -818,7 +746,6 @@ chrome.developerPrivate.addHostPermission = function(extensionId, host, callback
  * @param {string} extensionId The id of the extension to modify.
  * @param {string} host The host to remove.
  * @param {function():void=} callback
- * @see https://developer.chrome.com/extensions/developerPrivate#method-removeHostPermission
  */
 chrome.developerPrivate.removeHostPermission = function(extensionId, host, callback) {};
 
@@ -827,7 +754,6 @@ chrome.developerPrivate.removeHostPermission = function(extensionId, host, callb
  * @param {boolean} enabled
  * @param {function():void=} callback
  * @deprecated Use management.setEnabled
- * @see https://developer.chrome.com/extensions/developerPrivate#method-enable
  */
 chrome.developerPrivate.enable = function(id, enabled, callback) {};
 
@@ -836,7 +762,6 @@ chrome.developerPrivate.enable = function(id, enabled, callback) {};
  * @param {boolean} allow
  * @param {function():void=} callback
  * @deprecated Use updateExtensionConfiguration
- * @see https://developer.chrome.com/extensions/developerPrivate#method-allowIncognito
  */
 chrome.developerPrivate.allowIncognito = function(extensionId, allow, callback) {};
 
@@ -845,7 +770,6 @@ chrome.developerPrivate.allowIncognito = function(extensionId, allow, callback)
  * @param {boolean} allow
  * @param {function():void=} callback
  * @deprecated Use updateExtensionConfiguration
- * @see https://developer.chrome.com/extensions/developerPrivate#method-allowFileAccess
  */
 chrome.developerPrivate.allowFileAccess = function(extensionId, allow, callback) {};
 
@@ -853,20 +777,17 @@ chrome.developerPrivate.allowFileAccess = function(extensionId, allow, callback)
  * @param {!chrome.developerPrivate.InspectOptions} options
  * @param {function():void=} callback
  * @deprecated Use openDevTools
- * @see https://developer.chrome.com/extensions/developerPrivate#method-inspect
  */
 chrome.developerPrivate.inspect = function(options, callback) {};
 
 /**
  * Fired when a item state is changed.
  * @type {!ChromeEvent}
- * @see https://developer.chrome.com/extensions/developerPrivate#event-onItemStateChanged
  */
 chrome.developerPrivate.onItemStateChanged;
 
 /**
  * Fired when the profile's state has changed.
  * @type {!ChromeEvent}
- * @see https://developer.chrome.com/extensions/developerPrivate#event-onProfileStateChanged
  */
 chrome.developerPrivate.onProfileStateChanged;
diff --git a/third_party/closure_compiler/externs/input_method_private.js b/third_party/closure_compiler/externs/input_method_private.js
index 2e810a8e2f..b34f21a735 100644
--- a/third_party/closure_compiler/externs/input_method_private.js
+++ b/third_party/closure_compiler/externs/input_method_private.js
@@ -22,7 +22,6 @@ chrome.inputMethodPrivate = {};
  *   isPhysicalKeyboardAutocorrectEnabled: boolean,
  *   isImeMenuActivated: boolean
  * }):void} callback Callback which is called with the config object.
- * @see https://developer.chrome.com/extensions/inputMethodPrivate#method-getInputMethodConfig
  */
 chrome.inputMethodPrivate.getInputMethodConfig = function(callback) {};
 
@@ -33,7 +32,6 @@ chrome.inputMethodPrivate.getInputMethodConfig = function(callback) {};
  *   name: string,
  *   indicator: string
  * }>):void} callback Callback which is called with the input method objects.
- * @see https://developer.chrome.com/extensions/inputMethodPrivate#method-getInputMethods
  */
 chrome.inputMethodPrivate.getInputMethods = function(callback) {};
 
@@ -41,7 +39,6 @@ chrome.inputMethodPrivate.getInputMethods = function(callback) {};
  * Gets the current input method.
  * @param {function(string):void} callback Callback which is called with the
  *     current input method.
- * @see https://developer.chrome.com/extensions/inputMethodPrivate#method-getCurrentInputMethod
  */
 chrome.inputMethodPrivate.getCurrentInputMethod = function(callback) {};
 
@@ -51,7 +48,6 @@ chrome.inputMethodPrivate.getCurrentInputMethod = function(callback) {};
  *     method.
  * @param {function():void=} callback Callback which is called once the current
  *     input method is set. If unsuccessful $(ref:runtime.lastError) is set.
- * @see https://developer.chrome.com/extensions/inputMethodPrivate#method-setCurrentInputMethod
  */
 chrome.inputMethodPrivate.setCurrentInputMethod = function(inputMethodId, callback) {};
 
@@ -59,7 +55,6 @@ chrome.inputMethodPrivate.setCurrentInputMethod = function(inputMethodId, callba
  * Fetches a list of all the words currently in the dictionary.
  * @param {function(!Array<string>):void} callback Callback which is called once
  *     the list of dictionary words are ready.
- * @see https://developer.chrome.com/extensions/inputMethodPrivate#method-fetchAllDictionaryWords
  */
 chrome.inputMethodPrivate.fetchAllDictionaryWords = function(callback) {};
 
@@ -68,7 +63,6 @@ chrome.inputMethodPrivate.fetchAllDictionaryWords = function(callback) {};
  * @param {string} word A new word to add to the dictionary.
  * @param {function():void=} callback Callback which is called once the word is
  *     added. If unsuccessful $(ref:runtime.lastError) is set.
- * @see https://developer.chrome.com/extensions/inputMethodPrivate#method-addWordToDictionary
  */
 chrome.inputMethodPrivate.addWordToDictionary = function(word, callback) {};
 
@@ -76,7 +70,6 @@ chrome.inputMethodPrivate.addWordToDictionary = function(word, callback) {};
  * Gets whether the encrypt sync is enabled.
  * @param {function(boolean):void=} callback Callback which is called to provide
  *     the result.
- * @see https://developer.chrome.com/extensions/inputMethodPrivate#method-getEncryptSyncEnabled
  */
 chrome.inputMethodPrivate.getEncryptSyncEnabled = function(callback) {};
 
@@ -85,41 +78,35 @@ chrome.inputMethodPrivate.getEncryptSyncEnabled = function(callback) {};
  * @param {string} xkb_name The XKB layout name.
  * @param {function():void=} callback Callback which is called when the layout
  *     is set.
- * @see https://developer.chrome.com/extensions/inputMethodPrivate#method-setXkbLayout
  */
 chrome.inputMethodPrivate.setXkbLayout = function(xkb_name, callback) {};
 
 /**
  * Fired when the input method is changed.
  * @type {!ChromeEvent}
- * @see https://developer.chrome.com/extensions/inputMethodPrivate#event-onChanged
  */
 chrome.inputMethodPrivate.onChanged;
 
 /**
  * Fired when the composition bounds or cursor bounds are changed.
  * @type {!ChromeEvent}
- * @see https://developer.chrome.com/extensions/inputMethodPrivate#event-onCompositionBoundsChanged
  */
 chrome.inputMethodPrivate.onCompositionBoundsChanged;
 
 /**
  * Fired when the custom spelling dictionary is loaded.
  * @type {!ChromeEvent}
- * @see https://developer.chrome.com/extensions/inputMethodPrivate#event-onDictionaryLoaded
  */
 chrome.inputMethodPrivate.onDictionaryLoaded;
 
 /**
  * Fired when words are added or removed from the custom spelling dictionary.
  * @type {!ChromeEvent}
- * @see https://developer.chrome.com/extensions/inputMethodPrivate#event-onDictionaryChanged
  */
 chrome.inputMethodPrivate.onDictionaryChanged;
 
 /**
  * Fired when the IME menu is activated or deactivated.
  * @type {!ChromeEvent}
- * @see https://developer.chrome.com/extensions/inputMethodPrivate#event-onImeMenuActivationChanged
  */
 chrome.inputMethodPrivate.onImeMenuActivationChanged;
diff --git a/third_party/closure_compiler/externs/language_settings_private.js b/third_party/closure_compiler/externs/language_settings_private.js
index 2b041bfbc4..2618a5394f 100644
--- a/third_party/closure_compiler/externs/language_settings_private.js
+++ b/third_party/closure_compiler/externs/language_settings_private.js
@@ -18,7 +18,6 @@ chrome.languageSettingsPrivate = {};
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/languageSettingsPrivate#type-MoveType
  */
 chrome.languageSettingsPrivate.MoveType = {
   TOP: 'TOP',
@@ -37,7 +36,6 @@ chrome.languageSettingsPrivate.MoveType = {
  *   supportsTranslate: (boolean|undefined),
  *   isAllowedUILocale: (boolean|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/languageSettingsPrivate#type-Language
  */
 chrome.languageSettingsPrivate.Language;
 
@@ -48,7 +46,6 @@ chrome.languageSettingsPrivate.Language;
  *   isDownloading: (boolean|undefined),
  *   downloadFailed: (boolean|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/languageSettingsPrivate#type-SpellcheckDictionaryStatus
  */
 chrome.languageSettingsPrivate.SpellcheckDictionaryStatus;
 
@@ -60,7 +57,6 @@ chrome.languageSettingsPrivate.SpellcheckDictionaryStatus;
  *   enabled: (boolean|undefined),
  *   hasOptionsPage: (boolean|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/languageSettingsPrivate#type-InputMethod
  */
 chrome.languageSettingsPrivate.InputMethod;
 
@@ -69,7 +65,6 @@ chrome.languageSettingsPrivate.InputMethod;
  *   componentExtensionImes: !Array<!chrome.languageSettingsPrivate.InputMethod>,
  *   thirdPartyExtensionImes: !Array<!chrome.languageSettingsPrivate.InputMethod>
  * }}
- * @see https://developer.chrome.com/extensions/languageSettingsPrivate#type-InputMethodLists
  */
 chrome.languageSettingsPrivate.InputMethodLists;
 
@@ -77,7 +72,6 @@ chrome.languageSettingsPrivate.InputMethodLists;
  * Gets languages available for translate, spell checking, input and locale.
  * @param {function(!Array<!chrome.languageSettingsPrivate.Language>):void}
  *     callback
- * @see https://developer.chrome.com/extensions/languageSettingsPrivate#method-getLanguageList
  */
 chrome.languageSettingsPrivate.getLanguageList = function(callback) {};
 
@@ -85,14 +79,12 @@ chrome.languageSettingsPrivate.getLanguageList = function(callback) {};
  * Enables a language, adding it to the Accept-Language list (used to decide
  * which languages to translate, generate the Accept-Language header, etc.).
  * @param {string} languageCode
- * @see https://developer.chrome.com/extensions/languageSettingsPrivate#method-enableLanguage
  */
 chrome.languageSettingsPrivate.enableLanguage = function(languageCode) {};
 
 /**
  * Disables a language, removing it from the Accept-Language list.
  * @param {string} languageCode
- * @see https://developer.chrome.com/extensions/languageSettingsPrivate#method-disableLanguage
  */
 chrome.languageSettingsPrivate.disableLanguage = function(languageCode) {};
 
@@ -100,7 +92,6 @@ chrome.languageSettingsPrivate.disableLanguage = function(languageCode) {};
  * Enables or disables translation for a given language.
  * @param {string} languageCode
  * @param {boolean} enable
- * @see https://developer.chrome.com/extensions/languageSettingsPrivate#method-setEnableTranslationForLanguage
  */
 chrome.languageSettingsPrivate.setEnableTranslationForLanguage = function(languageCode, enable) {};
 
@@ -108,7 +99,6 @@ chrome.languageSettingsPrivate.setEnableTranslationForLanguage = function(langua
  * Moves a language inside the language list.
  * @param {string} languageCode
  * @param {!chrome.languageSettingsPrivate.MoveType} moveType
- * @see https://developer.chrome.com/extensions/languageSettingsPrivate#method-moveLanguage
  */
 chrome.languageSettingsPrivate.moveLanguage = function(languageCode, moveType) {};
 
@@ -116,35 +106,30 @@ chrome.languageSettingsPrivate.moveLanguage = function(languageCode, moveType) {
  * Gets the current status of the chosen spell check dictionaries.
  * @param {function(!Array<!chrome.languageSettingsPrivate.SpellcheckDictionaryStatus>):void}
  *     callback
- * @see https://developer.chrome.com/extensions/languageSettingsPrivate#method-getSpellcheckDictionaryStatuses
  */
 chrome.languageSettingsPrivate.getSpellcheckDictionaryStatuses = function(callback) {};
 
 /**
  * Gets the custom spell check words, in sorted order.
  * @param {function(!Array<string>):void} callback
- * @see https://developer.chrome.com/extensions/languageSettingsPrivate#method-getSpellcheckWords
  */
 chrome.languageSettingsPrivate.getSpellcheckWords = function(callback) {};
 
 /**
  * Adds a word to the custom dictionary.
  * @param {string} word
- * @see https://developer.chrome.com/extensions/languageSettingsPrivate#method-addSpellcheckWord
  */
 chrome.languageSettingsPrivate.addSpellcheckWord = function(word) {};
 
 /**
  * Removes a word from the custom dictionary.
  * @param {string} word
- * @see https://developer.chrome.com/extensions/languageSettingsPrivate#method-removeSpellcheckWord
  */
 chrome.languageSettingsPrivate.removeSpellcheckWord = function(word) {};
 
 /**
  * Gets the translate target language (in most cases, the display locale).
  * @param {function(string):void} callback
- * @see https://developer.chrome.com/extensions/languageSettingsPrivate#method-getTranslateTargetLanguage
  */
 chrome.languageSettingsPrivate.getTranslateTargetLanguage = function(callback) {};
 
@@ -152,7 +137,6 @@ chrome.languageSettingsPrivate.getTranslateTargetLanguage = function(callback) {
  * Gets all supported input methods, including third-party IMEs. Chrome OS only.
  * @param {function(!chrome.languageSettingsPrivate.InputMethodLists):void}
  *     callback
- * @see https://developer.chrome.com/extensions/languageSettingsPrivate#method-getInputMethodLists
  */
 chrome.languageSettingsPrivate.getInputMethodLists = function(callback) {};
 
@@ -160,7 +144,6 @@ chrome.languageSettingsPrivate.getInputMethodLists = function(callback) {};
  * Adds the input method to the current user's list of enabled input methods,
  * enabling the input method for the current user. Chrome OS only.
  * @param {string} inputMethodId
- * @see https://developer.chrome.com/extensions/languageSettingsPrivate#method-addInputMethod
  */
 chrome.languageSettingsPrivate.addInputMethod = function(inputMethodId) {};
 
@@ -168,14 +151,12 @@ chrome.languageSettingsPrivate.addInputMethod = function(inputMethodId) {};
  * Removes the input method from the current user's list of enabled input
  * methods, disabling the input method for the current user. Chrome OS only.
  * @param {string} inputMethodId
- * @see https://developer.chrome.com/extensions/languageSettingsPrivate#method-removeInputMethod
  */
 chrome.languageSettingsPrivate.removeInputMethod = function(inputMethodId) {};
 
 /**
  * Tries to download the dictionary after a failed download.
  * @param {string} languageCode
- * @see https://developer.chrome.com/extensions/languageSettingsPrivate#method-retryDownloadDictionary
  */
 chrome.languageSettingsPrivate.retryDownloadDictionary = function(languageCode) {};
 
@@ -183,7 +164,6 @@ chrome.languageSettingsPrivate.retryDownloadDictionary = function(languageCode)
  * Called when the pref for the dictionaries used for spell checking changes or
  * the status of one of the spell check dictionaries changes.
  * @type {!ChromeEvent}
- * @see https://developer.chrome.com/extensions/languageSettingsPrivate#event-onSpellcheckDictionariesChanged
  */
 chrome.languageSettingsPrivate.onSpellcheckDictionariesChanged;
 
@@ -191,20 +171,17 @@ chrome.languageSettingsPrivate.onSpellcheckDictionariesChanged;
  * Called when words are added to and/or removed from the custom spell check
  * dictionary.
  * @type {!ChromeEvent}
- * @see https://developer.chrome.com/extensions/languageSettingsPrivate#event-onCustomDictionaryChanged
  */
 chrome.languageSettingsPrivate.onCustomDictionaryChanged;
 
 /**
  * Called when an input method is added.
  * @type {!ChromeEvent}
- * @see https://developer.chrome.com/extensions/languageSettingsPrivate#event-onInputMethodAdded
  */
 chrome.languageSettingsPrivate.onInputMethodAdded;
 
 /**
  * Called when an input method is removed.
  * @type {!ChromeEvent}
- * @see https://developer.chrome.com/extensions/languageSettingsPrivate#event-onInputMethodRemoved
  */
-chrome.languageSettingsPrivate.onInputMethodRemoved;
\ No newline at end of file
+chrome.languageSettingsPrivate.onInputMethodRemoved;
diff --git a/third_party/closure_compiler/externs/metrics_private.js b/third_party/closure_compiler/externs/metrics_private.js
index 0eb0348692..f1acebef8c 100644
--- a/third_party/closure_compiler/externs/metrics_private.js
+++ b/third_party/closure_compiler/externs/metrics_private.js
@@ -18,7 +18,6 @@ chrome.metricsPrivate = {};
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/metricsPrivate#type-MetricTypeType
  */
 chrome.metricsPrivate.MetricTypeType = {
   HISTOGRAM_LOG: 'histogram-log',
@@ -34,14 +33,12 @@ chrome.metricsPrivate.MetricTypeType = {
  *   max: number,
  *   buckets: number
  * }}
- * @see https://developer.chrome.com/extensions/metricsPrivate#type-MetricType
  */
 chrome.metricsPrivate.MetricType;
 
 /**
  * Returns true if the user opted in to sending crash reports.
  * @param {function(boolean):void} callback
- * @see https://developer.chrome.com/extensions/metricsPrivate#method-getIsCrashReportingEnabled
  */
 chrome.metricsPrivate.getIsCrashReportingEnabled = function(callback) {};
 
@@ -50,7 +47,6 @@ chrome.metricsPrivate.getIsCrashReportingEnabled = function(callback) {};
  * trial does not exist or is not enabled.
  * @param {string} name
  * @param {function(string):void} callback
- * @see https://developer.chrome.com/extensions/metricsPrivate#method-getFieldTrial
  */
 chrome.metricsPrivate.getFieldTrial = function(name, callback) {};
 
@@ -59,14 +55,12 @@ chrome.metricsPrivate.getFieldTrial = function(name, callback) {};
  * otherwise.
  * @param {string} name
  * @param {function((Object|undefined)):void} callback
- * @see https://developer.chrome.com/extensions/metricsPrivate#method-getVariationParams
  */
 chrome.metricsPrivate.getVariationParams = function(name, callback) {};
 
 /**
  * Records an action performed by the user.
  * @param {string} name
- * @see https://developer.chrome.com/extensions/metricsPrivate#method-recordUserAction
  */
 chrome.metricsPrivate.recordUserAction = function(name) {};
 
@@ -74,7 +68,6 @@ chrome.metricsPrivate.recordUserAction = function(name) {};
  * Records a percentage value from 1 to 100.
  * @param {string} metricName
  * @param {number} value
- * @see https://developer.chrome.com/extensions/metricsPrivate#method-recordPercentage
  */
 chrome.metricsPrivate.recordPercentage = function(metricName, value) {};
 
@@ -82,7 +75,6 @@ chrome.metricsPrivate.recordPercentage = function(metricName, value) {};
  * Records a value than can range from 1 to 1,000,000.
  * @param {string} metricName
  * @param {number} value
- * @see https://developer.chrome.com/extensions/metricsPrivate#method-recordCount
  */
 chrome.metricsPrivate.recordCount = function(metricName, value) {};
 
@@ -90,7 +82,6 @@ chrome.metricsPrivate.recordCount = function(metricName, value) {};
  * Records a value than can range from 1 to 100.
  * @param {string} metricName
  * @param {number} value
- * @see https://developer.chrome.com/extensions/metricsPrivate#method-recordSmallCount
  */
 chrome.metricsPrivate.recordSmallCount = function(metricName, value) {};
 
@@ -98,7 +89,6 @@ chrome.metricsPrivate.recordSmallCount = function(metricName, value) {};
  * Records a value than can range from 1 to 10,000.
  * @param {string} metricName
  * @param {number} value
- * @see https://developer.chrome.com/extensions/metricsPrivate#method-recordMediumCount
  */
 chrome.metricsPrivate.recordMediumCount = function(metricName, value) {};
 
@@ -107,7 +97,6 @@ chrome.metricsPrivate.recordMediumCount = function(metricName, value) {};
  * specified in milliseconds.
  * @param {string} metricName
  * @param {number} value
- * @see https://developer.chrome.com/extensions/metricsPrivate#method-recordTime
  */
 chrome.metricsPrivate.recordTime = function(metricName, value) {};
 
@@ -116,7 +105,6 @@ chrome.metricsPrivate.recordTime = function(metricName, value) {};
  * specified in milliseconds.
  * @param {string} metricName
  * @param {number} value
- * @see https://developer.chrome.com/extensions/metricsPrivate#method-recordMediumTime
  */
 chrome.metricsPrivate.recordMediumTime = function(metricName, value) {};
 
@@ -125,7 +113,6 @@ chrome.metricsPrivate.recordMediumTime = function(metricName, value) {};
  * specified in milliseconds.
  * @param {string} metricName
  * @param {number} value
- * @see https://developer.chrome.com/extensions/metricsPrivate#method-recordLongTime
  */
 chrome.metricsPrivate.recordLongTime = function(metricName, value) {};
 
@@ -134,7 +121,6 @@ chrome.metricsPrivate.recordLongTime = function(metricName, value) {};
  * histogram defined by the |metricName|.
  * @param {string} metricName
  * @param {string} value
- * @see https://developer.chrome.com/extensions/metricsPrivate#method-recordSparseHashable
  */
 chrome.metricsPrivate.recordSparseHashable = function(metricName, value) {};
 
@@ -143,7 +129,6 @@ chrome.metricsPrivate.recordSparseHashable = function(metricName, value) {};
  * by the |metricName|.
  * @param {string} metricName
  * @param {number} value
- * @see https://developer.chrome.com/extensions/metricsPrivate#method-recordSparseValue
  */
 chrome.metricsPrivate.recordSparseValue = function(metricName, value) {};
 
@@ -151,7 +136,6 @@ chrome.metricsPrivate.recordSparseValue = function(metricName, value) {};
  * Adds a value to the given metric.
  * @param {!chrome.metricsPrivate.MetricType} metric
  * @param {number} value
- * @see https://developer.chrome.com/extensions/metricsPrivate#method-recordValue
  */
 chrome.metricsPrivate.recordValue = function(metric, value) {};
 
@@ -160,7 +144,6 @@ chrome.metricsPrivate.recordValue = function(metric, value) {};
  * base::UmaHistogramBoolean().
  * @param {string} metricName
  * @param {boolean} value
- * @see https://developer.chrome.com/extensions/metricsPrivate#method-recordBoolean
  */
 chrome.metricsPrivate.recordBoolean = function(metricName, value) {};
 
@@ -171,6 +154,5 @@ chrome.metricsPrivate.recordBoolean = function(metricName, value) {};
  * @param {string} metricName
  * @param {number} value
  * @param {number} enumSize
- * @see https://developer.chrome.com/extensions/metricsPrivate#method-recordEnumerationValue
  */
 chrome.metricsPrivate.recordEnumerationValue = function(metricName, value, enumSize) {};
diff --git a/third_party/closure_compiler/externs/networking_private.js b/third_party/closure_compiler/externs/networking_private.js
index 06888780a0..87ac9e1b84 100644
--- a/third_party/closure_compiler/externs/networking_private.js
+++ b/third_party/closure_compiler/externs/networking_private.js
@@ -18,7 +18,6 @@ chrome.networkingPrivate = {};
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ActivationStateType
  */
 chrome.networkingPrivate.ActivationStateType = {
   ACTIVATED: 'Activated',
@@ -29,7 +28,6 @@ chrome.networkingPrivate.ActivationStateType = {
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-CaptivePortalStatus
  */
 chrome.networkingPrivate.CaptivePortalStatus = {
   UNKNOWN: 'Unknown',
@@ -41,7 +39,6 @@ chrome.networkingPrivate.CaptivePortalStatus = {
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ConnectionStateType
  */
 chrome.networkingPrivate.ConnectionStateType = {
   CONNECTED: 'Connected',
@@ -51,7 +48,6 @@ chrome.networkingPrivate.ConnectionStateType = {
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-DeviceStateType
  */
 chrome.networkingPrivate.DeviceStateType = {
   UNINITIALIZED: 'Uninitialized',
@@ -63,7 +59,6 @@ chrome.networkingPrivate.DeviceStateType = {
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-IPConfigType
  */
 chrome.networkingPrivate.IPConfigType = {
   DHCP: 'DHCP',
@@ -72,7 +67,6 @@ chrome.networkingPrivate.IPConfigType = {
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-NetworkType
  */
 chrome.networkingPrivate.NetworkType = {
   ALL: 'All',
@@ -87,7 +81,6 @@ chrome.networkingPrivate.NetworkType = {
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ProxySettingsType
  */
 chrome.networkingPrivate.ProxySettingsType = {
   DIRECT: 'Direct',
@@ -107,7 +100,6 @@ chrome.networkingPrivate.ProxySettingsType = {
  *   UserEditable: (boolean|undefined),
  *   DeviceEditable: (boolean|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedBoolean
  */
 chrome.networkingPrivate.ManagedBoolean;
 
@@ -122,7 +114,6 @@ chrome.networkingPrivate.ManagedBoolean;
  *   UserEditable: (boolean|undefined),
  *   DeviceEditable: (boolean|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedLong
  */
 chrome.networkingPrivate.ManagedLong;
 
@@ -137,7 +128,6 @@ chrome.networkingPrivate.ManagedLong;
  *   UserEditable: (boolean|undefined),
  *   DeviceEditable: (boolean|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedDOMString
  */
 chrome.networkingPrivate.ManagedDOMString;
 
@@ -152,7 +142,6 @@ chrome.networkingPrivate.ManagedDOMString;
  *   UserEditable: (boolean|undefined),
  *   DeviceEditable: (boolean|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedDOMStringList
  */
 chrome.networkingPrivate.ManagedDOMStringList;
 
@@ -167,7 +156,6 @@ chrome.networkingPrivate.ManagedDOMStringList;
  *   UserEditable: (boolean|undefined),
  *   DeviceEditable: (boolean|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedIPConfigType
  */
 chrome.networkingPrivate.ManagedIPConfigType;
 
@@ -182,7 +170,6 @@ chrome.networkingPrivate.ManagedIPConfigType;
  *   UserEditable: (boolean|undefined),
  *   DeviceEditable: (boolean|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedProxySettingsType
  */
 chrome.networkingPrivate.ManagedProxySettingsType;
 
@@ -196,7 +183,6 @@ chrome.networkingPrivate.ManagedProxySettingsType;
  *   Password: (string|undefined),
  *   Username: (string|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-APNProperties
  */
 chrome.networkingPrivate.APNProperties;
 
@@ -210,7 +196,6 @@ chrome.networkingPrivate.APNProperties;
  *   Password: (!chrome.networkingPrivate.ManagedDOMString|undefined),
  *   Username: (!chrome.networkingPrivate.ManagedDOMString|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedAPNProperties
  */
 chrome.networkingPrivate.ManagedAPNProperties;
 
@@ -225,7 +210,6 @@ chrome.networkingPrivate.ManagedAPNProperties;
  *   UserEditable: (boolean|undefined),
  *   DeviceEditable: (boolean|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedAPNList
  */
 chrome.networkingPrivate.ManagedAPNList;
 
@@ -235,7 +219,6 @@ chrome.networkingPrivate.ManagedAPNList;
  *   Code: string,
  *   Country: (string|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-CellularProviderProperties
  */
 chrome.networkingPrivate.CellularProviderProperties;
 
@@ -245,7 +228,6 @@ chrome.networkingPrivate.CellularProviderProperties;
  *   currentPin: string,
  *   newPin: (string|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-CellularSimState
  */
 chrome.networkingPrivate.CellularSimState;
 
@@ -256,7 +238,6 @@ chrome.networkingPrivate.CellularSimState;
  *   Organization: (string|undefined),
  *   OrganizationalUnit: (string|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-IssuerSubjectPattern
  */
 chrome.networkingPrivate.IssuerSubjectPattern;
 
@@ -267,7 +248,6 @@ chrome.networkingPrivate.IssuerSubjectPattern;
  *   Organization: (!chrome.networkingPrivate.ManagedDOMString|undefined),
  *   OrganizationalUnit: (!chrome.networkingPrivate.ManagedDOMString|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedIssuerSubjectPattern
  */
 chrome.networkingPrivate.ManagedIssuerSubjectPattern;
 
@@ -278,7 +258,6 @@ chrome.networkingPrivate.ManagedIssuerSubjectPattern;
  *   IssuerCARef: (!Array<string>|undefined),
  *   Subject: (!chrome.networkingPrivate.IssuerSubjectPattern|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-CertificatePattern
  */
 chrome.networkingPrivate.CertificatePattern;
 
@@ -289,7 +268,6 @@ chrome.networkingPrivate.CertificatePattern;
  *   IssuerCARef: (!chrome.networkingPrivate.ManagedDOMStringList|undefined),
  *   Subject: (!chrome.networkingPrivate.ManagedIssuerSubjectPattern|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedCertificatePattern
  */
 chrome.networkingPrivate.ManagedCertificatePattern;
 
@@ -312,7 +290,6 @@ chrome.networkingPrivate.ManagedCertificatePattern;
  *   UseProactiveKeyCaching: (boolean|undefined),
  *   UseSystemCAs: (boolean|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-EAPProperties
  */
 chrome.networkingPrivate.EAPProperties;
 
@@ -335,7 +312,6 @@ chrome.networkingPrivate.EAPProperties;
  *   UseProactiveKeyCaching: (!chrome.networkingPrivate.ManagedBoolean|undefined),
  *   UseSystemCAs: (!chrome.networkingPrivate.ManagedBoolean|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedEAPProperties
  */
 chrome.networkingPrivate.ManagedEAPProperties;
 
@@ -347,7 +323,6 @@ chrome.networkingPrivate.ManagedEAPProperties;
  *   ShortName: (string|undefined),
  *   LongName: (string|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-FoundNetworkProperties
  */
 chrome.networkingPrivate.FoundNetworkProperties;
 
@@ -360,7 +335,6 @@ chrome.networkingPrivate.FoundNetworkProperties;
  *   Type: (string|undefined),
  *   WebProxyAutoDiscoveryUrl: (string|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-IPConfigProperties
  */
 chrome.networkingPrivate.IPConfigProperties;
 
@@ -373,7 +347,6 @@ chrome.networkingPrivate.IPConfigProperties;
  *   Type: (!chrome.networkingPrivate.ManagedDOMString|undefined),
  *   WebProxyAutoDiscoveryUrl: (!chrome.networkingPrivate.ManagedDOMString|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedIPConfigProperties
  */
 chrome.networkingPrivate.ManagedIPConfigProperties;
 
@@ -383,7 +356,6 @@ chrome.networkingPrivate.ManagedIPConfigProperties;
  *   SaveCredentials: (boolean|undefined),
  *   Username: (string|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-XAUTHProperties
  */
 chrome.networkingPrivate.XAUTHProperties;
 
@@ -393,7 +365,6 @@ chrome.networkingPrivate.XAUTHProperties;
  *   SaveCredentials: (!chrome.networkingPrivate.ManagedBoolean|undefined),
  *   Username: (!chrome.networkingPrivate.ManagedDOMString|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedXAUTHProperties
  */
 chrome.networkingPrivate.ManagedXAUTHProperties;
 
@@ -413,7 +384,6 @@ chrome.networkingPrivate.ManagedXAUTHProperties;
  *   ServerCARefs: (!Array<string>|undefined),
  *   XAUTH: (!chrome.networkingPrivate.XAUTHProperties|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-IPSecProperties
  */
 chrome.networkingPrivate.IPSecProperties;
 
@@ -433,7 +403,6 @@ chrome.networkingPrivate.IPSecProperties;
  *   ServerCARefs: (!chrome.networkingPrivate.ManagedDOMStringList|undefined),
  *   XAUTH: (!chrome.networkingPrivate.ManagedXAUTHProperties|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedIPSecProperties
  */
 chrome.networkingPrivate.ManagedIPSecProperties;
 
@@ -444,7 +413,6 @@ chrome.networkingPrivate.ManagedIPSecProperties;
  *   SaveCredentials: (boolean|undefined),
  *   Username: (string|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-L2TPProperties
  */
 chrome.networkingPrivate.L2TPProperties;
 
@@ -455,7 +423,6 @@ chrome.networkingPrivate.L2TPProperties;
  *   SaveCredentials: (!chrome.networkingPrivate.ManagedBoolean|undefined),
  *   Username: (!chrome.networkingPrivate.ManagedDOMString|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedL2TPProperties
  */
 chrome.networkingPrivate.ManagedL2TPProperties;
 
@@ -465,7 +432,6 @@ chrome.networkingPrivate.ManagedL2TPProperties;
  *   PostData: (string|undefined),
  *   Url: (string|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-PaymentPortal
  */
 chrome.networkingPrivate.PaymentPortal;
 
@@ -474,7 +440,6 @@ chrome.networkingPrivate.PaymentPortal;
  *   Host: string,
  *   Port: number
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ProxyLocation
  */
 chrome.networkingPrivate.ProxyLocation;
 
@@ -483,7 +448,6 @@ chrome.networkingPrivate.ProxyLocation;
  *   Host: !chrome.networkingPrivate.ManagedDOMString,
  *   Port: !chrome.networkingPrivate.ManagedLong
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedProxyLocation
  */
 chrome.networkingPrivate.ManagedProxyLocation;
 
@@ -494,7 +458,6 @@ chrome.networkingPrivate.ManagedProxyLocation;
  *   FTPProxy: (!chrome.networkingPrivate.ProxyLocation|undefined),
  *   SOCKS: (!chrome.networkingPrivate.ProxyLocation|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManualProxySettings
  */
 chrome.networkingPrivate.ManualProxySettings;
 
@@ -505,7 +468,6 @@ chrome.networkingPrivate.ManualProxySettings;
  *   FTPProxy: (!chrome.networkingPrivate.ManagedProxyLocation|undefined),
  *   SOCKS: (!chrome.networkingPrivate.ManagedProxyLocation|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedManualProxySettings
  */
 chrome.networkingPrivate.ManagedManualProxySettings;
 
@@ -516,7 +478,6 @@ chrome.networkingPrivate.ManagedManualProxySettings;
  *   ExcludeDomains: (!Array<string>|undefined),
  *   PAC: (string|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ProxySettings
  */
 chrome.networkingPrivate.ProxySettings;
 
@@ -527,7 +488,6 @@ chrome.networkingPrivate.ProxySettings;
  *   ExcludeDomains: (!chrome.networkingPrivate.ManagedDOMStringList|undefined),
  *   PAC: (!chrome.networkingPrivate.ManagedDOMString|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedProxySettings
  */
 chrome.networkingPrivate.ManagedProxySettings;
 
@@ -536,7 +496,6 @@ chrome.networkingPrivate.ManagedProxySettings;
  *   Name: (string|undefined),
  *   Type: (string|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-VerifyX509
  */
 chrome.networkingPrivate.VerifyX509;
 
@@ -545,7 +504,6 @@ chrome.networkingPrivate.VerifyX509;
  *   Name: (!chrome.networkingPrivate.ManagedDOMString|undefined),
  *   Type: (!chrome.networkingPrivate.ManagedDOMString|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedVerifyX509
  */
 chrome.networkingPrivate.ManagedVerifyX509;
 
@@ -590,7 +548,6 @@ chrome.networkingPrivate.ManagedVerifyX509;
  *   VerifyHash: (string|undefined),
  *   VerifyX509: (!chrome.networkingPrivate.VerifyX509|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-OpenVPNProperties
  */
 chrome.networkingPrivate.OpenVPNProperties;
 
@@ -635,7 +592,6 @@ chrome.networkingPrivate.OpenVPNProperties;
  *   VerifyHash: (!chrome.networkingPrivate.ManagedDOMString|undefined),
  *   VerifyX509: (!chrome.networkingPrivate.ManagedVerifyX509|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedOpenVPNProperties
  */
 chrome.networkingPrivate.ManagedOpenVPNProperties;
 
@@ -645,7 +601,6 @@ chrome.networkingPrivate.ManagedOpenVPNProperties;
  *   LockEnabled: boolean,
  *   RetriesLeft: (number|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-SIMLockStatus
  */
 chrome.networkingPrivate.SIMLockStatus;
 
@@ -654,7 +609,6 @@ chrome.networkingPrivate.SIMLockStatus;
  *   ExtensionID: string,
  *   ProviderName: (string|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ThirdPartyVPNProperties
  */
 chrome.networkingPrivate.ThirdPartyVPNProperties;
 
@@ -663,7 +617,6 @@ chrome.networkingPrivate.ThirdPartyVPNProperties;
  *   ExtensionID: !chrome.networkingPrivate.ManagedDOMString,
  *   ProviderName: (string|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedThirdPartyVPNProperties
  */
 chrome.networkingPrivate.ManagedThirdPartyVPNProperties;
 
@@ -702,7 +655,6 @@ chrome.networkingPrivate.ManagedThirdPartyVPNProperties;
  *   SupportNetworkScan: (boolean|undefined),
  *   SupportedCarriers: (!Array<string>|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-CellularProperties
  */
 chrome.networkingPrivate.CellularProperties;
 
@@ -741,7 +693,6 @@ chrome.networkingPrivate.CellularProperties;
  *   SupportNetworkScan: (boolean|undefined),
  *   SupportedCarriers: (!Array<string>|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedCellularProperties
  */
 chrome.networkingPrivate.ManagedCellularProperties;
 
@@ -754,7 +705,6 @@ chrome.networkingPrivate.ManagedCellularProperties;
  *   SIMPresent: (boolean|undefined),
  *   SignalStrength: (number|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-CellularStateProperties
  */
 chrome.networkingPrivate.CellularStateProperties;
 
@@ -764,7 +714,6 @@ chrome.networkingPrivate.CellularStateProperties;
  *   Authentication: (string|undefined),
  *   EAP: (!chrome.networkingPrivate.EAPProperties|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-EthernetProperties
  */
 chrome.networkingPrivate.EthernetProperties;
 
@@ -774,7 +723,6 @@ chrome.networkingPrivate.EthernetProperties;
  *   Authentication: (!chrome.networkingPrivate.ManagedDOMString|undefined),
  *   EAP: (!chrome.networkingPrivate.ManagedEAPProperties|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedEthernetProperties
  */
 chrome.networkingPrivate.ManagedEthernetProperties;
 
@@ -782,7 +730,6 @@ chrome.networkingPrivate.ManagedEthernetProperties;
  * @typedef {{
  *   Authentication: string
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-EthernetStateProperties
  */
 chrome.networkingPrivate.EthernetStateProperties;
 
@@ -793,7 +740,6 @@ chrome.networkingPrivate.EthernetStateProperties;
  *   HasConnectedToHost: boolean,
  *   SignalStrength: (number|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-TetherProperties
  */
 chrome.networkingPrivate.TetherProperties;
 
@@ -807,7 +753,6 @@ chrome.networkingPrivate.TetherProperties;
  *   ThirdPartyVPN: (!chrome.networkingPrivate.ThirdPartyVPNProperties|undefined),
  *   Type: (string|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-VPNProperties
  */
 chrome.networkingPrivate.VPNProperties;
 
@@ -821,7 +766,6 @@ chrome.networkingPrivate.VPNProperties;
  *   ThirdPartyVPN: (!chrome.networkingPrivate.ManagedThirdPartyVPNProperties|undefined),
  *   Type: (!chrome.networkingPrivate.ManagedDOMString|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedVPNProperties
  */
 chrome.networkingPrivate.ManagedVPNProperties;
 
@@ -831,7 +775,6 @@ chrome.networkingPrivate.ManagedVPNProperties;
  *   IPsec: (!chrome.networkingPrivate.IPSecProperties|undefined),
  *   ThirdPartyVPN: (!chrome.networkingPrivate.ThirdPartyVPNProperties|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-VPNStateProperties
  */
 chrome.networkingPrivate.VPNStateProperties;
 
@@ -852,7 +795,6 @@ chrome.networkingPrivate.VPNStateProperties;
  *   Security: (string|undefined),
  *   SignalStrength: (number|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-WiFiProperties
  */
 chrome.networkingPrivate.WiFiProperties;
 
@@ -873,7 +815,6 @@ chrome.networkingPrivate.WiFiProperties;
  *   Security: !chrome.networkingPrivate.ManagedDOMString,
  *   SignalStrength: (number|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedWiFiProperties
  */
 chrome.networkingPrivate.ManagedWiFiProperties;
 
@@ -886,7 +827,6 @@ chrome.networkingPrivate.ManagedWiFiProperties;
  *   SignalStrength: (number|undefined),
  *   SSID: (string|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-WiFiStateProperties
  */
 chrome.networkingPrivate.WiFiStateProperties;
 
@@ -896,7 +836,6 @@ chrome.networkingPrivate.WiFiStateProperties;
  *   EAP: (!chrome.networkingPrivate.EAPProperties|undefined),
  *   SignalStrength: (number|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-WiMAXProperties
  */
 chrome.networkingPrivate.WiMAXProperties;
 
@@ -906,7 +845,6 @@ chrome.networkingPrivate.WiMAXProperties;
  *   EAP: (!chrome.networkingPrivate.ManagedEAPProperties|undefined),
  *   SignalStrength: (number|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedWiMAXProperties
  */
 chrome.networkingPrivate.ManagedWiMAXProperties;
 
@@ -914,7 +852,6 @@ chrome.networkingPrivate.ManagedWiMAXProperties;
  * @typedef {{
  *   SignalStrength: (number|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-WiMAXStateProperties
  */
 chrome.networkingPrivate.WiMAXStateProperties;
 
@@ -934,7 +871,6 @@ chrome.networkingPrivate.WiMAXStateProperties;
  *   WiFi: (!chrome.networkingPrivate.WiFiProperties|undefined),
  *   WiMAX: (!chrome.networkingPrivate.WiMAXProperties|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-NetworkConfigProperties
  */
 chrome.networkingPrivate.NetworkConfigProperties;
 
@@ -963,7 +899,6 @@ chrome.networkingPrivate.NetworkConfigProperties;
  *   WiFi: (!chrome.networkingPrivate.WiFiProperties|undefined),
  *   WiMAX: (!chrome.networkingPrivate.WiMAXProperties|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-NetworkProperties
  */
 chrome.networkingPrivate.NetworkProperties;
 
@@ -992,7 +927,6 @@ chrome.networkingPrivate.NetworkProperties;
  *   WiFi: (!chrome.networkingPrivate.ManagedWiFiProperties|undefined),
  *   WiMAX: (!chrome.networkingPrivate.ManagedWiMAXProperties|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedProperties
  */
 chrome.networkingPrivate.ManagedProperties;
 
@@ -1013,7 +947,6 @@ chrome.networkingPrivate.ManagedProperties;
  *   WiFi: (!chrome.networkingPrivate.WiFiStateProperties|undefined),
  *   WiMAX: (!chrome.networkingPrivate.WiMAXStateProperties|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-NetworkStateProperties
  */
 chrome.networkingPrivate.NetworkStateProperties;
 
@@ -1025,7 +958,6 @@ chrome.networkingPrivate.NetworkStateProperties;
  *   State: !chrome.networkingPrivate.DeviceStateType,
  *   Type: !chrome.networkingPrivate.NetworkType
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-DeviceStateProperties
  */
 chrome.networkingPrivate.DeviceStateProperties;
 
@@ -1040,7 +972,6 @@ chrome.networkingPrivate.DeviceStateProperties;
  *   deviceSsid: string,
  *   deviceBssid: string
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-VerificationProperties
  */
 chrome.networkingPrivate.VerificationProperties;
 
@@ -1051,7 +982,6 @@ chrome.networkingPrivate.VerificationProperties;
  *   configured: (boolean|undefined),
  *   limit: (number|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-NetworkFilter
  */
 chrome.networkingPrivate.NetworkFilter;
 
@@ -1060,7 +990,6 @@ chrome.networkingPrivate.NetworkFilter;
  *   AllowOnlyPolicyNetworksToAutoconnect: (boolean|undefined),
  *   AllowOnlyPolicyNetworksToConnect: (boolean|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-GlobalPolicy
  */
 chrome.networkingPrivate.GlobalPolicy;
 
@@ -1073,7 +1002,6 @@ chrome.networkingPrivate.GlobalPolicy;
  *   PKCS11Id: (string|undefined),
  *   hardwareBacked: boolean
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-Certificate
  */
 chrome.networkingPrivate.Certificate;
 
@@ -1082,7 +1010,6 @@ chrome.networkingPrivate.Certificate;
  *   serverCaCertificates: !Array<!chrome.networkingPrivate.Certificate>,
  *   userCertificates: !Array<!chrome.networkingPrivate.Certificate>
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-CertificateLists
  */
 chrome.networkingPrivate.CertificateLists;
 
@@ -1092,7 +1019,6 @@ chrome.networkingPrivate.CertificateLists;
  * @param {string} networkGuid The GUID of the network to get properties for.
  * @param {function(!chrome.networkingPrivate.NetworkProperties):void} callback
  *     Called with the network properties when received.
- * @see https://developer.chrome.com/extensions/networkingPrivate#method-getProperties
  */
 chrome.networkingPrivate.getProperties = function(networkGuid, callback) {};
 
@@ -1103,7 +1029,6 @@ chrome.networkingPrivate.getProperties = function(networkGuid, callback) {};
  * @param {string} networkGuid The GUID of the network to get properties for.
  * @param {function(!chrome.networkingPrivate.ManagedProperties):void} callback
  *     Called with the managed network properties when received.
- * @see https://developer.chrome.com/extensions/networkingPrivate#method-getManagedProperties
  */
 chrome.networkingPrivate.getManagedProperties = function(networkGuid, callback) {};
 
@@ -1118,7 +1043,6 @@ chrome.networkingPrivate.getManagedProperties = function(networkGuid, callback)
  * @param {string} networkGuid The GUID of the network to get properties for.
  * @param {function(!chrome.networkingPrivate.NetworkStateProperties):void}
  *     callback Called immediately with the network state properties.
- * @see https://developer.chrome.com/extensions/networkingPrivate#method-getState
  */
 chrome.networkingPrivate.getState = function(networkGuid, callback) {};
 
@@ -1130,7 +1054,6 @@ chrome.networkingPrivate.getState = function(networkGuid, callback) {};
  * @param {!chrome.networkingPrivate.NetworkConfigProperties} properties The
  *     properties to set.
  * @param {function():void=} callback Called when the operation has completed.
- * @see https://developer.chrome.com/extensions/networkingPrivate#method-setProperties
  */
 chrome.networkingPrivate.setProperties = function(networkGuid, properties, callback) {};
 
@@ -1144,7 +1067,6 @@ chrome.networkingPrivate.setProperties = function(networkGuid, properties, callb
  *     properties to configure the new network with.
  * @param {function(string):void=} callback Called with the GUID for the new
  *     network configuration once     the network has been created.
- * @see https://developer.chrome.com/extensions/networkingPrivate#method-createNetwork
  */
 chrome.networkingPrivate.createNetwork = function(shared, properties, callback) {};
 
@@ -1155,7 +1077,6 @@ chrome.networkingPrivate.createNetwork = function(shared, properties, callback)
  * configuration exists, an error will be set and the operation will fail.
  * @param {string} networkGuid The GUID of the network to forget.
  * @param {function():void=} callback Called when the operation has completed.
- * @see https://developer.chrome.com/extensions/networkingPrivate#method-forgetNetwork
  */
 chrome.networkingPrivate.forgetNetwork = function(networkGuid, callback) {};
 
@@ -1170,7 +1091,6 @@ chrome.networkingPrivate.forgetNetwork = function(networkGuid, callback) {};
  * @param {function(!Array<!chrome.networkingPrivate.NetworkStateProperties>):void}
  *     callback Called with a dictionary of networks and their state
  *     properties when received.
- * @see https://developer.chrome.com/extensions/networkingPrivate#method-getNetworks
  */
 chrome.networkingPrivate.getNetworks = function(filter, callback) {};
 
@@ -1181,7 +1101,6 @@ chrome.networkingPrivate.getNetworks = function(filter, callback) {};
  * @param {function(!Array<!chrome.networkingPrivate.NetworkStateProperties>):void}
  *     callback
  * @deprecated Use getNetworks.
- * @see https://developer.chrome.com/extensions/networkingPrivate#method-getVisibleNetworks
  */
 chrome.networkingPrivate.getVisibleNetworks = function(networkType, callback) {};
 
@@ -1190,7 +1109,6 @@ chrome.networkingPrivate.getVisibleNetworks = function(networkType, callback) {}
  * @param {function(!Array<!chrome.networkingPrivate.NetworkType>):void}
  *     callback
  * @deprecated Use getDeviceStates.
- * @see https://developer.chrome.com/extensions/networkingPrivate#method-getEnabledNetworkTypes
  */
 chrome.networkingPrivate.getEnabledNetworkTypes = function(callback) {};
 
@@ -1198,7 +1116,6 @@ chrome.networkingPrivate.getEnabledNetworkTypes = function(callback) {};
  * Returns a list of $(ref:networkingPrivate.DeviceStateProperties) objects.
  * @param {function(!Array<!chrome.networkingPrivate.DeviceStateProperties>):void}
  *     callback Called with a list of devices and their state.
- * @see https://developer.chrome.com/extensions/networkingPrivate#method-getDeviceStates
  */
 chrome.networkingPrivate.getDeviceStates = function(callback) {};
 
@@ -1207,7 +1124,6 @@ chrome.networkingPrivate.getDeviceStates = function(callback) {};
  * represent multiple network types (e.g. 'Wireless').
  * @param {!chrome.networkingPrivate.NetworkType} networkType The type of
  *     network to enable.
- * @see https://developer.chrome.com/extensions/networkingPrivate#method-enableNetworkType
  */
 chrome.networkingPrivate.enableNetworkType = function(networkType) {};
 
@@ -1216,7 +1132,6 @@ chrome.networkingPrivate.enableNetworkType = function(networkType) {};
  * $(ref:networkingPrivate.enableNetworkType).
  * @param {!chrome.networkingPrivate.NetworkType} networkType The type of
  *     network to disable.
- * @see https://developer.chrome.com/extensions/networkingPrivate#method-disableNetworkType
  */
 chrome.networkingPrivate.disableNetworkType = function(networkType) {};
 
@@ -1228,7 +1143,6 @@ chrome.networkingPrivate.disableNetworkType = function(networkType) {};
  * @param {!chrome.networkingPrivate.NetworkType=} networkType If provided,
  *     requests a scan specific to the type.     For Cellular a mobile network
  *     scan will be requested if supported.
- * @see https://developer.chrome.com/extensions/networkingPrivate#method-requestNetworkScan
  */
 chrome.networkingPrivate.requestNetworkScan = function(networkType) {};
 
@@ -1241,7 +1155,6 @@ chrome.networkingPrivate.requestNetworkScan = function(networkType) {};
  *     If the connect request     immediately failed (e.g. the network is
  *     unconfigured),     $(ref:runtime.lastError) will be set with a failure
  *     reason.
- * @see https://developer.chrome.com/extensions/networkingPrivate#method-startConnect
  */
 chrome.networkingPrivate.startConnect = function(networkGuid, callback) {};
 
@@ -1250,7 +1163,6 @@ chrome.networkingPrivate.startConnect = function(networkGuid, callback) {};
  * @param {string} networkGuid The GUID of the network to disconnect from.
  * @param {function():void=} callback Called when the disconnect request has
  *     been sent. See note     for $(ref:startConnect).
- * @see https://developer.chrome.com/extensions/networkingPrivate#method-startDisconnect
  */
 chrome.networkingPrivate.startDisconnect = function(networkGuid, callback) {};
 
@@ -1263,7 +1175,6 @@ chrome.networkingPrivate.startDisconnect = function(networkGuid, callback) {};
  * @param {string=} carrier Optional name of carrier to activate.
  * @param {function():void=} callback Called when the activation request has
  *     been sent. See note     for $(ref:startConnect).
- * @see https://developer.chrome.com/extensions/networkingPrivate#method-startActivate
  */
 chrome.networkingPrivate.startActivate = function(networkGuid, carrier, callback) {};
 
@@ -1275,7 +1186,6 @@ chrome.networkingPrivate.startActivate = function(networkGuid, carrier, callback
  * @param {function(boolean):void} callback A callback function that indicates
  *     whether or not the device     is a trusted device.
  * @deprecated Use networking.castPrivate API.
- * @see https://developer.chrome.com/extensions/networkingPrivate#method-verifyDestination
  */
 chrome.networkingPrivate.verifyDestination = function(properties, callback) {};
 
@@ -1289,7 +1199,6 @@ chrome.networkingPrivate.verifyDestination = function(properties, callback) {};
  * @param {function(string):void} callback A callback function that receives
  *     base64-encoded encrypted     credential data to send to a trusted device.
  * @deprecated Use networking.castPrivate API.
- * @see https://developer.chrome.com/extensions/networkingPrivate#method-verifyAndEncryptCredentials
  */
 chrome.networkingPrivate.verifyAndEncryptCredentials = function(properties, networkGuid, callback) {};
 
@@ -1303,7 +1212,6 @@ chrome.networkingPrivate.verifyAndEncryptCredentials = function(properties, netw
  * @param {function(string):void} callback A callback function that receives
  *     base64-encoded encrypted     data to send to a trusted device.
  * @deprecated Use networking.castPrivate API.
- * @see https://developer.chrome.com/extensions/networkingPrivate#method-verifyAndEncryptData
  */
 chrome.networkingPrivate.verifyAndEncryptData = function(properties, data, callback) {};
 
@@ -1319,7 +1227,6 @@ chrome.networkingPrivate.verifyAndEncryptData = function(properties, data, callb
  *     indicates that the lookup     timed out. Otherwise a valid status is
  *     returned (see     $(ref:getWifiTDLSStatus)).
  * @deprecated Use networking.castPrivate API.
- * @see https://developer.chrome.com/extensions/networkingPrivate#method-setWifiTDLSEnabledState
  */
 chrome.networkingPrivate.setWifiTDLSEnabledState = function(ip_or_mac_address, enabled, callback) {};
 
@@ -1330,7 +1237,6 @@ chrome.networkingPrivate.setWifiTDLSEnabledState = function(ip_or_mac_address, e
  *     string with the current     TDLS status which can be 'Connected',
  *     'Disabled', 'Disconnected',     'Nonexistent', or 'Unknown'.
  * @deprecated Use networking.castPrivate API.
- * @see https://developer.chrome.com/extensions/networkingPrivate#method-getWifiTDLSStatus
  */
 chrome.networkingPrivate.getWifiTDLSStatus = function(ip_or_mac_address, callback) {};
 
@@ -1341,7 +1247,6 @@ chrome.networkingPrivate.getWifiTDLSStatus = function(ip_or_mac_address, callbac
  * @param {function(!chrome.networkingPrivate.CaptivePortalStatus):void}
  *     callback A callback function that returns the results of the query for
  *     network captive portal status.
- * @see https://developer.chrome.com/extensions/networkingPrivate#method-getCaptivePortalStatus
  */
 chrome.networkingPrivate.getCaptivePortalStatus = function(networkGuid, callback) {};
 
@@ -1356,7 +1261,6 @@ chrome.networkingPrivate.getCaptivePortalStatus = function(networkGuid, callback
  * @param {string} pin The current SIM PIN, or the new PIN if PUK is provided.
  * @param {string=} puk The operator provided PUK for unblocking a blocked SIM.
  * @param {function():void=} callback Called when the operation has completed.
- * @see https://developer.chrome.com/extensions/networkingPrivate#method-unlockCellularSim
  */
 chrome.networkingPrivate.unlockCellularSim = function(networkGuid, pin, puk, callback) {};
 
@@ -1373,7 +1277,6 @@ chrome.networkingPrivate.unlockCellularSim = function(networkGuid, pin, puk, cal
  * @param {!chrome.networkingPrivate.CellularSimState} simState The SIM state to
  *     set.
  * @param {function():void=} callback Called when the operation has completed.
- * @see https://developer.chrome.com/extensions/networkingPrivate#method-setCellularSimState
  */
 chrome.networkingPrivate.setCellularSimState = function(networkGuid, simState, callback) {};
 
@@ -1385,7 +1288,6 @@ chrome.networkingPrivate.setCellularSimState = function(networkGuid, simState, c
  *     network     for. If empty, the default cellular device will be used.
  * @param {string} networkId The networkId to select.
  * @param {function():void=} callback Called when the operation has completed.
- * @see https://developer.chrome.com/extensions/networkingPrivate#method-selectCellularMobileNetwork
  */
 chrome.networkingPrivate.selectCellularMobileNetwork = function(networkGuid, networkId, callback) {};
 
@@ -1393,14 +1295,12 @@ chrome.networkingPrivate.selectCellularMobileNetwork = function(networkGuid, net
  * Gets the global policy properties. These properties are not expected to
  * change during a session.
  * @param {function(!chrome.networkingPrivate.GlobalPolicy):void} callback
- * @see https://developer.chrome.com/extensions/networkingPrivate#method-getGlobalPolicy
  */
 chrome.networkingPrivate.getGlobalPolicy = function(callback) {};
 
 /**
  * Gets the lists of certificates available for network configuration.
  * @param {function(!chrome.networkingPrivate.CertificateLists):void} callback
- * @see https://developer.chrome.com/extensions/networkingPrivate#method-getCertificateLists
  */
 chrome.networkingPrivate.getCertificateLists = function(callback) {};
 
@@ -1408,7 +1308,6 @@ chrome.networkingPrivate.getCertificateLists = function(callback) {};
  * Fired when the properties change on any of the networks.  Sends a list of
  * GUIDs for networks whose properties have changed.
  * @type {!ChromeEvent}
- * @see https://developer.chrome.com/extensions/networkingPrivate#event-onNetworksChanged
  */
 chrome.networkingPrivate.onNetworksChanged;
 
@@ -1416,7 +1315,6 @@ chrome.networkingPrivate.onNetworksChanged;
  * Fired when the list of networks has changed.  Sends a complete list of GUIDs
  * for all the current networks.
  * @type {!ChromeEvent}
- * @see https://developer.chrome.com/extensions/networkingPrivate#event-onNetworkListChanged
  */
 chrome.networkingPrivate.onNetworkListChanged;
 
@@ -1424,7 +1322,6 @@ chrome.networkingPrivate.onNetworkListChanged;
  * Fired when the list of devices has changed or any device state properties
  * have changed.
  * @type {!ChromeEvent}
- * @see https://developer.chrome.com/extensions/networkingPrivate#event-onDeviceStateListChanged
  */
 chrome.networkingPrivate.onDeviceStateListChanged;
 
@@ -1432,13 +1329,11 @@ chrome.networkingPrivate.onDeviceStateListChanged;
  * Fired when a portal detection for a network completes. Sends the guid of the
  * network and the corresponding captive portal status.
  * @type {!ChromeEvent}
- * @see https://developer.chrome.com/extensions/networkingPrivate#event-onPortalDetectionCompleted
  */
 chrome.networkingPrivate.onPortalDetectionCompleted;
 
 /**
  * Fired when any certificate list has changed.
  * @type {!ChromeEvent}
- * @see https://developer.chrome.com/extensions/networkingPrivate#event-onCertificateListsChanged
  */
 chrome.networkingPrivate.onCertificateListsChanged;
diff --git a/third_party/closure_compiler/externs/passwords_private.js b/third_party/closure_compiler/externs/passwords_private.js
index ce982ad739..af5735bdd4 100644
--- a/third_party/closure_compiler/externs/passwords_private.js
+++ b/third_party/closure_compiler/externs/passwords_private.js
@@ -18,7 +18,6 @@ chrome.passwordsPrivate = {};
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/passwordsPrivate#type-ExportProgressStatus
  */
 chrome.passwordsPrivate.ExportProgressStatus = {
   NOT_STARTED: 'NOT_STARTED',
@@ -34,7 +33,6 @@ chrome.passwordsPrivate.ExportProgressStatus = {
  *   shown: string,
  *   link: string
  * }}
- * @see https://developer.chrome.com/extensions/passwordsPrivate#type-UrlCollection
  */
 chrome.passwordsPrivate.UrlCollection;
 
@@ -43,7 +41,6 @@ chrome.passwordsPrivate.UrlCollection;
  *   urls: !chrome.passwordsPrivate.UrlCollection,
  *   username: string
  * }}
- * @see https://developer.chrome.com/extensions/passwordsPrivate#type-LoginPair
  */
 chrome.passwordsPrivate.LoginPair;
 
@@ -54,7 +51,6 @@ chrome.passwordsPrivate.LoginPair;
  *   federationText: (string|undefined),
  *   index: number
  * }}
- * @see https://developer.chrome.com/extensions/passwordsPrivate#type-PasswordUiEntry
  */
 chrome.passwordsPrivate.PasswordUiEntry;
 
@@ -63,7 +59,6 @@ chrome.passwordsPrivate.PasswordUiEntry;
  *   index: number,
  *   plaintextPassword: string
  * }}
- * @see https://developer.chrome.com/extensions/passwordsPrivate#type-PlaintextPasswordEventParameters
  */
 chrome.passwordsPrivate.PlaintextPasswordEventParameters;
 
@@ -72,7 +67,6 @@ chrome.passwordsPrivate.PlaintextPasswordEventParameters;
  *   urls: !chrome.passwordsPrivate.UrlCollection,
  *   index: number
  * }}
- * @see https://developer.chrome.com/extensions/passwordsPrivate#type-ExceptionEntry
  */
 chrome.passwordsPrivate.ExceptionEntry;
 
@@ -81,7 +75,6 @@ chrome.passwordsPrivate.ExceptionEntry;
  *   status: !chrome.passwordsPrivate.ExportProgressStatus,
  *   message: (string|undefined),
  * }}
- * @see https://developer.chrome.com/extensions/passwordsPrivate#type-PasswordExportProgress
  */
 chrome.passwordsPrivate.PasswordExportProgress;
 
@@ -89,7 +82,6 @@ chrome.passwordsPrivate.PasswordExportProgress;
  * Removes the saved password corresponding to |loginPair|. If no saved password
  * for this pair exists, this function is a no-op.
  * @param {number} index The index for the password entry being removed.
- * @see https://developer.chrome.com/extensions/passwordsPrivate#method-removeSavedPassword
  */
 chrome.passwordsPrivate.removeSavedPassword = function(index) {};
 
@@ -97,13 +89,11 @@ chrome.passwordsPrivate.removeSavedPassword = function(index) {};
  * Removes the saved password exception corresponding to |exceptionUrl|. If no
  * exception with this URL exists, this function is a no-op.
  * @param {number} index The index for the exception url entry being removed.
- * @see https://developer.chrome.com/extensions/passwordsPrivate#method-removePasswordException
  */
 chrome.passwordsPrivate.removePasswordException = function(index) {};
 
 /**
  * Undoes the last removal of a saved password or exception.
- * @see https://developer.chrome.com/extensions/passwordsPrivate#method-undoRemoveSavedPasswordOrException
  */
 chrome.passwordsPrivate.undoRemoveSavedPasswordOrException = function() {};
 
@@ -114,7 +104,6 @@ chrome.passwordsPrivate.undoRemoveSavedPasswordOrException = function() {};
  * onPlaintextPasswordRetrieved event. TODO(hcarmona): Investigate using a
  * callback for consistency.
  * @param {number} index The index for the password entry being being retrieved.
- * @see https://developer.chrome.com/extensions/passwordsPrivate#method-requestPlaintextPassword
  */
 chrome.passwordsPrivate.requestPlaintextPassword = function(index) {};
 
@@ -122,7 +111,6 @@ chrome.passwordsPrivate.requestPlaintextPassword = function(index) {};
  * Returns the list of saved passwords.
  * @param {function(!Array<!chrome.passwordsPrivate.PasswordUiEntry>):void}
  *     callback Called with the list of saved passwords.
- * @see https://developer.chrome.com/extensions/passwordsPrivate#method-getSavedPasswordList
  */
 chrome.passwordsPrivate.getSavedPasswordList = function(callback) {};
 
@@ -130,13 +118,11 @@ chrome.passwordsPrivate.getSavedPasswordList = function(callback) {};
  * Returns the list of password exceptions.
  * @param {function(!Array<!chrome.passwordsPrivate.ExceptionEntry>):void}
  *     callback Called with the list of password exceptions.
- * @see https://developer.chrome.com/extensions/passwordsPrivate#method-getPasswordExceptionList
  */
 chrome.passwordsPrivate.getPasswordExceptionList = function(callback) {};
 
 /**
  * Triggers the Password Manager password import functionality.
- * @see https://developer.chrome.com/extensions/passwordsPrivate#method-importPasswords
  */
 chrome.passwordsPrivate.importPasswords = function() {};
 
@@ -146,13 +132,11 @@ chrome.passwordsPrivate.importPasswords = function() {};
  *     callback Called with no error, if the new export request was accepted and
  *         started. If rejected, <code>chrome.runtime.lastError</code> will be
  *         set to 'in-progress'.
- * @see https://developer.chrome.com/extensions/passwordsPrivate#method-exportPasswords
  */
 chrome.passwordsPrivate.exportPasswords = function(callback) {};
 
 /**
  * Triggers the cancelling of a password export flow.
- * @see https://developer.chrome.com/extensions/passwordsPrivate#method-cancelExportPasswords
  */
 chrome.passwordsPrivate.cancelExportPasswords = function() {};
 
@@ -160,7 +144,6 @@ chrome.passwordsPrivate.cancelExportPasswords = function() {};
  * Triggers the Password Manager password export status query functionality.
  * @param {function(!chrome.passwordsPrivate.ExportProgressStatus):void}
  *     callback Called with the status of the current export.
- * @see https://developer.chrome.com/extensions/passwordsPrivate#method-requestExportProgressStatus
  */
 chrome.passwordsPrivate.requestExportProgressStatus = function(callback) {};
 
@@ -168,7 +151,6 @@ chrome.passwordsPrivate.requestExportProgressStatus = function(callback) {};
  * Fired when the saved passwords list has changed, meaning that an entry has
  * been added or removed.
  * @type {!ChromeEvent}
- * @see https://developer.chrome.com/extensions/passwordsPrivate#event-onSavedPasswordsListChanged
  */
 chrome.passwordsPrivate.onSavedPasswordsListChanged;
 
@@ -176,7 +158,6 @@ chrome.passwordsPrivate.onSavedPasswordsListChanged;
  * Fired when the password exceptions list has changed, meaning that an entry
  * has been added or removed.
  * @type {!ChromeEvent}
- * @see https://developer.chrome.com/extensions/passwordsPrivate#event-onPasswordExceptionsListChanged
  */
 chrome.passwordsPrivate.onPasswordExceptionsListChanged;
 
@@ -184,7 +165,6 @@ chrome.passwordsPrivate.onPasswordExceptionsListChanged;
  * Fired when a plaintext password has been fetched in response to a call to
  * chrome.passwordsPrivate.requestPlaintextPassword().
  * @type {!ChromeEvent}
- * @see https://developer.chrome.com/extensions/passwordsPrivate#event-onPlaintextPasswordRetrieved
  */
 chrome.passwordsPrivate.onPlaintextPasswordRetrieved;
 
@@ -192,6 +172,5 @@ chrome.passwordsPrivate.onPlaintextPasswordRetrieved;
 /**
  * Fired when status of the export has progressed.
  * @type {!ChromeEvent}
- * @see https://developer.chrome.com/extensions/passwordsPrivate#event-onPasswordsExportCompleted
  */
 chrome.passwordsPrivate.onPasswordsFileExportProgress;
diff --git a/third_party/closure_compiler/externs/quick_unlock_private.js b/third_party/closure_compiler/externs/quick_unlock_private.js
index 4229b89ef7..38d1786b6c 100644
--- a/third_party/closure_compiler/externs/quick_unlock_private.js
+++ b/third_party/closure_compiler/externs/quick_unlock_private.js
@@ -21,13 +21,11 @@ chrome.quickUnlockPrivate = {};
  *   token: string,
  *   lifetimeSeconds: number
  * }}
- * @see https://developer.chrome.com/extensions/quickUnlockPrivate#type-TokenInfo
  */
 chrome.quickUnlockPrivate.TokenInfo;
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/quickUnlockPrivate#type-QuickUnlockMode
  */
 chrome.quickUnlockPrivate.QuickUnlockMode = {
   PIN: 'PIN',
@@ -35,7 +33,6 @@ chrome.quickUnlockPrivate.QuickUnlockMode = {
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/quickUnlockPrivate#type-CredentialProblem
  */
 chrome.quickUnlockPrivate.CredentialProblem = {
   TOO_SHORT: 'TOO_SHORT',
@@ -49,7 +46,6 @@ chrome.quickUnlockPrivate.CredentialProblem = {
  *   errors: !Array<!chrome.quickUnlockPrivate.CredentialProblem>,
  *   warnings: !Array<!chrome.quickUnlockPrivate.CredentialProblem>
  * }}
- * @see https://developer.chrome.com/extensions/quickUnlockPrivate#type-CredentialCheck
  */
 chrome.quickUnlockPrivate.CredentialCheck;
 
@@ -58,7 +54,6 @@ chrome.quickUnlockPrivate.CredentialCheck;
  *   minLength: number,
  *   maxLength: number
  * }}
- * @see https://developer.chrome.com/extensions/quickUnlockPrivate#type-CredentialRequirements
  */
 chrome.quickUnlockPrivate.CredentialRequirements;
 
@@ -67,7 +62,6 @@ chrome.quickUnlockPrivate.CredentialRequirements;
  * seconds until the token expires.
  * @param {string} accountPassword The account password for the logged in user.
  * @param {function(!chrome.quickUnlockPrivate.TokenInfo):void} onComplete
- * @see https://developer.chrome.com/extensions/quickUnlockPrivate#method-getAuthToken
  */
 chrome.quickUnlockPrivate.getAuthToken = function(accountPassword, onComplete) {};
 
@@ -79,7 +73,6 @@ chrome.quickUnlockPrivate.getAuthToken = function(accountPassword, onComplete) {
  * @param {string} token The token returned by $(ref:getAuthToken).
  * @param {boolean} enabled
  * @param {function():void=} onComplete
- * @see https://developer.chrome.com/extensions/quickUnlockPrivate#method-setLockScreenEnabled
  */
 chrome.quickUnlockPrivate.setLockScreenEnabled = function(token, enabled, onComplete) {};
 
@@ -88,7 +81,6 @@ chrome.quickUnlockPrivate.setLockScreenEnabled = function(token, enabled, onComp
  * Some quick unlock modes may be disabled by policy.
  * @param {function(!Array<!chrome.quickUnlockPrivate.QuickUnlockMode>):void}
  *     onComplete
- * @see https://developer.chrome.com/extensions/quickUnlockPrivate#method-getAvailableModes
  */
 chrome.quickUnlockPrivate.getAvailableModes = function(onComplete) {};
 
@@ -97,7 +89,6 @@ chrome.quickUnlockPrivate.getAvailableModes = function(onComplete) {};
  * lock screen.
  * @param {function(!Array<!chrome.quickUnlockPrivate.QuickUnlockMode>):void}
  *     onComplete
- * @see https://developer.chrome.com/extensions/quickUnlockPrivate#method-getActiveModes
  */
 chrome.quickUnlockPrivate.getActiveModes = function(onComplete) {};
 
@@ -110,7 +101,6 @@ chrome.quickUnlockPrivate.getActiveModes = function(onComplete) {};
  * @param {function(!chrome.quickUnlockPrivate.CredentialCheck):void} onComplete
  *     Called with a list of warnings and errors the given     |credential| has
  *     (or an empty list if there are none).
- * @see https://developer.chrome.com/extensions/quickUnlockPrivate#method-checkCredential
  */
 chrome.quickUnlockPrivate.checkCredential = function(mode, credential, onComplete) {};
 
@@ -121,7 +111,6 @@ chrome.quickUnlockPrivate.checkCredential = function(mode, credential, onComplet
  * @param {function(!chrome.quickUnlockPrivate.CredentialRequirements):void}
  *     onComplete Called with the credential requirements of the given
  *     |mode|.
- * @see https://developer.chrome.com/extensions/quickUnlockPrivate#method-getCredentialRequirements
  */
 chrome.quickUnlockPrivate.getCredentialRequirements = function(mode, onComplete) {};
 
@@ -136,13 +125,11 @@ chrome.quickUnlockPrivate.getCredentialRequirements = function(mode, onComplete)
  * @param {function():void} onComplete Called with true if the quick unlock
  *     state was updated,     false otherwise. The update is treated as a single
  *     atomic operation.
- * @see https://developer.chrome.com/extensions/quickUnlockPrivate#method-setModes
  */
 chrome.quickUnlockPrivate.setModes = function(token, modes, credentials, onComplete) {};
 
 /**
  * Called after the active set of quick unlock modes has changed.
  * @type {!ChromeEvent}
- * @see https://developer.chrome.com/extensions/quickUnlockPrivate#event-onActiveModesChanged
  */
 chrome.quickUnlockPrivate.onActiveModesChanged;
diff --git a/third_party/closure_compiler/externs/safe_browsing_private.js b/third_party/closure_compiler/externs/safe_browsing_private.js
index 48e7ef89d4..d11808b9ef 100644
--- a/third_party/closure_compiler/externs/safe_browsing_private.js
+++ b/third_party/closure_compiler/externs/safe_browsing_private.js
@@ -22,7 +22,6 @@ chrome.safeBrowsingPrivate = {};
  *   userName: string,
  *   isPhishing: boolean
  * }}
- * @see https://developer.chrome.com/extensions/safeBrowsingPrivate#type-PolicySpecifiedPasswordReuse
  */
 chrome.safeBrowsingPrivate.PolicySpecifiedPasswordReuse;
 
@@ -33,7 +32,6 @@ chrome.safeBrowsingPrivate.PolicySpecifiedPasswordReuse;
  *   sha256: string,
  *   userName: (string|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/safeBrowsingPrivate#type-DangerousDownloadInfo
  */
 chrome.safeBrowsingPrivate.DangerousDownloadInfo;
 
@@ -43,41 +41,35 @@ chrome.safeBrowsingPrivate.DangerousDownloadInfo;
  *   reason: string,
  *   netErrorCode: (number|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/safeBrowsingPrivate#type-InterstitialInfo
  */
 chrome.safeBrowsingPrivate.InterstitialInfo;
 
 /**
  * Fired when Chrome detects a reuse of a policy specified password.
  * @type {!ChromeEvent}
- * @see https://developer.chrome.com/extensions/safeBrowsingPrivate#event-onPolicySpecifiedPasswordReuseDetected
  */
 chrome.safeBrowsingPrivate.onPolicySpecifiedPasswordReuseDetected;
 
 /**
  * Fired when the user changed their policy specified password.
  * @type {!ChromeEvent}
- * @see https://developer.chrome.com/extensions/safeBrowsingPrivate#event-onPolicySpecifiedPasswordChanged
  */
 chrome.safeBrowsingPrivate.onPolicySpecifiedPasswordChanged;
 
 /**
  * Fired when the user opened a dangerous download.
  * @type {!ChromeEvent}
- * @see https://developer.chrome.com/extensions/safeBrowsingPrivate#event-onDangerousDownloadOpened
  */
 chrome.safeBrowsingPrivate.onDangerousDownloadOpened;
 
 /**
  * Fired when a security interstitial is shown to the user.
  * @type {!ChromeEvent}
- * @see https://developer.chrome.com/extensions/safeBrowsingPrivate#event-onInterstitialShown
  */
 chrome.safeBrowsingPrivate.onInterstitialShown;
 
 /**
  * Fired when the user clicked-through a security interstitial.
  * @type {!ChromeEvent}
- * @see https://developer.chrome.com/extensions/safeBrowsingPrivate#event-onInterstitialProceeded
  */
 chrome.safeBrowsingPrivate.onInterstitialProceeded;
diff --git a/third_party/closure_compiler/externs/settings_private.js b/third_party/closure_compiler/externs/settings_private.js
index f62dd3fa7a..a95a2ff183 100644
--- a/third_party/closure_compiler/externs/settings_private.js
+++ b/third_party/closure_compiler/externs/settings_private.js
@@ -18,7 +18,6 @@ chrome.settingsPrivate = {};
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/settingsPrivate#type-PrefType
  */
 chrome.settingsPrivate.PrefType = {
   BOOLEAN: 'BOOLEAN',
@@ -31,7 +30,6 @@ chrome.settingsPrivate.PrefType = {
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/settingsPrivate#type-ControlledBy
  */
 chrome.settingsPrivate.ControlledBy = {
   DEVICE_POLICY: 'DEVICE_POLICY',
@@ -43,7 +41,6 @@ chrome.settingsPrivate.ControlledBy = {
 
 /**
  * @enum {string}
- * @see https://developer.chrome.com/extensions/settingsPrivate#type-Enforcement
  */
 chrome.settingsPrivate.Enforcement = {
   ENFORCED: 'ENFORCED',
@@ -62,7 +59,6 @@ chrome.settingsPrivate.Enforcement = {
  *   extensionId: (string|undefined),
  *   extensionCanBeDisabled: (boolean|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/settingsPrivate#type-PrefObject
  */
 chrome.settingsPrivate.PrefObject;
 
@@ -73,14 +69,12 @@ chrome.settingsPrivate.PrefObject;
  * @param {string} pageId The user metrics identifier or null.
  * @param {function(boolean):void} callback The callback for whether the pref
  *     was set or not.
- * @see https://developer.chrome.com/extensions/settingsPrivate#method-setPref
  */
 chrome.settingsPrivate.setPref = function(name, value, pageId, callback) {};
 
 /**
  * Gets an array of all the prefs.
  * @param {function(!Array<!chrome.settingsPrivate.PrefObject>):void} callback
- * @see https://developer.chrome.com/extensions/settingsPrivate#method-getAllPrefs
  */
 chrome.settingsPrivate.getAllPrefs = function(callback) {};
 
@@ -88,7 +82,6 @@ chrome.settingsPrivate.getAllPrefs = function(callback) {};
  * Gets the value of a specific pref.
  * @param {string} name
  * @param {function(!chrome.settingsPrivate.PrefObject):void} callback
- * @see https://developer.chrome.com/extensions/settingsPrivate#method-getPref
  */
 chrome.settingsPrivate.getPref = function(name, callback) {};
 
@@ -96,7 +89,6 @@ chrome.settingsPrivate.getPref = function(name, callback) {};
  * Gets the default page zoom factor. Possible values are currently between 0.25
  * and 5. For a full list, see zoom::kPresetZoomFactors.
  * @param {function(number):void} callback
- * @see https://developer.chrome.com/extensions/settingsPrivate#method-getDefaultZoom
  */
 chrome.settingsPrivate.getDefaultZoom = function(callback) {};
 
@@ -105,7 +97,6 @@ chrome.settingsPrivate.getDefaultZoom = function(callback) {};
  * zoom::kPresetZoomFactors.
  * @param {number} zoom
  * @param {function(boolean):void=} callback
- * @see https://developer.chrome.com/extensions/settingsPrivate#method-setDefaultZoom
  */
 chrome.settingsPrivate.setDefaultZoom = function(zoom, callback) {};
 
@@ -113,6 +104,5 @@ chrome.settingsPrivate.setDefaultZoom = function(zoom, callback) {};
  * <p>Fired when a set of prefs has changed.</p><p>|prefs| The prefs that
  * changed.</p>
  * @type {!ChromeEvent}
- * @see https://developer.chrome.com/extensions/settingsPrivate#event-onPrefsChanged
  */
 chrome.settingsPrivate.onPrefsChanged;
diff --git a/third_party/closure_compiler/externs/users_private.js b/third_party/closure_compiler/externs/users_private.js
index c7338c5310..57bb0c0b58 100644
--- a/third_party/closure_compiler/externs/users_private.js
+++ b/third_party/closure_compiler/externs/users_private.js
@@ -25,14 +25,12 @@ chrome.usersPrivate = {};
  *   isSupervised: boolean,
  *   isChild: boolean
  * }}
- * @see https://developer.chrome.com/extensions/usersPrivate#type-User
  */
 chrome.usersPrivate.User;
 
 /**
  * Gets a list of the currently whitelisted users.
  * @param {function(!Array<!chrome.usersPrivate.User>):void} callback
- * @see https://developer.chrome.com/extensions/usersPrivate#method-getWhitelistedUsers
  */
 chrome.usersPrivate.getWhitelistedUsers = function(callback) {};
 
@@ -42,7 +40,6 @@ chrome.usersPrivate.getWhitelistedUsers = function(callback) {};
  * because the user was already present, or the current user isn't the owner).
  * @param {string} email
  * @param {function(boolean):void} callback
- * @see https://developer.chrome.com/extensions/usersPrivate#method-addWhitelistedUser
  */
 chrome.usersPrivate.addWhitelistedUser = function(email, callback) {};
 
@@ -53,20 +50,17 @@ chrome.usersPrivate.addWhitelistedUser = function(email, callback) {};
  * owner).
  * @param {string} email
  * @param {function(boolean):void} callback
- * @see https://developer.chrome.com/extensions/usersPrivate#method-removeWhitelistedUser
  */
 chrome.usersPrivate.removeWhitelistedUser = function(email, callback) {};
 
 /**
  * Whether the whitelist is managed by enterprise.
  * @param {function(boolean):void} callback
- * @see https://developer.chrome.com/extensions/usersPrivate#method-isWhitelistManaged
  */
 chrome.usersPrivate.isWhitelistManaged = function(callback) {};
 
 /**
  * Returns the current user.
  * @param {function(!chrome.usersPrivate.User):void} callback
- * @see https://developer.chrome.com/extensions/usersPrivate#method-getCurrentUser
  */
 chrome.usersPrivate.getCurrentUser = function(callback) {};