From 8806668465bfa7f8fea8f4cf94aca10e535832b1 Mon Sep 17 00:00:00 2001
From: Tatiana Kapos <tatianakapos@microsoft.com>
Date: Fri, 11 Apr 2025 10:42:09 -0700
Subject: [PATCH 01/13] merge in folly 2024.10.14.00

---
 vnext/Directory.Build.props                   |    4 +-
 vnext/Folly/Folly.vcxproj                     |    1 +
 .../TEMP_UntilFollyUpdate/ConstexprMath.h     | 1886 +++++------
 .../Folly/TEMP_UntilFollyUpdate/dynamic-inl.h | 2767 ++++++++---------
 vnext/Folly/TEMP_UntilFollyUpdate/json.cpp    | 2191 ++++++-------
 .../TEMP_UntilFollyUpdate/lang/SafeAssert.h   |  333 +-
 .../TEMP_UntilFollyUpdate/lang/ToAscii.h      |   10 +-
 vnext/Folly/cgmanifest.json                   |    2 +-
 .../packages.lock.json                        |   73 +-
 9 files changed, 3602 insertions(+), 3665 deletions(-)

diff --git a/vnext/Directory.Build.props b/vnext/Directory.Build.props
index 51977c2e25c..eede3d0724b 100644
--- a/vnext/Directory.Build.props
+++ b/vnext/Directory.Build.props
@@ -20,8 +20,8 @@
     <EnableSourceLink Condition="'$(EnableSourceLink)' == '' AND '$(BuildingInRnwRepo)' == 'true'">true</EnableSourceLink>
     <EnableSourceLink Condition="'$(EnableSourceLink)' == ''">false</EnableSourceLink>
     <!-- When bumping the Folly version, be sure to bump the git hash of that version's commit and build Folly.vcxproj (to update its cgmanifest.json) too. -->
-    <FollyVersion>2024.01.01.00</FollyVersion>
-    <FollyCommitHash>234d39a36a43106747d10cc19efada72fd810dd3</FollyCommitHash>
+    <FollyVersion>2024.10.14.00</FollyVersion>
+    <FollyCommitHash>ad90720829db5ba0c3d0e44994856dcce33d7940</FollyCommitHash>
     <!-- When bumping the fmt version, be sure to bump the git hash of that version's commit and build fmt.vcxproj (to update its cgmanifest.json) too. -->
     <FmtVersion>10.1.0</FmtVersion>
     <FmtCommitHash>ca2e3685b160617d3d95fcd9e789c4e06ca88</FmtCommitHash>
diff --git a/vnext/Folly/Folly.vcxproj b/vnext/Folly/Folly.vcxproj
index ab9d5344d55..9c6c9f06d78 100644
--- a/vnext/Folly/Folly.vcxproj
+++ b/vnext/Folly/Folly.vcxproj
@@ -219,6 +219,7 @@
     <ClInclude Include="$(FollyDir)\folly\SpinLock.h" />
     <ClInclude Include="$(FollyDir)\folly\stop_watch.h" />
     <ClInclude Include="$(FollyDir)\folly\String-inl.h" />
+    <ClInclude Include="$(FollyDir)\hash\MurmurHash.h" />
     <ClInclude Include="$(FollyDir)\folly\String.h" />
     <ClInclude Include="$(FollyDir)\folly\Subprocess.h" />
     <ClInclude Include="$(FollyDir)\folly\Synchronized.h" />
diff --git a/vnext/Folly/TEMP_UntilFollyUpdate/ConstexprMath.h b/vnext/Folly/TEMP_UntilFollyUpdate/ConstexprMath.h
index 707eb604e8f..3eeacc95f8b 100644
--- a/vnext/Folly/TEMP_UntilFollyUpdate/ConstexprMath.h
+++ b/vnext/Folly/TEMP_UntilFollyUpdate/ConstexprMath.h
@@ -14,247 +14,239 @@
  * limitations under the License.
  */
 
-#pragma once
-
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <functional>
-#include <limits>
-#include <type_traits>
-
-#include <folly/Portability.h>
-
-namespace folly {
-
-/// numbers
-///
-/// mimic: std::numbers, C++20 (partial)
-namespace numbers {
-
-namespace detail {
-template <typename T>
-using enable_if_floating_t =
-    std::enable_if_t<std::is_floating_point<T>::value, T>;
-}
-
-/// e_v
-///
-/// mimic: std::numbers::e_v, C++20
-template <typename T>
-FOLLY_INLINE_VARIABLE constexpr T e_v = detail::enable_if_floating_t<T>(
-    2.71828182845904523536028747135266249775724709369995L);
-
-/// ln2_v
-///
-/// mimic: std::numbers::ln2_v, C++20
-template <typename T>
-FOLLY_INLINE_VARIABLE constexpr T ln2_v = detail::enable_if_floating_t<T>(
-    0.69314718055994530941723212145817656807550013436025L);
-
-/// e
-///
-/// mimic: std::numbers::e, C++20
-FOLLY_INLINE_VARIABLE constexpr double e = e_v<double>;
-
-/// ln2
-///
-/// mimic: std::numbers::ln2, C++20
-FOLLY_INLINE_VARIABLE constexpr double ln2 = ln2_v<double>;
-
-} // namespace numbers
-
-/// floating_point_integral_constant
-///
-/// Like std::integral_constant but for floating-point types holding integral
-/// values representable in an integral type.
-template <typename T, typename S, S Value>
-struct floating_point_integral_constant {
-  using value_type = T;
-  static constexpr value_type value = static_cast<value_type>(Value);
-  constexpr operator value_type() const noexcept { return value; }
-  constexpr value_type operator()() const noexcept { return value; }
-};
-#if FOLLY_CPLUSPLUS < 201703L
-template <typename T, typename S, S Value>
-constexpr typename floating_point_integral_constant<T, S, Value>::value_type
-    floating_point_integral_constant<T, S, Value>::value;
-#endif
-
-//  ----
-
-namespace detail {
-
-template <typename T>
-constexpr size_t constexpr_iterated_squares_desc_size_(T const base) {
-  using lim = std::numeric_limits<T>;
-  size_t s = 1;
-  auto r = base;
-  while (r <= lim::max() / r) {
-    ++s;
-    r *= r;
-  }
-  return s;
-}
-
-} // namespace detail
-
-/// constexpr_iterated_squares_desc_size_v
-///
-/// Effectively calculates: floor(log(max_exponent)/log(base))
-///
-/// For use with constexpr_iterated_squares_desc below.
-template <typename Base>
-FOLLY_INLINE_VARIABLE constexpr size_t constexpr_iterated_squares_desc_size_v =
-    detail::constexpr_iterated_squares_desc_size_(Base::value);
-
-/// constexpr_iterated_squares_desc
-///
-/// A constexpr scaling array of integer powers-of-powers-of-two, descending,
-/// with the associated powers-of-two.
-///
-/// scaling = [..., {8, b^8}, {4, b^4}, {2, b^2}, {1, b^1}] for b = base
-///
-/// Includes select constexpr scaling algorithms based on the scaling array.
-///
-/// The scaling array and the scaling algorithms are general-purpose, if niche.
-/// They may be used by other constexpr math functions (floating-point) either
-/// to improve runtime performance or to improve numerical approximations.
-///
-/// Some compilers fail to support passing some types as non-type template
-/// params. In particular, long double is not universally supported. Therefore,
-/// this utility takes its base as a type rather than as a value. For floating-
-/// point integral bases, that is, bases of floating-point type but of integral
-/// value, floating_point_integral_constant is the easiest parameterization.
-template <typename T, std::size_t Size>
-struct constexpr_iterated_squares_desc {
-  static_assert(Size > 0, "requires non-zero size");
-
-  using size_type = decltype(Size);
-  using base_type = T;
-
-  struct item_type {
-    size_type power;
-    base_type scale;
-  };
-
-  static constexpr size_type size = Size;
-  base_type base;
-  item_type scaling[size];
-
- private:
-  using lim = std::numeric_limits<base_type>;
-
-  static_assert(
-      lim::max_exponent < std::numeric_limits<size_type>::max(),
-      "size_type too small for base_type");
-
- public:
-  explicit constexpr constexpr_iterated_squares_desc(base_type r) noexcept
-      : base{r}, scaling{} {
-    assert(size <= detail::constexpr_iterated_squares_desc_size_(base));
-    size_type i = 0;
-    size_type p = 1;
-    while (true) { // a for-loop might cause multiplication overflow below
-      scaling[size - 1 - i] = {p, r};
-      if (++i == size) {
-        break;
-      }
-      p *= 2;
-      r *= r;
-    }
-  }
-
-  /// shrink
-  ///
-  /// Returns scaling params of the form:
-  ///   item_type{power, scale} with scale = base ^ power
-  /// With power the smallest nonnegative integer such that:
-  ///   abs(num) / scale <= max
-  constexpr item_type shrink(base_type const num, base_type const max) const {
-    assert(max > base_type(0));
-    auto const rmax = max / base;
-    auto const snum = num < base_type(0) ? -num : num;
-    auto power = size_type(0);
-    auto scale = base_type(1);
-    if (!(snum / scale <= max)) {
-      for (auto const& i : scaling) {
-        auto const next = scale * i.scale;
-        auto const div = snum / next;
-        if (div <= rmax) {
-          continue;
-        }
-        power += i.power;
-        scale = next;
-        if (div <= max) {
-          break;
-        }
-      }
-    }
-    assert(snum / scale <= max);
-    return {power, scale};
-  }
-
-  /// growth
-  ///
-  /// Returns scaling params of the form:
-  ///   item_type{power, scale} with scale = base ^ power
-  /// With power the smallest nonnegative integer such that:
-  ///   abs(num) * scale >= min
-  constexpr item_type growth(base_type const num, base_type const min) const {
-    assert(min > base_type(0));
-    auto const rmin = min * base;
-    auto const snum = num < base_type(0) ? -num : num;
-    auto power = size_type(0);
-    auto scale = base_type(1);
-    if (!(snum * scale >= min)) {
-      for (auto const& i : scaling) {
-        auto const next = scale * i.scale;
-        auto const mul = snum * next;
-        if (mul >= rmin) {
-          continue;
-        }
-        power += i.power;
-        scale = next;
-        if (mul >= min) {
-          break;
-        }
-      }
-    }
-    assert(snum * scale >= min);
-    return {power, scale};
-  }
-};
-#if FOLLY_CPLUSPLUS < 201703L
-template <typename T, std::size_t Size>
-constexpr typename constexpr_iterated_squares_desc<T, Size>::size_type
-    constexpr_iterated_squares_desc<T, Size>::size;
-#endif
-
-/// constexpr_iterated_squares_desc_v
-///
-/// An instance of constexpr_iterated_squares_desc of max size with the given
-/// base.
-template <typename Base>
-FOLLY_INLINE_VARIABLE constexpr auto constexpr_iterated_squares_desc_v =
-    constexpr_iterated_squares_desc<
-        typename Base::value_type,
-        constexpr_iterated_squares_desc_size_v<Base>>{Base::value};
-
-/// constexpr_iterated_squares_desc_2_v
-///
-/// An alias for constexpr_iterated_squares_desc_v with base 2, which is the
-/// most common base to use with iterated-squares.
-template <typename T>
-constexpr auto& constexpr_iterated_squares_desc_2_v =
-    constexpr_iterated_squares_desc_v<
-        floating_point_integral_constant<T, int, 2>>;
-
-// TLDR: Prefer using operator< for ordering. And when
-// a and b are equivalent objects, we return b to make
-// sorting stable.
-// See http://stepanovpapers.com/notes.pdf for details.
-template <typename T, typename... Ts>
+ #pragma once
+
+ #include <cassert>
+ #include <cstddef>
+ #include <cstdint>
+ #include <functional>
+ #include <limits>
+ #include <type_traits>
+ 
+ #include <folly/Portability.h>
+ #include <folly/lang/CheckedMath.h>
+ #include <folly/portability/Constexpr.h>
+ 
+ namespace folly {
+ 
+ /// numbers
+ ///
+ /// mimic: std::numbers, C++20 (partial)
+ namespace numbers {
+ 
+ namespace detail {
+ template <typename T>
+ using enable_if_floating_t =
+     std::enable_if_t<std::is_floating_point<T>::value, T>;
+ }
+ 
+ /// e_v
+ ///
+ /// mimic: std::numbers::e_v, C++20
+ template <typename T>
+ inline constexpr T e_v = detail::enable_if_floating_t<T>(
+     2.71828182845904523536028747135266249775724709369995L);
+ 
+ /// ln2_v
+ ///
+ /// mimic: std::numbers::ln2_v, C++20
+ template <typename T>
+ inline constexpr T ln2_v = detail::enable_if_floating_t<T>(
+     0.69314718055994530941723212145817656807550013436025L);
+ 
+ /// e
+ ///
+ /// mimic: std::numbers::e, C++20
+ inline constexpr double e = e_v<double>;
+ 
+ /// ln2
+ ///
+ /// mimic: std::numbers::ln2, C++20
+ inline constexpr double ln2 = ln2_v<double>;
+ 
+ } // namespace numbers
+ 
+ /// floating_point_integral_constant
+ ///
+ /// Like std::integral_constant but for floating-point types holding integral
+ /// values representable in an integral type.
+ template <typename T, typename S, S Value>
+ struct floating_point_integral_constant {
+   using value_type = T;
+   static constexpr value_type value = static_cast<value_type>(Value);
+   constexpr operator value_type() const noexcept { return value; }
+   constexpr value_type operator()() const noexcept { return value; }
+ };
+ 
+ //  ----
+ 
+ namespace detail {
+ 
+ template <typename T>
+ constexpr size_t constexpr_iterated_squares_desc_size_(T const base) {
+   using lim = std::numeric_limits<T>;
+   size_t s = 1;
+   auto r = base;
+   while (r <= lim::max() / r) {
+     ++s;
+     r *= r;
+   }
+   return s;
+ }
+ 
+ } // namespace detail
+ 
+ /// constexpr_iterated_squares_desc_size_v
+ ///
+ /// Effectively calculates: floor(log(max_exponent)/log(base))
+ ///
+ /// For use with constexpr_iterated_squares_desc below.
+ template <typename Base>
+ inline constexpr size_t constexpr_iterated_squares_desc_size_v =
+     detail::constexpr_iterated_squares_desc_size_(Base::value);
+ 
+ /// constexpr_iterated_squares_desc
+ ///
+ /// A constexpr scaling array of integer powers-of-powers-of-two, descending,
+ /// with the associated powers-of-two.
+ ///
+ /// scaling = [..., {8, b^8}, {4, b^4}, {2, b^2}, {1, b^1}] for b = base
+ ///
+ /// Includes select constexpr scaling algorithms based on the scaling array.
+ ///
+ /// The scaling array and the scaling algorithms are general-purpose, if niche.
+ /// They may be used by other constexpr math functions (floating-point) either
+ /// to improve runtime performance or to improve numerical approximations.
+ ///
+ /// Some compilers fail to support passing some types as non-type template
+ /// params. In particular, long double is not universally supported. Therefore,
+ /// this utility takes its base as a type rather than as a value. For floating-
+ /// point integral bases, that is, bases of floating-point type but of integral
+ /// value, floating_point_integral_constant is the easiest parameterization.
+ template <typename T, std::size_t Size>
+ struct constexpr_iterated_squares_desc {
+   static_assert(Size > 0, "requires non-zero size");
+ 
+   using size_type = decltype(Size);
+   using base_type = T;
+ 
+   struct item_type {
+     size_type power;
+     base_type scale;
+   };
+ 
+   static constexpr size_type size = Size;
+   base_type base;
+   item_type scaling[size];
+ 
+  private:
+   using lim = std::numeric_limits<base_type>;
+ 
+   static_assert(
+       lim::max_exponent < std::numeric_limits<size_type>::max(),
+       "size_type too small for base_type");
+ 
+  public:
+   explicit constexpr constexpr_iterated_squares_desc(base_type r) noexcept
+       : base{r}, scaling{} {
+     assert(size <= detail::constexpr_iterated_squares_desc_size_(base));
+     size_type i = 0;
+     size_type p = 1;
+     while (true) { // a for-loop might cause multiplication overflow below
+       scaling[size - 1 - i] = {p, r};
+       if (++i == size) {
+         break;
+       }
+       p *= 2;
+       r *= r;
+     }
+   }
+ 
+   /// shrink
+   ///
+   /// Returns scaling params of the form:
+   ///   item_type{power, scale} with scale = base ^ power
+   /// With power the smallest nonnegative integer such that:
+   ///   abs(num) / scale <= max
+   constexpr item_type shrink(base_type const num, base_type const max) const {
+     assert(max > base_type(0));
+     auto const rmax = max / base;
+     auto const snum = num < base_type(0) ? -num : num;
+     auto power = size_type(0);
+     auto scale = base_type(1);
+     if (!(snum / scale <= max)) {
+       for (auto const& i : scaling) {
+         auto const next = scale * i.scale;
+         auto const div = snum / next;
+         if (div <= rmax) {
+           continue;
+         }
+         power += i.power;
+         scale = next;
+         if (div <= max) {
+           break;
+         }
+       }
+     }
+     assert(snum / scale <= max);
+     return {power, scale};
+   }
+ 
+   /// growth
+   ///
+   /// Returns scaling params of the form:
+   ///   item_type{power, scale} with scale = base ^ power
+   /// With power the smallest nonnegative integer such that:
+   ///   abs(num) * scale >= min
+   constexpr item_type growth(base_type const num, base_type const min) const {
+     assert(min > base_type(0));
+     auto const rmin = min * base;
+     auto const snum = num < base_type(0) ? -num : num;
+     auto power = size_type(0);
+     auto scale = base_type(1);
+     if (!(snum * scale >= min)) {
+       for (auto const& i : scaling) {
+         auto const next = scale * i.scale;
+         auto const mul = snum * next;
+         if (mul >= rmin) {
+           continue;
+         }
+         power += i.power;
+         scale = next;
+         if (mul >= min) {
+           break;
+         }
+       }
+     }
+     assert(snum * scale >= min);
+     return {power, scale};
+   }
+ };
+ 
+ /// constexpr_iterated_squares_desc_v
+ ///
+ /// An instance of constexpr_iterated_squares_desc of max size with the given
+ /// base.
+ template <typename Base>
+ inline constexpr auto constexpr_iterated_squares_desc_v =
+     constexpr_iterated_squares_desc<
+         typename Base::value_type,
+         constexpr_iterated_squares_desc_size_v<Base>>{Base::value};
+ 
+ /// constexpr_iterated_squares_desc_2_v
+ ///
+ /// An alias for constexpr_iterated_squares_desc_v with base 2, which is the
+ /// most common base to use with iterated-squares.
+ template <typename T>
+ constexpr auto& constexpr_iterated_squares_desc_2_v =
+     constexpr_iterated_squares_desc_v<
+         floating_point_integral_constant<T, int, 2>>;
+ 
+ // TLDR: Prefer using operator< for ordering. And when
+ // a and b are equivalent objects, we return b to make
+ // sorting stable.
+ // See http://stepanovpapers.com/notes.pdf for details.
+ template <typename T, typename... Ts>
 constexpr T constexpr_max(T a, Ts... ts) {
   T list[] = {ts..., a}; // 0-length arrays are illegal
   // [Windows #12703 - Fix folly CodeQL issues]
@@ -263,708 +255,724 @@ constexpr T constexpr_max(T a, Ts... ts) {
   }
   return a;
 }
-
-// When a and b are equivalent objects, we return a to
-// make sorting stable.
-template <typename T, typename... Ts>
-constexpr T constexpr_min(T a, Ts... ts) {
+ 
+ // When a and b are equivalent objects, we return a to
+ // make sorting stable.
+ template <typename T, typename... Ts>
+ constexpr T constexpr_min(T a, Ts... ts) {
   T list[] = {ts..., a}; // 0-length arrays are illegal
   // [Windows #12703 - Fix folly CodeQL issues]
   for (size_t i = 0; i < sizeof...(Ts); ++i) {
     a = list[i] < a ? list[i] : a;
   }
   return a;
-}
-
-template <typename T, typename Less>
-constexpr T const& constexpr_clamp(
-    T const& v, T const& lo, T const& hi, Less less) {
-  T const& a = less(v, lo) ? lo : v;
-  T const& b = less(hi, a) ? hi : a;
-  return b;
-}
-template <typename T>
-constexpr T const& constexpr_clamp(T const& v, T const& lo, T const& hi) {
-  return constexpr_clamp(v, lo, hi, std::less<T>{});
-}
-
-template <typename T>
-constexpr bool constexpr_isnan(T const t) {
-  return t != t; // NOLINT
-}
-
-namespace detail {
-
-template <typename T, typename = void>
-struct constexpr_abs_helper {};
-
-template <typename T>
-struct constexpr_abs_helper<
-    T,
-    typename std::enable_if<std::is_floating_point<T>::value>::type> {
-  static constexpr T go(T t) { return t < static_cast<T>(0) ? -t : t; }
-};
-
-template <typename T>
-struct constexpr_abs_helper<
-    T,
-    typename std::enable_if<
-        std::is_integral<T>::value && !std::is_same<T, bool>::value &&
-        std::is_unsigned<T>::value>::type> {
-  static constexpr T go(T t) { return t; }
-};
-
-template <typename T>
-struct constexpr_abs_helper<
-    T,
-    typename std::enable_if<
-        std::is_integral<T>::value && !std::is_same<T, bool>::value &&
-        std::is_signed<T>::value>::type> {
-  static constexpr typename std::make_unsigned<T>::type go(T t) {
-    return typename std::make_unsigned<T>::type(t < static_cast<T>(0) ? -t : t);
-  }
-};
-
-} // namespace detail
-
-template <typename T>
-constexpr auto constexpr_abs(T t)
-    -> decltype(detail::constexpr_abs_helper<T>::go(t)) {
-  return detail::constexpr_abs_helper<T>::go(t);
-}
-
-namespace detail {
-
-template <typename T>
-constexpr T constexpr_log2_(T a, T e) {
-  return e == T(1) ? a : constexpr_log2_(a + T(1), e / T(2));
-}
-
-template <typename T>
-constexpr T constexpr_log2_ceil_(T l2, T t) {
-  return l2 + T(T(1) << l2 < t ? 1 : 0);
-}
-
-} // namespace detail
-
-template <typename T>
-constexpr T constexpr_log2(T t) {
-  return detail::constexpr_log2_(T(0), t);
-}
-
-template <typename T>
-constexpr T constexpr_log2_ceil(T t) {
-  return detail::constexpr_log2_ceil_(constexpr_log2(t), t);
-}
-
-/// constexpr_trunc
-///
-/// mimic: std::trunc (C++23)
-template <
-    typename T,
-    std::enable_if_t<std::is_floating_point<T>::value, int> = 0>
-constexpr T constexpr_trunc(T const t) {
-  using lim = std::numeric_limits<T>;
-  using int_type = std::uintmax_t;
-  using int_lim = std::numeric_limits<int_type>;
-  static_assert(lim::radix == 2, "non-binary radix");
-  static_assert(lim::digits <= int_lim::digits, "overwide mantissa");
-  constexpr auto bound = static_cast<T>(std::uintmax_t(1) << (lim::digits - 1));
-  auto const neg = !constexpr_isnan(t) && t < T(0);
-  auto const s = neg ? -t : t;
-  if (constexpr_isnan(t) || t == T(0) || !(s < bound)) {
-    return t;
-  }
-  if (s < T(1)) {
-    return neg ? -T(0) : T(0);
-  }
-  auto const r = static_cast<T>(static_cast<int_type>(s));
-  return neg ? -r : r;
-}
-
-template <typename T, std::enable_if_t<std::is_integral<T>::value, int> = 0>
-constexpr T constexpr_trunc(T const t) {
-  return t;
-}
-
-/// constexpr_round
-///
-/// mimic: std::round (C++23)
-template <typename T>
-constexpr T constexpr_round(T const t) {
-  constexpr auto half = T(1) / T(2);
-  auto const same = constexpr_isnan(t) || t == T(0);
-  return same ? t : constexpr_trunc(t < T(0) ? t - half : t + half);
-}
-
-/// constexpr_floor
-///
-/// mimic: std::floor (C++23)
-template <typename T>
-constexpr T constexpr_floor(T const t) {
-  auto const s = constexpr_trunc(t);
-  return t < s ? s - T(1) : s;
-}
-
-/// constexpr_ceil
-///
-/// mimic: std::ceil (C++23)
-template <typename T>
-constexpr T constexpr_ceil(T const t) {
-  auto const s = constexpr_trunc(t);
-  return s < t ? s + T(1) : s;
-}
-
-/// constexpr_ceil
-///
-/// The least integer at least t that round divides.
-template <typename T>
-constexpr T constexpr_ceil(T t, T round) {
-  return round == T(0)
-      ? t
-      : ((t + (t < T(0) ? T(0) : round - T(1))) / round) * round;
-}
-
-/// constexpr_mult
-///
-/// Multiply two values, allowing for constexpr floating-pooint overflow to
-/// infinity.
-template <typename T>
-constexpr T constexpr_mult(T const a, T const b) {
-  using lim = std::numeric_limits<T>;
-  if (constexpr_isnan(a) || constexpr_isnan(b)) {
-    return constexpr_isnan(a) ? a : b;
-  }
-  if (std::is_floating_point<T>::value) {
-    constexpr auto inf = lim::infinity();
-    auto const ax = constexpr_abs(a);
-    auto const bx = constexpr_abs(b);
-    if ((ax == T(0) && bx == inf) || (bx == T(0) && ax == inf)) {
-      return lim::quiet_NaN();
-    }
-    // floating-point multiplication overflow, ie where multiplication of two
-    // finite values overflows to infinity of either sign, is not constexpr per
-    // gcc
-    // floating-point division overflow, ie where division of two finite values
-    // overflows to infinity of either sign, is not constexpr per gcc
-    // floating-point division by zero is not constexpr per any compiler, but we
-    // use it in the checks for the other two conditions
-    if (ax != inf && bx != inf && T(1) < bx && lim::max() / bx < ax) {
-      auto const a_neg = static_cast<bool>(a < T(0));
-      auto const b_neg = static_cast<bool>(b < T(0));
-      auto const sign = a_neg == b_neg ? T(1) : T(-1);
-      return sign * inf;
-    }
-  }
-  return a * b;
-}
-
-namespace detail {
-
-template <
-    typename T,
-    typename E,
-    std::enable_if_t<std::is_signed<E>::value, int> = 1>
-constexpr T constexpr_ipow(T const base, E const exp) {
-  if (std::is_floating_point<T>::value) {
-    if (exp < E(0)) {
-      return T(1) / constexpr_ipow(base, -exp);
-    }
-    if (exp == E(0)) {
-      return T(1);
-    }
-    if (constexpr_isnan(base)) {
-      return base;
-    }
-  }
-  assert(!(exp < E(0)) && "negative exponent with integral base");
-  if (exp == E(0)) {
-    return T(1);
-  }
-  if (exp == E(1)) {
-    return base;
-  }
-  auto const hexp = constexpr_trunc(exp / E(2));
-  auto const div = constexpr_ipow(base, hexp);
-  auto const rem = hexp * E(2) == exp ? T(1) : base;
-  return constexpr_mult(constexpr_mult(div, div), rem);
-}
-
-template <
-    typename T,
-    typename E,
-    std::enable_if_t<std::is_unsigned<E>::value, int> = 1>
-constexpr T constexpr_ipow(T const base, E const exp) {
-  if (std::is_floating_point<T>::value) {
-    if (exp == E(0)) {
-      return T(1);
-    }
-    if (constexpr_isnan(base)) {
-      return base;
-    }
-  }
-  if (exp == E(0)) {
-    return T(1);
-  }
-  if (exp == E(1)) {
-    return base;
-  }
-  auto const hexp = constexpr_trunc(exp / E(2));
-  auto const div = constexpr_ipow(base, hexp);
-  auto const rem = hexp * E(2) == exp ? T(1) : base;
-  return constexpr_mult(constexpr_mult(div, div), rem);
-}
-
-} // namespace detail
-
-/// constexpr_exp
-///
-/// Calculates an approximation of the mathematical function exp(num). Usable in
-/// constant evaluations. Like std::exp, which becomes constexpr in C++26.
-///
-/// The integer overload uses iterated squaring and multiplication. The
-/// floating-point overlaod naively evaluates the taylor series of exp(num)
-/// until approximate convergence.
-///
-/// mimic: std::exp (C++23, C++26)
-template <
-    typename T,
-    typename N,
-    std::enable_if_t<
-        std::is_floating_point<T>::value && std::is_integral<N>::value &&
-            !std::is_same<N, bool>::value,
-        int> = 0>
-constexpr T constexpr_exp(N const power) {
-  auto const npower = constexpr_abs(power);
-  auto const result = detail::constexpr_ipow(numbers::e_v<T>, npower);
-  return power < N(0) ? T(1) / result : result;
-}
-template <
-    typename N,
-    std::enable_if_t<
-        std::is_integral<N>::value && !std::is_same<N, bool>::value,
-        int> = 0>
-constexpr double constexpr_exp(N const power) {
-  return constexpr_exp<double>(power);
-}
-template <
-    typename T,
-    std::enable_if_t<std::is_floating_point<T>::value, int> = 0>
-constexpr T constexpr_exp(T const power) {
-  using lim = std::numeric_limits<T>;
-
-  // edge cases
-  if (constexpr_isnan(power)) {
-    return power;
-  }
-  if (power == -lim::infinity()) {
-    return +T(0);
-  }
-  if (power == +lim::infinity()) {
-    return power;
-  }
-
-  // convergence works better with positive powers since signs do not alternate
-  auto const abspower = constexpr_abs(power);
-  // convergence must short-circuit when terms grow to floating-point infinity
-  auto const bound = T(1) < abspower ? lim::max() / abspower : lim::infinity();
-
-  // term #index = power * coeff
-  auto index = size_t(0);
-  auto term = T(1);
-  // result = sum of terms
-  auto result = T(1);
-  // sum the terms until ~convergence
-  while (!(constexpr_abs(term) < lim::epsilon())) {
-    if (bound < term) {
-      return power < T(0) ? T(0) : lim::infinity();
-    }
-    index += 1;
-    term = term * abspower / index;
-    result += term;
-  }
-  return power < T(0) ? T(1) / result : result;
-}
-
-/// constexpr_log
-///
-/// Calculates an approximation of the natural logarithm ln(num).
-///
-/// The implementation uses a quickly-converging, high-precision iterative
-/// technique as described in:
-///   https://en.wikipedia.org/wiki/Natural_logarithm#High_precision
-///
-/// The technique works best with numbers that are close enough to 1, so the
-/// implementation uses a quick shrink/growth technique as described in:
-///   https://en.wikipedia.org/wiki/Natural_logarithm#Efficient_computation
-template <
-    typename T,
-    std::enable_if_t<std::is_floating_point<T>::value, int> = 0>
-constexpr T constexpr_log(T const num) {
-  using lim = std::numeric_limits<T>;
-  constexpr auto& isq = constexpr_iterated_squares_desc_2_v<T>;
-
-  // edge cases
-  if (constexpr_isnan(num)) {
-    return num;
-  }
-  if (num < T(0)) {
-    return lim::quiet_NaN();
-  }
-  if (num == T(0)) {
-    return -lim::infinity();
-  }
-  if (num == lim::infinity()) {
-    return num;
-  }
-
-  // compression
-  auto const shrink = isq.shrink(num, isq.base);
-  auto const growth = isq.growth(num, T(1));
-  auto const scaled = num * growth.scale / shrink.scale;
-  assert(scaled <= isq.base);
-  assert(scaled >= T(1));
-
-  auto sum = T(0);
-  auto delta = T(2);
-  while (constexpr_abs(delta) >= lim::epsilon()) {
-    auto expterm = constexpr_exp(sum);
-    delta = T(2) * (scaled - expterm) / (scaled + expterm);
-    sum += delta;
-  }
-  auto const ln2 = numbers::ln2_v<T>;
-  return sum - growth.power * ln2 + shrink.power * ln2;
-}
-
-/// constexpr_pow
-///
-/// Calculates an approximation of the value of base raised to the exponent exp.
-///
-/// The implementation uses iterated squaring and multiplication for the integer
-/// part of the exponent and uses the identity x^y = exp(y * log(x)) for the
-/// fractional part of the exponent.
-///
-/// Notes:
-/// * Forbids base of +0 or -0 with finite non-positive exponent: in part since
-///   the plausible infinite result would be sensitive to the sign of the zero;
-///   and in part since std::pow would be required or permitted to raise error
-///   div-by-zero.
-/// * Forbids finite negative base with finite non-integer exponent: in part
-///   since std::pow would be required to raise error invalid.
-///
-/// mimic: std::pow (C++26)
-template <
-    typename T,
-    typename E,
-    std::enable_if_t<
-        std::is_integral<E>::value && !std::is_same<E, bool>::value,
-        int> = 0>
-constexpr T constexpr_pow(T const base, E const exp) {
-  return detail::constexpr_ipow(base, exp);
-}
-template <
-    typename T,
-    std::enable_if_t<std::is_floating_point<T>::value, int> = 0>
-constexpr T constexpr_pow(T const base, T const exp) {
-  using lim = std::numeric_limits<T>;
-
-  // edge cases
-  if (exp == T(0)) {
-    return T(1);
-  }
-  if (constexpr_isnan(base)) {
-    return base;
-  }
-  if (exp == lim::infinity() || exp == -lim::infinity()) {
-    auto const abase = constexpr_abs(base);
-    if (abase < T(1)) {
-      return exp == lim::infinity() ? T(0) : lim::infinity();
-    }
-    if (T(1) < abase) {
-      return exp == lim::infinity() ? lim::infinity() : T(0);
-    }
-    return T(1);
-  }
-  if (base == T(1)) {
-    return base;
-  }
-  if (constexpr_isnan(exp)) {
-    return exp;
-  }
-  assert(base != T(0) || exp > T(0)); // error div-by-zero
-  if (base == lim::infinity()) {
-    return exp < T(0) ? T(0) : lim::infinity();
-  }
-  if (base == -lim::infinity()) {
-    auto const oddi = //
-        exp == constexpr_trunc(exp) &&
-        exp != constexpr_trunc(exp / T(2)) * T(2);
-    return (oddi ? -T(1) : T(1)) * (exp < T(0) ? T(0) : lim::infinity());
-  }
-  if (base == T(0)) {
-    auto const oddi = //
-        exp == constexpr_trunc(exp) &&
-        exp != constexpr_trunc(exp / T(2)) * T(2);
-    return oddi ? base : T(0);
-  }
-  if (exp < T(0)) {
-    return T(1) / constexpr_pow(base, -exp);
-  }
-
-  // as an identity: x^y = exp(y * log(x)); but calculation is imprecise ... so,
-  // for better precision, split the calculation into its integral-power and its
-  // fractional-power components
-  // as a cost, the complexity of constexpr_ipow here is logarithmic in y, i.e.,
-  // linear in the logarithm of y, which can be prohibitive
-  auto const exp_trunc = constexpr_trunc(exp);
-  assert(T(0) < base || exp == exp_trunc); // error invalid
-  auto const exp_fract = exp - exp_trunc;
-  auto const anyi = exp_fract == T(0);
-  return constexpr_mult(
-      detail::constexpr_ipow(base, exp_trunc),
-      anyi ? T(1) : constexpr_exp(exp_fract * constexpr_log(base)));
-}
-
-/// constexpr_find_last_set
-///
-/// Return the 1-based index of the most significant bit which is set.
-/// For x > 0, constexpr_find_last_set(x) == 1 + floor(log2(x)).
-template <typename T>
-constexpr std::size_t constexpr_find_last_set(T const t) {
-  using U = std::make_unsigned_t<T>;
-  return t == T(0) ? 0 : 1 + constexpr_log2(static_cast<U>(t));
-}
-
-namespace detail {
-template <typename U>
-constexpr std::size_t constexpr_find_first_set_(
-    std::size_t s, std::size_t a, U const u) {
-  return s == 0 ? a
-                : constexpr_find_first_set_(
-                      s / 2, a + s * bool((u >> a) % (U(1) << s) == U(0)), u);
-}
-} // namespace detail
-
-/// constexpr_find_first_set
-///
-/// Return the 1-based index of the least significant bit which is set.
-/// For x > 0, the exponent in the largest power of two which does not divide x.
-template <typename T>
-constexpr std::size_t constexpr_find_first_set(T t) {
-  using U = std::make_unsigned_t<T>;
-  using size = std::integral_constant<std::size_t, sizeof(T) * 4>;
-  return t == T(0)
-      ? 0
-      : 1 + detail::constexpr_find_first_set_(size{}, 0, static_cast<U>(t));
-}
-
-template <typename T>
-constexpr T constexpr_add_overflow_clamped(T a, T b) {
-  using L = std::numeric_limits<T>;
-  using M = std::intmax_t;
-  static_assert(
-      !std::is_integral<T>::value || sizeof(T) <= sizeof(M),
-      "Integral type too large!");
-  // clang-format off
-  return
-    // don't do anything special for non-integral types.
-    !std::is_integral<T>::value ? a + b :
-    // for narrow integral types, just convert to intmax_t.
-    sizeof(T) < sizeof(M)
-      ? T(constexpr_clamp(
-          static_cast<M>(a) + static_cast<M>(b),
-          static_cast<M>(L::min()),
-          static_cast<M>(L::max()))) :
-    // when a >= 0, cannot add more than `MAX - a` onto a.
-    !(a < 0) ? a + constexpr_min(b, T(L::max() - a)) :
-    // a < 0 && b >= 0, `a + b` will always be in valid range of type T.
-    !(b < 0) ? a + b :
-    // a < 0 && b < 0, keep the result >= MIN.
+ }
+ 
+ template <typename T, typename Less>
+ constexpr T const& constexpr_clamp(
+     T const& v, T const& lo, T const& hi, Less less) {
+   T const& a = less(v, lo) ? lo : v;
+   T const& b = less(hi, a) ? hi : a;
+   return b;
+ }
+ template <typename T>
+ constexpr T const& constexpr_clamp(T const& v, T const& lo, T const& hi) {
+   return constexpr_clamp(v, lo, hi, std::less<T>{});
+ }
+ 
+ template <typename T>
+ constexpr bool constexpr_isnan(T const t) {
+   return t != t; // NOLINT
+ }
+ 
+ namespace detail {
+ 
+ template <typename T, typename = void>
+ struct constexpr_abs_helper {};
+ 
+ template <typename T>
+ struct constexpr_abs_helper<
+     T,
+     typename std::enable_if<std::is_floating_point<T>::value>::type> {
+   static constexpr T go(T t) { return t < static_cast<T>(0) ? -t : t; }
+ };
+ 
+ template <typename T>
+ struct constexpr_abs_helper<
+     T,
+     typename std::enable_if<
+         std::is_integral<T>::value && !std::is_same<T, bool>::value &&
+         std::is_unsigned<T>::value>::type> {
+   static constexpr T go(T t) { return t; }
+ };
+ 
+ template <typename T>
+ struct constexpr_abs_helper<
+     T,
+     typename std::enable_if<
+         std::is_integral<T>::value && !std::is_same<T, bool>::value &&
+         std::is_signed<T>::value>::type> {
+   static constexpr typename std::make_unsigned<T>::type go(T t) {
+     return typename std::make_unsigned<T>::type(t < static_cast<T>(0) ? -t : t);
+   }
+ };
+ 
+ } // namespace detail
+ 
+ template <typename T>
+ constexpr auto constexpr_abs(T t)
+     -> decltype(detail::constexpr_abs_helper<T>::go(t)) {
+   return detail::constexpr_abs_helper<T>::go(t);
+ }
+ 
+ namespace detail {
+ 
+ template <typename T>
+ constexpr T constexpr_log2_(T a, T e) {
+   return e == T(1) ? a : constexpr_log2_(a + T(1), e / T(2));
+ }
+ 
+ template <typename T>
+ constexpr T constexpr_log2_ceil_(T l2, T t) {
+   return l2 + T(T(1) << l2 < t ? 1 : 0);
+ }
+ 
+ } // namespace detail
+ 
+ template <typename T>
+ constexpr T constexpr_log2(T t) {
+   return detail::constexpr_log2_(T(0), t);
+ }
+ 
+ template <typename T>
+ constexpr T constexpr_log2_ceil(T t) {
+   return detail::constexpr_log2_ceil_(constexpr_log2(t), t);
+ }
+ 
+ /// constexpr_trunc
+ ///
+ /// mimic: std::trunc (C++23)
+ template <
+     typename T,
+     std::enable_if_t<std::is_floating_point<T>::value, int> = 0>
+ constexpr T constexpr_trunc(T const t) {
+   using lim = std::numeric_limits<T>;
+   using int_type = std::uintmax_t;
+   using int_lim = std::numeric_limits<int_type>;
+   static_assert(lim::radix == 2, "non-binary radix");
+   static_assert(lim::digits <= int_lim::digits, "overwide mantissa");
+   constexpr auto bound = static_cast<T>(std::uintmax_t(1) << (lim::digits - 1));
+   auto const neg = !constexpr_isnan(t) && t < T(0);
+   auto const s = neg ? -t : t;
+   if (constexpr_isnan(t) || t == T(0) || !(s < bound)) {
+     return t;
+   }
+   if (s < T(1)) {
+     return neg ? -T(0) : T(0);
+   }
+   auto const r = static_cast<T>(static_cast<int_type>(s));
+   return neg ? -r : r;
+ }
+ 
+ template <typename T, std::enable_if_t<std::is_integral<T>::value, int> = 0>
+ constexpr T constexpr_trunc(T const t) {
+   return t;
+ }
+ 
+ /// constexpr_round
+ ///
+ /// mimic: std::round (C++23)
+ template <typename T>
+ constexpr T constexpr_round(T const t) {
+   constexpr auto half = T(1) / T(2);
+   auto const same = constexpr_isnan(t) || t == T(0);
+   return same ? t : constexpr_trunc(t < T(0) ? t - half : t + half);
+ }
+ 
+ /// constexpr_floor
+ ///
+ /// mimic: std::floor (C++23)
+ template <typename T>
+ constexpr T constexpr_floor(T const t) {
+   auto const s = constexpr_trunc(t);
+   return t < s ? s - T(1) : s;
+ }
+ 
+ /// constexpr_ceil
+ ///
+ /// mimic: std::ceil (C++23)
+ template <typename T>
+ constexpr T constexpr_ceil(T const t) {
+   auto const s = constexpr_trunc(t);
+   return s < t ? s + T(1) : s;
+ }
+ 
+ /// constexpr_ceil
+ ///
+ /// The least integer at least t that round divides.
+ template <typename T>
+ constexpr T constexpr_ceil(T t, T round) {
+   return round == T(0)
+       ? t
+       : ((t + (t <= T(0) ? T(0) : round - T(1))) / round) * round;
+ }
+ 
+ /// constexpr_mult
+ ///
+ /// Multiply two values, allowing for constexpr floating-pooint overflow to
+ /// infinity.
+ template <typename T>
+ constexpr T constexpr_mult(T const a, T const b) {
+   using lim = std::numeric_limits<T>;
+   if (constexpr_isnan(a) || constexpr_isnan(b)) {
+     return constexpr_isnan(a) ? a : b;
+   }
+   if (std::is_floating_point<T>::value) {
+     constexpr auto inf = lim::infinity();
+     auto const ax = constexpr_abs(a);
+     auto const bx = constexpr_abs(b);
+     if ((ax == T(0) && bx == inf) || (bx == T(0) && ax == inf)) {
+       return lim::quiet_NaN();
+     }
+     // floating-point multiplication overflow, ie where multiplication of two
+     // finite values overflows to infinity of either sign, is not constexpr per
+     // gcc
+     // floating-point division overflow, ie where division of two finite values
+     // overflows to infinity of either sign, is not constexpr per gcc
+     // floating-point division by zero is not constexpr per any compiler, but we
+     // use it in the checks for the other two conditions
+     if (ax != inf && bx != inf && T(1) < bx && lim::max() / bx < ax) {
+       auto const a_neg = static_cast<bool>(a < T(0));
+       auto const b_neg = static_cast<bool>(b < T(0));
+       auto const sign = a_neg == b_neg ? T(1) : T(-1);
+       return sign * inf;
+     }
+   }
+   return a * b;
+ }
+ 
+ namespace detail {
+ 
+ template <
+     typename T,
+     typename E,
+     std::enable_if_t<std::is_signed<E>::value, int> = 1>
+ constexpr T constexpr_ipow(T const base, E const exp) {
+   if (std::is_floating_point<T>::value) {
+     if (exp < E(0)) {
+       return T(1) / constexpr_ipow(base, -exp);
+     }
+     if (exp == E(0)) {
+       return T(1);
+     }
+     if (constexpr_isnan(base)) {
+       return base;
+     }
+   }
+   assert(!(exp < E(0)) && "negative exponent with integral base");
+   if (exp == E(0)) {
+     return T(1);
+   }
+   if (exp == E(1)) {
+     return base;
+   }
+   auto const hexp = constexpr_trunc(exp / E(2));
+   auto const div = constexpr_ipow(base, hexp);
+   auto const rem = hexp * E(2) == exp ? T(1) : base;
+   return constexpr_mult(constexpr_mult(div, div), rem);
+ }
+ 
+ template <
+     typename T,
+     typename E,
+     std::enable_if_t<std::is_unsigned<E>::value, int> = 1>
+ constexpr T constexpr_ipow(T const base, E const exp) {
+   if (std::is_floating_point<T>::value) {
+     if (exp == E(0)) {
+       return T(1);
+     }
+     if (constexpr_isnan(base)) {
+       return base;
+     }
+   }
+   if (exp == E(0)) {
+     return T(1);
+   }
+   if (exp == E(1)) {
+     return base;
+   }
+   auto const hexp = constexpr_trunc(exp / E(2));
+   auto const div = constexpr_ipow(base, hexp);
+   auto const rem = hexp * E(2) == exp ? T(1) : base;
+   return constexpr_mult(constexpr_mult(div, div), rem);
+ }
+ 
+ } // namespace detail
+ 
+ /// constexpr_exp
+ ///
+ /// Calculates an approximation of the mathematical function exp(num). Usable in
+ /// constant evaluations. Like std::exp, which becomes constexpr in C++26.
+ ///
+ /// The integer overload uses iterated squaring and multiplication. The
+ /// floating-point overlaod naively evaluates the taylor series of exp(num)
+ /// until approximate convergence.
+ ///
+ /// mimic: std::exp (C++23, C++26)
+ template <
+     typename T,
+     typename N,
+     std::enable_if_t<
+         std::is_floating_point<T>::value && std::is_integral<N>::value &&
+             !std::is_same<N, bool>::value,
+         int> = 0>
+ constexpr T constexpr_exp(N const power) {
+   auto const npower = constexpr_abs(power);
+   auto const result = detail::constexpr_ipow(numbers::e_v<T>, npower);
+   return power < N(0) ? T(1) / result : result;
+ }
+ template <
+     typename N,
+     std::enable_if_t<
+         std::is_integral<N>::value && !std::is_same<N, bool>::value,
+         int> = 0>
+ constexpr double constexpr_exp(N const power) {
+   return constexpr_exp<double>(power);
+ }
+ template <
+     typename T,
+     std::enable_if_t<std::is_floating_point<T>::value, int> = 0>
+ constexpr T constexpr_exp(T const power) {
+   using lim = std::numeric_limits<T>;
+ 
+   // edge cases
+   if (constexpr_isnan(power)) {
+     return power;
+   }
+   if (power == -lim::infinity()) {
+     return +T(0);
+   }
+   if (power == +lim::infinity()) {
+     return power;
+   }
+ 
+   // convergence works better with positive powers since signs do not alternate
+   auto const abspower = constexpr_abs(power);
+   // convergence must short-circuit when terms grow to floating-point infinity
+   auto const bound = T(1) < abspower ? lim::max() / abspower : lim::infinity();
+ 
+   // term #index = power * coeff
+   auto index = size_t(0);
+   auto term = T(1);
+   // result = sum of terms
+   auto result = T(1);
+   // sum the terms until ~convergence
+   while (!(constexpr_abs(term) < lim::epsilon())) {
+     if (bound < term) {
+       return power < T(0) ? T(0) : lim::infinity();
+     }
+     index += 1;
+     term = term * abspower / index;
+     result += term;
+   }
+   return power < T(0) ? T(1) / result : result;
+ }
+ 
+ /// constexpr_log
+ ///
+ /// Calculates an approximation of the natural logarithm ln(num).
+ ///
+ /// The implementation uses a quickly-converging, high-precision iterative
+ /// technique as described in:
+ ///   https://en.wikipedia.org/wiki/Natural_logarithm#High_precision
+ ///
+ /// The technique works best with numbers that are close enough to 1, so the
+ /// implementation uses a quick shrink/growth technique as described in:
+ ///   https://en.wikipedia.org/wiki/Natural_logarithm#Efficient_computation
+ template <
+     typename T,
+     std::enable_if_t<std::is_floating_point<T>::value, int> = 0>
+ constexpr T constexpr_log(T const num) {
+   using lim = std::numeric_limits<T>;
+   constexpr auto& isq = constexpr_iterated_squares_desc_2_v<T>;
+ 
+   // edge cases
+   if (constexpr_isnan(num)) {
+     return num;
+   }
+   if (num < T(0)) {
+     return lim::quiet_NaN();
+   }
+   if (num == T(0)) {
+     return -lim::infinity();
+   }
+   if (num == lim::infinity()) {
+     return num;
+   }
+ 
+   // compression
+   auto const shrink = isq.shrink(num, isq.base);
+   auto const growth = isq.growth(num, T(1));
+   auto const scaled = num * growth.scale / shrink.scale;
+   assert(scaled <= isq.base);
+   assert(scaled >= T(1));
+ 
+   auto sum = T(0);
+   auto delta = T(2);
+   while (constexpr_abs(delta) >= lim::epsilon()) {
+     auto expterm = constexpr_exp(sum);
+     delta = T(2) * (scaled - expterm) / (scaled + expterm);
+     sum += delta;
+   }
+   auto const ln2 = numbers::ln2_v<T>;
+   return sum - growth.power * ln2 + shrink.power * ln2;
+ }
+ 
+ /// constexpr_pow
+ ///
+ /// Calculates an approximation of the value of base raised to the exponent exp.
+ ///
+ /// The implementation uses iterated squaring and multiplication for the integer
+ /// part of the exponent and uses the identity x^y = exp(y * log(x)) for the
+ /// fractional part of the exponent.
+ ///
+ /// Notes:
+ /// * Forbids base of +0 or -0 with finite non-positive exponent: in part since
+ ///   the plausible infinite result would be sensitive to the sign of the zero;
+ ///   and in part since std::pow would be required or permitted to raise error
+ ///   div-by-zero.
+ /// * Forbids finite negative base with finite non-integer exponent: in part
+ ///   since std::pow would be required to raise error invalid.
+ ///
+ /// mimic: std::pow (C++26)
+ template <
+     typename T,
+     typename E,
+     std::enable_if_t<
+         std::is_integral<E>::value && !std::is_same<E, bool>::value,
+         int> = 0>
+ constexpr T constexpr_pow(T const base, E const exp) {
+   return detail::constexpr_ipow(base, exp);
+ }
+ template <
+     typename T,
+     std::enable_if_t<std::is_floating_point<T>::value, int> = 0>
+ constexpr T constexpr_pow(T const base, T const exp) {
+   using lim = std::numeric_limits<T>;
+ 
+   // edge cases
+   if (exp == T(0)) {
+     return T(1);
+   }
+   if (constexpr_isnan(base)) {
+     return base;
+   }
+   if (exp == lim::infinity() || exp == -lim::infinity()) {
+     auto const abase = constexpr_abs(base);
+     if (abase < T(1)) {
+       return exp == lim::infinity() ? T(0) : lim::infinity();
+     }
+     if (T(1) < abase) {
+       return exp == lim::infinity() ? lim::infinity() : T(0);
+     }
+     return T(1);
+   }
+   if (base == T(1)) {
+     return base;
+   }
+   if (constexpr_isnan(exp)) {
+     return exp;
+   }
+   assert(base != T(0) || exp > T(0)); // error div-by-zero
+   if (base == lim::infinity()) {
+     return exp < T(0) ? T(0) : lim::infinity();
+   }
+   if (base == -lim::infinity()) {
+     auto const oddi = //
+         exp == constexpr_trunc(exp) &&
+         exp != constexpr_trunc(exp / T(2)) * T(2);
+     return (oddi ? -T(1) : T(1)) * (exp < T(0) ? T(0) : lim::infinity());
+   }
+   if (base == T(0)) {
+     auto const oddi = //
+         exp == constexpr_trunc(exp) &&
+         exp != constexpr_trunc(exp / T(2)) * T(2);
+     return oddi ? base : T(0);
+   }
+   if (exp < T(0)) {
+     return T(1) / constexpr_pow(base, -exp);
+   }
+ 
+   // as an identity: x^y = exp(y * log(x)); but calculation is imprecise ... so,
+   // for better precision, split the calculation into its integral-power and its
+   // fractional-power components
+   // as a cost, the complexity of constexpr_ipow here is logarithmic in y, i.e.,
+   // linear in the logarithm of y, which can be prohibitive
+   auto const exp_trunc = constexpr_trunc(exp);
+   assert(T(0) < base || exp == exp_trunc); // error invalid
+   auto const exp_fract = exp - exp_trunc;
+   auto const anyi = exp_fract == T(0);
+   return constexpr_mult(
+       detail::constexpr_ipow(base, exp_trunc),
+       anyi ? T(1) : constexpr_exp(exp_fract * constexpr_log(base)));
+ }
+ 
+ /// constexpr_find_last_set
+ ///
+ /// Return the 1-based index of the most significant bit which is set.
+ /// For x > 0, constexpr_find_last_set(x) == 1 + floor(log2(x)).
+ template <typename T>
+ constexpr std::size_t constexpr_find_last_set(T const t) {
+   using U = std::make_unsigned_t<T>;
+   return t == T(0) ? 0 : 1 + constexpr_log2(static_cast<U>(t));
+ }
+ 
+ namespace detail {
+ template <typename U>
+ constexpr std::size_t constexpr_find_first_set_(
+     std::size_t s, std::size_t a, U const u) {
+   return s == 0 ? a
+                 : constexpr_find_first_set_(
+                       s / 2, a + s * bool((u >> a) % (U(1) << s) == U(0)), u);
+ }
+ } // namespace detail
+ 
+ /// constexpr_find_first_set
+ ///
+ /// Return the 1-based index of the least significant bit which is set.
+ /// For x > 0, the exponent in the largest power of two which does not divide x.
+ template <typename T>
+ constexpr std::size_t constexpr_find_first_set(T t) {
+   using U = std::make_unsigned_t<T>;
+   using size = std::integral_constant<std::size_t, sizeof(T) * 4>;
+   return t == T(0)
+       ? 0
+       : 1 + detail::constexpr_find_first_set_(size{}, 0, static_cast<U>(t));
+ }
+ 
+ template <typename T>
+ constexpr T constexpr_add_overflow_clamped(T a, T b) {
+   using L = std::numeric_limits<T>;
+   using M = std::intmax_t;
+   static_assert(
+       !std::is_integral<T>::value || sizeof(T) <= sizeof(M),
+       "Integral type too large!");
+   if (!folly::is_constant_evaluated_or(true)) {
+     if constexpr (std::is_integral_v<T>) {
+       T ret{};
+       if (FOLLY_UNLIKELY(!checked_add(&ret, a, b))) {
+         if constexpr (std::is_signed_v<T>) {
+           // Could be either overflow or underflow for signed types.
+           // Can only be underflow if both inputs are negative.
+           if (a < 0 && b < 0) {
+             return L::min();
+           }
+         }
+         return L::max();
+       }
+       return ret;
+     }
+   }
+   // clang-format off
+   return
+     // don't do anything special for non-integral types.
+     !std::is_integral<T>::value ? a + b :
+     // for narrow integral types, just convert to intmax_t.
+     sizeof(T) < sizeof(M)
+       ? T(constexpr_clamp(
+           static_cast<M>(a) + static_cast<M>(b),
+           static_cast<M>(L::min()),
+           static_cast<M>(L::max()))) :
+     // when a >= 0, cannot add more than `MAX - a` onto a.
+     !(a < 0) ? a + constexpr_min(b, T(L::max() - a)) :
+     // a < 0 && b >= 0, `a + b` will always be in valid range of type T.
+     !(b < 0) ? a + b :
+     // a < 0 && b < 0, keep the result >= MIN.
                a + constexpr_max(b, T(L::min() - a));
-  // clang-format on
-}
-
-template <typename T>
-constexpr T constexpr_sub_overflow_clamped(T a, T b) {
-  using L = std::numeric_limits<T>;
-  using M = std::intmax_t;
-  static_assert(
-      !std::is_integral<T>::value || sizeof(T) <= sizeof(M),
-      "Integral type too large!");
-  // clang-format off
-  return
-    // don't do anything special for non-integral types.
-    !std::is_integral<T>::value ? a - b :
-    // for unsigned type, keep result >= 0.
-    std::is_unsigned<T>::value ? (a < b ? 0 : a - b) :
-    // for narrow signed integral types, just convert to intmax_t.
-    sizeof(T) < sizeof(M)
-      ? T(constexpr_clamp(
-          static_cast<M>(a) - static_cast<M>(b),
-          static_cast<M>(L::min()),
-          static_cast<M>(L::max()))) :
-    // (a >= 0 && b >= 0) || (a < 0 && b < 0), `a - b` will always be valid.
-    (a < 0) == (b < 0) ? a - b :
-    // MIN < b, so `-b` should be in valid range (-MAX <= -b <= MAX),
-    // convert subtraction to addition.
-    L::min() < b ? constexpr_add_overflow_clamped(a, T(-b)) :
-    // -b = -MIN = (MAX + 1) and a <= -1, result is in valid range.
-    a < 0 ? a - b :
-    // -b = -MIN = (MAX + 1) and a >= 0, result > MAX.
-            L::max();
-  // clang-format on
-}
-
-// clamp_cast<> provides sane numeric conversions from float point numbers to
-// integral numbers, and between different types of integral numbers. It helps
-// to avoid unexpected bugs introduced by bad conversion, and undefined behavior
-// like overflow when casting float point numbers to integral numbers.
-//
-// When doing clamp_cast<Dst>(value), if `value` is in valid range of Dst,
-// it will give correct result in Dst, equal to `value`.
-//
-// If `value` is outside the representable range of Dst, it will be clamped to
-// MAX or MIN in Dst, instead of being undefined behavior.
-//
-// Float NaNs are converted to 0 in integral type.
-//
-// Here's some comparison with static_cast<>:
-// (with FB-internal gcc-5-glibc-2.23 toolchain)
-//
-// static_cast<int32_t>(NaN) = 6
-// clamp_cast<int32_t>(NaN) = 0
-//
-// static_cast<int32_t>(9999999999.0f) = -348639895
-// clamp_cast<int32_t>(9999999999.0f) = 2147483647
-//
-// static_cast<int32_t>(2147483647.0f) = -348639895
-// clamp_cast<int32_t>(2147483647.0f) = 2147483647
-//
-// static_cast<uint32_t>(4294967295.0f) = 0
-// clamp_cast<uint32_t>(4294967295.0f) = 4294967295
-//
-// static_cast<uint32_t>(-1) = 4294967295
-// clamp_cast<uint32_t>(-1) = 0
-//
-// static_cast<int16_t>(32768u) = -32768
-// clamp_cast<int16_t>(32768u) = 32767
-
-template <typename Dst, typename Src>
-constexpr typename std::enable_if<std::is_integral<Src>::value, Dst>::type
-constexpr_clamp_cast(Src src) {
-  static_assert(
-      std::is_integral<Dst>::value && sizeof(Dst) <= sizeof(int64_t),
-      "constexpr_clamp_cast can only cast into integral type (up to 64bit)");
-
-  using L = std::numeric_limits<Dst>;
-  // clang-format off
-  return
-    // Check if Src and Dst have same signedness.
-    std::is_signed<Src>::value == std::is_signed<Dst>::value
-    ? (
-      // Src and Dst have same signedness. If sizeof(Src) <= sizeof(Dst),
-      // we can safely convert Src to Dst without any loss of accuracy.
-      sizeof(Src) <= sizeof(Dst) ? Dst(src) :
-      // If Src is larger in size, we need to clamp it to valid range in Dst.
-      Dst(constexpr_clamp(src, Src(L::min()), Src(L::max()))))
-    // Src and Dst have different signedness.
-    // Check if it's signed -> unsigend cast.
-    : std::is_signed<Src>::value && std::is_unsigned<Dst>::value
-    ? (
-      // If src < 0, the result should be 0.
-      src < 0 ? Dst(0) :
-      // Otherwise, src >= 0. If src can fit into Dst, we can safely cast it
-      // without loss of accuracy.
-      sizeof(Src) <= sizeof(Dst) ? Dst(src) :
-      // If Src is larger in size than Dst, we need to ensure the result is
-      // at most Dst MAX.
-      Dst(constexpr_min(src, Src(L::max()))))
-    // It's unsigned -> signed cast.
-    : (
-      // Since Src is unsigned, and Dst is signed, Src can fit into Dst only
-      // when sizeof(Src) < sizeof(Dst).
-      sizeof(Src) < sizeof(Dst) ? Dst(src) :
-      // If Src does not fit into Dst, we need to ensure the result is at most
-      // Dst MAX.
-      Dst(constexpr_min(src, Src(L::max()))));
-  // clang-format on
-}
-
-namespace detail {
-// Upper/lower bound values that could be accurately represented in both
-// integral and float point types.
-constexpr double kClampCastLowerBoundDoubleToInt64F = -9223372036854774784.0;
-constexpr double kClampCastUpperBoundDoubleToInt64F = 9223372036854774784.0;
-constexpr double kClampCastUpperBoundDoubleToUInt64F = 18446744073709549568.0;
-
-constexpr float kClampCastLowerBoundFloatToInt32F = -2147483520.0f;
-constexpr float kClampCastUpperBoundFloatToInt32F = 2147483520.0f;
-constexpr float kClampCastUpperBoundFloatToUInt32F = 4294967040.0f;
-
-// This works the same as constexpr_clamp, but the comparison are done in Src
-// to prevent any implicit promotions.
-template <typename D, typename S>
-constexpr D constexpr_clamp_cast_helper(S src, S sl, S su, D dl, D du) {
-  return src < sl ? dl : (src > su ? du : D(src));
-}
-} // namespace detail
-
-template <typename Dst, typename Src>
-constexpr typename std::enable_if<std::is_floating_point<Src>::value, Dst>::type
-constexpr_clamp_cast(Src src) {
-  static_assert(
-      std::is_integral<Dst>::value && sizeof(Dst) <= sizeof(int64_t),
-      "constexpr_clamp_cast can only cast into integral type (up to 64bit)");
-
-  using L = std::numeric_limits<Dst>;
-  // clang-format off
-  return
-    // Special case: cast NaN into 0.
-    constexpr_isnan(src) ? Dst(0) :
-    // using `sizeof(Src) > sizeof(Dst)` as a heuristic that Dst can be
-    // represented in Src without loss of accuracy.
-    // see: https://en.wikipedia.org/wiki/Floating-point_arithmetic
-    sizeof(Src) > sizeof(Dst) ?
-      detail::constexpr_clamp_cast_helper(
-          src, Src(L::min()), Src(L::max()), L::min(), L::max()) :
-    // sizeof(Src) < sizeof(Dst) only happens when doing cast of
-    // 32bit float -> u/int64_t.
-    // Losslessly promote float into double, change into double -> u/int64_t.
-    sizeof(Src) < sizeof(Dst) ? (
-      src >= 0.0
-      ? constexpr_clamp_cast<Dst>(
-            constexpr_clamp_cast<std::uint64_t>(double(src)))
-      : constexpr_clamp_cast<Dst>(
-            constexpr_clamp_cast<std::int64_t>(double(src)))) :
-    // The following are for sizeof(Src) == sizeof(Dst).
-    std::is_same<Src, double>::value && std::is_same<Dst, int64_t>::value ?
-      detail::constexpr_clamp_cast_helper(
-          double(src),
-          detail::kClampCastLowerBoundDoubleToInt64F,
-          detail::kClampCastUpperBoundDoubleToInt64F,
-          L::min(),
-          L::max()) :
-    std::is_same<Src, double>::value && std::is_same<Dst, uint64_t>::value ?
-      detail::constexpr_clamp_cast_helper(
-          double(src),
-          0.0,
-          detail::kClampCastUpperBoundDoubleToUInt64F,
-          L::min(),
-          L::max()) :
-    std::is_same<Src, float>::value && std::is_same<Dst, int32_t>::value ?
-      detail::constexpr_clamp_cast_helper(
-          float(src),
-          detail::kClampCastLowerBoundFloatToInt32F,
-          detail::kClampCastUpperBoundFloatToInt32F,
-          L::min(),
-          L::max()) :
-      detail::constexpr_clamp_cast_helper(
-          float(src),
-          0.0f,
-          detail::kClampCastUpperBoundFloatToUInt32F,
-          L::min(),
-          L::max());
-  // clang-format on
-}
-
-} // namespace folly
+   // clang-format on
+ }
+ 
+ template <typename T>
+ constexpr T constexpr_sub_overflow_clamped(T a, T b) {
+   using L = std::numeric_limits<T>;
+   using M = std::intmax_t;
+   static_assert(
+       !std::is_integral<T>::value || sizeof(T) <= sizeof(M),
+       "Integral type too large!");
+   // clang-format off
+   return
+     // don't do anything special for non-integral types.
+     !std::is_integral<T>::value ? a - b :
+     // for unsigned type, keep result >= 0.
+     std::is_unsigned<T>::value ? (a < b ? 0 : a - b) :
+     // for narrow signed integral types, just convert to intmax_t.
+     sizeof(T) < sizeof(M)
+       ? T(constexpr_clamp(
+           static_cast<M>(a) - static_cast<M>(b),
+           static_cast<M>(L::min()),
+           static_cast<M>(L::max()))) :
+     // (a >= 0 && b >= 0) || (a < 0 && b < 0), `a - b` will always be valid.
+     (a < 0) == (b < 0) ? a - b :
+     // MIN < b, so `-b` should be in valid range (-MAX <= -b <= MAX),
+     // convert subtraction to addition.
+     L::min() < b ? constexpr_add_overflow_clamped(a, T(-b)) :
+     // -b = -MIN = (MAX + 1) and a <= -1, result is in valid range.
+     a < 0 ? a - b :
+     // -b = -MIN = (MAX + 1) and a >= 0, result > MAX.
+             L::max();
+   // clang-format on
+ }
+ 
+ // clamp_cast<> provides sane numeric conversions from float point numbers to
+ // integral numbers, and between different types of integral numbers. It helps
+ // to avoid unexpected bugs introduced by bad conversion, and undefined behavior
+ // like overflow when casting float point numbers to integral numbers.
+ //
+ // When doing clamp_cast<Dst>(value), if `value` is in valid range of Dst,
+ // it will give correct result in Dst, equal to `value`.
+ //
+ // If `value` is outside the representable range of Dst, it will be clamped to
+ // MAX or MIN in Dst, instead of being undefined behavior.
+ //
+ // Float NaNs are converted to 0 in integral type.
+ //
+ // Here's some comparison with static_cast<>:
+ // (with FB-internal gcc-5-glibc-2.23 toolchain)
+ //
+ // static_cast<int32_t>(NaN) = 6
+ // clamp_cast<int32_t>(NaN) = 0
+ //
+ // static_cast<int32_t>(9999999999.0f) = -348639895
+ // clamp_cast<int32_t>(9999999999.0f) = 2147483647
+ //
+ // static_cast<int32_t>(2147483647.0f) = -348639895
+ // clamp_cast<int32_t>(2147483647.0f) = 2147483647
+ //
+ // static_cast<uint32_t>(4294967295.0f) = 0
+ // clamp_cast<uint32_t>(4294967295.0f) = 4294967295
+ //
+ // static_cast<uint32_t>(-1) = 4294967295
+ // clamp_cast<uint32_t>(-1) = 0
+ //
+ // static_cast<int16_t>(32768u) = -32768
+ // clamp_cast<int16_t>(32768u) = 32767
+ 
+ template <typename Dst, typename Src>
+ constexpr typename std::enable_if<std::is_integral<Src>::value, Dst>::type
+ constexpr_clamp_cast(Src src) {
+   static_assert(
+       std::is_integral<Dst>::value && sizeof(Dst) <= sizeof(int64_t),
+       "constexpr_clamp_cast can only cast into integral type (up to 64bit)");
+ 
+   using L = std::numeric_limits<Dst>;
+   // clang-format off
+   return
+     // Check if Src and Dst have same signedness.
+     std::is_signed<Src>::value == std::is_signed<Dst>::value
+     ? (
+       // Src and Dst have same signedness. If sizeof(Src) <= sizeof(Dst),
+       // we can safely convert Src to Dst without any loss of accuracy.
+       sizeof(Src) <= sizeof(Dst) ? Dst(src) :
+       // If Src is larger in size, we need to clamp it to valid range in Dst.
+       Dst(constexpr_clamp(src, Src(L::min()), Src(L::max()))))
+     // Src and Dst have different signedness.
+     // Check if it's signed -> unsigend cast.
+     : std::is_signed<Src>::value && std::is_unsigned<Dst>::value
+     ? (
+       // If src < 0, the result should be 0.
+       src < 0 ? Dst(0) :
+       // Otherwise, src >= 0. If src can fit into Dst, we can safely cast it
+       // without loss of accuracy.
+       sizeof(Src) <= sizeof(Dst) ? Dst(src) :
+       // If Src is larger in size than Dst, we need to ensure the result is
+       // at most Dst MAX.
+       Dst(constexpr_min(src, Src(L::max()))))
+     // It's unsigned -> signed cast.
+     : (
+       // Since Src is unsigned, and Dst is signed, Src can fit into Dst only
+       // when sizeof(Src) < sizeof(Dst).
+       sizeof(Src) < sizeof(Dst) ? Dst(src) :
+       // If Src does not fit into Dst, we need to ensure the result is at most
+       // Dst MAX.
+       Dst(constexpr_min(src, Src(L::max()))));
+   // clang-format on
+ }
+ 
+ namespace detail {
+ // Upper/lower bound values that could be accurately represented in both
+ // integral and float point types.
+ constexpr double kClampCastLowerBoundDoubleToInt64F = -9223372036854774784.0;
+ constexpr double kClampCastUpperBoundDoubleToInt64F = 9223372036854774784.0;
+ constexpr double kClampCastUpperBoundDoubleToUInt64F = 18446744073709549568.0;
+ 
+ constexpr float kClampCastLowerBoundFloatToInt32F = -2147483520.0f;
+ constexpr float kClampCastUpperBoundFloatToInt32F = 2147483520.0f;
+ constexpr float kClampCastUpperBoundFloatToUInt32F = 4294967040.0f;
+ 
+ // This works the same as constexpr_clamp, but the comparison are done in Src
+ // to prevent any implicit promotions.
+ template <typename D, typename S>
+ constexpr D constexpr_clamp_cast_helper(S src, S sl, S su, D dl, D du) {
+   return src < sl ? dl : (src > su ? du : D(src));
+ }
+ } // namespace detail
+ 
+ template <typename Dst, typename Src>
+ constexpr typename std::enable_if<std::is_floating_point<Src>::value, Dst>::type
+ constexpr_clamp_cast(Src src) {
+   static_assert(
+       std::is_integral<Dst>::value && sizeof(Dst) <= sizeof(int64_t),
+       "constexpr_clamp_cast can only cast into integral type (up to 64bit)");
+ 
+   using L = std::numeric_limits<Dst>;
+   // clang-format off
+   return
+     // Special case: cast NaN into 0.
+     constexpr_isnan(src) ? Dst(0) :
+     // using `sizeof(Src) > sizeof(Dst)` as a heuristic that Dst can be
+     // represented in Src without loss of accuracy.
+     // see: https://en.wikipedia.org/wiki/Floating-point_arithmetic
+     sizeof(Src) > sizeof(Dst) ?
+       detail::constexpr_clamp_cast_helper(
+           src, Src(L::min()), Src(L::max()), L::min(), L::max()) :
+     // sizeof(Src) < sizeof(Dst) only happens when doing cast of
+     // 32bit float -> u/int64_t.
+     // Losslessly promote float into double, change into double -> u/int64_t.
+     sizeof(Src) < sizeof(Dst) ? (
+       src >= 0.0
+       ? constexpr_clamp_cast<Dst>(
+             constexpr_clamp_cast<std::uint64_t>(double(src)))
+       : constexpr_clamp_cast<Dst>(
+             constexpr_clamp_cast<std::int64_t>(double(src)))) :
+     // The following are for sizeof(Src) == sizeof(Dst).
+     std::is_same<Src, double>::value && std::is_same<Dst, int64_t>::value ?
+       detail::constexpr_clamp_cast_helper(
+           double(src),
+           detail::kClampCastLowerBoundDoubleToInt64F,
+           detail::kClampCastUpperBoundDoubleToInt64F,
+           L::min(),
+           L::max()) :
+     std::is_same<Src, double>::value && std::is_same<Dst, uint64_t>::value ?
+       detail::constexpr_clamp_cast_helper(
+           double(src),
+           0.0,
+           detail::kClampCastUpperBoundDoubleToUInt64F,
+           L::min(),
+           L::max()) :
+     std::is_same<Src, float>::value && std::is_same<Dst, int32_t>::value ?
+       detail::constexpr_clamp_cast_helper(
+           float(src),
+           detail::kClampCastLowerBoundFloatToInt32F,
+           detail::kClampCastUpperBoundFloatToInt32F,
+           L::min(),
+           L::max()) :
+       detail::constexpr_clamp_cast_helper(
+           float(src),
+           0.0f,
+           detail::kClampCastUpperBoundFloatToUInt32F,
+           L::min(),
+           L::max());
+   // clang-format on
+ }
+ 
+ } // namespace folly
diff --git a/vnext/Folly/TEMP_UntilFollyUpdate/dynamic-inl.h b/vnext/Folly/TEMP_UntilFollyUpdate/dynamic-inl.h
index 4495e2ac88b..a90471ff4dd 100644
--- a/vnext/Folly/TEMP_UntilFollyUpdate/dynamic-inl.h
+++ b/vnext/Folly/TEMP_UntilFollyUpdate/dynamic-inl.h
@@ -14,1098 +14,1097 @@
  * limitations under the License.
  */
 
-#pragma once
-
-#include <functional>
-
-#include <folly/CPortability.h>
-#include <folly/Conv.h>
-#include <folly/Format.h>
-#include <folly/Likely.h>
-#include <folly/Portability.h>
-#include <folly/detail/Iterators.h>
-#include <folly/lang/Exception.h>
-
-namespace folly {
-namespace detail {
-
-struct DynamicHasher {
-  using is_transparent = void;
-  using folly_is_avalanching = std::true_type;
-
-  size_t operator()(dynamic const& d) const { return d.hash(); }
-
-  template <typename T>
-  std::enable_if_t<std::is_convertible<T, StringPiece>::value, size_t>
-  operator()(T const& val) const {
-    // keep consistent with dynamic::hash() for strings
-    return Hash()(static_cast<StringPiece>(val));
-  }
-};
-
-struct DynamicKeyEqual {
-  using is_transparent = void;
-
-  bool operator()(const dynamic& lhs, const dynamic& rhs) const {
-    return std::equal_to<dynamic>()(lhs, rhs);
-  }
-
-  // Dynamic objects contains a map<dynamic, dynamic>. At least one of the
-  // operands should be a dynamic. Hence, an operator() where both operands are
-  // convertible to StringPiece is unnecessary.
-  template <typename A, typename B>
-  std::enable_if_t<
-      std::is_convertible<A, StringPiece>::value &&
-          std::is_convertible<B, StringPiece>::value,
-      bool>
-  operator()(A const& lhs, B const& rhs) const = delete;
-
-  template <typename A>
-  std::enable_if_t<std::is_convertible<A, StringPiece>::value, bool> operator()(
-      A const& lhs, dynamic const& rhs) const {
-    return FOLLY_LIKELY(rhs.type() == dynamic::Type::STRING) &&
-        std::equal_to<StringPiece>()(lhs, rhs.stringPiece());
-  }
-
-  template <typename B>
-  std::enable_if_t<std::is_convertible<B, StringPiece>::value, bool> operator()(
-      dynamic const& lhs, B const& rhs) const {
-    return FOLLY_LIKELY(lhs.type() == dynamic::Type::STRING) &&
-        std::equal_to<StringPiece>()(lhs.stringPiece(), rhs);
-  }
-};
-} // namespace detail
-} // namespace folly
-
-//////////////////////////////////////////////////////////////////////
-
-/* clang-format off */
-// This is a higher-order preprocessor macro to aid going from runtime
-// types to the compile time type system.
-
-#define FB_DYNAMIC_APPLY(type, apply)                                             \
-  do {                                                                            \
-    FOLLY_PUSH_WARNING FOLLY_CLANG_DISABLE_WARNING("-Wcovered-switch-default")    \
-    switch ((type)) {                                                             \
-      case NULLT:                                                                 \
-        apply(std::nullptr_t);                                                    \
-        break;                                                                    \
-      case ARRAY:                                                                 \
-        apply(Array);                                                             \
-        break;                                                                    \
-      case BOOL:                                                                  \
-        apply(bool);                                                              \
-        break;                                                                    \
-      case DOUBLE:                                                                \
-        apply(double);                                                            \
-        break;                                                                    \
-      case INT64:                                                                 \
-        apply(int64_t);                                                           \
-        break;                                                                    \
-      case OBJECT:                                                                \
-        apply(ObjectImpl);                                                        \
-        break;                                                                    \
-      case STRING:                                                                \
-        apply(std::string);                                                       \
-        break;                                                                    \
-      default:                                                                    \
-        abort();                                                                  \
-    }                                                                             \
-    FOLLY_POP_WARNING                                                             \
-  } while (0)
-/* clang-format on */
-//////////////////////////////////////////////////////////////////////
-
-namespace folly {
-
-struct FOLLY_EXPORT TypeError : std::runtime_error {
-  explicit TypeError(const std::string& expected, dynamic::Type actual);
-  explicit TypeError(
-      const std::string& expected,
-      dynamic::Type actual1,
-      dynamic::Type actual2);
-};
-
-//////////////////////////////////////////////////////////////////////
-
-namespace detail {
-
-// This helper is used in destroy() to be able to run destructors on
-// types like "int64_t" without a compiler error.
-struct Destroy {
-  template <class T>
-  static void destroy(T* t) {
-    t->~T();
-  }
-};
-
-/*
- * Helper for implementing numeric conversions in operators on
- * numbers.  Just promotes to double when one of the arguments is
- * double, or throws if either is not a numeric type.
- */
-template <template <class> class Op>
-dynamic numericOp(dynamic const& a, dynamic const& b) {
-  if (!a.isNumber() || !b.isNumber()) {
-    throw_exception<TypeError>("numeric", a.type(), b.type());
-  }
-  if (a.isDouble() || b.isDouble()) {
-    return Op<double>()(a.asDouble(), b.asDouble());
-  }
-  return Op<int64_t>()(a.asInt(), b.asInt());
-}
-
-} // namespace detail
-
-//////////////////////////////////////////////////////////////////////
-
-/*
- * We're doing this instead of a simple member typedef to avoid the
- * undefined behavior of parameterizing F14NodeMap<> with an
- * incomplete type.
- *
- * Note: Later we may add separate order tracking here (a multi-index
- * type of thing.)
- */
-struct dynamic::ObjectImpl : F14NodeMap<
-                                 dynamic,
-                                 dynamic,
-                                 detail::DynamicHasher,
-                                 detail::DynamicKeyEqual> {};
-
-//////////////////////////////////////////////////////////////////////
-
-// Helper object for creating objects conveniently.  See object and
-// the dynamic::dynamic(ObjectMaker&&) ctor.
-struct dynamic::ObjectMaker {
-  friend struct dynamic;
-
-  explicit ObjectMaker() : val_(dynamic::object) {}
-  explicit ObjectMaker(dynamic key, dynamic val) : val_(dynamic::object) {
-    val_.insert(std::move(key), std::move(val));
-  }
-
-  // Make sure no one tries to save one of these into an lvalue with
-  // auto or anything like that.
-  ObjectMaker(ObjectMaker&&) = default;
-  ObjectMaker(ObjectMaker const&) = delete;
-  ObjectMaker& operator=(ObjectMaker const&) = delete;
-  ObjectMaker& operator=(ObjectMaker&&) = delete;
-
-  // This returns an rvalue-reference instead of an lvalue-reference
-  // to allow constructs like this to moved instead of copied:
-  //  dynamic a = dynamic::object("a", "b")("c", "d")
-  ObjectMaker&& operator()(dynamic key, dynamic val) {
-    val_.insert(std::move(key), std::move(val));
-    return std::move(*this);
-  }
-
- private:
-  dynamic val_;
-};
-
-inline void dynamic::array(EmptyArrayTag) {}
-
-template <class... Args>
-inline dynamic dynamic::array(Args&&... args) {
-  return dynamic(Array{std::forward<Args>(args)...});
-}
-
-inline dynamic::ObjectMaker dynamic::object() {
-  return ObjectMaker();
-}
-inline dynamic::ObjectMaker dynamic::object(dynamic a, dynamic b) {
-  return ObjectMaker(std::move(a), std::move(b));
-}
-
-//////////////////////////////////////////////////////////////////////
-
-struct dynamic::item_iterator : detail::IteratorAdaptor<
-                                    dynamic::item_iterator,
-                                    dynamic::ObjectImpl::iterator,
-                                    std::pair<dynamic const, dynamic>,
-                                    std::forward_iterator_tag> {
-  using Super = detail::IteratorAdaptor<
-      dynamic::item_iterator,
-      dynamic::ObjectImpl::iterator,
-      std::pair<dynamic const, dynamic>,
-      std::forward_iterator_tag>;
-  item_iterator() = default;
-  /* implicit */ item_iterator(dynamic::ObjectImpl::iterator b) : Super(b) {}
-
-  using object_type = dynamic::ObjectImpl;
-};
-
-struct dynamic::value_iterator : detail::IteratorAdaptor<
-                                     dynamic::value_iterator,
+ #pragma once
+
+ #include <functional>
+ 
+ #include <folly/CPortability.h>
+ #include <folly/Conv.h>
+ #include <folly/Format.h>
+ #include <folly/Likely.h>
+ #include <folly/Portability.h>
+ #include <folly/detail/Iterators.h>
+ #include <folly/lang/Exception.h>
+ 
+ namespace folly {
+ namespace detail {
+ 
+ struct DynamicHasher {
+   using is_transparent = void;
+   using folly_is_avalanching = std::true_type;
+ 
+   size_t operator()(dynamic const& d) const { return d.hash(); }
+ 
+   template <typename T>
+   std::enable_if_t<std::is_convertible<T, StringPiece>::value, size_t>
+   operator()(T const& val) const {
+     // keep consistent with dynamic::hash() for strings
+     return Hash()(static_cast<StringPiece>(val));
+   }
+ };
+ 
+ struct DynamicKeyEqual {
+   using is_transparent = void;
+ 
+   bool operator()(const dynamic& lhs, const dynamic& rhs) const {
+     return std::equal_to<dynamic>()(lhs, rhs);
+   }
+ 
+   // Dynamic objects contains a map<dynamic, dynamic>. At least one of the
+   // operands should be a dynamic. Hence, an operator() where both operands are
+   // convertible to StringPiece is unnecessary.
+   template <typename A, typename B>
+   std::enable_if_t<
+       std::is_convertible<A, StringPiece>::value &&
+           std::is_convertible<B, StringPiece>::value,
+       bool>
+   operator()(A const& lhs, B const& rhs) const = delete;
+ 
+   template <typename A>
+   std::enable_if_t<std::is_convertible<A, StringPiece>::value, bool> operator()(
+       A const& lhs, dynamic const& rhs) const {
+     return FOLLY_LIKELY(rhs.type() == dynamic::Type::STRING) &&
+         std::equal_to<StringPiece>()(lhs, rhs.stringPiece());
+   }
+ 
+   template <typename B>
+   std::enable_if_t<std::is_convertible<B, StringPiece>::value, bool> operator()(
+       dynamic const& lhs, B const& rhs) const {
+     return FOLLY_LIKELY(lhs.type() == dynamic::Type::STRING) &&
+         std::equal_to<StringPiece>()(lhs.stringPiece(), rhs);
+   }
+ };
+ } // namespace detail
+ } // namespace folly
+ 
+ //////////////////////////////////////////////////////////////////////
+ 
+ /* clang-format off */
+ // This is a higher-order preprocessor macro to aid going from runtime
+ // types to the compile time type system.
+ 
+ #define FB_DYNAMIC_APPLY(type, apply)                                             \
+   do {                                                                            \
+     FOLLY_PUSH_WARNING FOLLY_CLANG_DISABLE_WARNING("-Wcovered-switch-default")    \
+     switch ((type)) {                                                             \
+       case NULLT:                                                                 \
+         apply(std::nullptr_t);                                                    \
+         break;                                                                    \
+       case ARRAY:                                                                 \
+         apply(Array);                                                             \
+         break;                                                                    \
+       case BOOL:                                                                  \
+         apply(bool);                                                              \
+         break;                                                                    \
+       case DOUBLE:                                                                \
+         apply(double);                                                            \
+         break;                                                                    \
+       case INT64:                                                                 \
+         apply(int64_t);                                                           \
+         break;                                                                    \
+       case OBJECT:                                                                \
+         apply(ObjectImpl);                                                        \
+         break;                                                                    \
+       case STRING:                                                                \
+         apply(std::string);                                                       \
+         break;                                                                    \
+       default:                                                                    \
+         abort();                                                                  \
+     }                                                                             \
+     FOLLY_POP_WARNING                                                             \
+   } while (0)
+ /* clang-format on */
+ //////////////////////////////////////////////////////////////////////
+ 
+ namespace folly {
+ 
+ struct FOLLY_EXPORT TypeError : std::runtime_error {
+   explicit TypeError(const std::string& expected, dynamic::Type actual);
+   explicit TypeError(
+       const std::string& expected,
+       dynamic::Type actual1,
+       dynamic::Type actual2);
+ };
+ 
+ //////////////////////////////////////////////////////////////////////
+ 
+ namespace detail {
+ 
+ // This helper is used in destroy() to be able to run destructors on
+ // types like "int64_t" without a compiler error.
+ struct Destroy {
+   template <class T>
+   static void destroy(T* t) {
+     t->~T();
+   }
+ };
+ 
+ /*
+  * Helper for implementing numeric conversions in operators on
+  * numbers.  Just promotes to double when one of the arguments is
+  * double, or throws if either is not a numeric type.
+  */
+ template <template <class> class Op>
+ dynamic numericOp(dynamic const& a, dynamic const& b) {
+   if (!a.isNumber() || !b.isNumber()) {
+     throw_exception<TypeError>("numeric", a.type(), b.type());
+   }
+   if (a.isDouble() || b.isDouble()) {
+     return Op<double>()(a.asDouble(), b.asDouble());
+   }
+   return Op<int64_t>()(a.asInt(), b.asInt());
+ }
+ 
+ } // namespace detail
+ 
+ //////////////////////////////////////////////////////////////////////
+ 
+ /*
+  * We're doing this instead of a simple member typedef to avoid the
+  * undefined behavior of parameterizing F14NodeMap<> with an
+  * incomplete type.
+  *
+  * Note: Later we may add separate order tracking here (a multi-index
+  * type of thing.)
+  */
+ struct dynamic::ObjectImpl : F14NodeMap<
+                                  dynamic,
+                                  dynamic,
+                                  detail::DynamicHasher,
+                                  detail::DynamicKeyEqual> {};
+ 
+ //////////////////////////////////////////////////////////////////////
+ 
+ // Helper object for creating objects conveniently.  See object and
+ // the dynamic::dynamic(ObjectMaker&&) ctor.
+ struct dynamic::ObjectMaker {
+   friend struct dynamic;
+ 
+   explicit ObjectMaker() : val_(dynamic::object) {}
+   explicit ObjectMaker(dynamic key, dynamic val) : val_(dynamic::object) {
+     val_.insert(std::move(key), std::move(val));
+   }
+ 
+   // Make sure no one tries to save one of these into an lvalue with
+   // auto or anything like that.
+   ObjectMaker(ObjectMaker&&) = default;
+   ObjectMaker(ObjectMaker const&) = delete;
+   ObjectMaker& operator=(ObjectMaker const&) = delete;
+   ObjectMaker& operator=(ObjectMaker&&) = delete;
+ 
+   // This returns an rvalue-reference instead of an lvalue-reference
+   // to allow constructs like this to moved instead of copied:
+   //  dynamic a = dynamic::object("a", "b")("c", "d")
+   ObjectMaker&& operator()(dynamic key, dynamic val) {
+     val_.insert(std::move(key), std::move(val));
+     return std::move(*this);
+   }
+ 
+  private:
+   dynamic val_;
+ };
+ 
+ inline void dynamic::array(EmptyArrayTag) {}
+ 
+ template <class... Args>
+ inline dynamic dynamic::array(Args&&... args) {
+   return dynamic(Array{std::forward<Args>(args)...});
+ }
+ 
+ inline dynamic::ObjectMaker dynamic::object() {
+   return ObjectMaker();
+ }
+ inline dynamic::ObjectMaker dynamic::object(dynamic a, dynamic b) {
+   return ObjectMaker(std::move(a), std::move(b));
+ }
+ 
+ //////////////////////////////////////////////////////////////////////
+ 
+ struct dynamic::item_iterator : detail::IteratorAdaptor<
+                                     dynamic::item_iterator,
                                      dynamic::ObjectImpl::iterator,
-                                     dynamic,
+                                     std::pair<dynamic const, dynamic>,
                                      std::forward_iterator_tag> {
-  using Super = detail::IteratorAdaptor<
-      dynamic::value_iterator,
-      dynamic::ObjectImpl::iterator,
-      dynamic,
-      std::forward_iterator_tag>;
-  value_iterator() = default;
-  /* implicit */ value_iterator(dynamic::ObjectImpl::iterator b) : Super(b) {}
-
-  using object_type = dynamic::ObjectImpl;
-
-  dynamic& dereference() const { return base()->second; }
-};
-
-struct dynamic::const_item_iterator
-    : detail::IteratorAdaptor<
-          dynamic::const_item_iterator,
-          dynamic::ObjectImpl::const_iterator,
-          std::pair<dynamic const, dynamic> const,
-          std::forward_iterator_tag> {
-  using Super = detail::IteratorAdaptor<
-      dynamic::const_item_iterator,
-      dynamic::ObjectImpl::const_iterator,
-      std::pair<dynamic const, dynamic> const,
-      std::forward_iterator_tag>;
-  const_item_iterator() = default;
-  /* implicit */ const_item_iterator(dynamic::ObjectImpl::const_iterator b)
-      : Super(b) {}
-  /* implicit */ const_item_iterator(const_item_iterator const& i)
-      : Super(i.base()) {}
-  /* implicit */ const_item_iterator(item_iterator i) : Super(i.base()) {}
-
-  using object_type = dynamic::ObjectImpl const;
-};
-
-struct dynamic::const_key_iterator : detail::IteratorAdaptor<
-                                         dynamic::const_key_iterator,
-                                         dynamic::ObjectImpl::const_iterator,
-                                         dynamic const,
-                                         std::forward_iterator_tag> {
-  using Super = detail::IteratorAdaptor<
-      dynamic::const_key_iterator,
-      dynamic::ObjectImpl::const_iterator,
-      dynamic const,
-      std::forward_iterator_tag>;
-  const_key_iterator() = default;
-  /* implicit */ const_key_iterator(dynamic::ObjectImpl::const_iterator b)
-      : Super(b) {}
-
-  using object_type = dynamic::ObjectImpl const;
-
-  dynamic const& dereference() const { return base()->first; }
-};
-
-struct dynamic::const_value_iterator : detail::IteratorAdaptor<
-                                           dynamic::const_value_iterator,
-                                           dynamic::ObjectImpl::const_iterator,
-                                           dynamic const,
-                                           std::forward_iterator_tag> {
-  using Super = detail::IteratorAdaptor<
-      dynamic::const_value_iterator,
-      dynamic::ObjectImpl::const_iterator,
-      dynamic const,
-      std::forward_iterator_tag>;
-  const_value_iterator() = default;
-  /* implicit */ const_value_iterator(dynamic::ObjectImpl::const_iterator b)
-      : Super(b) {}
-  /* implicit */ const_value_iterator(value_iterator i) : Super(i.base()) {}
-  /* implicit */ const_value_iterator(dynamic::ObjectImpl::iterator i)
-      : Super(i) {}
-
-  using object_type = dynamic::ObjectImpl const;
-
-  dynamic const& dereference() const { return base()->second; }
-};
-
-//////////////////////////////////////////////////////////////////////
-
-inline dynamic::dynamic() : dynamic(nullptr) {}
-
-inline dynamic::dynamic(std::nullptr_t) : type_(NULLT) {}
-
-inline dynamic::dynamic(void (*)(EmptyArrayTag)) : type_(ARRAY) {
-  new (&u_.array) Array();
-}
-
-inline dynamic::dynamic(ObjectMaker (*)()) : type_(OBJECT) {
-  new (getAddress<ObjectImpl>()) ObjectImpl();
-}
-
-inline dynamic::dynamic(char const* s) : type_(STRING) {
-  new (&u_.string) std::string(s);
-}
-
-inline dynamic::dynamic(std::string s) : type_(STRING) {
-  new (&u_.string) std::string(std::move(s));
-}
-
-template <typename Stringish, typename>
-inline dynamic::dynamic(Stringish&& s) : type_(STRING) {
-  new (&u_.string) std::string(s.data(), s.size());
-}
-
-inline dynamic::dynamic(ObjectMaker&& maker) : type_(OBJECT) {
-  new (getAddress<ObjectImpl>())
-      ObjectImpl(std::move(*maker.val_.getAddress<ObjectImpl>()));
-}
-
-inline dynamic::~dynamic() noexcept {
-  destroy();
-}
-
-// Integral types except bool convert to int64_t, float types to double.
-template <class T>
-struct dynamic::NumericTypeHelper<
-    T,
-    typename std::enable_if<std::is_integral<T>::value>::type> {
-  static_assert(
-      !kIsObjC || sizeof(T) > sizeof(char),
-      "char-sized types are ambiguous in objc; cast to bool or wider type");
-  using type = int64_t;
-};
-template <>
-struct dynamic::NumericTypeHelper<bool> {
-  using type = bool;
-};
-template <>
-struct dynamic::NumericTypeHelper<float> {
-  using type = double;
-};
-template <>
-struct dynamic::NumericTypeHelper<double> {
-  using type = double;
-};
-
-inline dynamic::dynamic(std::vector<bool>::reference b)
-    : dynamic(static_cast<bool>(b)) {}
-inline dynamic::dynamic(VectorBoolConstRefCtorType b)
-    : dynamic(static_cast<bool>(b)) {}
-
-template <
-    class T,
-    class NumericType /* = typename NumericTypeHelper<T>::type */>
-dynamic::dynamic(T t) {
-  type_ = TypeInfo<NumericType>::type;
-  new (getAddress<NumericType>()) NumericType(NumericType(t));
-}
-
-template <class Iterator>
-dynamic::dynamic(Iterator first, Iterator last) : type_(ARRAY) {
-  new (&u_.array) Array(first, last);
-}
-
-template <
-    class T,
-    class NumericType /* = typename NumericTypeHelper<T>::type */>
-dynamic& dynamic::operator=(T t) {
-  const auto newType = TypeInfo<NumericType>::type;
-  if (type_ == newType) {
-    *getAddress<NumericType>() = t;
-  } else {
-    destroy();
-    new (getAddress<NumericType>()) NumericType(t);
-    type_ = newType;
-  }
-  return *this;
-}
-//////////////////////////////////////////////////////////////////////
-
-inline dynamic::const_iterator dynamic::begin() const {
-  return get<Array>().begin();
-}
-inline dynamic::const_iterator dynamic::end() const {
-  return get<Array>().end();
-}
-
-inline dynamic::iterator dynamic::begin() {
-  return get<Array>().begin();
-}
-inline dynamic::iterator dynamic::end() {
-  return get<Array>().end();
-}
-
-template <class It>
-struct dynamic::IterableProxy {
-  typedef It iterator;
-  typedef typename It::value_type value_type;
-  typedef typename It::object_type object_type;
-
-  /* implicit */ IterableProxy(object_type* o) : o_(o) {}
-
-  It begin() const { return o_->begin(); }
-
-  It end() const { return o_->end(); }
-
- private:
-  object_type* o_;
-};
-
-inline dynamic::IterableProxy<dynamic::const_key_iterator> dynamic::keys()
-    const {
-  return &(get<ObjectImpl>());
-}
-
-inline dynamic::IterableProxy<dynamic::const_value_iterator> dynamic::values()
-    const {
-  return &(get<ObjectImpl>());
-}
-
-inline dynamic::IterableProxy<dynamic::const_item_iterator> dynamic::items()
-    const {
-  return &(get<ObjectImpl>());
-}
-
-inline dynamic::IterableProxy<dynamic::value_iterator> dynamic::values() {
-  return &(get<ObjectImpl>());
-}
-
-inline dynamic::IterableProxy<dynamic::item_iterator> dynamic::items() {
-  return &(get<ObjectImpl>());
-}
-
-inline bool dynamic::isString() const {
-  return get_nothrow<std::string>() != nullptr;
-}
-inline bool dynamic::isObject() const {
-  return get_nothrow<ObjectImpl>() != nullptr;
-}
-inline bool dynamic::isBool() const {
-  return get_nothrow<bool>() != nullptr;
-}
-inline bool dynamic::isArray() const {
-  return get_nothrow<Array>() != nullptr;
-}
-inline bool dynamic::isDouble() const {
-  return get_nothrow<double>() != nullptr;
-}
-inline bool dynamic::isInt() const {
-  return get_nothrow<int64_t>() != nullptr;
-}
-inline bool dynamic::isNull() const {
-  return get_nothrow<std::nullptr_t>() != nullptr;
-}
-inline bool dynamic::isNumber() const {
-  return isInt() || isDouble();
-}
-
-inline dynamic::Type dynamic::type() const {
-  return type_;
-}
-
-inline std::string dynamic::asString() const {
-  return asImpl<std::string>();
-}
-inline double dynamic::asDouble() const {
-  return asImpl<double>();
-}
-inline int64_t dynamic::asInt() const {
-  return asImpl<int64_t>();
-}
-inline bool dynamic::asBool() const {
-  return asImpl<bool>();
-}
-
-inline const std::string& dynamic::getString() const& {
-  return get<std::string>();
-}
-inline double dynamic::getDouble() const& {
-  return get<double>();
-}
-inline int64_t dynamic::getInt() const& {
-  return get<int64_t>();
-}
-inline bool dynamic::getBool() const& {
-  return get<bool>();
-}
-
-inline std::string& dynamic::getString() & {
-  return get<std::string>();
-}
-inline double& dynamic::getDouble() & {
-  return get<double>();
-}
-inline int64_t& dynamic::getInt() & {
-  return get<int64_t>();
-}
-inline bool& dynamic::getBool() & {
-  return get<bool>();
-}
-
-inline std::string&& dynamic::getString() && {
-  return std::move(get<std::string>());
-}
-inline double dynamic::getDouble() && {
-  return get<double>();
-}
-inline int64_t dynamic::getInt() && {
-  return get<int64_t>();
-}
-inline bool dynamic::getBool() && {
-  return get<bool>();
-}
-
-inline const char* dynamic::c_str() const& {
-  return get<std::string>().c_str();
-}
-inline StringPiece dynamic::stringPiece() const {
-  return get<std::string>();
-}
-
-template <class T>
-struct dynamic::CompareOp {
-  static bool comp(T const& a, T const& b) { return a < b; }
-};
-template <>
-struct dynamic::CompareOp<dynamic::ObjectImpl> {
-  static bool comp(ObjectImpl const&, ObjectImpl const&) {
-    // This code never executes; it is just here for the compiler.
-    return false;
-  }
-};
-template <>
-struct dynamic::CompareOp<std::nullptr_t> {
-  static bool comp(std::nullptr_t const&, std::nullptr_t const&) {
-    return false;
-  }
-};
-
-inline dynamic& dynamic::operator+=(dynamic const& o) {
-  if (type() == STRING && o.type() == STRING) {
-    *getAddress<std::string>() += *o.getAddress<std::string>();
-    return *this;
-  }
-  *this = detail::numericOp<std::plus>(*this, o);
-  return *this;
-}
-
-inline dynamic& dynamic::operator-=(dynamic const& o) {
-  *this = detail::numericOp<std::minus>(*this, o);
-  return *this;
-}
-
-inline dynamic& dynamic::operator*=(dynamic const& o) {
-  *this = detail::numericOp<std::multiplies>(*this, o);
-  return *this;
-}
-
-inline dynamic& dynamic::operator/=(dynamic const& o) {
-  *this = detail::numericOp<std::divides>(*this, o);
-  return *this;
-}
-
-#define FB_DYNAMIC_INTEGER_OP(op)                            \
-  inline dynamic& dynamic::operator op(dynamic const& o) {   \
-    if (!isInt() || !o.isInt()) {                            \
-      throw_exception<TypeError>("int64", type(), o.type()); \
-    }                                                        \
-    *getAddress<int64_t>() op o.asInt();                     \
-    return *this;                                            \
-  }
-
-FB_DYNAMIC_INTEGER_OP(%=)
-FB_DYNAMIC_INTEGER_OP(|=)
-FB_DYNAMIC_INTEGER_OP(&=)
-FB_DYNAMIC_INTEGER_OP(^=)
-
-#undef FB_DYNAMIC_INTEGER_OP
-
-inline dynamic& dynamic::operator++() {
-  ++get<int64_t>();
-  return *this;
-}
-
-inline dynamic& dynamic::operator--() {
-  --get<int64_t>();
-  return *this;
-}
-
-template <typename K>
-dynamic::IfIsNonStringDynamicConvertible<K, dynamic const&> dynamic::operator[](
-    K&& idx) const& {
-  return at(std::forward<K>(idx));
-}
-
-template <typename K>
-dynamic::IfIsNonStringDynamicConvertible<K, dynamic&> dynamic::operator[](
-    K&& idx) & {
-  if (!isObject() && !isArray()) {
-    throw_exception<TypeError>("object/array", type());
-  }
-  if (isArray()) {
-    return at(std::forward<K>(idx));
-  }
-  auto& obj = get<ObjectImpl>();
-  auto ret = obj.emplace(std::forward<K>(idx), nullptr);
-  return ret.first->second;
-}
-
-template <typename K>
-dynamic::IfIsNonStringDynamicConvertible<K, dynamic&&> dynamic::operator[](
-    K&& idx) && {
-  return std::move((*this)[std::forward<K>(idx)]);
-}
-
-inline dynamic const& dynamic::operator[](StringPiece k) const& {
-  return at(k);
-}
-
-inline dynamic&& dynamic::operator[](StringPiece k) && {
-  return std::move((*this)[k]);
-}
-
-template <typename K>
-dynamic::IfIsNonStringDynamicConvertible<K, dynamic> dynamic::getDefault(
-    K&& k, const dynamic& v) const& {
-  auto& obj = get<ObjectImpl>();
-  auto it = obj.find(std::forward<K>(k));
-  return it == obj.end() ? v : it->second;
-}
-
-template <typename K>
-dynamic::IfIsNonStringDynamicConvertible<K, dynamic> dynamic::getDefault(
-    K&& k, dynamic&& v) const& {
-  auto& obj = get<ObjectImpl>();
-  auto it = obj.find(std::forward<K>(k));
-  // Avoid clang bug with ternary
-  if (it == obj.end()) {
-    return std::move(v);
-  } else {
-    return it->second;
-  }
-}
-
-template <typename K>
-dynamic::IfIsNonStringDynamicConvertible<K, dynamic> dynamic::getDefault(
-    K&& k, const dynamic& v) && {
-  auto& obj = get<ObjectImpl>();
-  auto it = obj.find(std::forward<K>(k));
-  // Avoid clang bug with ternary
-  if (it == obj.end()) {
-    return v;
-  } else {
-    return std::move(it->second);
-  }
-}
-
-template <typename K>
-dynamic::IfIsNonStringDynamicConvertible<K, dynamic> dynamic::getDefault(
-    K&& k, dynamic&& v) && {
-  auto& obj = get<ObjectImpl>();
-  auto it = obj.find(std::forward<K>(k));
-  return std::move(it == obj.end() ? v : it->second);
-}
-
-template <typename K, typename V>
-dynamic::IfIsNonStringDynamicConvertible<K, dynamic&> dynamic::setDefault(
-    K&& k, V&& v) {
-  auto& obj = get<ObjectImpl>();
-  return obj.emplace(std::forward<K>(k), std::forward<V>(v)).first->second;
-}
-
-template <typename K>
-dynamic::IfIsNonStringDynamicConvertible<K, dynamic&> dynamic::setDefault(
-    K&& k, dynamic&& v) {
-  auto& obj = get<ObjectImpl>();
-  return obj.emplace(std::forward<K>(k), std::move(v)).first->second;
-}
-
-template <typename K>
-dynamic::IfIsNonStringDynamicConvertible<K, dynamic&> dynamic::setDefault(
-    K&& k, const dynamic& v) {
-  auto& obj = get<ObjectImpl>();
-  return obj.emplace(std::forward<K>(k), v).first->second;
-}
-
-template <typename V>
-dynamic& dynamic::setDefault(StringPiece k, V&& v) {
-  auto& obj = get<ObjectImpl>();
-  return obj.emplace(k, std::forward<V>(v)).first->second;
-}
-
-inline dynamic& dynamic::setDefault(StringPiece k, dynamic&& v) {
-  auto& obj = get<ObjectImpl>();
-  return obj.emplace(k, std::move(v)).first->second;
-}
-
-inline dynamic& dynamic::setDefault(StringPiece k, const dynamic& v) {
-  auto& obj = get<ObjectImpl>();
-  return obj.emplace(k, v).first->second;
-}
-
-template <typename K>
-dynamic::IfIsNonStringDynamicConvertible<K, dynamic const*> dynamic::get_ptr(
-    K&& k) const& {
-  return get_ptrImpl(std::forward<K>(k));
-}
-
-template <typename K>
-dynamic::IfIsNonStringDynamicConvertible<K, dynamic*> dynamic::get_ptr(
-    K&& idx) & {
-  return const_cast<dynamic*>(const_cast<dynamic const*>(this)->get_ptr(idx));
-}
-
-inline dynamic* dynamic::get_ptr(StringPiece idx) & {
-  return const_cast<dynamic*>(const_cast<dynamic const*>(this)->get_ptr(idx));
-}
-
-// clang-format off
-inline
-dynamic::resolved_json_pointer<dynamic>
-dynamic::try_get_ptr(json_pointer const& jsonPtr) & {
-  auto ret = const_cast<dynamic const*>(this)->try_get_ptr(jsonPtr);
-  if (ret.hasValue()) {
-    return json_pointer_resolved_value<dynamic>{
-        const_cast<dynamic*>(ret.value().parent),
-        const_cast<dynamic*>(ret.value().value),
-        ret.value().parent_key, ret.value().parent_index};
-  } else {
-    return makeUnexpected(
-        json_pointer_resolution_error<dynamic>{
-            ret.error().error_code,
-            ret.error().index,
-            const_cast<dynamic*>(ret.error().context)}
-        );
-  }
-}
-// clang-format on
-
-inline dynamic* dynamic::get_ptr(json_pointer const& jsonPtr) & {
-  return const_cast<dynamic*>(
-      const_cast<dynamic const*>(this)->get_ptr(jsonPtr));
-}
-
-template <typename K>
-dynamic::IfIsNonStringDynamicConvertible<K, dynamic const&> dynamic::at(
-    K&& k) const& {
-  return atImpl(std::forward<K>(k));
-}
-
-template <typename K>
-dynamic::IfIsNonStringDynamicConvertible<K, dynamic&> dynamic::at(K&& idx) & {
-  return const_cast<dynamic&>(const_cast<dynamic const*>(this)->at(idx));
-}
-
-template <typename K>
-dynamic::IfIsNonStringDynamicConvertible<K, dynamic&&> dynamic::at(K&& idx) && {
-  return std::move(at(idx));
-}
-
-inline dynamic& dynamic::at(StringPiece idx) & {
-  return const_cast<dynamic&>(const_cast<dynamic const*>(this)->at(idx));
-}
-
-inline dynamic&& dynamic::at(StringPiece idx) && {
-  return std::move(at(idx));
-}
-
-inline bool dynamic::empty() const {
-  if (isNull()) {
-    return true;
-  }
-  return !size();
-}
-
-template <typename K>
-dynamic::IfIsNonStringDynamicConvertible<K, dynamic::const_item_iterator>
-dynamic::find(K&& key) const {
-  return get<ObjectImpl>().find(std::forward<K>(key));
-}
-
-template <typename K>
-dynamic::IfIsNonStringDynamicConvertible<K, dynamic::item_iterator>
-dynamic::find(K&& key) {
-  return get<ObjectImpl>().find(std::forward<K>(key));
-}
-
-inline dynamic::const_item_iterator dynamic::find(StringPiece key) const {
-  return get<ObjectImpl>().find(key);
-}
-
-inline dynamic::item_iterator dynamic::find(StringPiece key) {
-  return get<ObjectImpl>().find(key);
-}
-
-template <typename K>
-dynamic::IfIsNonStringDynamicConvertible<K, std::size_t> dynamic::count(
-    K&& key) const {
-  return find(std::forward<K>(key)) != items().end() ? 1u : 0u;
-}
-
-inline std::size_t dynamic::count(StringPiece key) const {
-  return find(key) != items().end() ? 1u : 0u;
-}
-
-template <class K, class V>
-inline dynamic::IfNotIterator<K, void> dynamic::insert(K&& key, V&& val) {
-  auto& obj = get<ObjectImpl>();
-  obj[std::forward<K>(key)] = std::forward<V>(val);
-}
-
-template <class... Args>
-inline std::pair<dynamic::item_iterator, bool> dynamic::emplace(
-    Args&&... args) {
-  auto& obj = get<ObjectImpl>();
-  return obj.emplace(std::forward<Args>(args)...);
-}
-
-template <class K, class... Args>
-inline std::pair<dynamic::item_iterator, bool> dynamic::try_emplace(
-    K&& key, Args&&... args) {
-  auto& obj = get<ObjectImpl>();
-  return obj.try_emplace(std::forward<K>(key), std::forward<Args>(args)...);
-}
-
-template <class T>
-inline dynamic::iterator dynamic::insert(const_iterator pos, T&& value) {
-  auto& arr = get<Array>();
-  return arr.insert(pos, std::forward<T>(value));
-}
-
-template <class InputIt>
-inline dynamic::iterator dynamic::insert(
-    const_iterator pos, InputIt first, InputIt last) {
-  auto& arr = get<Array>();
-  return arr.insert(pos, first, last);
-}
-
-inline void dynamic::update(const dynamic& mergeObj) {
-  if (!isObject() || !mergeObj.isObject()) {
-    throw_exception<TypeError>("object", type(), mergeObj.type());
-  }
-
-  for (const auto& pair : mergeObj.items()) {
-    (*this)[pair.first] = pair.second;
-  }
-}
-
-inline void dynamic::update_missing(const dynamic& mergeObj1) {
-  if (!isObject() || !mergeObj1.isObject()) {
-    throw_exception<TypeError>("object", type(), mergeObj1.type());
-  }
-
-  // Only add if not already there
-  for (const auto& pair : mergeObj1.items()) {
-    if ((*this).find(pair.first) == (*this).items().end()) {
-      (*this)[pair.first] = pair.second;
-    }
-  }
-}
-
-inline void dynamic::merge_patch(const dynamic& patch) {
-  auto& self = *this;
-  if (!patch.isObject()) {
-    self = patch;
-    return;
-  }
-  // if we are not an object, erase all contents, reset to object
-  if (!isObject()) {
-    self = object;
-  }
-  for (const auto& pair : patch.items()) {
-    if (pair.second.isNull()) {
-      // if name could be found in current object, remove it
-      auto it = self.find(pair.first);
-      if (it != self.items().end()) {
-        self.erase(it);
-      }
-    } else {
-      self[pair.first].merge_patch(pair.second);
-    }
-  }
-}
-
-inline dynamic dynamic::merge(
-    const dynamic& mergeObj1, const dynamic& mergeObj2) {
-  // No checks on type needed here because they are done in update_missing
-  // Note that we do update_missing here instead of update() because
-  // it will prevent the extra writes that would occur with update()
-  auto ret = mergeObj2;
-  ret.update_missing(mergeObj1);
-  return ret;
-}
-
-template <typename K>
-dynamic::IfIsNonStringDynamicConvertible<K, std::size_t> dynamic::erase(
-    K&& key) {
-  auto& obj = get<ObjectImpl>();
-  return obj.erase(std::forward<K>(key));
-}
-inline std::size_t dynamic::erase(StringPiece key) {
-  auto& obj = get<ObjectImpl>();
-  return obj.erase(key);
-}
-
-inline dynamic::iterator dynamic::erase(const_iterator it) {
-  auto& arr = get<Array>();
-  // std::vector doesn't have an erase method that works on const iterators,
-  // even though the standard says it should, so this hack converts to a
-  // non-const iterator before calling erase.
-  return get<Array>().erase(arr.begin() + (it - arr.begin()));
-}
-
-inline dynamic::const_key_iterator dynamic::erase(const_key_iterator it) {
-  return const_key_iterator(get<ObjectImpl>().erase(it.base()));
-}
-
-inline dynamic::const_key_iterator dynamic::erase(
-    const_key_iterator first, const_key_iterator last) {
-  return const_key_iterator(get<ObjectImpl>().erase(first.base(), last.base()));
-}
-
-inline dynamic::value_iterator dynamic::erase(const_value_iterator it) {
-  return value_iterator(get<ObjectImpl>().erase(it.base()));
-}
-
-inline dynamic::value_iterator dynamic::erase(
-    const_value_iterator first, const_value_iterator last) {
-  return value_iterator(get<ObjectImpl>().erase(first.base(), last.base()));
-}
-
-inline dynamic::item_iterator dynamic::erase(const_item_iterator it) {
-  return item_iterator(get<ObjectImpl>().erase(it.base()));
-}
-
-inline dynamic::item_iterator dynamic::erase(
-    const_item_iterator first, const_item_iterator last) {
-  return item_iterator(get<ObjectImpl>().erase(first.base(), last.base()));
-}
-
-inline void dynamic::resize(std::size_t sz, dynamic const& c) {
-  auto& arr = get<Array>();
-  arr.resize(sz, c);
-}
-
-inline void dynamic::push_back(dynamic const& v) {
-  auto& arr = get<Array>();
-  arr.push_back(v);
-}
-
-inline void dynamic::push_back(dynamic&& v) {
-  auto& arr = get<Array>();
-  arr.push_back(std::move(v));
-}
-
-inline void dynamic::pop_back() {
-  auto& arr = get<Array>();
-  arr.pop_back();
-}
-
-inline const dynamic& dynamic::back() const {
-  auto& arr = get<Array>();
-  return arr.back();
-}
-
-//////////////////////////////////////////////////////////////////////
-
-inline dynamic::dynamic(Array&& r) : type_(ARRAY) {
-  new (&u_.array) Array(std::move(r));
-}
-
-#define FOLLY_DYNAMIC_DEC_TYPEINFO(T, val)     \
-  template <>                                  \
-  struct dynamic::TypeInfo<T> {                \
-    static const char* const name;             \
-    static constexpr dynamic::Type type = val; \
-  };                                           \
-  //
-
-FOLLY_DYNAMIC_DEC_TYPEINFO(std::nullptr_t, dynamic::NULLT)
-FOLLY_DYNAMIC_DEC_TYPEINFO(bool, dynamic::BOOL)
-FOLLY_DYNAMIC_DEC_TYPEINFO(std::string, dynamic::STRING)
-FOLLY_DYNAMIC_DEC_TYPEINFO(dynamic::Array, dynamic::ARRAY)
-FOLLY_DYNAMIC_DEC_TYPEINFO(double, dynamic::DOUBLE)
-FOLLY_DYNAMIC_DEC_TYPEINFO(int64_t, dynamic::INT64)
-FOLLY_DYNAMIC_DEC_TYPEINFO(dynamic::ObjectImpl, dynamic::OBJECT)
-
-#undef FOLLY_DYNAMIC_DEC_TYPEINFO
-
-template <class T>
-T dynamic::asImpl() const {
-  FOLLY_PUSH_WARNING
-  FOLLY_CLANG_DISABLE_WARNING("-Wcovered-switch-default")
-  switch (type()) {
-    case INT64:
-      return to<T>(*get_nothrow<int64_t>());
-    case DOUBLE:
-      return to<T>(*get_nothrow<double>());
-    case BOOL:
-      return to<T>(*get_nothrow<bool>());
-    case STRING:
-      return to<T>(*get_nothrow<std::string>());
-    case NULLT:
-    case ARRAY:
-    case OBJECT:
-    default:
-      throw_exception<TypeError>("int/double/bool/string", type());
-  }
-  FOLLY_POP_WARNING
-}
-
-// Return a T* to our type, or null if we're not that type.
-template <class T>
-T* dynamic::get_nothrow() & noexcept {
-  if (type_ != TypeInfo<T>::type) {
-    return nullptr;
-  }
-  return getAddress<T>();
-}
-
-template <class T>
-T const* dynamic::get_nothrow() const& noexcept {
-  return const_cast<dynamic*>(this)->get_nothrow<T>();
-}
-
-// Return T* for where we can put a T, without type checking.  (Memory
-// might be uninitialized, even.)
-template <class T>
-T* dynamic::getAddress() noexcept {
-  return GetAddrImpl<T>::get(u_);
-}
-
-template <class T>
-T const* dynamic::getAddress() const noexcept {
-  return const_cast<dynamic*>(this)->getAddress<T>();
-}
-
-template <class T>
-struct dynamic::GetAddrImpl {};
-template <>
-struct dynamic::GetAddrImpl<std::nullptr_t> {
-  static std::nullptr_t* get(Data& d) noexcept { return &d.nul; }
-};
-template <>
-struct dynamic::GetAddrImpl<dynamic::Array> {
-  static Array* get(Data& d) noexcept { return &d.array; }
-};
-template <>
-struct dynamic::GetAddrImpl<bool> {
-  static bool* get(Data& d) noexcept { return &d.boolean; }
-};
-template <>
-struct dynamic::GetAddrImpl<int64_t> {
-  static int64_t* get(Data& d) noexcept { return &d.integer; }
-};
-template <>
-struct dynamic::GetAddrImpl<double> {
-  static double* get(Data& d) noexcept { return &d.doubl; }
-};
-template <>
-struct dynamic::GetAddrImpl<std::string> {
-  static std::string* get(Data& d) noexcept { return &d.string; }
-};
-template <>
-struct dynamic::GetAddrImpl<dynamic::ObjectImpl> {
-  static_assert(
-      sizeof(ObjectImpl) <= sizeof(Data::objectBuffer),
-      "In your implementation, F14NodeMap<> apparently takes different"
-      " amount of space depending on its template parameters.  This is "
-      "weird.  Make objectBuffer bigger if you want to compile dynamic.");
-
-  static ObjectImpl* get(Data& d) noexcept {
-    void* data = &d.objectBuffer;
-    return static_cast<ObjectImpl*>(data);
-  }
-};
-
+   using Super = detail::IteratorAdaptor<
+       dynamic::item_iterator,
+       dynamic::ObjectImpl::iterator,
+       std::pair<dynamic const, dynamic>,
+       std::forward_iterator_tag>;
+   item_iterator() = default;
+   /* implicit */ item_iterator(dynamic::ObjectImpl::iterator b) : Super(b) {}
+ 
+   using object_type = dynamic::ObjectImpl;
+ };
+ 
+ struct dynamic::value_iterator : detail::IteratorAdaptor<
+                                      dynamic::value_iterator,
+                                      dynamic::ObjectImpl::iterator,
+                                      dynamic,
+                                      std::forward_iterator_tag> {
+   using Super = detail::IteratorAdaptor<
+       dynamic::value_iterator,
+       dynamic::ObjectImpl::iterator,
+       dynamic,
+       std::forward_iterator_tag>;
+   value_iterator() = default;
+   /* implicit */ value_iterator(dynamic::ObjectImpl::iterator b) : Super(b) {}
+ 
+   using object_type = dynamic::ObjectImpl;
+ 
+   dynamic& dereference() const { return base()->second; }
+ };
+ 
+ struct dynamic::const_item_iterator
+     : detail::IteratorAdaptor<
+           dynamic::const_item_iterator,
+           dynamic::ObjectImpl::const_iterator,
+           std::pair<dynamic const, dynamic> const,
+           std::forward_iterator_tag> {
+   using Super = detail::IteratorAdaptor<
+       dynamic::const_item_iterator,
+       dynamic::ObjectImpl::const_iterator,
+       std::pair<dynamic const, dynamic> const,
+       std::forward_iterator_tag>;
+   const_item_iterator() = default;
+   /* implicit */ const_item_iterator(dynamic::ObjectImpl::const_iterator b)
+       : Super(b) {}
+   /* implicit */ const_item_iterator(item_iterator i) : Super(i.base()) {}
+ 
+   using object_type = dynamic::ObjectImpl const;
+ };
+ 
+ struct dynamic::const_key_iterator : detail::IteratorAdaptor<
+                                          dynamic::const_key_iterator,
+                                          dynamic::ObjectImpl::const_iterator,
+                                          dynamic const,
+                                          std::forward_iterator_tag> {
+   using Super = detail::IteratorAdaptor<
+       dynamic::const_key_iterator,
+       dynamic::ObjectImpl::const_iterator,
+       dynamic const,
+       std::forward_iterator_tag>;
+   const_key_iterator() = default;
+   /* implicit */ const_key_iterator(dynamic::ObjectImpl::const_iterator b)
+       : Super(b) {}
+ 
+   using object_type = dynamic::ObjectImpl const;
+ 
+   dynamic const& dereference() const { return base()->first; }
+ };
+ 
+ struct dynamic::const_value_iterator : detail::IteratorAdaptor<
+                                            dynamic::const_value_iterator,
+                                            dynamic::ObjectImpl::const_iterator,
+                                            dynamic const,
+                                            std::forward_iterator_tag> {
+   using Super = detail::IteratorAdaptor<
+       dynamic::const_value_iterator,
+       dynamic::ObjectImpl::const_iterator,
+       dynamic const,
+       std::forward_iterator_tag>;
+   const_value_iterator() = default;
+   /* implicit */ const_value_iterator(dynamic::ObjectImpl::const_iterator b)
+       : Super(b) {}
+   /* implicit */ const_value_iterator(value_iterator i) : Super(i.base()) {}
+   /* implicit */ const_value_iterator(dynamic::ObjectImpl::iterator i)
+       : Super(i) {}
+ 
+   using object_type = dynamic::ObjectImpl const;
+ 
+   dynamic const& dereference() const { return base()->second; }
+ };
+ 
+ //////////////////////////////////////////////////////////////////////
+ 
+ inline dynamic::dynamic() : dynamic(nullptr) {}
+ 
+ inline dynamic::dynamic(std::nullptr_t) : type_(NULLT) {}
+ 
+ inline dynamic::dynamic(void (*)(EmptyArrayTag)) : type_(ARRAY) {
+   new (&u_.array) Array();
+ }
+ 
+ inline dynamic::dynamic(ObjectMaker (*)()) : type_(OBJECT) {
+   new (getAddress<ObjectImpl>()) ObjectImpl();
+ }
+ 
+ inline dynamic::dynamic(char const* s) : type_(STRING) {
+   new (&u_.string) std::string(s);
+ }
+ 
+ inline dynamic::dynamic(std::string s) : type_(STRING) {
+   new (&u_.string) std::string(std::move(s));
+ }
+ 
+ template <typename Stringish, typename>
+ inline dynamic::dynamic(Stringish&& s) : type_(STRING) {
+   new (&u_.string) std::string(s.data(), s.size());
+ }
+ 
+ inline dynamic::dynamic(ObjectMaker&& maker) : type_(OBJECT) {
+   new (getAddress<ObjectImpl>())
+       ObjectImpl(std::move(*maker.val_.getAddress<ObjectImpl>()));
+ }
+ 
+ inline dynamic::~dynamic() noexcept {
+   destroy();
+ }
+ 
+ // Integral types except bool convert to int64_t, float types to double.
+ template <class T>
+ struct dynamic::NumericTypeHelper<
+     T,
+     typename std::enable_if<std::is_integral<T>::value>::type> {
+   static_assert(
+       !kIsObjC || sizeof(T) > sizeof(char),
+       "char-sized types are ambiguous in objc; cast to bool or wider type");
+   using type = int64_t;
+ };
+ template <>
+ struct dynamic::NumericTypeHelper<bool> {
+   using type = bool;
+ };
+ template <>
+ struct dynamic::NumericTypeHelper<float> {
+   using type = double;
+ };
+ template <>
+ struct dynamic::NumericTypeHelper<double> {
+   using type = double;
+ };
+ 
+ inline dynamic::dynamic(std::vector<bool>::reference b)
+     : dynamic(static_cast<bool>(b)) {}
+ inline dynamic::dynamic(VectorBoolConstRefCtorType b)
+     : dynamic(static_cast<bool>(b)) {}
+ 
+ template <
+     class T,
+     class NumericType /* = typename NumericTypeHelper<T>::type */>
+ dynamic::dynamic(T t) {
+   type_ = TypeInfo<NumericType>::type;
+   new (getAddress<NumericType>()) NumericType(NumericType(t));
+ }
+ 
+ template <class Iterator>
+ dynamic::dynamic(array_range_construct_t, Iterator first, Iterator last)
+     : type_(ARRAY) {
+   new (&u_.array) Array(first, last);
+ }
+ 
+ template <
+     class T,
+     class NumericType /* = typename NumericTypeHelper<T>::type */>
+ dynamic& dynamic::operator=(T t) {
+   const auto newType = TypeInfo<NumericType>::type;
+   if (type_ == newType) {
+     *getAddress<NumericType>() = t;
+   } else {
+     destroy();
+     new (getAddress<NumericType>()) NumericType(t);
+     type_ = newType;
+   }
+   return *this;
+ }
+ //////////////////////////////////////////////////////////////////////
+ 
+ inline dynamic::const_iterator dynamic::begin() const {
+   return get<Array>().begin();
+ }
+ inline dynamic::const_iterator dynamic::end() const {
+   return get<Array>().end();
+ }
+ 
+ inline dynamic::iterator dynamic::begin() {
+   return get<Array>().begin();
+ }
+ inline dynamic::iterator dynamic::end() {
+   return get<Array>().end();
+ }
+ 
+ template <class It>
+ struct dynamic::IterableProxy {
+   typedef It iterator;
+   typedef typename It::value_type value_type;
+   typedef typename It::object_type object_type;
+ 
+   /* implicit */ IterableProxy(object_type* o) : o_(o) {}
+ 
+   It begin() const { return o_->begin(); }
+ 
+   It end() const { return o_->end(); }
+ 
+  private:
+   object_type* o_;
+ };
+ 
+ inline dynamic::IterableProxy<dynamic::const_key_iterator> dynamic::keys()
+     const {
+   return &(get<ObjectImpl>());
+ }
+ 
+ inline dynamic::IterableProxy<dynamic::const_value_iterator> dynamic::values()
+     const {
+   return &(get<ObjectImpl>());
+ }
+ 
+ inline dynamic::IterableProxy<dynamic::const_item_iterator> dynamic::items()
+     const {
+   return &(get<ObjectImpl>());
+ }
+ 
+ inline dynamic::IterableProxy<dynamic::value_iterator> dynamic::values() {
+   return &(get<ObjectImpl>());
+ }
+ 
+ inline dynamic::IterableProxy<dynamic::item_iterator> dynamic::items() {
+   return &(get<ObjectImpl>());
+ }
+ 
+ inline bool dynamic::isString() const {
+   return get_nothrow<std::string>() != nullptr;
+ }
+ inline bool dynamic::isObject() const {
+   return get_nothrow<ObjectImpl>() != nullptr;
+ }
+ inline bool dynamic::isBool() const {
+   return get_nothrow<bool>() != nullptr;
+ }
+ inline bool dynamic::isArray() const {
+   return get_nothrow<Array>() != nullptr;
+ }
+ inline bool dynamic::isDouble() const {
+   return get_nothrow<double>() != nullptr;
+ }
+ inline bool dynamic::isInt() const {
+   return get_nothrow<int64_t>() != nullptr;
+ }
+ inline bool dynamic::isNull() const {
+   return get_nothrow<std::nullptr_t>() != nullptr;
+ }
+ inline bool dynamic::isNumber() const {
+   return isInt() || isDouble();
+ }
+ 
+ inline dynamic::Type dynamic::type() const {
+   return type_;
+ }
+ 
+ inline std::string dynamic::asString() const {
+   return asImpl<std::string>();
+ }
+ inline double dynamic::asDouble() const {
+   return asImpl<double>();
+ }
+ inline int64_t dynamic::asInt() const {
+   return asImpl<int64_t>();
+ }
+ inline bool dynamic::asBool() const {
+   return asImpl<bool>();
+ }
+ 
+ inline const std::string& dynamic::getString() const& {
+   return get<std::string>();
+ }
+ inline double dynamic::getDouble() const& {
+   return get<double>();
+ }
+ inline int64_t dynamic::getInt() const& {
+   return get<int64_t>();
+ }
+ inline bool dynamic::getBool() const& {
+   return get<bool>();
+ }
+ 
+ inline std::string& dynamic::getString() & {
+   return get<std::string>();
+ }
+ inline double& dynamic::getDouble() & {
+   return get<double>();
+ }
+ inline int64_t& dynamic::getInt() & {
+   return get<int64_t>();
+ }
+ inline bool& dynamic::getBool() & {
+   return get<bool>();
+ }
+ 
+ inline std::string&& dynamic::getString() && {
+   return std::move(get<std::string>());
+ }
+ inline double dynamic::getDouble() && {
+   return get<double>();
+ }
+ inline int64_t dynamic::getInt() && {
+   return get<int64_t>();
+ }
+ inline bool dynamic::getBool() && {
+   return get<bool>();
+ }
+ 
+ inline const char* dynamic::c_str() const& {
+   return get<std::string>().c_str();
+ }
+ inline StringPiece dynamic::stringPiece() const {
+   return get<std::string>();
+ }
+ 
+ template <class T>
+ struct dynamic::CompareOp {
+   static bool comp(T const& a, T const& b) { return a < b; }
+ };
+ template <>
+ struct dynamic::CompareOp<dynamic::ObjectImpl> {
+   static bool comp(ObjectImpl const&, ObjectImpl const&) {
+     // This code never executes; it is just here for the compiler.
+     return false;
+   }
+ };
+ template <>
+ struct dynamic::CompareOp<std::nullptr_t> {
+   static bool comp(std::nullptr_t const&, std::nullptr_t const&) {
+     return false;
+   }
+ };
+ 
+ inline dynamic& dynamic::operator+=(dynamic const& o) {
+   if (type() == STRING && o.type() == STRING) {
+     *getAddress<std::string>() += *o.getAddress<std::string>();
+     return *this;
+   }
+   *this = detail::numericOp<std::plus>(*this, o);
+   return *this;
+ }
+ 
+ inline dynamic& dynamic::operator-=(dynamic const& o) {
+   *this = detail::numericOp<std::minus>(*this, o);
+   return *this;
+ }
+ 
+ inline dynamic& dynamic::operator*=(dynamic const& o) {
+   *this = detail::numericOp<std::multiplies>(*this, o);
+   return *this;
+ }
+ 
+ inline dynamic& dynamic::operator/=(dynamic const& o) {
+   *this = detail::numericOp<std::divides>(*this, o);
+   return *this;
+ }
+ 
+ #define FB_DYNAMIC_INTEGER_OP(op)                            \
+   inline dynamic& dynamic::operator op(dynamic const& o) {   \
+     if (!isInt() || !o.isInt()) {                            \
+       throw_exception<TypeError>("int64", type(), o.type()); \
+     }                                                        \
+     *getAddress<int64_t>() op o.asInt();                     \
+     return *this;                                            \
+   }
+ 
+ FB_DYNAMIC_INTEGER_OP(%=)
+ FB_DYNAMIC_INTEGER_OP(|=)
+ FB_DYNAMIC_INTEGER_OP(&=)
+ FB_DYNAMIC_INTEGER_OP(^=)
+ 
+ #undef FB_DYNAMIC_INTEGER_OP
+ 
+ inline dynamic& dynamic::operator++() {
+   ++get<int64_t>();
+   return *this;
+ }
+ 
+ inline dynamic& dynamic::operator--() {
+   --get<int64_t>();
+   return *this;
+ }
+ 
+ template <typename K>
+ dynamic::IfIsNonStringDynamicConvertible<K, dynamic const&> dynamic::operator[](
+     K&& idx) const& {
+   return at(std::forward<K>(idx));
+ }
+ 
+ template <typename K>
+ dynamic::IfIsNonStringDynamicConvertible<K, dynamic&> dynamic::operator[](
+     K&& idx) & {
+   if (!isObject() && !isArray()) {
+     throw_exception<TypeError>("object/array", type());
+   }
+   if (isArray()) {
+     return at(std::forward<K>(idx));
+   }
+   auto& obj = get<ObjectImpl>();
+   auto ret = obj.emplace(std::forward<K>(idx), nullptr);
+   return ret.first->second;
+ }
+ 
+ template <typename K>
+ dynamic::IfIsNonStringDynamicConvertible<K, dynamic&&> dynamic::operator[](
+     K&& idx) && {
+   return std::move((*this)[std::forward<K>(idx)]);
+ }
+ 
+ inline dynamic const& dynamic::operator[](StringPiece k) const& {
+   return at(k);
+ }
+ 
+ inline dynamic&& dynamic::operator[](StringPiece k) && {
+   return std::move((*this)[k]);
+ }
+ 
+ template <typename K>
+ dynamic::IfIsNonStringDynamicConvertible<K, dynamic> dynamic::getDefault(
+     K&& k, const dynamic& v) const& {
+   auto& obj = get<ObjectImpl>();
+   auto it = obj.find(std::forward<K>(k));
+   return it == obj.end() ? v : it->second;
+ }
+ 
+ template <typename K>
+ dynamic::IfIsNonStringDynamicConvertible<K, dynamic> dynamic::getDefault(
+     K&& k, dynamic&& v) const& {
+   auto& obj = get<ObjectImpl>();
+   auto it = obj.find(std::forward<K>(k));
+   // Avoid clang bug with ternary
+   if (it == obj.end()) {
+     return std::move(v);
+   } else {
+     return it->second;
+   }
+ }
+ 
+ template <typename K>
+ dynamic::IfIsNonStringDynamicConvertible<K, dynamic> dynamic::getDefault(
+     K&& k, const dynamic& v) && {
+   auto& obj = get<ObjectImpl>();
+   auto it = obj.find(std::forward<K>(k));
+   // Avoid clang bug with ternary
+   if (it == obj.end()) {
+     return v;
+   } else {
+     return std::move(it->second);
+   }
+ }
+ 
+ template <typename K>
+ dynamic::IfIsNonStringDynamicConvertible<K, dynamic> dynamic::getDefault(
+     K&& k, dynamic&& v) && {
+   auto& obj = get<ObjectImpl>();
+   auto it = obj.find(std::forward<K>(k));
+   return std::move(it == obj.end() ? v : it->second);
+ }
+ 
+ template <typename K, typename V>
+ dynamic::IfIsNonStringDynamicConvertible<K, dynamic&> dynamic::setDefault(
+     K&& k, V&& v) {
+   auto& obj = get<ObjectImpl>();
+   return obj.emplace(std::forward<K>(k), std::forward<V>(v)).first->second;
+ }
+ 
+ template <typename K>
+ dynamic::IfIsNonStringDynamicConvertible<K, dynamic&> dynamic::setDefault(
+     K&& k, dynamic&& v) {
+   auto& obj = get<ObjectImpl>();
+   return obj.emplace(std::forward<K>(k), std::move(v)).first->second;
+ }
+ 
+ template <typename K>
+ dynamic::IfIsNonStringDynamicConvertible<K, dynamic&> dynamic::setDefault(
+     K&& k, const dynamic& v) {
+   auto& obj = get<ObjectImpl>();
+   return obj.emplace(std::forward<K>(k), v).first->second;
+ }
+ 
+ template <typename V>
+ dynamic& dynamic::setDefault(StringPiece k, V&& v) {
+   auto& obj = get<ObjectImpl>();
+   return obj.emplace(k, std::forward<V>(v)).first->second;
+ }
+ 
+ inline dynamic& dynamic::setDefault(StringPiece k, dynamic&& v) {
+   auto& obj = get<ObjectImpl>();
+   return obj.emplace(k, std::move(v)).first->second;
+ }
+ 
+ inline dynamic& dynamic::setDefault(StringPiece k, const dynamic& v) {
+   auto& obj = get<ObjectImpl>();
+   return obj.emplace(k, v).first->second;
+ }
+ 
+ template <typename K>
+ dynamic::IfIsNonStringDynamicConvertible<K, dynamic const*> dynamic::get_ptr(
+     K&& k) const& {
+   return get_ptrImpl(std::forward<K>(k));
+ }
+ 
+ template <typename K>
+ dynamic::IfIsNonStringDynamicConvertible<K, dynamic*> dynamic::get_ptr(
+     K&& idx) & {
+   return const_cast<dynamic*>(const_cast<dynamic const*>(this)->get_ptr(idx));
+ }
+ 
+ inline dynamic* dynamic::get_ptr(StringPiece idx) & {
+   return const_cast<dynamic*>(const_cast<dynamic const*>(this)->get_ptr(idx));
+ }
+ 
+ // clang-format off
+ inline
+ dynamic::resolved_json_pointer<dynamic>
+ dynamic::try_get_ptr(json_pointer const& jsonPtr) & {
+   auto ret = const_cast<dynamic const*>(this)->try_get_ptr(jsonPtr);
+   if (ret.hasValue()) {
+     return json_pointer_resolved_value<dynamic>{
+         const_cast<dynamic*>(ret.value().parent),
+         const_cast<dynamic*>(ret.value().value),
+         ret.value().parent_key, ret.value().parent_index};
+   } else {
+     return makeUnexpected(
+         json_pointer_resolution_error<dynamic>{
+             ret.error().error_code,
+             ret.error().index,
+             const_cast<dynamic*>(ret.error().context)}
+         );
+   }
+ }
+ // clang-format on
+ 
+ inline dynamic* dynamic::get_ptr(json_pointer const& jsonPtr) & {
+   return const_cast<dynamic*>(
+       const_cast<dynamic const*>(this)->get_ptr(jsonPtr));
+ }
+ 
+ template <typename K>
+ dynamic::IfIsNonStringDynamicConvertible<K, dynamic const&> dynamic::at(
+     K&& k) const& {
+   return atImpl(std::forward<K>(k));
+ }
+ 
+ template <typename K>
+ dynamic::IfIsNonStringDynamicConvertible<K, dynamic&> dynamic::at(K&& idx) & {
+   return const_cast<dynamic&>(const_cast<dynamic const*>(this)->at(idx));
+ }
+ 
+ template <typename K>
+ dynamic::IfIsNonStringDynamicConvertible<K, dynamic&&> dynamic::at(K&& idx) && {
+   return std::move(at(idx));
+ }
+ 
+ inline dynamic& dynamic::at(StringPiece idx) & {
+   return const_cast<dynamic&>(const_cast<dynamic const*>(this)->at(idx));
+ }
+ 
+ inline dynamic&& dynamic::at(StringPiece idx) && {
+   return std::move(at(idx));
+ }
+ 
+ inline bool dynamic::empty() const {
+   if (isNull()) {
+     return true;
+   }
+   return !size();
+ }
+ 
+ template <typename K>
+ dynamic::IfIsNonStringDynamicConvertible<K, dynamic::const_item_iterator>
+ dynamic::find(K&& key) const {
+   return get<ObjectImpl>().find(std::forward<K>(key));
+ }
+ 
+ template <typename K>
+ dynamic::IfIsNonStringDynamicConvertible<K, dynamic::item_iterator>
+ dynamic::find(K&& key) {
+   return get<ObjectImpl>().find(std::forward<K>(key));
+ }
+ 
+ inline dynamic::const_item_iterator dynamic::find(StringPiece key) const {
+   return get<ObjectImpl>().find(key);
+ }
+ 
+ inline dynamic::item_iterator dynamic::find(StringPiece key) {
+   return get<ObjectImpl>().find(key);
+ }
+ 
+ template <typename K>
+ dynamic::IfIsNonStringDynamicConvertible<K, std::size_t> dynamic::count(
+     K&& key) const {
+   return find(std::forward<K>(key)) != items().end() ? 1u : 0u;
+ }
+ 
+ inline std::size_t dynamic::count(StringPiece key) const {
+   return find(key) != items().end() ? 1u : 0u;
+ }
+ 
+ template <class K, class V>
+ inline dynamic::IfNotIterator<K, void> dynamic::insert(K&& key, V&& val) {
+   auto& obj = get<ObjectImpl>();
+   obj[std::forward<K>(key)] = std::forward<V>(val);
+ }
+ 
+ template <class... Args>
+ inline std::pair<dynamic::item_iterator, bool> dynamic::emplace(
+     Args&&... args) {
+   auto& obj = get<ObjectImpl>();
+   return obj.emplace(std::forward<Args>(args)...);
+ }
+ 
+ template <class K, class... Args>
+ inline std::pair<dynamic::item_iterator, bool> dynamic::try_emplace(
+     K&& key, Args&&... args) {
+   auto& obj = get<ObjectImpl>();
+   return obj.try_emplace(std::forward<K>(key), std::forward<Args>(args)...);
+ }
+ 
+ template <class T>
+ inline dynamic::iterator dynamic::insert(const_iterator pos, T&& value) {
+   auto& arr = get<Array>();
+   return arr.insert(pos, std::forward<T>(value));
+ }
+ 
+ template <class InputIt>
+ inline dynamic::iterator dynamic::insert(
+     const_iterator pos, InputIt first, InputIt last) {
+   auto& arr = get<Array>();
+   return arr.insert(pos, first, last);
+ }
+ 
+ inline void dynamic::update(const dynamic& mergeObj) {
+   if (!isObject() || !mergeObj.isObject()) {
+     throw_exception<TypeError>("object", type(), mergeObj.type());
+   }
+ 
+   for (const auto& pair : mergeObj.items()) {
+     (*this)[pair.first] = pair.second;
+   }
+ }
+ 
+ inline void dynamic::update_missing(const dynamic& mergeObj1) {
+   if (!isObject() || !mergeObj1.isObject()) {
+     throw_exception<TypeError>("object", type(), mergeObj1.type());
+   }
+ 
+   // Only add if not already there
+   for (const auto& pair : mergeObj1.items()) {
+     if ((*this).find(pair.first) == (*this).items().end()) {
+       (*this)[pair.first] = pair.second;
+     }
+   }
+ }
+ 
+ inline void dynamic::merge_patch(const dynamic& patch) {
+   auto& self = *this;
+   if (!patch.isObject()) {
+     self = patch;
+     return;
+   }
+   // if we are not an object, erase all contents, reset to object
+   if (!isObject()) {
+     self = object;
+   }
+   for (const auto& pair : patch.items()) {
+     if (pair.second.isNull()) {
+       // if name could be found in current object, remove it
+       auto it = self.find(pair.first);
+       if (it != self.items().end()) {
+         self.erase(it);
+       }
+     } else {
+       self[pair.first].merge_patch(pair.second);
+     }
+   }
+ }
+ 
+ inline dynamic dynamic::merge(
+     const dynamic& mergeObj1, const dynamic& mergeObj2) {
+   // No checks on type needed here because they are done in update_missing
+   // Note that we do update_missing here instead of update() because
+   // it will prevent the extra writes that would occur with update()
+   auto ret = mergeObj2;
+   ret.update_missing(mergeObj1);
+   return ret;
+ }
+ 
+ template <typename K>
+ dynamic::IfIsNonStringDynamicConvertible<K, std::size_t> dynamic::erase(
+     K&& key) {
+   auto& obj = get<ObjectImpl>();
+   return obj.erase(std::forward<K>(key));
+ }
+ inline std::size_t dynamic::erase(StringPiece key) {
+   auto& obj = get<ObjectImpl>();
+   return obj.erase(key);
+ }
+ 
+ inline dynamic::iterator dynamic::erase(const_iterator it) {
+   auto& arr = get<Array>();
+   // std::vector doesn't have an erase method that works on const iterators,
+   // even though the standard says it should, so this hack converts to a
+   // non-const iterator before calling erase.
+   return get<Array>().erase(arr.begin() + (it - arr.begin()));
+ }
+ 
+ inline dynamic::const_key_iterator dynamic::erase(const_key_iterator it) {
+   return const_key_iterator(get<ObjectImpl>().erase(it.base()));
+ }
+ 
+ inline dynamic::const_key_iterator dynamic::erase(
+     const_key_iterator first, const_key_iterator last) {
+   return const_key_iterator(get<ObjectImpl>().erase(first.base(), last.base()));
+ }
+ 
+ inline dynamic::value_iterator dynamic::erase(const_value_iterator it) {
+   return value_iterator(get<ObjectImpl>().erase(it.base()));
+ }
+ 
+ inline dynamic::value_iterator dynamic::erase(
+     const_value_iterator first, const_value_iterator last) {
+   return value_iterator(get<ObjectImpl>().erase(first.base(), last.base()));
+ }
+ 
+ inline dynamic::item_iterator dynamic::erase(const_item_iterator it) {
+   return item_iterator(get<ObjectImpl>().erase(it.base()));
+ }
+ 
+ inline dynamic::item_iterator dynamic::erase(
+     const_item_iterator first, const_item_iterator last) {
+   return item_iterator(get<ObjectImpl>().erase(first.base(), last.base()));
+ }
+ 
+ inline void dynamic::resize(std::size_t sz, dynamic const& c) {
+   auto& arr = get<Array>();
+   arr.resize(sz, c);
+ }
+ 
+ inline void dynamic::push_back(dynamic const& v) {
+   auto& arr = get<Array>();
+   arr.push_back(v);
+ }
+ 
+ inline void dynamic::push_back(dynamic&& v) {
+   auto& arr = get<Array>();
+   arr.push_back(std::move(v));
+ }
+ 
+ inline void dynamic::pop_back() {
+   auto& arr = get<Array>();
+   arr.pop_back();
+ }
+ 
+ inline const dynamic& dynamic::back() const {
+   auto& arr = get<Array>();
+   return arr.back();
+ }
+ 
+ //////////////////////////////////////////////////////////////////////
+ 
+ inline dynamic::dynamic(Array&& r) : type_(ARRAY) {
+   new (&u_.array) Array(std::move(r));
+ }
+ 
+ #define FOLLY_DYNAMIC_DEC_TYPEINFO(T, val)     \
+   template <>                                  \
+   struct dynamic::TypeInfo<T> {                \
+     static const char* const name;             \
+     static constexpr dynamic::Type type = val; \
+   };                                           \
+   //
+ 
+ FOLLY_DYNAMIC_DEC_TYPEINFO(std::nullptr_t, dynamic::NULLT)
+ FOLLY_DYNAMIC_DEC_TYPEINFO(bool, dynamic::BOOL)
+ FOLLY_DYNAMIC_DEC_TYPEINFO(std::string, dynamic::STRING)
+ FOLLY_DYNAMIC_DEC_TYPEINFO(dynamic::Array, dynamic::ARRAY)
+ FOLLY_DYNAMIC_DEC_TYPEINFO(double, dynamic::DOUBLE)
+ FOLLY_DYNAMIC_DEC_TYPEINFO(int64_t, dynamic::INT64)
+ FOLLY_DYNAMIC_DEC_TYPEINFO(dynamic::ObjectImpl, dynamic::OBJECT)
+ 
+ #undef FOLLY_DYNAMIC_DEC_TYPEINFO
+ 
+ template <class T>
+ T dynamic::asImpl() const {
+   FOLLY_PUSH_WARNING
+   FOLLY_CLANG_DISABLE_WARNING("-Wcovered-switch-default")
+   switch (type()) {
+     case INT64:
+       return to<T>(*get_nothrow<int64_t>());
+     case DOUBLE:
+       return to<T>(*get_nothrow<double>());
+     case BOOL:
+       return to<T>(*get_nothrow<bool>());
+     case STRING:
+       return to<T>(*get_nothrow<std::string>());
+     case NULLT:
+     case ARRAY:
+     case OBJECT:
+     default:
+       throw_exception<TypeError>("int/double/bool/string", type());
+   }
+   FOLLY_POP_WARNING
+ }
+ 
+ // Return a T* to our type, or null if we're not that type.
+ template <class T>
+ T* dynamic::get_nothrow() & noexcept {
+   if (type_ != TypeInfo<T>::type) {
+     return nullptr;
+   }
+   return getAddress<T>();
+ }
+ 
+ template <class T>
+ T const* dynamic::get_nothrow() const& noexcept {
+   return const_cast<dynamic*>(this)->get_nothrow<T>();
+ }
+ 
+ // Return T* for where we can put a T, without type checking.  (Memory
+ // might be uninitialized, even.)
+ template <class T>
+ T* dynamic::getAddress() noexcept {
+   return GetAddrImpl<T>::get(u_);
+ }
+ 
+ template <class T>
+ T const* dynamic::getAddress() const noexcept {
+   return const_cast<dynamic*>(this)->getAddress<T>();
+ }
+ 
+ template <class T>
+ struct dynamic::GetAddrImpl {};
+ template <>
+ struct dynamic::GetAddrImpl<std::nullptr_t> {
+   static std::nullptr_t* get(Data& d) noexcept { return &d.nul; }
+ };
+ template <>
+ struct dynamic::GetAddrImpl<dynamic::Array> {
+   static Array* get(Data& d) noexcept { return &d.array; }
+ };
+ template <>
+ struct dynamic::GetAddrImpl<bool> {
+   static bool* get(Data& d) noexcept { return &d.boolean; }
+ };
+ template <>
+ struct dynamic::GetAddrImpl<int64_t> {
+   static int64_t* get(Data& d) noexcept { return &d.integer; }
+ };
+ template <>
+ struct dynamic::GetAddrImpl<double> {
+   static double* get(Data& d) noexcept { return &d.doubl; }
+ };
+ template <>
+ struct dynamic::GetAddrImpl<std::string> {
+   static std::string* get(Data& d) noexcept { return &d.string; }
+ };
+ template <>
+ struct dynamic::GetAddrImpl<dynamic::ObjectImpl> {
+   static_assert(
+       sizeof(ObjectImpl) <= sizeof(Data::objectBuffer),
+       "In your implementation, F14NodeMap<> apparently takes different"
+       " amount of space depending on its template parameters.  This is "
+       "weird.  Make objectBuffer bigger if you want to compile dynamic.");
+ 
+   static ObjectImpl* get(Data& d) noexcept {
+     void* data = &d.objectBuffer;
+     return static_cast<ObjectImpl*>(data);
+   }
+ };
+ 
 // [Win - Forked to avoid using exported data across the dll boundary.  Using exported data prevents the ability to
 // delay load the dll We can remove this, once react-native-win32 stops exporting folly (gets entirely onto the ABI
 // interface)
@@ -1143,297 +1142,297 @@ T &dynamic::get() {
   }
 }
 // Win]
-
-template <class T>
-T const& dynamic::get() const {
-  return const_cast<dynamic*>(this)->get<T>();
-}
-
-//////////////////////////////////////////////////////////////////////
-
-/*
- * Helper for implementing operator<<.  Throws if the type shouldn't
- * support it.
- */
-template <class T>
-struct dynamic::PrintImpl {
-  static void print(dynamic const&, std::ostream& out, T const& t) { out << t; }
-};
-// Otherwise, null, being (void*)0, would print as 0.
-template <>
-struct dynamic::PrintImpl<std::nullptr_t> {
-  static void print(
-      dynamic const& /* d */, std::ostream& out, std::nullptr_t const&) {
-    out << "null";
-  }
-};
-template <>
-struct dynamic::PrintImpl<dynamic::ObjectImpl> {
-  static void print(
-      dynamic const& d, std::ostream& out, dynamic::ObjectImpl const&) {
-    d.print_as_pseudo_json(out);
-  }
-};
-template <>
-struct dynamic::PrintImpl<dynamic::Array> {
-  static void print(
-      dynamic const& d, std::ostream& out, dynamic::Array const&) {
-    d.print_as_pseudo_json(out);
-  }
-};
-
-inline void dynamic::print(std::ostream& out) const {
-#define FB_X(T) PrintImpl<T>::print(*this, out, *getAddress<T>())
-  FB_DYNAMIC_APPLY(type_, FB_X);
-#undef FB_X
-}
-
-inline std::ostream& operator<<(std::ostream& out, dynamic const& d) {
-  d.print(out);
-  return out;
-}
-
-//////////////////////////////////////////////////////////////////////
-
-inline const_dynamic_view::const_dynamic_view(dynamic const& d) noexcept
-    : d_(&d) {}
-
-inline const_dynamic_view::const_dynamic_view(dynamic const* d) noexcept
-    : d_(d) {}
-
-inline const_dynamic_view::operator bool() const noexcept {
-  return !empty();
-}
-
-inline bool const_dynamic_view::empty() const noexcept {
-  return d_ == nullptr;
-}
-
-inline void const_dynamic_view::reset() noexcept {
-  d_ = nullptr;
-}
-
-template <typename Key, typename... Keys>
-inline const_dynamic_view const_dynamic_view::descend(
-    Key const& key, Keys const&... keys) const noexcept {
-  return descend_(key, keys...);
-}
-
-template <typename Key1, typename Key2, typename... Keys>
-inline dynamic const* const_dynamic_view::descend_(
-    Key1 const& key1, Key2 const& key2, Keys const&... keys) const noexcept {
-  if (!d_) {
-    return nullptr;
-  }
-  return const_dynamic_view{descend_unchecked_(key1)}.descend_(key2, keys...);
-}
-
-template <typename Key>
-inline dynamic const* const_dynamic_view::descend_(
-    Key const& key) const noexcept {
-  if (!d_) {
-    return nullptr;
-  }
-  return descend_unchecked_(key);
-}
-
-template <typename Key>
-inline dynamic::IfIsNonStringDynamicConvertible<Key, dynamic const*>
-const_dynamic_view::descend_unchecked_(Key const& key) const noexcept {
-  if (auto* parray = d_->get_nothrow<dynamic::Array>()) {
-    if /* constexpr */ (!std::is_integral<Key>::value) {
-      return nullptr;
-    }
-    if (key < 0 || folly::to_unsigned(key) >= parray->size()) {
-      return nullptr;
-    }
-    return &(*parray)[size_t(key)];
-  } else if (auto* pobject = d_->get_nothrow<dynamic::ObjectImpl>()) {
-    auto it = pobject->find(key);
-    if (it == pobject->end()) {
-      return nullptr;
-    }
-    return &it->second;
-  }
-  return nullptr;
-}
-
-inline dynamic const* const_dynamic_view::descend_unchecked_(
-    folly::StringPiece key) const noexcept {
-  if (auto* pobject = d_->get_nothrow<dynamic::ObjectImpl>()) {
-    auto it = pobject->find(key);
-    if (it == pobject->end()) {
-      return nullptr;
-    }
-    return &it->second;
-  }
-  return nullptr;
-}
-
-inline dynamic const_dynamic_view::value_or(dynamic&& val) const {
-  if (d_) {
-    return *d_;
-  }
-  return std::move(val);
-}
-
-template <typename T, typename... Args>
-inline T const_dynamic_view::get_copy(Args&&... args) const {
-  if (auto* v = (d_ ? d_->get_nothrow<T>() : nullptr)) {
-    return *v;
-  }
-  return T(std::forward<Args>(args)...);
-}
-
-inline std::string const_dynamic_view::string_or(char const* val) const {
-  return get_copy<std::string>(val);
-}
-
-inline std::string const_dynamic_view::string_or(std::string val) const {
-  return get_copy<std::string>(std::move(val));
-}
-
-// Specialized version for StringPiece, FixedString, and other types which are
-// not convertible to std::string, but can construct one from .data and .size
-// to std::string. Will not trigger a copy unless data and size require it.
-template <typename Stringish, typename>
-inline std::string const_dynamic_view::string_or(Stringish&& val) const {
-  return get_copy(val.data(), val.size());
-}
-
-inline double const_dynamic_view::double_or(double val) const noexcept {
-  return get_copy<double>(val);
-}
-
-inline int64_t const_dynamic_view::int_or(int64_t val) const noexcept {
-  return get_copy<int64_t>(val);
-}
-
-inline bool const_dynamic_view::bool_or(bool val) const noexcept {
-  return get_copy<bool>(val);
-}
-
-inline dynamic_view::dynamic_view(dynamic& d) noexcept
-    : const_dynamic_view(d) {}
-
-template <typename Key, typename... Keys>
-inline dynamic_view dynamic_view::descend(
-    Key const& key, Keys const&... keys) const noexcept {
-  if (auto* child = const_dynamic_view::descend_(key, keys...)) {
-    return *const_cast<dynamic*>(child);
-  }
-  return {};
-}
-
-inline dynamic dynamic_view::move_value_or(dynamic&& val) noexcept {
-  if (d_) {
-    return std::move(*const_cast<dynamic*>(d_));
-  }
-  return std::move(val);
-}
-
-template <typename T, typename... Args>
-inline T dynamic_view::get_move(Args&&... args) {
-  if (auto* v = (d_ ? const_cast<dynamic*>(d_)->get_nothrow<T>() : nullptr)) {
-    return std::move(*v);
-  }
-  return T(std::forward<Args>(args)...);
-}
-
-inline std::string dynamic_view::move_string_or(char const* val) {
-  return get_move<std::string>(val);
-}
-
-inline std::string dynamic_view::move_string_or(std::string val) noexcept {
-  return get_move<std::string>(std::move(val));
-}
-
-template <typename Stringish, typename>
-inline std::string dynamic_view::move_string_or(Stringish&& val) {
-  return get_move<std::string>(val.begin(), val.end());
-}
-
-//////////////////////////////////////////////////////////////////////
-
-// Specialization of FormatValue so dynamic objects can be formatted
-template <>
-class FormatValue<dynamic> {
- public:
-  explicit FormatValue(const dynamic& val) : val_(val) {}
-
-  template <class FormatCallback>
-  void format(FormatArg& arg, FormatCallback& cb) const {
-    switch (val_.type()) {
-      case dynamic::NULLT:
-        FormatValue<std::nullptr_t>(nullptr).format(arg, cb);
-        break;
-      case dynamic::BOOL:
-        FormatValue<bool>(val_.asBool()).format(arg, cb);
-        break;
-      case dynamic::INT64:
-        FormatValue<int64_t>(val_.asInt()).format(arg, cb);
-        break;
-      case dynamic::STRING:
-        FormatValue<std::string>(val_.asString()).format(arg, cb);
-        break;
-      case dynamic::DOUBLE:
-        FormatValue<double>(val_.asDouble()).format(arg, cb);
-        break;
-      case dynamic::ARRAY:
-        FormatValue(val_.at(arg.splitIntKey())).format(arg, cb);
-        break;
-      case dynamic::OBJECT:
-        FormatValue(val_.at(arg.splitKey().toString())).format(arg, cb);
-        break;
-    }
-  }
-
- private:
-  const dynamic& val_;
-};
-
-template <class V>
-class FormatValue<detail::DefaultValueWrapper<dynamic, V>> {
- public:
-  explicit FormatValue(const detail::DefaultValueWrapper<dynamic, V>& val)
-      : val_(val) {}
-
-  template <class FormatCallback>
-  void format(FormatArg& arg, FormatCallback& cb) const {
-    auto& c = val_.container;
-    switch (c.type()) {
-      case dynamic::NULLT:
-      case dynamic::BOOL:
-      case dynamic::INT64:
-      case dynamic::STRING:
-      case dynamic::DOUBLE:
-        FormatValue<dynamic>(c).format(arg, cb);
-        break;
-      case dynamic::ARRAY: {
-        int key = arg.splitIntKey();
-        if (key >= 0 && size_t(key) < c.size()) {
-          FormatValue<dynamic>(c.at(key)).format(arg, cb);
-        } else {
-          FormatValue<V>(val_.defaultValue).format(arg, cb);
-        }
-        break;
-      }
-      case dynamic::OBJECT: {
-        auto pos = c.find(arg.splitKey());
-        if (pos != c.items().end()) {
-          FormatValue<dynamic>(pos->second).format(arg, cb);
-        } else {
-          FormatValue<V>(val_.defaultValue).format(arg, cb);
-        }
-        break;
-      }
-    }
-  }
-
- private:
-  const detail::DefaultValueWrapper<dynamic, V>& val_;
-};
-
-} // namespace folly
-
-#undef FB_DYNAMIC_APPLY
+ 
+ template <class T>
+ T const& dynamic::get() const {
+   return const_cast<dynamic*>(this)->get<T>();
+ }
+ 
+ //////////////////////////////////////////////////////////////////////
+ 
+ /*
+  * Helper for implementing operator<<.  Throws if the type shouldn't
+  * support it.
+  */
+ template <class T>
+ struct dynamic::PrintImpl {
+   static void print(dynamic const&, std::ostream& out, T const& t) { out << t; }
+ };
+ // Otherwise, null, being (void*)0, would print as 0.
+ template <>
+ struct dynamic::PrintImpl<std::nullptr_t> {
+   static void print(
+       dynamic const& /* d */, std::ostream& out, std::nullptr_t const&) {
+     out << "null";
+   }
+ };
+ template <>
+ struct dynamic::PrintImpl<dynamic::ObjectImpl> {
+   static void print(
+       dynamic const& d, std::ostream& out, dynamic::ObjectImpl const&) {
+     d.print_as_pseudo_json(out);
+   }
+ };
+ template <>
+ struct dynamic::PrintImpl<dynamic::Array> {
+   static void print(
+       dynamic const& d, std::ostream& out, dynamic::Array const&) {
+     d.print_as_pseudo_json(out);
+   }
+ };
+ 
+ inline void dynamic::print(std::ostream& out) const {
+ #define FB_X(T) PrintImpl<T>::print(*this, out, *getAddress<T>())
+   FB_DYNAMIC_APPLY(type_, FB_X);
+ #undef FB_X
+ }
+ 
+ inline std::ostream& operator<<(std::ostream& out, dynamic const& d) {
+   d.print(out);
+   return out;
+ }
+ 
+ //////////////////////////////////////////////////////////////////////
+ 
+ inline const_dynamic_view::const_dynamic_view(dynamic const& d) noexcept
+     : d_(&d) {}
+ 
+ inline const_dynamic_view::const_dynamic_view(dynamic const* d) noexcept
+     : d_(d) {}
+ 
+ inline const_dynamic_view::operator bool() const noexcept {
+   return !empty();
+ }
+ 
+ inline bool const_dynamic_view::empty() const noexcept {
+   return d_ == nullptr;
+ }
+ 
+ inline void const_dynamic_view::reset() noexcept {
+   d_ = nullptr;
+ }
+ 
+ template <typename Key, typename... Keys>
+ inline const_dynamic_view const_dynamic_view::descend(
+     Key const& key, Keys const&... keys) const noexcept {
+   return descend_(key, keys...);
+ }
+ 
+ template <typename Key1, typename Key2, typename... Keys>
+ inline dynamic const* const_dynamic_view::descend_(
+     Key1 const& key1, Key2 const& key2, Keys const&... keys) const noexcept {
+   if (!d_) {
+     return nullptr;
+   }
+   return const_dynamic_view{descend_unchecked_(key1)}.descend_(key2, keys...);
+ }
+ 
+ template <typename Key>
+ inline dynamic const* const_dynamic_view::descend_(
+     Key const& key) const noexcept {
+   if (!d_) {
+     return nullptr;
+   }
+   return descend_unchecked_(key);
+ }
+ 
+ template <typename Key>
+ inline dynamic::IfIsNonStringDynamicConvertible<Key, dynamic const*>
+ const_dynamic_view::descend_unchecked_(Key const& key) const noexcept {
+   if (auto* parray = d_->get_nothrow<dynamic::Array>()) {
+     if /* constexpr */ (!std::is_integral<Key>::value) {
+       return nullptr;
+     }
+     if (key < 0 || folly::to_unsigned(key) >= parray->size()) {
+       return nullptr;
+     }
+     return &(*parray)[size_t(key)];
+   } else if (auto* pobject = d_->get_nothrow<dynamic::ObjectImpl>()) {
+     auto it = pobject->find(key);
+     if (it == pobject->end()) {
+       return nullptr;
+     }
+     return &it->second;
+   }
+   return nullptr;
+ }
+ 
+ inline dynamic const* const_dynamic_view::descend_unchecked_(
+     folly::StringPiece key) const noexcept {
+   if (auto* pobject = d_->get_nothrow<dynamic::ObjectImpl>()) {
+     auto it = pobject->find(key);
+     if (it == pobject->end()) {
+       return nullptr;
+     }
+     return &it->second;
+   }
+   return nullptr;
+ }
+ 
+ inline dynamic const_dynamic_view::value_or(dynamic&& val) const {
+   if (d_) {
+     return *d_;
+   }
+   return std::move(val);
+ }
+ 
+ template <typename T, typename... Args>
+ inline T const_dynamic_view::get_copy(Args&&... args) const {
+   if (auto* v = (d_ ? d_->get_nothrow<T>() : nullptr)) {
+     return *v;
+   }
+   return T(std::forward<Args>(args)...);
+ }
+ 
+ inline std::string const_dynamic_view::string_or(char const* val) const {
+   return get_copy<std::string>(val);
+ }
+ 
+ inline std::string const_dynamic_view::string_or(std::string val) const {
+   return get_copy<std::string>(std::move(val));
+ }
+ 
+ // Specialized version for StringPiece, FixedString, and other types which are
+ // not convertible to std::string, but can construct one from .data and .size
+ // to std::string. Will not trigger a copy unless data and size require it.
+ template <typename Stringish, typename>
+ inline std::string const_dynamic_view::string_or(Stringish&& val) const {
+   return get_copy(val.data(), val.size());
+ }
+ 
+ inline double const_dynamic_view::double_or(double val) const noexcept {
+   return get_copy<double>(val);
+ }
+ 
+ inline int64_t const_dynamic_view::int_or(int64_t val) const noexcept {
+   return get_copy<int64_t>(val);
+ }
+ 
+ inline bool const_dynamic_view::bool_or(bool val) const noexcept {
+   return get_copy<bool>(val);
+ }
+ 
+ inline dynamic_view::dynamic_view(dynamic& d) noexcept
+     : const_dynamic_view(d) {}
+ 
+ template <typename Key, typename... Keys>
+ inline dynamic_view dynamic_view::descend(
+     Key const& key, Keys const&... keys) const noexcept {
+   if (auto* child = const_dynamic_view::descend_(key, keys...)) {
+     return *const_cast<dynamic*>(child);
+   }
+   return {};
+ }
+ 
+ inline dynamic dynamic_view::move_value_or(dynamic&& val) noexcept {
+   if (d_) {
+     return std::move(*const_cast<dynamic*>(d_));
+   }
+   return std::move(val);
+ }
+ 
+ template <typename T, typename... Args>
+ inline T dynamic_view::get_move(Args&&... args) {
+   if (auto* v = (d_ ? const_cast<dynamic*>(d_)->get_nothrow<T>() : nullptr)) {
+     return std::move(*v);
+   }
+   return T(std::forward<Args>(args)...);
+ }
+ 
+ inline std::string dynamic_view::move_string_or(char const* val) {
+   return get_move<std::string>(val);
+ }
+ 
+ inline std::string dynamic_view::move_string_or(std::string val) noexcept {
+   return get_move<std::string>(std::move(val));
+ }
+ 
+ template <typename Stringish, typename>
+ inline std::string dynamic_view::move_string_or(Stringish&& val) {
+   return get_move<std::string>(val.begin(), val.end());
+ }
+ 
+ //////////////////////////////////////////////////////////////////////
+ 
+ // Specialization of FormatValue so dynamic objects can be formatted
+ template <>
+ class FormatValue<dynamic> {
+  public:
+   explicit FormatValue(const dynamic& val) : val_(val) {}
+ 
+   template <class FormatCallback>
+   void format(FormatArg& arg, FormatCallback& cb) const {
+     switch (val_.type()) {
+       case dynamic::NULLT:
+         FormatValue<std::nullptr_t>(nullptr).format(arg, cb);
+         break;
+       case dynamic::BOOL:
+         FormatValue<bool>(val_.asBool()).format(arg, cb);
+         break;
+       case dynamic::INT64:
+         FormatValue<int64_t>(val_.asInt()).format(arg, cb);
+         break;
+       case dynamic::STRING:
+         FormatValue<std::string>(val_.asString()).format(arg, cb);
+         break;
+       case dynamic::DOUBLE:
+         FormatValue<double>(val_.asDouble()).format(arg, cb);
+         break;
+       case dynamic::ARRAY:
+         FormatValue(val_.at(arg.splitIntKey())).format(arg, cb);
+         break;
+       case dynamic::OBJECT:
+         FormatValue(val_.at(arg.splitKey().toString())).format(arg, cb);
+         break;
+     }
+   }
+ 
+  private:
+   const dynamic& val_;
+ };
+ 
+ template <class V>
+ class FormatValue<detail::DefaultValueWrapper<dynamic, V>> {
+  public:
+   explicit FormatValue(const detail::DefaultValueWrapper<dynamic, V>& val)
+       : val_(val) {}
+ 
+   template <class FormatCallback>
+   void format(FormatArg& arg, FormatCallback& cb) const {
+     auto& c = val_.container;
+     switch (c.type()) {
+       case dynamic::NULLT:
+       case dynamic::BOOL:
+       case dynamic::INT64:
+       case dynamic::STRING:
+       case dynamic::DOUBLE:
+         FormatValue<dynamic>(c).format(arg, cb);
+         break;
+       case dynamic::ARRAY: {
+         int key = arg.splitIntKey();
+         if (key >= 0 && size_t(key) < c.size()) {
+           FormatValue<dynamic>(c.at(key)).format(arg, cb);
+         } else {
+           FormatValue<V>(val_.defaultValue).format(arg, cb);
+         }
+         break;
+       }
+       case dynamic::OBJECT: {
+         auto pos = c.find(arg.splitKey());
+         if (pos != c.items().end()) {
+           FormatValue<dynamic>(pos->second).format(arg, cb);
+         } else {
+           FormatValue<V>(val_.defaultValue).format(arg, cb);
+         }
+         break;
+       }
+     }
+   }
+ 
+  private:
+   const detail::DefaultValueWrapper<dynamic, V>& val_;
+ };
+ 
+ } // namespace folly
+ 
+ #undef FB_DYNAMIC_APPLY
\ No newline at end of file
diff --git a/vnext/Folly/TEMP_UntilFollyUpdate/json.cpp b/vnext/Folly/TEMP_UntilFollyUpdate/json.cpp
index e6a1718af01..1f094b51bbd 100644
--- a/vnext/Folly/TEMP_UntilFollyUpdate/json.cpp
+++ b/vnext/Folly/TEMP_UntilFollyUpdate/json.cpp
@@ -14,1101 +14,1104 @@
  * limitations under the License.
  */
 
-#include <folly/json.h>
-
-#include <algorithm>
-#include <functional>
-#include <iterator>
-#include <sstream>
-#include <type_traits>
-
-#include <boost/algorithm/string.hpp>
-#include <glog/logging.h>
-
-#include <folly/Conv.h>
-#include <folly/Portability.h>
-#include <folly/Range.h>
-#include <folly/String.h>
-#include <folly/Unicode.h>
-#include <folly/Utility.h>
-#include <folly/lang/Bits.h>
-#include <folly/portability/Constexpr.h>
-
-namespace folly {
-
-//////////////////////////////////////////////////////////////////////
-
-namespace json {
-
-namespace {
-
-parse_error make_parse_error(
-    unsigned int line,
-    std::string const& context,
-    std::string const& expected) {
-  return parse_error(to<std::string>(
-      "json parse error on line ",
-      line,
-      !context.empty() ? to<std::string>(" near `", context, '\'') : "",
-      ": ",
-      expected));
-}
-
-struct Printer {
-  // Context class is allows to restore the path to element that we are about to
-  // print so that if error happens we can throw meaningful exception.
-  class Context {
-   public:
-    Context(const Context* parent_context, const dynamic& key)
-        : parent_context_(parent_context), key_(key), is_key_(false) {}
-    Context(const Context* parent_context, const dynamic& key, bool is_key)
-        : parent_context_(parent_context), key_(key), is_key_(is_key) {}
-
-    // Return location description of a context as a chain of keys
-    // ex., '"outherKey"->"innerKey"'.
-    std::string locationDescription() const {
-      std::vector<std::string> keys;
-      const Context* ptr = parent_context_;
-      while (ptr) {
-        keys.push_back(ptr->getName());
-        ptr = ptr->parent_context_;
-      }
-      keys.push_back(getName());
-      std::ostringstream stream;
-      std::reverse_copy(
-          keys.begin(),
-          keys.end() - 1,
-          std::ostream_iterator<std::string>(stream, "->"));
-
-      // Add current key.
-      stream << keys.back();
-      return stream.str();
-    }
-    std::string getName() const {
-      return Printer::toStringOr(key_, "<unprintable>");
-    }
-    std::string typeDescription() const { return is_key_ ? "key" : "value"; }
-
-   private:
-    const Context* const parent_context_;
-    const dynamic& key_;
-    bool is_key_;
-  };
-
-  explicit Printer(
-      std::string& out, unsigned* indentLevel, serialization_opts const* opts)
-      : out_(out), indentLevel_(indentLevel), opts_(*opts) {}
-
-  void operator()(dynamic const& v, const Context& context) const {
-    (*this)(v, &context);
-  }
-  void operator()(dynamic const& v, const Context* context) const {
-    switch (v.type()) {
-      case dynamic::DOUBLE:
-        if (!opts_.allow_nan_inf) {
-          if (std::isnan(v.asDouble())) {
-            throw json::print_error(
-                "folly::toJson: JSON object value was a NaN when serializing " +
-                contextDescription(context));
-          }
-          if (std::isinf(v.asDouble())) {
-            throw json::print_error(
-                "folly::toJson: JSON object value was an INF when serializing " +
-                contextDescription(context));
-          }
-        }
-        toAppend(
-            v.asDouble(),
-            &out_,
-            opts_.double_mode,
-            opts_.double_num_digits,
-            opts_.double_flags);
-        break;
-      case dynamic::INT64: {
-        auto intval = v.asInt();
-        if (opts_.javascript_safe) {
-          // Use folly::to to check that this integer can be represented
-          // as a double without loss of precision.
-          intval = int64_t(to<double>(intval));
-        }
-        toAppend(intval, &out_);
-        break;
-      }
-      case dynamic::BOOL:
-        out_ += v.asBool() ? "true" : "false";
-        break;
-      case dynamic::NULLT:
-        out_ += "null";
-        break;
-      case dynamic::STRING:
-        escapeString(v.stringPiece(), out_, opts_);
-        break;
-      case dynamic::OBJECT:
-        printObject(v, context);
-        break;
-      case dynamic::ARRAY:
-        printArray(v, context);
-        break;
-      default:
-        CHECK(0) << "Bad type " << v.type();
-    }
-  }
-
- private:
-  void printKV(
-      dynamic const& o,
-      const std::pair<const dynamic, dynamic>& p,
-      const Context* context) const {
-    if (opts_.convert_int_keys && p.first.isInt()) {
-      auto strKey = p.first.asString();
-      if (o.count(strKey)) {
-        throw json::print_error(folly::to<std::string>(
-            "folly::toJson: Source object has integer and string keys "
-            "representing the same value: ",
-            p.first.asInt()));
-      }
-      (*this)(p.first.asString(), Context(context, p.first, true));
-    } else if (!opts_.allow_non_string_keys && !p.first.isString()) {
-      throw json::print_error(
-          "folly::toJson: JSON object key " +
-          toStringOr(p.first, "<unprintable key>") + " was not a string " +
-          (opts_.convert_int_keys ? "or integer " : "") +
-          "when serializing key at " +
-          Context(context, p.first, true).locationDescription());
-    } else {
-      (*this)(p.first, Context(context, p.first, true)); // Key
-    }
-    mapColon();
-    (*this)(p.second, Context(context, p.first, false)); // Value
-  }
-
-  template <typename Iterator>
-  void printKVPairs(
-      dynamic const& o,
-      Iterator begin,
-      Iterator end,
-      const Context* context) const {
-    printKV(o, *begin, context);
-    for (++begin; begin != end; ++begin) {
-      out_ += ',';
-      newline();
-      printKV(o, *begin, context);
-    }
-  }
-
-  void printObject(dynamic const& o, const Context* context) const {
-    if (o.empty()) {
-      out_ += "{}";
-      return;
-    }
-
-    out_ += '{';
-    indent();
-    newline();
-    if (opts_.sort_keys || opts_.sort_keys_by) {
-      using ref = std::reference_wrapper<decltype(o.items())::value_type const>;
-      auto sort_keys_by = [&](auto begin, auto end, const auto& comp) {
-        std::sort(begin, end, [&](ref a, ref b) {
-          // Only compare keys.  No ordering among identical keys.
-          return comp(a.get().first, b.get().first);
-        });
-      };
-      std::vector<ref> refs(o.items().begin(), o.items().end());
-      if (opts_.sort_keys_by) {
-        sort_keys_by(refs.begin(), refs.end(), opts_.sort_keys_by);
-      } else {
-        sort_keys_by(refs.begin(), refs.end(), std::less<>());
-      }
-      printKVPairs(o, refs.cbegin(), refs.cend(), context);
-    } else {
-      printKVPairs(o, o.items().begin(), o.items().end(), context);
-    }
-    outdent();
-    newline();
-    out_ += '}';
-  }
-
-  static std::string toStringOr(dynamic const& v, const char* placeholder) {
-    try {
-      std::string result;
-      unsigned indentLevel = 0;
-      serialization_opts opts;
-      opts.allow_nan_inf = true;
-      opts.allow_non_string_keys = true;
-      Printer printer(result, &indentLevel, &opts);
-      printer(v, nullptr);
-      return result;
-    } catch (...) {
-      return placeholder;
-    }
-  }
-
-  static std::string contextDescription(const Context* context) {
-    if (!context) {
-      return "<undefined location>";
-    }
-    return context->typeDescription() + " at " + context->locationDescription();
-  }
-
-  void printArray(dynamic const& a, const Context* context) const {
-    if (a.empty()) {
-      out_ += "[]";
-      return;
-    }
-
-    out_ += '[';
-    indent();
-    newline();
-    (*this)(a[0], Context(context, dynamic(0)));
-    for (auto it = std::next(a.begin()); it != a.end(); ++it) {
-      out_ += ',';
-      newline();
-      (*this)(*it, Context(context, dynamic(std::distance(a.begin(), it))));
-    }
-    outdent();
-    newline();
-    out_ += ']';
-  }
-
- private:
-  void outdent() const {
-    if (indentLevel_) {
-      --*indentLevel_;
-    }
-  }
-
-  void indent() const {
-    if (indentLevel_) {
-      ++*indentLevel_;
-    }
-  }
-
-  void newline() const {
-    if (indentLevel_) {
-      auto indent = *indentLevel_ * opts_.pretty_formatting_indent_width;
-      out_ += to<std::string>('\n', std::string(indent, ' '));
-    }
-  }
-
-  void mapColon() const { out_ += indentLevel_ ? ": " : ":"; }
-
- private:
-  std::string& out_;
-  unsigned* const indentLevel_;
-  serialization_opts const& opts_;
-};
-
-//////////////////////////////////////////////////////////////////////
-
-// Wraps our input buffer with some helper functions.
-struct Input {
-  explicit Input(StringPiece range, json::serialization_opts const* opts)
-      : range_(range), opts_(*opts), lineNum_(0) {
-    storeCurrent();
-  }
-
-  Input(Input const&) = delete;
-  Input& operator=(Input const&) = delete;
-
-  char const* begin() const { return range_.begin(); }
-
-  unsigned getLineNum() const { return lineNum_; }
-
-  // Parse ahead for as long as the supplied predicate is satisfied,
-  // returning a range of what was skipped.
-  template <class Predicate>
-  StringPiece skipWhile(const Predicate& p) {
-    std::size_t skipped = 0;
-    for (; skipped < range_.size(); ++skipped) {
-      if (!p(range_[skipped])) {
-        break;
-      }
-      if (range_[skipped] == '\n') {
-        ++lineNum_;
-      }
-    }
-    auto ret = range_.subpiece(0, skipped);
-    range_.advance(skipped);
-    storeCurrent();
-    return ret;
-  }
-
-  StringPiece skipDigits() {
-    return skipWhile([](char c) { return c >= '0' && c <= '9'; });
-  }
-
-  StringPiece skipMinusAndDigits() {
-    bool firstChar = true;
-    return skipWhile([&firstChar](char c) {
-      bool result = (c >= '0' && c <= '9') || (firstChar && c == '-');
-      firstChar = false;
-      return result;
-    });
-  }
-
-  void skipWhitespace() {
-    // [Windows #12703 - CodeQL patch]
-    std::size_t index = 0;
-    while (true) {
-      while (index < range_.size() && range_[index] == ' ') {
-        index++;
-      }
-      if (index < range_.size()) {
-        if (range_[index] == '\n') {
-          index++;
-          ++lineNum_;
-          continue;
-        }
-        if (range_[index] == '\t' || range_[index] == '\r') {
-          index++;
-          continue;
-        }
-      }
-      break;
-    }
-    range_.advance(index);
-    storeCurrent();
-  }
-
-  void expect(char c) {
-    if (**this != c) {
-      throw json::make_parse_error(
-          lineNum_, context(), to<std::string>("expected '", c, '\''));
-    }
-    ++*this;
-  }
-
-  std::size_t size() const { return range_.size(); }
-
-  int operator*() const { return current_; }
-
-  void operator++() {
-    range_.pop_front();
-    storeCurrent();
-  }
-
-  template <class T>
-  T extract() {
-    try {
-      return to<T>(&range_);
-    } catch (std::exception const& e) {
-      error(e.what());
-    }
-  }
-
-  bool consume(StringPiece str) {
-    if (boost::starts_with(range_, str)) {
-      range_.advance(str.size());
-      storeCurrent();
-      return true;
-    }
-    return false;
-  }
-
-  std::string context() const {
-    return range_.subpiece(0, 16 /* arbitrary */).toString();
-  }
-
-  [[noreturn]] dynamic error(char const* what) const {
-    throw json::make_parse_error(lineNum_, context(), what);
-  }
-
-  json::serialization_opts const& getOpts() { return opts_; }
-
-  void incrementRecursionLevel() {
-    if (currentRecursionLevel_ > opts_.recursion_limit) {
-      error("recursion limit exceeded");
-    }
-    currentRecursionLevel_++;
-  }
-
-  void decrementRecursionLevel() { currentRecursionLevel_--; }
-
- private:
-  void storeCurrent() { current_ = range_.empty() ? EOF : range_.front(); }
-
- private:
-  StringPiece range_;
-  json::serialization_opts const& opts_;
-  unsigned lineNum_;
-  int current_;
-  unsigned int currentRecursionLevel_{0};
-};
-
-class RecursionGuard {
- public:
-  explicit RecursionGuard(Input& in) : in_(in) {
-    in_.incrementRecursionLevel();
-  }
-
-  ~RecursionGuard() { in_.decrementRecursionLevel(); }
-
- private:
-  Input& in_;
-};
-
-dynamic parseValue(Input& in, json::metadata_map* map);
-std::string parseString(Input& in);
-dynamic parseNumber(Input& in);
-
-void parseObjectKeyValue(
-    Input& in,
-    dynamic& ret,
-    dynamic&& key,
-    json::metadata_map* map,
-    bool distinct) {
-  auto keyLineNumber = in.getLineNum();
-  in.skipWhitespace();
-  in.expect(':');
-  in.skipWhitespace();
-  auto valueLineNumber = in.getLineNum();
-  auto value = parseValue(in, map);
-  auto [it, inserted] = ret.try_emplace(std::move(key), std::move(value));
-  if (!inserted) {
-    if (distinct) {
-      in.error("duplicate key inserted");
-    }
-    it->second = std::move(value);
-  }
-  if (map) {
-    map->emplace(
-        &it->second,
-        json::parse_metadata{{{keyLineNumber}}, {{valueLineNumber}}});
-  }
-}
-
-dynamic parseObject(Input& in, json::metadata_map* map) {
-  DCHECK_EQ(*in, '{');
-  ++in;
-
-  dynamic ret = dynamic::object;
-
-  in.skipWhitespace();
-  if (*in == '}') {
-    ++in;
-    return ret;
-  }
-
-  const auto& opts = in.getOpts();
-  const bool distinct = opts.validate_keys || opts.convert_int_keys;
-  for (;;) {
-    if (opts.allow_trailing_comma && *in == '}') {
-      break;
-    }
-    dynamic key = parseValue(in, map);
-    if (opts.convert_int_keys && key.isInt()) {
-      key = key.asString();
-    } else if (!opts.allow_non_string_keys && !key.isString()) {
-      in.error(
-          opts.convert_int_keys ? "expected string or integer for object key"
-                                : "expected string for object key");
-    }
-    parseObjectKeyValue(in, ret, std::move(key), map, distinct);
-
-    in.skipWhitespace();
-    if (*in != ',') {
-      break;
-    }
-    ++in;
-    in.skipWhitespace();
-  }
-  in.expect('}');
-
-  return ret;
-}
-
-dynamic parseArray(Input& in, json::metadata_map* map) {
-  DCHECK_EQ(*in, '[');
-  ++in;
-
-  dynamic ret = dynamic::array;
-
-  in.skipWhitespace();
-  if (*in == ']') {
-    ++in;
-    return ret;
-  }
-
-  std::vector<uint32_t> lineNumbers;
-  for (;;) {
-    if (in.getOpts().allow_trailing_comma && *in == ']') {
-      break;
-    }
-    ret.push_back(parseValue(in, map));
-    if (map) {
-      lineNumbers.push_back(in.getLineNum());
-    }
-    in.skipWhitespace();
-    if (*in != ',') {
-      break;
-    }
-    ++in;
-    in.skipWhitespace();
-  }
-  if (map) {
-    for (size_t i = 0, e = ret.size(); i < e; i++) {
-      map->emplace(&ret[i], json::parse_metadata{{{0}}, {{lineNumbers[i]}}});
-    }
-  }
-  in.expect(']');
-
-  return ret;
-}
-
-dynamic parseNumber(Input& in) {
-  bool const negative = (*in == '-');
-  if (negative && in.consume("-Infinity")) {
-    if (in.getOpts().parse_numbers_as_strings) {
-      return "-Infinity";
-    } else {
-      return -std::numeric_limits<double>::infinity();
-    }
-  }
-
-  auto integral = in.skipMinusAndDigits();
-  if (negative && integral.size() < 2) {
-    in.error("expected digits after `-'");
-  }
-
-  auto const wasE = *in == 'e' || *in == 'E';
-
-  if (*in != '.' && !wasE && in.getOpts().parse_numbers_as_strings) {
-    return integral;
-  }
-
-  constexpr const char* maxIntStr = "9223372036854775807";
-  constexpr const char* minIntStr = "-9223372036854775808";
-  constexpr auto maxIntLen = constexpr_strlen(maxIntStr);
-  constexpr auto minIntLen = constexpr_strlen(minIntStr);
-  auto extremaLen = negative ? minIntLen : maxIntLen;
-  auto extremaStr = negative ? minIntStr : maxIntStr;
-  if (*in != '.' && !wasE) {
-    if (FOLLY_LIKELY(
-            !in.getOpts().double_fallback || integral.size() < extremaLen) ||
-        (integral.size() == extremaLen && integral <= extremaStr)) {
-      auto val = to<int64_t>(integral);
-      in.skipWhitespace();
-      return val;
-    } else {
-      auto val = to<double>(integral);
-      in.skipWhitespace();
-      return val;
-    }
-  }
-
-  auto end = !wasE ? (++in, in.skipDigits().end()) : in.begin();
-  if (*in == 'e' || *in == 'E') {
-    ++in;
-    if (*in == '+' || *in == '-') {
-      ++in;
-    }
-    auto expPart = in.skipDigits();
-    end = expPart.end();
-  }
-  auto fullNum = range(integral.begin(), end);
-  if (in.getOpts().parse_numbers_as_strings) {
-    return fullNum;
-  }
-  auto val = to<double>(fullNum);
-  return val;
-}
-
-void decodeUnicodeEscape(Input& in, std::string& out) {
-  auto hexVal = [&](int c) -> uint16_t {
-    // clang-format off
-    return uint16_t(
-        c >= '0' && c <= '9' ? c - '0' :
-        c >= 'a' && c <= 'f' ? c - 'a' + 10 :
-        c >= 'A' && c <= 'F' ? c - 'A' + 10 :
-        (in.error("invalid hex digit"), 0));
-    // clang-format on
-  };
-
-  auto readHex = [&]() -> uint16_t {
-    if (in.size() < 4) {
-      in.error("expected 4 hex digits");
-    }
-
-    auto ret = uint16_t(hexVal(*in) * 4096);
-    ++in;
-    ret += hexVal(*in) * 256;
-    ++in;
-    ret += hexVal(*in) * 16;
-    ++in;
-    ret += hexVal(*in);
-    ++in;
-    return ret;
-  };
-
-  //  If the value encoded is in the surrogate pair range, we need to make
-  //  sure there is another escape that we can use also.
-  //
-  //  See the explanation in folly/Unicode.h.
-  uint16_t prefix = readHex();
-  char32_t codePoint = prefix;
-  if (utf16_code_unit_is_high_surrogate(prefix)) {
-    if (!in.consume("\\u")) {
-      in.error(
-          "expected another unicode escape for second half of "
-          "surrogate pair");
-    }
-    uint16_t suffix = readHex();
-    if (!utf16_code_unit_is_low_surrogate(suffix)) {
-      in.error("second character in surrogate pair is invalid");
-    }
-    codePoint = unicode_code_point_from_utf16_surrogate_pair(prefix, suffix);
-  } else if (!utf16_code_unit_is_bmp(prefix)) {
-    in.error("invalid unicode code point (in range [0xdc00,0xdfff])");
-  }
-
-  appendCodePointToUtf8(codePoint, out);
-}
-
-std::string parseString(Input& in) {
-  DCHECK_EQ(*in, '\"');
-  ++in;
-
-  std::string ret;
-  for (;;) {
-    auto range = in.skipWhile([](char c) { return c != '\"' && c != '\\'; });
-    ret.append(range.begin(), range.end());
-
-    if (*in == '\"') {
-      ++in;
-      break;
-    }
-    if (*in == '\\') {
-      ++in;
-      switch (*in) {
-        // clang-format off
-        case '\"':    ret.push_back('\"'); ++in; break;
-        case '\\':    ret.push_back('\\'); ++in; break;
-        case '/':     ret.push_back('/');  ++in; break;
-        case 'b':     ret.push_back('\b'); ++in; break;
-        case 'f':     ret.push_back('\f'); ++in; break;
-        case 'n':     ret.push_back('\n'); ++in; break;
-        case 'r':     ret.push_back('\r'); ++in; break;
-        case 't':     ret.push_back('\t'); ++in; break;
-        case 'u':     ++in; decodeUnicodeEscape(in, ret); break;
-        // clang-format on
-        default:
-          in.error(
-              to<std::string>("unknown escape ", *in, " in string").c_str());
-      }
-      continue;
-    }
-    if (*in == EOF) {
-      in.error("unterminated string");
-    }
-    if (!*in) {
-      /*
-       * Apparently we're actually supposed to ban all control
-       * characters from strings.  This seems unnecessarily
-       * restrictive, so we're only banning zero bytes.  (Since the
-       * string is presumed to be UTF-8 encoded it's fine to just
-       * check this way.)
-       */
-      in.error("null byte in string");
-    }
-
-    ret.push_back(char(*in));
-    ++in;
-  }
-
-  return ret;
-}
-
-dynamic parseValue(Input& in, json::metadata_map* map) {
-  RecursionGuard guard(in);
-
-  in.skipWhitespace();
-  // clang-format off
-  return
-      *in == '[' ? parseArray(in, map) :
-      *in == '{' ? parseObject(in, map) :
-      *in == '\"' ? parseString(in) :
-      (*in == '-' || (*in >= '0' && *in <= '9')) ? parseNumber(in) :
-      in.consume("true") ? true :
-      in.consume("false") ? false :
-      in.consume("null") ? nullptr :
-      in.consume("Infinity") ?
-      (in.getOpts().parse_numbers_as_strings ? (dynamic)"Infinity" :
-        (dynamic)std::numeric_limits<double>::infinity()) :
-      in.consume("NaN") ?
-        (in.getOpts().parse_numbers_as_strings ? (dynamic)"NaN" :
-          (dynamic)std::numeric_limits<double>::quiet_NaN()) :
-      in.error("expected json value");
-  // clang-format on
-}
-
-} // namespace
-
-//////////////////////////////////////////////////////////////////////
-
-std::array<uint64_t, 2> buildExtraAsciiToEscapeBitmap(StringPiece chars) {
-  std::array<uint64_t, 2> escapes{{0, 0}};
-  for (auto b : ByteRange(chars)) {
-    if (b >= 0x20 && b < 0x80) {
-      escapes[b / 64] |= uint64_t(1) << (b % 64);
-    }
-  }
-  return escapes;
-}
-
-std::string serialize(dynamic const& dyn, serialization_opts const& opts) {
-  std::string ret;
-  unsigned indentLevel = 0;
-  Printer p(ret, opts.pretty_formatting ? &indentLevel : nullptr, &opts);
-  p(dyn, nullptr);
-  return ret;
-}
-
-// Fast path to determine the longest prefix that can be left
-// unescaped in a string of sizeof(T) bytes packed in an integer of
-// type T.
-template <bool EnableExtraAsciiEscapes, class T>
-size_t firstEscapableInWord(T s, const serialization_opts& opts) {
-  static_assert(std::is_unsigned<T>::value, "Unsigned integer required");
-  static constexpr T kOnes = ~T() / 255; // 0x...0101
-  static constexpr T kMsbs = kOnes * 0x80; // 0x...8080
-
-  // Sets the MSB of bytes < b. Precondition: b < 128.
-  auto isLess = [](T w, uint8_t b) {
-    // A byte is < b iff subtracting b underflows, so we check that
-    // the MSB wasn't set before and it's set after the subtraction.
-    return (w - kOnes * b) & ~w & kMsbs;
-  };
-
-  auto isChar = [&](uint8_t c) {
-    // A byte is == c iff it is 0 if xor'd with c.
-    return isLess(s ^ (kOnes * c), 1);
-  };
-
-  // The following masks have the MSB set for each byte of the word
-  // that satisfies the corresponding condition.
-  auto isHigh = s & kMsbs; // >= 128
-  auto isLow = isLess(s, 0x20); // <= 0x1f
-  auto needsEscape = isHigh | isLow | isChar('\\') | isChar('"');
-
-  if /* constexpr */ (EnableExtraAsciiEscapes) {
-    // Deal with optional bitmap for unicode escapes. Escapes can optionally be
-    // set for ascii characters 32 - 127, so the inner loop may run up to 96
-    // times. However, for the case where 0 or a handful of bits are set,
-    // looping will be minimal through use of findFirstSet.
-    for (size_t i = 0, e = opts.extra_ascii_to_escape_bitmap.size(); i < e;
-         ++i) {
-      const auto offset = i * 64;
-      // Clear first 32 characters if this is the first index, since those are
-      // always escaped.
-      auto bitmap = opts.extra_ascii_to_escape_bitmap[i] &
-          (i == 0 ? uint64_t(-1) << 32 : ~0ULL);
-      while (bitmap) {
-        auto bit = folly::findFirstSet(bitmap);
-        needsEscape |= isChar(static_cast<uint8_t>(offset + bit - 1));
-        bitmap &= bitmap - 1;
-      }
-    }
-  }
-
-  if (!needsEscape) {
-    return sizeof(T);
-  }
-
-  if (folly::kIsLittleEndian) {
-    return folly::findFirstSet(needsEscape) / 8 - 1;
-  } else {
-    return sizeof(T) - folly::findLastSet(needsEscape) / 8;
-  }
-}
-
-// Escape a string so that it is legal to print it in JSON text.
-template <bool EnableExtraAsciiEscapes>
-void escapeStringImpl(
-    StringPiece input, std::string& out, const serialization_opts& opts) {
-  auto hexDigit = [](uint8_t c) -> char {
-    return c < 10 ? c + '0' : c - 10 + 'a';
-  };
-
-  out.push_back('\"');
-
-  auto* p = reinterpret_cast<const unsigned char*>(input.begin());
-  auto* q = reinterpret_cast<const unsigned char*>(input.begin());
-  auto* e = reinterpret_cast<const unsigned char*>(input.end());
-
-  while (p < e) {
-    // Find the longest prefix that does not need escaping, and copy
-    // it literally into the output string.
-    auto firstEsc = p;
-    while (firstEsc < e) {
-      auto avail = to_unsigned(e - firstEsc);
-      uint64_t word = 0;
-      if (avail >= 8) {
-        word = folly::loadUnaligned<uint64_t>(firstEsc);
-      } else {
-        word = folly::partialLoadUnaligned<uint64_t>(firstEsc, avail);
-      }
-      auto prefix = firstEscapableInWord<EnableExtraAsciiEscapes>(word, opts);
-      DCHECK_LE(prefix, avail);
+ #include <folly/json/json.h>
+
+ #include <algorithm>
+ #include <functional>
+ #include <iterator>
+ #include <sstream>
+ #include <type_traits>
+ 
+ #include <boost/algorithm/string.hpp>
+ #include <glog/logging.h>
+ 
+ #include <folly/Conv.h>
+ #include <folly/Portability.h>
+ #include <folly/Range.h>
+ #include <folly/Unicode.h>
+ #include <folly/Utility.h>
+ #include <folly/lang/Bits.h>
+ #include <folly/portability/Constexpr.h>
+ 
+ namespace folly {
+ 
+ //////////////////////////////////////////////////////////////////////
+ 
+ namespace json {
+ 
+ namespace {
+ 
+ parse_error make_parse_error(
+     unsigned int line,
+     std::string const& context,
+     std::string const& expected) {
+   return parse_error(to<std::string>(
+       "json parse error on line ",
+       line,
+       !context.empty() ? to<std::string>(" near `", context, '\'') : "",
+       ": ",
+       expected));
+ }
+ 
+ struct Printer {
+   // Context class is allows to restore the path to element that we are about to
+   // print so that if error happens we can throw meaningful exception.
+   class Context {
+    public:
+     Context(const Context* parent_context, const dynamic& key)
+         : parent_context_(parent_context), key_(key), is_key_(false) {}
+     Context(const Context* parent_context, const dynamic& key, bool is_key)
+         : parent_context_(parent_context), key_(key), is_key_(is_key) {}
+ 
+     // Return location description of a context as a chain of keys
+     // ex., '"outherKey"->"innerKey"'.
+     std::string locationDescription() const {
+       std::vector<std::string> keys;
+       const Context* ptr = parent_context_;
+       while (ptr) {
+         keys.push_back(ptr->getName());
+         ptr = ptr->parent_context_;
+       }
+       keys.push_back(getName());
+       std::ostringstream stream;
+       std::reverse_copy(
+           keys.begin(),
+           keys.end() - 1,
+           std::ostream_iterator<std::string>(stream, "->"));
+ 
+       // Add current key.
+       stream << keys.back();
+       return stream.str();
+     }
+     std::string getName() const {
+       return Printer::toStringOr(key_, "<unprintable>");
+     }
+     std::string typeDescription() const { return is_key_ ? "key" : "value"; }
+ 
+    private:
+     const Context* const parent_context_;
+     const dynamic& key_;
+     bool is_key_;
+   };
+ 
+   explicit Printer(
+       std::string& out, unsigned* indentLevel, serialization_opts const* opts)
+       : out_(out), indentLevel_(indentLevel), opts_(*opts) {}
+ 
+   void operator()(dynamic const& v, const Context& context) const {
+     (*this)(v, &context);
+   }
+   void operator()(dynamic const& v, const Context* context) const {
+     switch (v.type()) {
+       case dynamic::DOUBLE: {
+         if (!opts_.allow_nan_inf) {
+           if (std::isnan(v.asDouble())) {
+             throw json::print_error(
+                 "folly::toJson: JSON object value was a NaN when serializing " +
+                 contextDescription(context));
+           }
+           if (std::isinf(v.asDouble())) {
+             throw json::print_error(
+                 "folly::toJson: JSON object value was an INF when serializing " +
+                 contextDescription(context));
+           }
+         }
+         toAppend(
+             v.asDouble(),
+             &out_,
+             opts_.dtoa_mode,
+             opts_.double_num_digits,
+             opts_.dtoa_flags);
+         break;
+       }
+       case dynamic::INT64: {
+         auto intval = v.asInt();
+         if (opts_.javascript_safe) {
+           // Use folly::to to check that this integer can be represented
+           // as a double without loss of precision.
+           intval = int64_t(to<double>(intval));
+         }
+         toAppend(intval, &out_);
+         break;
+       }
+       case dynamic::BOOL:
+         out_ += v.asBool() ? "true" : "false";
+         break;
+       case dynamic::NULLT:
+         out_ += "null";
+         break;
+       case dynamic::STRING:
+         escapeString(v.stringPiece(), out_, opts_);
+         break;
+       case dynamic::OBJECT:
+         printObject(v, context);
+         break;
+       case dynamic::ARRAY:
+         printArray(v, context);
+         break;
+       default:
+         CHECK(0) << "Bad type " << v.type();
+     }
+   }
+ 
+  private:
+   void printKV(
+       dynamic const& o,
+       const std::pair<const dynamic, dynamic>& p,
+       const Context* context) const {
+     if (opts_.convert_int_keys && p.first.isInt()) {
+       auto strKey = p.first.asString();
+       if (o.count(strKey)) {
+         throw json::print_error(folly::to<std::string>(
+             "folly::toJson: Source object has integer and string keys "
+             "representing the same value: ",
+             p.first.asInt()));
+       }
+       (*this)(p.first.asString(), Context(context, p.first, true));
+     } else if (!opts_.allow_non_string_keys && !p.first.isString()) {
+       throw json::print_error(
+           "folly::toJson: JSON object key " +
+           toStringOr(p.first, "<unprintable key>") + " was not a string " +
+           (opts_.convert_int_keys ? "or integer " : "") +
+           "when serializing key at " +
+           Context(context, p.first, true).locationDescription());
+     } else {
+       (*this)(p.first, Context(context, p.first, true)); // Key
+     }
+     mapColon();
+     (*this)(p.second, Context(context, p.first, false)); // Value
+   }
+ 
+   template <typename Iterator>
+   void printKVPairs(
+       dynamic const& o,
+       Iterator begin,
+       Iterator end,
+       const Context* context) const {
+     printKV(o, *begin, context);
+     for (++begin; begin != end; ++begin) {
+       out_ += ',';
+       newline();
+       printKV(o, *begin, context);
+     }
+   }
+ 
+   void printObject(dynamic const& o, const Context* context) const {
+     if (o.empty()) {
+       out_ += "{}";
+       return;
+     }
+ 
+     out_ += '{';
+     indent();
+     newline();
+     if (opts_.sort_keys || opts_.sort_keys_by) {
+       using ref = std::reference_wrapper<decltype(o.items())::value_type const>;
+       auto sort_keys_by = [&](auto begin, auto end, const auto& comp) {
+         std::sort(begin, end, [&](ref a, ref b) {
+           // Only compare keys.  No ordering among identical keys.
+           return comp(a.get().first, b.get().first);
+         });
+       };
+       std::vector<ref> refs(o.items().begin(), o.items().end());
+       if (opts_.sort_keys_by) {
+         sort_keys_by(refs.begin(), refs.end(), opts_.sort_keys_by);
+       } else {
+         sort_keys_by(refs.begin(), refs.end(), std::less<>());
+       }
+       printKVPairs(o, refs.cbegin(), refs.cend(), context);
+     } else {
+       printKVPairs(o, o.items().begin(), o.items().end(), context);
+     }
+     outdent();
+     newline();
+     out_ += '}';
+   }
+ 
+   static std::string toStringOr(dynamic const& v, const char* placeholder) {
+     try {
+       std::string result;
+       unsigned indentLevel = 0;
+       serialization_opts opts;
+       opts.allow_nan_inf = true;
+       opts.allow_non_string_keys = true;
+       Printer printer(result, &indentLevel, &opts);
+       printer(v, nullptr);
+       return result;
+     } catch (...) {
+       return placeholder;
+     }
+   }
+ 
+   static std::string contextDescription(const Context* context) {
+     if (!context) {
+       return "<undefined location>";
+     }
+     return context->typeDescription() + " at " + context->locationDescription();
+   }
+ 
+   void printArray(dynamic const& a, const Context* context) const {
+     if (a.empty()) {
+       out_ += "[]";
+       return;
+     }
+ 
+     out_ += '[';
+     indent();
+     newline();
+     (*this)(a[0], Context(context, dynamic(0)));
+     for (auto it = std::next(a.begin()); it != a.end(); ++it) {
+       out_ += ',';
+       newline();
+       (*this)(*it, Context(context, dynamic(std::distance(a.begin(), it))));
+     }
+     outdent();
+     newline();
+     out_ += ']';
+   }
+ 
+  private:
+   void outdent() const {
+     if (indentLevel_) {
+       --*indentLevel_;
+     }
+   }
+ 
+   void indent() const {
+     if (indentLevel_) {
+       ++*indentLevel_;
+     }
+   }
+ 
+   void newline() const {
+     if (indentLevel_) {
+       auto indent = *indentLevel_ * opts_.pretty_formatting_indent_width;
+       out_ += to<std::string>('\n', std::string(indent, ' '));
+     }
+   }
+ 
+   void mapColon() const { out_ += indentLevel_ ? ": " : ":"; }
+ 
+  private:
+   std::string& out_;
+   unsigned* const indentLevel_;
+   serialization_opts const& opts_;
+ };
+ 
+ //////////////////////////////////////////////////////////////////////
+ 
+ // Wraps our input buffer with some helper functions.
+ struct Input {
+   explicit Input(StringPiece range, json::serialization_opts const* opts)
+       : range_(range), opts_(*opts), lineNum_(0) {
+     storeCurrent();
+   }
+ 
+   Input(Input const&) = delete;
+   Input& operator=(Input const&) = delete;
+ 
+   char const* begin() const { return range_.begin(); }
+ 
+   unsigned getLineNum() const { return lineNum_; }
+ 
+   // Parse ahead for as long as the supplied predicate is satisfied,
+   // returning a range of what was skipped.
+   template <class Predicate>
+   StringPiece skipWhile(const Predicate& p) {
+     std::size_t skipped = 0;
+     for (; skipped < range_.size(); ++skipped) {
+       if (!p(range_[skipped])) {
+         break;
+       }
+       if (range_[skipped] == '\n') {
+         ++lineNum_;
+       }
+     }
+     auto ret = range_.subpiece(0, skipped);
+     range_.advance(skipped);
+     storeCurrent();
+     return ret;
+   }
+ 
+   StringPiece skipDigits() {
+     return skipWhile([](char c) { return c >= '0' && c <= '9'; });
+   }
+ 
+   StringPiece skipMinusAndDigits() {
+     bool firstChar = true;
+     return skipWhile([&firstChar](char c) {
+       bool result = (c >= '0' && c <= '9') || (firstChar && c == '-');
+       firstChar = false;
+       return result;
+     });
+   }
+ 
+   void skipWhitespace() {
+     unsigned index = 0;
+     while (true) {
+       while (index < range_.size() && range_[index] == ' ') {
+         index++;
+       }
+       if (index < range_.size()) {
+         if (range_[index] == '\n') {
+           index++;
+           ++lineNum_;
+           continue;
+         }
+         if (range_[index] == '\t' || range_[index] == '\r') {
+           index++;
+           continue;
+         }
+       }
+       break;
+     }
+     range_.advance(index);
+     storeCurrent();
+   }
+ 
+   void expect(char c) {
+     if (**this != c) {
+       throw json::make_parse_error(
+           lineNum_, context(), to<std::string>("expected '", c, '\''));
+     }
+     ++*this;
+   }
+ 
+   std::size_t size() const { return range_.size(); }
+ 
+   int operator*() const { return current_; }
+ 
+   void operator++() {
+     range_.pop_front();
+     storeCurrent();
+   }
+ 
+   template <class T>
+   T extract() {
+     try {
+       return to<T>(&range_);
+     } catch (std::exception const& e) {
+       error(e.what());
+     }
+   }
+ 
+   bool consume(StringPiece str) {
+     if (boost::starts_with(range_, str)) {
+       range_.advance(str.size());
+       storeCurrent();
+       return true;
+     }
+     return false;
+   }
+ 
+   std::string context() const {
+     return range_.subpiece(0, 16 /* arbitrary */).toString();
+   }
+ 
+   [[noreturn]] void error(char const* what) const {
+     throw json::make_parse_error(lineNum_, context(), what);
+   }
+   template <typename R>
+   R error(char const* what) const {
+     error(what);
+   }
+ 
+   json::serialization_opts const& getOpts() { return opts_; }
+ 
+   void incrementRecursionLevel() {
+     if (currentRecursionLevel_ > opts_.recursion_limit) {
+       error("recursion limit exceeded");
+     }
+     currentRecursionLevel_++;
+   }
+ 
+   void decrementRecursionLevel() { currentRecursionLevel_--; }
+ 
+  private:
+   void storeCurrent() { current_ = range_.empty() ? EOF : range_.front(); }
+ 
+  private:
+   StringPiece range_;
+   json::serialization_opts const& opts_;
+   unsigned lineNum_;
+   int current_;
+   unsigned int currentRecursionLevel_{0};
+ };
+ 
+ class RecursionGuard {
+  public:
+   explicit RecursionGuard(Input& in) : in_(in) {
+     in_.incrementRecursionLevel();
+   }
+ 
+   ~RecursionGuard() { in_.decrementRecursionLevel(); }
+ 
+  private:
+   Input& in_;
+ };
+ 
+ dynamic parseValue(Input& in, json::metadata_map* map);
+ std::string parseString(Input& in);
+ dynamic parseNumber(Input& in);
+ 
+ void parseObjectKeyValue(
+     Input& in,
+     dynamic& ret,
+     dynamic&& key,
+     json::metadata_map* map,
+     bool distinct) {
+   auto keyLineNumber = in.getLineNum();
+   in.skipWhitespace();
+   in.expect(':');
+   in.skipWhitespace();
+   auto valueLineNumber = in.getLineNum();
+   auto value = parseValue(in, map);
+   auto [it, inserted] = ret.try_emplace(std::move(key), std::move(value));
+   if (!inserted) {
+     if (distinct) {
+       in.error("duplicate key inserted");
+     }
+     it->second = std::move(value);
+   }
+   if (map) {
+     map->emplace(
+         &it->second,
+         json::parse_metadata{{{keyLineNumber}}, {{valueLineNumber}}});
+   }
+ }
+ 
+ dynamic parseObject(Input& in, json::metadata_map* map) {
+   DCHECK_EQ(*in, '{');
+   ++in;
+ 
+   dynamic ret = dynamic::object;
+ 
+   in.skipWhitespace();
+   if (*in == '}') {
+     ++in;
+     return ret;
+   }
+ 
+   const auto& opts = in.getOpts();
+   const bool distinct = opts.validate_keys || opts.convert_int_keys;
+   for (;;) {
+     if (opts.allow_trailing_comma && *in == '}') {
+       break;
+     }
+     dynamic key = parseValue(in, map);
+     if (opts.convert_int_keys && key.isInt()) {
+       key = key.asString();
+     } else if (!opts.allow_non_string_keys && !key.isString()) {
+       in.error(
+           opts.convert_int_keys ? "expected string or integer for object key"
+                                 : "expected string for object key");
+     }
+     parseObjectKeyValue(in, ret, std::move(key), map, distinct);
+ 
+     in.skipWhitespace();
+     if (*in != ',') {
+       break;
+     }
+     ++in;
+     in.skipWhitespace();
+   }
+   in.expect('}');
+ 
+   return ret;
+ }
+ 
+ dynamic parseArray(Input& in, json::metadata_map* map) {
+   DCHECK_EQ(*in, '[');
+   ++in;
+ 
+   dynamic ret = dynamic::array;
+ 
+   in.skipWhitespace();
+   if (*in == ']') {
+     ++in;
+     return ret;
+   }
+ 
+   std::vector<uint32_t> lineNumbers;
+   for (;;) {
+     if (in.getOpts().allow_trailing_comma && *in == ']') {
+       break;
+     }
+     ret.push_back(parseValue(in, map));
+     if (map) {
+       lineNumbers.push_back(in.getLineNum());
+     }
+     in.skipWhitespace();
+     if (*in != ',') {
+       break;
+     }
+     ++in;
+     in.skipWhitespace();
+   }
+   if (map) {
+     for (size_t i = 0, e = ret.size(); i < e; i++) {
+       map->emplace(&ret[i], json::parse_metadata{{{0}}, {{lineNumbers[i]}}});
+     }
+   }
+   in.expect(']');
+ 
+   return ret;
+ }
+ 
+ dynamic parseNumber(Input& in) {
+   bool const negative = (*in == '-');
+   if (negative && in.consume("-Infinity")) {
+     if (in.getOpts().parse_numbers_as_strings) {
+       return "-Infinity";
+     } else {
+       return -std::numeric_limits<double>::infinity();
+     }
+   }
+ 
+   auto integral = in.skipMinusAndDigits();
+   if (negative && integral.size() < 2) {
+     in.error("expected digits after `-'");
+   }
+ 
+   auto const wasE = *in == 'e' || *in == 'E';
+ 
+   if (*in != '.' && !wasE && in.getOpts().parse_numbers_as_strings) {
+     return integral;
+   }
+ 
+   constexpr const char* maxIntStr = "9223372036854775807";
+   constexpr const char* minIntStr = "-9223372036854775808";
+   constexpr auto maxIntLen = constexpr_strlen(maxIntStr);
+   constexpr auto minIntLen = constexpr_strlen(minIntStr);
+   auto extremaLen = negative ? minIntLen : maxIntLen;
+   auto extremaStr = negative ? minIntStr : maxIntStr;
+   if (*in != '.' && !wasE) {
+     if (FOLLY_LIKELY(
+             !in.getOpts().double_fallback || integral.size() < extremaLen) ||
+         (integral.size() == extremaLen && integral <= extremaStr)) {
+       auto val = to<int64_t>(integral);
+       in.skipWhitespace();
+       return val;
+     } else {
+       auto val = to<double>(integral);
+       in.skipWhitespace();
+       return val;
+     }
+   }
+ 
+   auto end = !wasE ? (++in, in.skipDigits().end()) : in.begin();
+   if (*in == 'e' || *in == 'E') {
+     ++in;
+     if (*in == '+' || *in == '-') {
+       ++in;
+     }
+     auto expPart = in.skipDigits();
+     end = expPart.end();
+   }
+   auto fullNum = range(integral.begin(), end);
+   if (in.getOpts().parse_numbers_as_strings) {
+     return fullNum;
+   }
+   auto val = to<double>(fullNum);
+   return val;
+ }
+ 
+ void decodeUnicodeEscape(Input& in, std::string& out) {
+   auto hexVal = [&](int c) -> uint16_t {
+     // clang-format off
+     return uint16_t(
+         c >= '0' && c <= '9' ? c - '0' :
+         c >= 'a' && c <= 'f' ? c - 'a' + 10 :
+         c >= 'A' && c <= 'F' ? c - 'A' + 10 :
+         in.error<uint16_t>("invalid hex digit"));
+     // clang-format on
+   };
+ 
+   auto readHex = [&]() -> uint16_t {
+     if (in.size() < 4) {
+       in.error("expected 4 hex digits");
+     }
+ 
+     auto ret = uint16_t(hexVal(*in) * 4096);
+     ++in;
+     ret += hexVal(*in) * 256;
+     ++in;
+     ret += hexVal(*in) * 16;
+     ++in;
+     ret += hexVal(*in);
+     ++in;
+     return ret;
+   };
+ 
+   //  If the value encoded is in the surrogate pair range, we need to make
+   //  sure there is another escape that we can use also.
+   //
+   //  See the explanation in folly/Unicode.h.
+   uint16_t prefix = readHex();
+   char32_t codePoint = prefix;
+   if (utf16_code_unit_is_high_surrogate(prefix)) {
+     if (!in.consume("\\u")) {
+       in.error(
+           "expected another unicode escape for second half of "
+           "surrogate pair");
+     }
+     uint16_t suffix = readHex();
+     if (!utf16_code_unit_is_low_surrogate(suffix)) {
+       in.error("second character in surrogate pair is invalid");
+     }
+     codePoint = unicode_code_point_from_utf16_surrogate_pair(prefix, suffix);
+   } else if (!utf16_code_unit_is_bmp(prefix)) {
+     in.error("invalid unicode code point (in range [0xdc00,0xdfff])");
+   }
+ 
+   appendCodePointToUtf8(codePoint, out);
+ }
+ 
+ std::string parseString(Input& in) {
+   DCHECK_EQ(*in, '\"');
+   ++in;
+ 
+   std::string ret;
+   for (;;) {
+     auto range = in.skipWhile([](char c) { return c != '\"' && c != '\\'; });
+     ret.append(range.begin(), range.end());
+ 
+     if (*in == '\"') {
+       ++in;
+       break;
+     }
+     if (*in == '\\') {
+       ++in;
+       switch (*in) {
+           // clang-format off
+         case '\"':    ret.push_back('\"'); ++in; break;
+         case '\\':    ret.push_back('\\'); ++in; break;
+         case '/':     ret.push_back('/');  ++in; break;
+         case 'b':     ret.push_back('\b'); ++in; break;
+         case 'f':     ret.push_back('\f'); ++in; break;
+         case 'n':     ret.push_back('\n'); ++in; break;
+         case 'r':     ret.push_back('\r'); ++in; break;
+         case 't':     ret.push_back('\t'); ++in; break;
+         case 'u':     ++in; decodeUnicodeEscape(in, ret); break;
+         // clang-format on
+         default:
+           in.error(
+               to<std::string>("unknown escape ", *in, " in string").c_str());
+       }
+       continue;
+     }
+     if (*in == EOF) {
+       in.error("unterminated string");
+     }
+     if (!*in) {
+       /*
+        * Apparently we're actually supposed to ban all control
+        * characters from strings.  This seems unnecessarily
+        * restrictive, so we're only banning zero bytes.  (Since the
+        * string is presumed to be UTF-8 encoded it's fine to just
+        * check this way.)
+        */
+       in.error("null byte in string");
+     }
+ 
+     ret.push_back(char(*in));
+     ++in;
+   }
+ 
+   return ret;
+ }
+ 
+ dynamic parseValue(Input& in, json::metadata_map* map) {
+   RecursionGuard guard(in);
+ 
+   in.skipWhitespace();
+   // clang-format off
+   return
+       *in == '[' ? parseArray(in, map) :
+       *in == '{' ? parseObject(in, map) :
+       *in == '\"' ? parseString(in) :
+       (*in == '-' || (*in >= '0' && *in <= '9')) ? parseNumber(in) :
+       in.consume("true") ? true :
+       in.consume("false") ? false :
+       in.consume("null") ? nullptr :
+       in.consume("Infinity") ?
+       (in.getOpts().parse_numbers_as_strings ? (dynamic)"Infinity" :
+         (dynamic)std::numeric_limits<double>::infinity()) :
+       in.consume("NaN") ?
+         (in.getOpts().parse_numbers_as_strings ? (dynamic)"NaN" :
+           (dynamic)std::numeric_limits<double>::quiet_NaN()) :
+       in.error<dynamic>("expected json value");
+   // clang-format on
+ }
+ 
+ } // namespace
+ 
+ //////////////////////////////////////////////////////////////////////
+ 
+ std::array<uint64_t, 2> buildExtraAsciiToEscapeBitmap(StringPiece chars) {
+   std::array<uint64_t, 2> escapes{{0, 0}};
+   for (auto b : ByteRange(chars)) {
+     if (b >= 0x20 && b < 0x80) {
+       escapes[b / 64] |= uint64_t(1) << (b % 64);
+     }
+   }
+   return escapes;
+ }
+ 
+ std::string serialize(dynamic const& dyn, serialization_opts const& opts) {
+   std::string ret;
+   unsigned indentLevel = 0;
+   Printer p(ret, opts.pretty_formatting ? &indentLevel : nullptr, &opts);
+   p(dyn, nullptr);
+   return ret;
+ }
+ 
+ // Fast path to determine the longest prefix that can be left
+ // unescaped in a string of sizeof(T) bytes packed in an integer of
+ // type T.
+ template <bool EnableExtraAsciiEscapes, class T>
+ size_t firstEscapableInWord(T s, const serialization_opts& opts) {
+   static_assert(std::is_unsigned<T>::value, "Unsigned integer required");
+   static constexpr T kOnes = ~T() / 255; // 0x...0101
+   static constexpr T kMsbs = kOnes * 0x80; // 0x...8080
+ 
+   // Sets the MSB of bytes < b. Precondition: b < 128.
+   auto isLess = [](T w, uint8_t b) {
+     // A byte is < b iff subtracting b underflows, so we check that
+     // the MSB wasn't set before and it's set after the subtraction.
+     return (w - kOnes * b) & ~w & kMsbs;
+   };
+ 
+   auto isChar = [&](uint8_t c) {
+     // A byte is == c iff it is 0 if xor'd with c.
+     return isLess(s ^ (kOnes * c), 1);
+   };
+ 
+   // The following masks have the MSB set for each byte of the word
+   // that satisfies the corresponding condition.
+   auto isHigh = s & kMsbs; // >= 128
+   auto isLow = isLess(s, 0x20); // <= 0x1f
+   auto needsEscape = isHigh | isLow | isChar('\\') | isChar('"');
+ 
+   if /* constexpr */ (EnableExtraAsciiEscapes) {
+     // Deal with optional bitmap for unicode escapes. Escapes can optionally be
+     // set for ascii characters 32 - 127, so the inner loop may run up to 96
+     // times. However, for the case where 0 or a handful of bits are set,
+     // looping will be minimal through use of findFirstSet.
+     for (size_t i = 0, e = opts.extra_ascii_to_escape_bitmap.size(); i < e;
+          ++i) {
+       const auto offset = i * 64;
+       // Clear first 32 characters if this is the first index, since those are
+       // always escaped.
+       auto bitmap = opts.extra_ascii_to_escape_bitmap[i] &
+           (i == 0 ? uint64_t(-1) << 32 : ~0ULL);
+       while (bitmap) {
+         auto bit = folly::findFirstSet(bitmap);
+         needsEscape |= isChar(static_cast<uint8_t>(offset + bit - 1));
+         bitmap &= bitmap - 1;
+       }
+     }
+   }
+ 
+   if (!needsEscape) {
+     return sizeof(T);
+   }
+ 
+   if (folly::kIsLittleEndian) {
+     return folly::findFirstSet(needsEscape) / 8 - 1;
+   } else {
+     return sizeof(T) - folly::findLastSet(needsEscape) / 8;
+   }
+ }
+ 
+ // Escape a string so that it is legal to print it in JSON text.
+ template <bool EnableExtraAsciiEscapes>
+ void escapeStringImpl(
+     StringPiece input, std::string& out, const serialization_opts& opts) {
+   auto hexDigit = [](uint8_t c) -> char {
+     return c < 10 ? c + '0' : c - 10 + 'a';
+   };
+ 
+   out.push_back('\"');
+ 
+   auto* p = reinterpret_cast<const unsigned char*>(input.begin());
+   auto* q = reinterpret_cast<const unsigned char*>(input.begin());
+   auto* e = reinterpret_cast<const unsigned char*>(input.end());
+ 
+   while (p < e) {
+     // Find the longest prefix that does not need escaping, and copy
+     // it literally into the output string.
+     auto firstEsc = p;
+     while (firstEsc < e) {
+       auto avail = to_unsigned(e - firstEsc);
+       uint64_t word = 0;
+       if (avail >= 8) {
+         word = folly::loadUnaligned<uint64_t>(firstEsc);
+       } else {
+         word = folly::partialLoadUnaligned<uint64_t>(firstEsc, avail);
+       }
+       auto prefix = firstEscapableInWord<EnableExtraAsciiEscapes>(word, opts);
+       DCHECK_LE(prefix, avail);
       // [Windows Sometimes prefix is completely wrong (corrupt?), only in Release, causing a later AV (see issue #14394).
       // Prefix should always be <= avail, capping it here as a workaround, hoping the assert above eventually catches this in Debug.
       prefix = std::min(prefix, (size_t)avail);
       // Windows]
-      firstEsc += prefix;
-      if (prefix < 8) {
-        break;
-      }
-    }
-    if (firstEsc > p) {
-      out.append(reinterpret_cast<const char*>(p), firstEsc - p);
-      p = firstEsc;
-      // We can't be in the middle of a multibyte sequence, so we can reset q.
-      q = p;
-      if (p == e) {
-        break;
-      }
-    }
-
-    // Handle the next byte that may need escaping.
-
-    // Since non-ascii encoding inherently does utf8 validation
-    // we explicitly validate utf8 only if non-ascii encoding is disabled.
-    if ((opts.validate_utf8 || opts.skip_invalid_utf8) &&
-        !opts.encode_non_ascii) {
-      // To achieve better spatial and temporal coherence
-      // we do utf8 validation progressively along with the
-      // string-escaping instead of two separate passes.
-
-      // As the encoding progresses, q will stay at or ahead of p.
-      CHECK_GE(q, p);
-
-      // As p catches up with q, move q forward.
-      if (q == p) {
-        // calling utf8_decode has the side effect of
-        // checking that utf8 encodings are valid
-        char32_t v = utf8ToCodePoint(q, e, opts.skip_invalid_utf8);
-        if (opts.skip_invalid_utf8 && v == U'\ufffd') {
-          out.append(reinterpret_cast<const char*>(u8"\ufffd"));
-          p = q;
-          continue;
-        }
-      }
-    }
-
-    auto encodeUnicode = opts.encode_non_ascii && (*p & 0x80);
-    if /* constexpr */ (EnableExtraAsciiEscapes) {
-      encodeUnicode = encodeUnicode ||
-          (*p >= 0x20 && *p < 0x80 &&
-           (opts.extra_ascii_to_escape_bitmap[*p / 64] &
-            (uint64_t(1) << (*p % 64))));
-    }
-
-    if (encodeUnicode) {
-      // note that this if condition captures utf8 chars
-      // with value > 127, so size > 1 byte (or they are whitelisted for
-      // Unicode encoding).
-      // NOTE: char32_t / char16_t are both unsigned.
-      char32_t cp = utf8ToCodePoint(p, e, opts.skip_invalid_utf8);
-      auto writeHex = [&](char16_t v) {
-        char buf[] = "\\u\0\0\0\0";
-        buf[2] = hexDigit((v >> 12) & 0x0f);
-        buf[3] = hexDigit((v >> 8) & 0x0f);
-        buf[4] = hexDigit((v >> 4) & 0x0f);
-        buf[5] = hexDigit(v & 0x0f);
-        out.append(buf, 6);
-      };
-      // From the ECMA-404 The JSON Data Interchange Syntax 2nd Edition Dec 2017
-      if (cp < 0x10000u) {
-        // If the code point is in the Basic Multilingual Plane (U+0000 through
-        // U+FFFF), then it may be represented as a six-character sequence:
-        // a reverse solidus, followed by the lowercase letter u, followed by
-        // four hexadecimal digits that encode the code point.
-        writeHex(static_cast<char16_t>(cp));
-      } else {
-        // To escape a code point that is not in the Basic Multilingual Plane,
-        // the character may be represented as a twelve-character sequence,
-        // encoding the UTF-16 surrogate pair corresponding to the code point.
-        writeHex(static_cast<char16_t>(
-            0xd800u + (((cp - 0x10000u) >> 10) & 0x3ffu)));
-        writeHex(static_cast<char16_t>(0xdc00u + ((cp - 0x10000u) & 0x3ffu)));
-      }
-    } else if (*p == '\\' || *p == '\"') {
-      char buf[] = "\\\0";
-      buf[1] = char(*p++);
-      out.append(buf, 2);
-    } else if (*p <= 0x1f) {
-      switch (*p) {
-        // clang-format off
-        case '\b': out.append("\\b"); p++; break;
-        case '\f': out.append("\\f"); p++; break;
-        case '\n': out.append("\\n"); p++; break;
-        case '\r': out.append("\\r"); p++; break;
-        case '\t': out.append("\\t"); p++; break;
-        // clang-format on
-        default:
-          // Note that this if condition captures non readable chars
-          // with value < 32, so size = 1 byte (e.g control chars).
-          char buf[] = "\\u00\0\0";
-          buf[4] = hexDigit(uint8_t((*p & 0xf0) >> 4));
-          buf[5] = hexDigit(uint8_t(*p & 0xf));
-          out.append(buf, 6);
-          p++;
-      }
-    } else {
-      out.push_back(char(*p++));
-    }
-  }
-
-  out.push_back('\"');
-}
-
-void escapeString(
-    StringPiece input, std::string& out, const serialization_opts& opts) {
-  if (FOLLY_UNLIKELY(
-          opts.extra_ascii_to_escape_bitmap[0] ||
-          opts.extra_ascii_to_escape_bitmap[1])) {
-    escapeStringImpl<true>(input, out, opts);
-  } else {
-    escapeStringImpl<false>(input, out, opts);
-  }
-}
-
-std::string stripComments(StringPiece jsonC) {
-  std::string result;
-  enum class State {
-    None,
-    InString,
-    InlineComment,
-    LineComment
-  } state = State::None;
-
-  for (size_t i = 0; i < jsonC.size(); ++i) {
-    auto s = jsonC.subpiece(i);
-    switch (state) {
-      case State::None:
-        if (s.startsWith("/*")) {
-          state = State::InlineComment;
-          ++i;
-          continue;
-        } else if (s.startsWith("//")) {
-          state = State::LineComment;
-          ++i;
-          continue;
-        } else if (s[0] == '\"') {
-          state = State::InString;
-        }
-        result.push_back(s[0]);
-        break;
-      case State::InString:
-        if (s[0] == '\\') {
-          if (FOLLY_UNLIKELY(s.size() == 1)) {
-            throw std::logic_error("Invalid JSONC: string is not terminated");
-          }
-          result.push_back(s[0]);
-          result.push_back(s[1]);
-          ++i;
-          continue;
-        } else if (s[0] == '\"') {
-          state = State::None;
-        }
-        result.push_back(s[0]);
-        break;
-      case State::InlineComment:
-        if (s.startsWith('\n')) {
-          // preserve the line break to preserve the line count
-          result.push_back(s[0]);
-        } else if (s.startsWith("*/")) {
-          state = State::None;
-          ++i;
-        }
-        break;
-      case State::LineComment:
-        if (s[0] == '\n') {
-          // preserve the line break to preserve the line count
-          result.push_back(s[0]);
-          state = State::None;
-        }
-        break;
-      default:
-        throw std::logic_error("Unknown comment state");
-    }
-  }
-  return result;
-}
-
-} // namespace json
-
-//////////////////////////////////////////////////////////////////////
-
-dynamic parseJsonWithMetadata(StringPiece range, json::metadata_map* map) {
-  return parseJsonWithMetadata(range, json::serialization_opts(), map);
-}
-
-dynamic parseJsonWithMetadata(
-    StringPiece range,
-    json::serialization_opts const& opts,
-    json::metadata_map* map) {
-  json::Input in(range, &opts);
-
-  uint32_t n = in.getLineNum();
-  auto ret = parseValue(in, map);
-  if (map) {
-    map->emplace(&ret, json::parse_metadata{{{0}}, {{n}}});
-  }
-
-  in.skipWhitespace();
-  if (in.size() && *in != '\0') {
-    in.error("parsing didn't consume all input");
-  }
-  return ret;
-}
-
-dynamic parseJson(StringPiece range) {
-  return parseJson(range, json::serialization_opts());
-}
-
-dynamic parseJson(StringPiece range, json::serialization_opts const& opts) {
-  json::Input in(range, &opts);
-
-  auto ret = parseValue(in, nullptr);
-  in.skipWhitespace();
-  if (in.size() && *in != '\0') {
-    in.error("parsing didn't consume all input");
-  }
-  return ret;
-}
-
-std::string toJson(dynamic const& dyn) {
-  return json::serialize(dyn, json::serialization_opts());
-}
-
-std::string toPrettyJson(dynamic const& dyn) {
-  json::serialization_opts opts;
-  opts.pretty_formatting = true;
-  opts.sort_keys = true;
-  return json::serialize(dyn, opts);
-}
-
-//////////////////////////////////////////////////////////////////////
-// dynamic::print_as_pseudo_json() is implemented here for header
-// ordering reasons (most of the dynamic implementation is in
-// dynamic-inl.h, which we don't want to include json.h).
-
-void dynamic::print_as_pseudo_json(std::ostream& out) const {
-  json::serialization_opts opts;
-  opts.allow_non_string_keys = true;
-  opts.allow_nan_inf = true;
-  out << json::serialize(*this, opts);
-}
-
-void PrintTo(const dynamic& dyn, std::ostream* os) {
-  json::serialization_opts opts;
-  opts.allow_nan_inf = true;
-  opts.allow_non_string_keys = true;
-  opts.pretty_formatting = true;
-  opts.sort_keys = true;
-  *os << json::serialize(dyn, opts);
-}
-
-//////////////////////////////////////////////////////////////////////
-
-} // namespace folly
+       firstEsc += prefix;
+       if (prefix < 8) {
+         break;
+       }
+     }
+     if (firstEsc > p) {
+       out.append(reinterpret_cast<const char*>(p), firstEsc - p);
+       p = firstEsc;
+       // We can't be in the middle of a multibyte sequence, so we can reset q.
+       q = p;
+       if (p == e) {
+         break;
+       }
+     }
+ 
+     // Handle the next byte that may need escaping.
+ 
+     // Since non-ascii encoding inherently does utf8 validation
+     // we explicitly validate utf8 only if non-ascii encoding is disabled.
+     if ((opts.validate_utf8 || opts.skip_invalid_utf8) &&
+         !opts.encode_non_ascii) {
+       // To achieve better spatial and temporal coherence
+       // we do utf8 validation progressively along with the
+       // string-escaping instead of two separate passes.
+ 
+       // As the encoding progresses, q will stay at or ahead of p.
+       CHECK_GE(q, p);
+ 
+       // As p catches up with q, move q forward.
+       if (q == p) {
+         // calling utf8_decode has the side effect of
+         // checking that utf8 encodings are valid
+         char32_t v = utf8ToCodePoint(q, e, opts.skip_invalid_utf8);
+         if (opts.skip_invalid_utf8 && v == U'\ufffd') {
+           out.append(reinterpret_cast<const char*>(u8"\ufffd"));
+           p = q;
+           continue;
+         }
+       }
+     }
+ 
+     auto encodeUnicode = opts.encode_non_ascii && (*p & 0x80);
+     if /* constexpr */ (EnableExtraAsciiEscapes) {
+       encodeUnicode = encodeUnicode ||
+           (*p >= 0x20 && *p < 0x80 &&
+            (opts.extra_ascii_to_escape_bitmap[*p / 64] &
+             (uint64_t(1) << (*p % 64))));
+     }
+ 
+     if (encodeUnicode) {
+       // note that this if condition captures utf8 chars
+       // with value > 127, so size > 1 byte (or they are whitelisted for
+       // Unicode encoding).
+       // NOTE: char32_t / char16_t are both unsigned.
+       char32_t cp = utf8ToCodePoint(p, e, opts.skip_invalid_utf8);
+       auto writeHex = [&](char16_t v) {
+         char buf[] = "\\u\0\0\0\0";
+         buf[2] = hexDigit((v >> 12) & 0x0f);
+         buf[3] = hexDigit((v >> 8) & 0x0f);
+         buf[4] = hexDigit((v >> 4) & 0x0f);
+         buf[5] = hexDigit(v & 0x0f);
+         out.append(buf, 6);
+       };
+       // From the ECMA-404 The JSON Data Interchange Syntax 2nd Edition Dec 2017
+       if (cp < 0x10000u) {
+         // If the code point is in the Basic Multilingual Plane (U+0000 through
+         // U+FFFF), then it may be represented as a six-character sequence:
+         // a reverse solidus, followed by the lowercase letter u, followed by
+         // four hexadecimal digits that encode the code point.
+         writeHex(static_cast<char16_t>(cp));
+       } else {
+         // To escape a code point that is not in the Basic Multilingual Plane,
+         // the character may be represented as a twelve-character sequence,
+         // encoding the UTF-16 surrogate pair corresponding to the code point.
+         writeHex(static_cast<char16_t>(
+             0xd800u + (((cp - 0x10000u) >> 10) & 0x3ffu)));
+         writeHex(static_cast<char16_t>(0xdc00u + ((cp - 0x10000u) & 0x3ffu)));
+       }
+     } else if (*p == '\\' || *p == '\"') {
+       char buf[] = "\\\0";
+       buf[1] = char(*p++);
+       out.append(buf, 2);
+     } else if (*p <= 0x1f) {
+       switch (*p) {
+           // clang-format off
+         case '\b': out.append("\\b"); p++; break;
+         case '\f': out.append("\\f"); p++; break;
+         case '\n': out.append("\\n"); p++; break;
+         case '\r': out.append("\\r"); p++; break;
+         case '\t': out.append("\\t"); p++; break;
+         // clang-format on
+         default:
+           // Note that this if condition captures non readable chars
+           // with value < 32, so size = 1 byte (e.g control chars).
+           char buf[] = "\\u00\0\0";
+           buf[4] = hexDigit(uint8_t((*p & 0xf0) >> 4));
+           buf[5] = hexDigit(uint8_t(*p & 0xf));
+           out.append(buf, 6);
+           p++;
+       }
+     } else {
+       out.push_back(char(*p++));
+     }
+   }
+ 
+   out.push_back('\"');
+ }
+ 
+ void escapeString(
+     StringPiece input, std::string& out, const serialization_opts& opts) {
+   if (FOLLY_UNLIKELY(
+           opts.extra_ascii_to_escape_bitmap[0] ||
+           opts.extra_ascii_to_escape_bitmap[1])) {
+     escapeStringImpl<true>(input, out, opts);
+   } else {
+     escapeStringImpl<false>(input, out, opts);
+   }
+ }
+ 
+ std::string stripComments(StringPiece jsonC) {
+   std::string result;
+   enum class State {
+     None,
+     InString,
+     InlineComment,
+     LineComment
+   } state = State::None;
+ 
+   for (size_t i = 0; i < jsonC.size(); ++i) {
+     auto s = jsonC.subpiece(i);
+     switch (state) {
+       case State::None:
+         if (s.startsWith("/*")) {
+           state = State::InlineComment;
+           ++i;
+           continue;
+         } else if (s.startsWith("//")) {
+           state = State::LineComment;
+           ++i;
+           continue;
+         } else if (s[0] == '\"') {
+           state = State::InString;
+         }
+         result.push_back(s[0]);
+         break;
+       case State::InString:
+         if (s[0] == '\\') {
+           if (FOLLY_UNLIKELY(s.size() == 1)) {
+             throw std::logic_error("Invalid JSONC: string is not terminated");
+           }
+           result.push_back(s[0]);
+           result.push_back(s[1]);
+           ++i;
+           continue;
+         } else if (s[0] == '\"') {
+           state = State::None;
+         }
+         result.push_back(s[0]);
+         break;
+       case State::InlineComment:
+         if (s.startsWith('\n')) {
+           // preserve the line break to preserve the line count
+           result.push_back(s[0]);
+         } else if (s.startsWith("*/")) {
+           state = State::None;
+           ++i;
+         }
+         break;
+       case State::LineComment:
+         if (s[0] == '\n') {
+           // preserve the line break to preserve the line count
+           result.push_back(s[0]);
+           state = State::None;
+         }
+         break;
+       default:
+         throw std::logic_error("Unknown comment state");
+     }
+   }
+   return result;
+ }
+ 
+ } // namespace json
+ 
+ //////////////////////////////////////////////////////////////////////
+ 
+ dynamic parseJsonWithMetadata(StringPiece range, json::metadata_map* map) {
+   return parseJsonWithMetadata(range, json::serialization_opts(), map);
+ }
+ 
+ dynamic parseJsonWithMetadata(
+     StringPiece range,
+     json::serialization_opts const& opts,
+     json::metadata_map* map) {
+   json::Input in(range, &opts);
+ 
+   uint32_t n = in.getLineNum();
+   auto ret = parseValue(in, map);
+   if (map) {
+     map->emplace(&ret, json::parse_metadata{{{0}}, {{n}}});
+   }
+ 
+   in.skipWhitespace();
+   if (in.size() && *in != '\0') {
+     in.error("parsing didn't consume all input");
+   }
+   return ret;
+ }
+ 
+ dynamic parseJson(StringPiece range) {
+   return parseJson(range, json::serialization_opts());
+ }
+ 
+ dynamic parseJson(StringPiece range, json::serialization_opts const& opts) {
+   json::Input in(range, &opts);
+ 
+   auto ret = parseValue(in, nullptr);
+   in.skipWhitespace();
+   if (in.size() && *in != '\0') {
+     in.error("parsing didn't consume all input");
+   }
+   return ret;
+ }
+ 
+ std::string toJson(dynamic const& dyn) {
+   return json::serialize(dyn, json::serialization_opts());
+ }
+ 
+ std::string toPrettyJson(dynamic const& dyn) {
+   json::serialization_opts opts;
+   opts.pretty_formatting = true;
+   opts.sort_keys = true;
+   return json::serialize(dyn, opts);
+ }
+ 
+ //////////////////////////////////////////////////////////////////////
+ // dynamic::print_as_pseudo_json() is implemented here for header
+ // ordering reasons (most of the dynamic implementation is in
+ // dynamic-inl.h, which we don't want to include json.h).
+ 
+ void dynamic::print_as_pseudo_json(std::ostream& out) const {
+   json::serialization_opts opts;
+   opts.allow_non_string_keys = true;
+   opts.allow_nan_inf = true;
+   out << json::serialize(*this, opts);
+ }
+ 
+ void PrintTo(const dynamic& dyn, std::ostream* os) {
+   json::serialization_opts opts;
+   opts.allow_nan_inf = true;
+   opts.allow_non_string_keys = true;
+   opts.pretty_formatting = true;
+   opts.sort_keys = true;
+   *os << json::serialize(dyn, opts);
+ }
+ 
+ //////////////////////////////////////////////////////////////////////
+ 
+ } // namespace folly
\ No newline at end of file
diff --git a/vnext/Folly/TEMP_UntilFollyUpdate/lang/SafeAssert.h b/vnext/Folly/TEMP_UntilFollyUpdate/lang/SafeAssert.h
index d565dff810b..b46e4faefbb 100644
--- a/vnext/Folly/TEMP_UntilFollyUpdate/lang/SafeAssert.h
+++ b/vnext/Folly/TEMP_UntilFollyUpdate/lang/SafeAssert.h
@@ -14,182 +14,175 @@
  * limitations under the License.
  */
 
-#pragma once
-
-#include <cstdint>
-#include <utility>
-
-#include <folly/CppAttributes.h>
-#include <folly/Portability.h>
-#include <folly/Preprocessor.h>
-#include <folly/lang/CArray.h>
-
-#define FOLLY_DETAIL_SAFE_CHECK_IMPL(d, p, u, expr, ...)                  \
-  do {                                                                    \
-    if ((!d || ::folly::kIsDebug || ::folly::kIsSanitize) &&              \
-        !static_cast<bool>(expr)) {                                       \
-      static constexpr auto __folly_detail_safe_assert_fun = __func__;    \
-      static constexpr ::folly::detail::safe_assert_arg                   \
-          __folly_detail_safe_assert_arg{                                 \
-              u ? nullptr : #expr,                                        \
-              __FILE__,                                                   \
-              FOLLY_PP_CONSTINIT_LINE_UNSIGNED,                           \
-              __folly_detail_safe_assert_fun,                             \
-              ::folly::detail::safe_assert_msg_types<                     \
-                  decltype(::folly::detail::safe_assert_msg_types_seq_of( \
-                      __VA_ARGS__))>::value.data};                        \
-      constexpr ::folly::detail::safe_assert_terminate_w<p>               \
-          __folly_detail_safe_assert_terminate_w{                         \
-              __folly_detail_safe_assert_arg};                            \
-      __folly_detail_safe_assert_terminate_w(__VA_ARGS__);                \
-    }                                                                     \
-  } while (false)
-
-//  FOLLY_SAFE_CHECK
-//
-//  If expr evaluates to false after explicit conversion to bool, prints context
-//  information to stderr and aborts. Context information includes the remaining
-//  variadic arguments.
-//
-//  When the remaining variadic arguments are printed to stderr, there are two
-//  supported types after implicit conversions: char const* and uint64_t. This
-//  facility is intentionally not extensible to custom types.
-//
-//  multi-thread-safe
-//  async-signal-safe
-#define FOLLY_SAFE_CHECK(expr, ...) \
-  FOLLY_DETAIL_SAFE_CHECK_IMPL(0, 0, 0, expr, __VA_ARGS__)
-
-//  FOLLY_SAFE_DCHECK
-//
-//  Equivalent to FOLLY_SAFE_CHECK when in debug or instrumented builds, where
-//  debug builds are signalled by NDEBUG being undefined and instrumented builds
-//  include sanitizer builds.
-//
-//  multi-thread-safe
-//  async-signal-safe
-#define FOLLY_SAFE_DCHECK(expr, ...) \
-  FOLLY_DETAIL_SAFE_CHECK_IMPL(1, 0, 0, expr, __VA_ARGS__)
-
-//  FOLLY_SAFE_PCHECK
-//
-//  Equivalent to FOLLY_SAFE_CHECK but includes errno in the contextual
-//  information printed to stderr.
-//
-//  multi-thread-safe
-//  async-signal-safe
-#define FOLLY_SAFE_PCHECK(expr, ...) \
-  FOLLY_DETAIL_SAFE_CHECK_IMPL(0, 1, 0, expr, __VA_ARGS__)
-
-//  FOLLY_SAFE_DPCHECK
-//
-//  Equivalent to FOLLY_SAFE_DCHECK but includes errno in the contextual
-//  information printed to stderr.
-//
-//  multi-thread-safe
-//  async-signal-safe
-#define FOLLY_SAFE_DPCHECK(expr, ...) \
-  FOLLY_DETAIL_SAFE_CHECK_IMPL(1, 1, 0, expr, __VA_ARGS__)
-
-//  FOLLY_SAFE_FATAL
-//
-//  Equivalent to FOLLY_SAFE_CHECK(false, ...) but excludes any failing
-//  expression from the contextual information printed to stderr.
-//
-//  multi-thread-safe
-//  async-signal-safe
-#define FOLLY_SAFE_FATAL(...) \
-  FOLLY_DETAIL_SAFE_CHECK_IMPL(0, 0, 1, false, __VA_ARGS__)
-
-//  FOLLY_SAFE_DFATAL
-//
-//  Equivalent to FOLLY_SAFE_DCHECK(false, ...) but excludes any failing
-//  expression from the contextual information printed to stderr.
-//
-//  multi-thread-safe
-//  async-signal-safe
-#define FOLLY_SAFE_DFATAL(...) \
-  FOLLY_DETAIL_SAFE_CHECK_IMPL(1, 0, 1, false, __VA_ARGS__)
-
-namespace folly {
-namespace detail {
-
-enum class safe_assert_msg_type : char { term, cstr, ui64 };
-
-template <safe_assert_msg_type... A>
-struct safe_assert_msg_type_s {};
-
-struct safe_assert_msg_types_one_fn {
-  template <safe_assert_msg_type A>
-  using c = std::integral_constant<safe_assert_msg_type, A>;
-  // only used in unevaluated contexts:
-  c<safe_assert_msg_type::cstr> operator()(char const*) const;
-  c<safe_assert_msg_type::ui64> operator()(uint64_t) const;
-};
-FOLLY_INLINE_VARIABLE constexpr safe_assert_msg_types_one_fn
-    safe_assert_msg_types_one{}; // a function object to prevent extensions
-
-template <typename... A>
-safe_assert_msg_type_s<decltype(safe_assert_msg_types_one((A)A{}))::value...>
-safe_assert_msg_types_seq_of(A...); // only used in unevaluated contexts
-
-template <typename>
-struct safe_assert_msg_types;
-template <safe_assert_msg_type... A>
-struct safe_assert_msg_types<safe_assert_msg_type_s<A...>> {
-  using value_type = c_array<safe_assert_msg_type, sizeof...(A) + 1>;
-  static constexpr value_type value = {{A..., safe_assert_msg_type::term}};
-};
-
-#if FOLLY_CPLUSPLUS < 201703L
-template <safe_assert_msg_type... A>
-constexpr
-    typename safe_assert_msg_types<safe_assert_msg_type_s<A...>>::value_type
-        safe_assert_msg_types<safe_assert_msg_type_s<A...>>::value;
-#endif
-
-struct safe_assert_arg {
-  char const* expr;
-  char const* file;
-  unsigned int line;
-  char const* function;
-  safe_assert_msg_type const* msg_types;
-};
-
-struct safe_assert_msg_cast_one_fn {
-  FOLLY_ERASE auto operator()(char const* const a) const { return a; }
-  FOLLY_ERASE auto operator()(uint64_t const a) const { return a; }
-};
-FOLLY_INLINE_VARIABLE constexpr safe_assert_msg_cast_one_fn
-    safe_assert_msg_cast_one{}; // a function object to prevent extensions
-
-template <bool P>
-[[noreturn]] FOLLY_COLD FOLLY_NOINLINE void safe_assert_terminate(
-    safe_assert_arg const* arg, ...) noexcept; // the true backing function
+ #pragma once
+
+ #include <cstdint>
+ #include <utility>
+ 
+ #include <folly/CppAttributes.h>
+ #include <folly/Portability.h>
+ #include <folly/Preprocessor.h>
+ #include <folly/lang/CArray.h>
+ 
+ #define FOLLY_DETAIL_SAFE_CHECK_IMPL(d, p, u, expr, ...)                  \
+   do {                                                                    \
+     if ((!d || ::folly::kIsDebug || ::folly::kIsSanitize) &&              \
+         !static_cast<bool>(expr)) {                                       \
+       static constexpr auto __folly_detail_safe_assert_fun = __func__;    \
+       static constexpr ::folly::detail::safe_assert_arg                   \
+           __folly_detail_safe_assert_arg{                                 \
+               u ? nullptr : #expr,                                        \
+               __FILE__,                                                   \
+               FOLLY_PP_CONSTINIT_LINE_UNSIGNED,                           \
+               __folly_detail_safe_assert_fun,                             \
+               ::folly::detail::safe_assert_msg_types<                     \
+                   decltype(::folly::detail::safe_assert_msg_types_seq_of( \
+                       __VA_ARGS__))>::value.data};                        \
+       constexpr ::folly::detail::safe_assert_terminate_w<p>               \
+           __folly_detail_safe_assert_terminate_w{                         \
+               __folly_detail_safe_assert_arg};                            \
+       __folly_detail_safe_assert_terminate_w(__VA_ARGS__);                \
+     }                                                                     \
+   } while (false)
+ 
+ //  FOLLY_SAFE_CHECK
+ //
+ //  If expr evaluates to false after explicit conversion to bool, prints context
+ //  information to stderr and aborts. Context information includes the remaining
+ //  variadic arguments.
+ //
+ //  When the remaining variadic arguments are printed to stderr, there are two
+ //  supported types after implicit conversions: char const* and uint64_t. This
+ //  facility is intentionally not extensible to custom types.
+ //
+ //  multi-thread-safe
+ //  async-signal-safe
+ #define FOLLY_SAFE_CHECK(expr, ...) \
+   FOLLY_DETAIL_SAFE_CHECK_IMPL(0, 0, 0, expr, __VA_ARGS__)
+ 
+ //  FOLLY_SAFE_DCHECK
+ //
+ //  Equivalent to FOLLY_SAFE_CHECK when in debug or instrumented builds, where
+ //  debug builds are signalled by NDEBUG being undefined and instrumented builds
+ //  include sanitizer builds.
+ //
+ //  multi-thread-safe
+ //  async-signal-safe
+ #define FOLLY_SAFE_DCHECK(expr, ...) \
+   FOLLY_DETAIL_SAFE_CHECK_IMPL(1, 0, 0, expr, __VA_ARGS__)
+ 
+ //  FOLLY_SAFE_PCHECK
+ //
+ //  Equivalent to FOLLY_SAFE_CHECK but includes errno in the contextual
+ //  information printed to stderr.
+ //
+ //  multi-thread-safe
+ //  async-signal-safe
+ #define FOLLY_SAFE_PCHECK(expr, ...) \
+   FOLLY_DETAIL_SAFE_CHECK_IMPL(0, 1, 0, expr, __VA_ARGS__)
+ 
+ //  FOLLY_SAFE_DPCHECK
+ //
+ //  Equivalent to FOLLY_SAFE_DCHECK but includes errno in the contextual
+ //  information printed to stderr.
+ //
+ //  multi-thread-safe
+ //  async-signal-safe
+ #define FOLLY_SAFE_DPCHECK(expr, ...) \
+   FOLLY_DETAIL_SAFE_CHECK_IMPL(1, 1, 0, expr, __VA_ARGS__)
+ 
+ //  FOLLY_SAFE_FATAL
+ //
+ //  Equivalent to FOLLY_SAFE_CHECK(false, ...) but excludes any failing
+ //  expression from the contextual information printed to stderr.
+ //
+ //  multi-thread-safe
+ //  async-signal-safe
+ #define FOLLY_SAFE_FATAL(...) \
+   FOLLY_DETAIL_SAFE_CHECK_IMPL(0, 0, 1, false, __VA_ARGS__)
+ 
+ //  FOLLY_SAFE_DFATAL
+ //
+ //  Equivalent to FOLLY_SAFE_DCHECK(false, ...) but excludes any failing
+ //  expression from the contextual information printed to stderr.
+ //
+ //  multi-thread-safe
+ //  async-signal-safe
+ #define FOLLY_SAFE_DFATAL(...) \
+   FOLLY_DETAIL_SAFE_CHECK_IMPL(1, 0, 1, false, __VA_ARGS__)
+ 
+ namespace folly {
+ namespace detail {
+ 
+ enum class safe_assert_msg_type : char { term, cstr, ui64 };
+ 
+ template <safe_assert_msg_type... A>
+ struct safe_assert_msg_type_s {};
+ 
+ struct safe_assert_msg_types_one_fn {
+   template <safe_assert_msg_type A>
+   using c = std::integral_constant<safe_assert_msg_type, A>;
+   // only used in unevaluated contexts:
+   c<safe_assert_msg_type::cstr> operator()(char const*) const;
+   c<safe_assert_msg_type::ui64> operator()(uint64_t) const;
+ };
+ inline constexpr safe_assert_msg_types_one_fn
+     safe_assert_msg_types_one{}; // a function object to prevent extensions
+ 
+ template <typename... A>
+ safe_assert_msg_type_s<decltype(safe_assert_msg_types_one((A)A{}))::value...>
+ safe_assert_msg_types_seq_of(A...); // only used in unevaluated contexts
+ 
+ template <typename>
+ struct safe_assert_msg_types;
+ template <safe_assert_msg_type... A>
+ struct safe_assert_msg_types<safe_assert_msg_type_s<A...>> {
+   using value_type = c_array<safe_assert_msg_type, sizeof...(A) + 1>;
+   static constexpr value_type value = {{A..., safe_assert_msg_type::term}};
+ };
+ 
+ struct safe_assert_arg {
+   char const* expr;
+   char const* file;
+   unsigned int line;
+   char const* function;
+   safe_assert_msg_type const* msg_types;
+ };
+ 
+ struct safe_assert_msg_cast_one_fn {
+   FOLLY_ERASE auto operator()(char const* const a) const { return a; }
+   FOLLY_ERASE auto operator()(uint64_t const a) const { return a; }
+ };
+ inline constexpr safe_assert_msg_cast_one_fn
+     safe_assert_msg_cast_one{}; // a function object to prevent extensions
+ 
+ template <bool P>
+ [[noreturn, FOLLY_ATTR_GNU_COLD]] FOLLY_NOINLINE void safe_assert_terminate(
+     safe_assert_arg const* arg, ...) noexcept; // the true backing function
 
 // [Win - Fixes Error C2908 explicit specialization; 'void folly::detail::safe_assert_terminate<false>(const folly::detail::safe_assert_arg *,...) noexcept' has already been instantiated
 template <>
-[[noreturn]] FOLLY_COLD FOLLY_NOINLINE void safe_assert_terminate<0>(
+[[noreturn, FOLLY_ATTR_GNU_COLD]] FOLLY_NOINLINE void safe_assert_terminate<0>(
     safe_assert_arg const* arg, ...) noexcept;
 
 template <>
-[[noreturn]] FOLLY_COLD FOLLY_NOINLINE void safe_assert_terminate<1>(
+[[noreturn, FOLLY_ATTR_GNU_COLD]] FOLLY_NOINLINE void safe_assert_terminate<1>(
     safe_assert_arg const* arg, ...) noexcept;
 // Win]
 
-template <bool P>
-struct safe_assert_terminate_w {
-  safe_assert_arg const& arg;
-
-  FOLLY_ERASE constexpr safe_assert_terminate_w(
-      safe_assert_arg const& arg_) noexcept
-      : arg{arg_} {}
-
-  template <typename... A>
-  [[noreturn]] FOLLY_ERASE void operator()(A... a) const noexcept {
-    safe_assert_terminate<P>(&arg, safe_assert_msg_cast_one(a)...);
-  }
-};
-
-} // namespace detail
-} // namespace folly
+ template <bool P>
+ struct safe_assert_terminate_w {
+   safe_assert_arg const& arg;
+ 
+   FOLLY_ERASE constexpr safe_assert_terminate_w(
+       safe_assert_arg const& arg_) noexcept
+       : arg{arg_} {}
+ 
+   template <typename... A>
+   [[noreturn]] FOLLY_ERASE void operator()(A... a) const noexcept {
+     safe_assert_terminate<P>(&arg, safe_assert_msg_cast_one(a)...);
+   }
+ };
+ 
+ } // namespace detail
+ } // namespace folly
diff --git a/vnext/Folly/TEMP_UntilFollyUpdate/lang/ToAscii.h b/vnext/Folly/TEMP_UntilFollyUpdate/lang/ToAscii.h
index bad7147bd1d..f4545362bef 100644
--- a/vnext/Folly/TEMP_UntilFollyUpdate/lang/ToAscii.h
+++ b/vnext/Folly/TEMP_UntilFollyUpdate/lang/ToAscii.h
@@ -62,21 +62,21 @@ using to_ascii_alphabet_upper = to_ascii_alphabet<true>;
 //  and u8 at most 3.
 /*
 template <uint64_t Base, typename Int>
-FOLLY_INLINE_VARIABLE constexpr size_t to_ascii_size_max =
+inline  constexpr size_t to_ascii_size_max =
     detail::to_ascii_powers<Base, Int>::size;
 */
 //  to_ascii_size_max_decimal
 //
 //  An alias to to_ascii_size_max<10>.
 template <typename Int>
-FOLLY_INLINE_VARIABLE constexpr size_t to_ascii_size_max_decimal;
+inline  constexpr size_t to_ascii_size_max_decimal;
 
 template <>
-FOLLY_INLINE_VARIABLE constexpr size_t to_ascii_size_max_decimal<uint16_t> = 5;
+inline  constexpr size_t to_ascii_size_max_decimal<uint16_t> = 5;
 template <>
-FOLLY_INLINE_VARIABLE constexpr size_t to_ascii_size_max_decimal<uint32_t> = 10;
+inline  constexpr size_t to_ascii_size_max_decimal<uint32_t> = 10;
 template <>
-FOLLY_INLINE_VARIABLE constexpr size_t to_ascii_size_max_decimal<uint64_t> = 20;
+inline  constexpr size_t to_ascii_size_max_decimal<uint64_t> = 20;
 
 
 namespace detail {
diff --git a/vnext/Folly/cgmanifest.json b/vnext/Folly/cgmanifest.json
index e87e1493ce2..975cfc38d44 100644
--- a/vnext/Folly/cgmanifest.json
+++ b/vnext/Folly/cgmanifest.json
@@ -6,7 +6,7 @@
                 "Type": "git",
                 "Git": {
                   "RepositoryUrl": "https://github.com/facebook/folly",
-                  "CommitHash": "234d39a36a43106747d10cc19efada72fd810dd3"
+                  "CommitHash": "ad90720829db5ba0c3d0e44994856dcce33d7940"
                 }
             },
             "DevelopmentDependency": false
diff --git a/vnext/Microsoft.ReactNative.Managed/packages.lock.json b/vnext/Microsoft.ReactNative.Managed/packages.lock.json
index 0d7d0738511..8d89bc1efd5 100644
--- a/vnext/Microsoft.ReactNative.Managed/packages.lock.json
+++ b/vnext/Microsoft.ReactNative.Managed/packages.lock.json
@@ -24,21 +24,11 @@
           "Microsoft.SourceLink.Common": "1.1.1"
         }
       },
-      "boost": {
-        "type": "Transitive",
-        "resolved": "1.83.0",
-        "contentHash": "cy53VNMzysEMvhBixDe8ujPk67Fcj3v6FPHQnH91NYJNLHpc6jxa2xq9ruCaaJjE4M3YrGSHDi4uUSTGBWw6EQ=="
-      },
       "Microsoft.Build.Tasks.Git": {
         "type": "Transitive",
         "resolved": "1.1.1",
         "contentHash": "AT3HlgTjsqHnWpBHSNeR0KxbLZD7bztlZVj7I8vgeYG9SYqbeFGh0TM/KVtC6fg53nrWHl3VfZFvb5BiQFcY6Q=="
       },
-      "Microsoft.JavaScript.Hermes": {
-        "type": "Transitive",
-        "resolved": "0.1.23",
-        "contentHash": "cA9t1GjY4Yo0JD1AfA//e1lOwk48hLANfuX6GXrikmEBNZVr2TIX5ONJt5tqCnpZyLz6xGiPDgTfFNKbSfb21g=="
-      },
       "Microsoft.Net.Native.Compiler": {
         "type": "Transitive",
         "resolved": "2.2.12-rel-31116-00",
@@ -70,19 +60,6 @@
         "resolved": "1.1.1",
         "contentHash": "WMcGpWKrmJmzrNeuaEb23bEMnbtR/vLmvZtkAP5qWu7vQsY59GqfRJd65sFpBszbd2k/bQ8cs8eWawQKAabkVg=="
       },
-      "Microsoft.UI.Xaml": {
-        "type": "Transitive",
-        "resolved": "2.8.0",
-        "contentHash": "vxdHxTr63s5KVtNddMFpgvjBjUH50z7seq/5jLWmmSuf8poxg+sXrywkofUdE8ZstbpO9y3FL/IXXUcPYbeesA==",
-        "dependencies": {
-          "Microsoft.Web.WebView2": "1.0.1264.42"
-        }
-      },
-      "Microsoft.Web.WebView2": {
-        "type": "Transitive",
-        "resolved": "1.0.1264.42",
-        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
-      },
       "NETStandard.Library": {
         "type": "Transitive",
         "resolved": "2.0.3",
@@ -159,10 +136,7 @@
         "contentHash": "V/hZioMMAwoKZFmfq/SuMA/mfoNFu4+Aedwdld/tpL8ZheehFab0RlAR3pgsPgOWOU+GjyePNIgyUXM5J/Y3Ig=="
       },
       "common": {
-        "type": "Project",
-        "dependencies": {
-          "boost": "[1.83.0, )"
-        }
+        "type": "Project"
       },
       "fmt": {
         "type": "Project"
@@ -170,7 +144,6 @@
       "folly": {
         "type": "Project",
         "dependencies": {
-          "boost": "[1.83.0, )",
           "fmt": "[1.0.0, )"
         }
       },
@@ -179,18 +152,13 @@
         "dependencies": {
           "Common": "[1.0.0, )",
           "Folly": "[1.0.0, )",
-          "Microsoft.JavaScript.Hermes": "[0.1.23, )",
-          "Microsoft.SourceLink.GitHub": "[1.1.1, )",
-          "Microsoft.UI.Xaml": "[2.8.0, )",
-          "ReactCommon": "[1.0.0, )",
-          "boost": "[1.83.0, )"
+          "ReactCommon": "[1.0.0, )"
         }
       },
       "reactcommon": {
         "type": "Project",
         "dependencies": {
-          "Folly": "[1.0.0, )",
-          "boost": "[1.83.0, )"
+          "Folly": "[1.0.0, )"
         }
       }
     },
@@ -208,11 +176,6 @@
           "runtime.win10-arm.Microsoft.NETCore.UniversalWindowsPlatform": "6.2.14"
         }
       },
-      "Microsoft.Web.WebView2": {
-        "type": "Transitive",
-        "resolved": "1.0.1264.42",
-        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
-      },
       "runtime.win10-arm.Microsoft.NETCore.UniversalWindowsPlatform": {
         "type": "Transitive",
         "resolved": "6.2.14",
@@ -233,11 +196,6 @@
           "runtime.win10-arm-aot.Microsoft.NETCore.UniversalWindowsPlatform": "6.2.14"
         }
       },
-      "Microsoft.Web.WebView2": {
-        "type": "Transitive",
-        "resolved": "1.0.1264.42",
-        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
-      },
       "runtime.win10-arm-aot.Microsoft.NETCore.UniversalWindowsPlatform": {
         "type": "Transitive",
         "resolved": "6.2.14",
@@ -258,11 +216,6 @@
           "runtime.win10-arm64-aot.Microsoft.NETCore.UniversalWindowsPlatform": "6.2.14"
         }
       },
-      "Microsoft.Web.WebView2": {
-        "type": "Transitive",
-        "resolved": "1.0.1264.42",
-        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
-      },
       "runtime.win10-arm64-aot.Microsoft.NETCore.UniversalWindowsPlatform": {
         "type": "Transitive",
         "resolved": "6.2.14",
@@ -283,11 +236,6 @@
           "runtime.win10-x64.Microsoft.NETCore.UniversalWindowsPlatform": "6.2.14"
         }
       },
-      "Microsoft.Web.WebView2": {
-        "type": "Transitive",
-        "resolved": "1.0.1264.42",
-        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
-      },
       "runtime.win10-x64.Microsoft.NETCore.UniversalWindowsPlatform": {
         "type": "Transitive",
         "resolved": "6.2.14",
@@ -308,11 +256,6 @@
           "runtime.win10-x64-aot.Microsoft.NETCore.UniversalWindowsPlatform": "6.2.14"
         }
       },
-      "Microsoft.Web.WebView2": {
-        "type": "Transitive",
-        "resolved": "1.0.1264.42",
-        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
-      },
       "runtime.win10-x64-aot.Microsoft.NETCore.UniversalWindowsPlatform": {
         "type": "Transitive",
         "resolved": "6.2.14",
@@ -333,11 +276,6 @@
           "runtime.win10-x86.Microsoft.NETCore.UniversalWindowsPlatform": "6.2.14"
         }
       },
-      "Microsoft.Web.WebView2": {
-        "type": "Transitive",
-        "resolved": "1.0.1264.42",
-        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
-      },
       "runtime.win10-x86.Microsoft.NETCore.UniversalWindowsPlatform": {
         "type": "Transitive",
         "resolved": "6.2.14",
@@ -358,11 +296,6 @@
           "runtime.win10-x86-aot.Microsoft.NETCore.UniversalWindowsPlatform": "6.2.14"
         }
       },
-      "Microsoft.Web.WebView2": {
-        "type": "Transitive",
-        "resolved": "1.0.1264.42",
-        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
-      },
       "runtime.win10-x86-aot.Microsoft.NETCore.UniversalWindowsPlatform": {
         "type": "Transitive",
         "resolved": "6.2.14",

From ca5c1d44f8e885e201cc3a09f760d5b53f18b3e5 Mon Sep 17 00:00:00 2001
From: Tatiana Kapos <tatianakapos@microsoft.com>
Date: Mon, 14 Apr 2025 17:19:06 -0700
Subject: [PATCH 02/13] download fastfloat into node_modules

---
 vnext/Folly/Folly.vcxproj                  |   23 +-
 vnext/Folly/Folly.vcxproj.filters          |    7 +-
 vnext/Folly/TEMP_UntilFollyUpdate/Conv.cpp | 1205 ++++++++++++++++++++
 3 files changed, 1230 insertions(+), 5 deletions(-)
 create mode 100644 vnext/Folly/TEMP_UntilFollyUpdate/Conv.cpp

diff --git a/vnext/Folly/Folly.vcxproj b/vnext/Folly/Folly.vcxproj
index 9c6c9f06d78..2917eb7e6bc 100644
--- a/vnext/Folly/Folly.vcxproj
+++ b/vnext/Folly/Folly.vcxproj
@@ -63,7 +63,7 @@
     <ClCompile Include="$(FollyDir)\folly\system\ThreadId.cpp" />
     <ClCompile Include="$(FollyDir)\folly\lang\SafeAssert.cpp" />
     <ClCompile Include="$(FollyDir)\folly\lang\ToAscii.cpp" />
-    <ClCompile Include="$(FollyDir)\folly\json_pointer.cpp" />
+    <ClCompile Include="$(FollyDir)\folly\json\json_pointer.cpp" />
     <ClCompile Include="$(FollyDir)\folly\Format.cpp" />
     <ClCompile Include="$(FollyDir)\folly\String.cpp" />
     <ClCompile Include="$(FollyDir)\folly\container\detail\F14Table.cpp" />
@@ -72,7 +72,7 @@
       <ObjectFileName>$(IntDir)\portabilityString.obj</ObjectFileName>
     </ClCompile>
     <ClCompile Include="$(FollyDir)\folly\Demangle.cpp" />
-    <ClCompile Include="$(FollyDir)\folly\dynamic.cpp" />
+    <ClCompile Include="$(FollyDir)\folly\json\dynamic.cpp" />
     <ClCompile Include="$(FollyDir)\folly\json.cpp" />
     <ClCompile Include="$(FollyDir)\folly\hash\SpookyHashV2.cpp" />
     <ClCompile Include="$(FollyDir)\folly\ScopeGuard.cpp" />
@@ -235,6 +235,7 @@
     <ClInclude Include="$(FollyDir)\folly\Uri-inl.h" />
     <ClInclude Include="$(FollyDir)\folly\Uri.h" />
     <ClInclude Include="$(FollyDir)\folly\Varint.h" />
+    <ClInclude Include="$(FollyDir)\..\fast_float-6.1.4\include\fast_float\fast_float.h" />
     <ClInclude Include="pch.h" />
   </ItemGroup>
   <ItemGroup>
@@ -262,7 +263,7 @@
       <PrecompiledHeader>Use</PrecompiledHeader>
       <CompileAsWinRT>false</CompileAsWinRT>
       <SDLCheck>true</SDLCheck>
-      <AdditionalIncludeDirectories>$(ReactNativeWindowsDir)stubs;$(FollyDir);$(FmtDir)\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(ReactNativeWindowsDir)stubs;$(FollyDir);$(FollyDir)\..\fast_float-6.1.4\include;$(FmtDir)\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>FOLLY_CFG_NO_COROUTINES;FOLLY_NO_CONFIG;NOMINMAX;_CRT_SECURE_NO_WARNINGS;WINAPI_PARTITION_APP;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ForcedUsingFiles />
       <DisableSpecificWarnings>4251;4293;4305;4800;4804;4310;%(DisableSpecificWarnings)</DisableSpecificWarnings>
@@ -290,6 +291,14 @@
       DestinationFolder="$(FollyZipDir)"
       Retries="10" />
   </Target>
+  <Target Name="DownloadFastFloat" BeforeTargets="PrepareForBuild" Inputs="$(FollyDir)..\.fastfloatzip\fastfloat.zip" Outputs="$(FollyDir)..\.fastfloatzip\fastfloat.zip">
+    <Message Importance="High" Text="Downloading FastFloat (folly dependency)..." />
+    <DownloadFile
+      SourceUrl="https://github.com/fastfloat/fast_float/archive/refs/tags/v6.1.4.zip"
+      DestinationFileName="$(FollyDir)..\.fastfloatzip\fastfloat.zip"
+      DestinationFolder="$(FollyDir)..\.fastfloatzip"
+      Retries="10" />
+  </Target>
   <Target Name="UnzipFolly" BeforeTargets="PrepareForBuild" DependsOnTargets="DownloadFolly">
     <Message Condition="!Exists('$(FollyDir)folly\dynamic.h')" Importance="High" Text="Unzipping folly to $([MSBuild]::NormalizePath($(FollyDir)..))." />
     <Unzip
@@ -298,6 +307,14 @@
       DestinationFolder="$([MSBuild]::NormalizePath($(FollyDir)..))"
       OverwriteReadOnlyFiles="true" />
   </Target>
+  <Target Name="UnzipFastFloat" BeforeTargets="PrepareForBuild" DependsOnTargets="DownloadFastFloat">
+    <Message Condition="!Exists('$(FollyDir)..\.fastfloatzip\dynamic.h')" Importance="High" Text="Unzipping FastFloat to $([MSBuild]::NormalizePath($(FollyDir)..))." />
+    <Unzip
+      Condition="!Exists('$(FollyDir)..\.fastfloatzip\dynamic.h')"
+      SourceFiles="$(FollyDir)..\.fastfloatzip\fastfloat.zip"
+      DestinationFolder="$([MSBuild]::NormalizePath($(FollyDir)..))"
+      OverwriteReadOnlyFiles="true" />
+  </Target>
   <Target Name="WriteCGManifest" BeforeTargets="PrepareForBuild" DependsOnTargets="DownloadFolly" Inputs="$(FollyZipFile)" Outputs="$(CGManifestFile)">
     <PropertyGroup>
       <CGManifestText>{
diff --git a/vnext/Folly/Folly.vcxproj.filters b/vnext/Folly/Folly.vcxproj.filters
index 64fe8659cfd..a563aa172f7 100644
--- a/vnext/Folly/Folly.vcxproj.filters
+++ b/vnext/Folly/Folly.vcxproj.filters
@@ -48,13 +48,13 @@
     <ClCompile Include="$(FollyDir)\folly\Demangle.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="$(FollyDir)\folly\dynamic.cpp">
+    <ClCompile Include="$(FollyDir)\folly\json\dynamic.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
     <ClCompile Include="$(FollyDir)\folly\container\detail\F14Table.cpp">
       <Filter>Source Files\container\detail</Filter>
     </ClCompile>
-    <ClCompile Include="$(FollyDir)\folly\json_pointer.cpp">
+    <ClCompile Include="$(FollyDir)\folly\json\json_pointer.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
     <ClCompile Include="$(FollyDir)\folly\json.cpp">
@@ -151,6 +151,9 @@
     <ClInclude Include="$(FollyDir)\folly\ConcurrentSkipList.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="$(FollyDir)\..\fast_float-6.1.4\include\fast_float\fast_float.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
     <ClInclude Include="$(FollyDir)\folly\portability\Constexpr.h">
       <Filter>Header Files\portability</Filter>
     </ClInclude>
diff --git a/vnext/Folly/TEMP_UntilFollyUpdate/Conv.cpp b/vnext/Folly/TEMP_UntilFollyUpdate/Conv.cpp
new file mode 100644
index 00000000000..da5a205056c
--- /dev/null
+++ b/vnext/Folly/TEMP_UntilFollyUpdate/Conv.cpp
@@ -0,0 +1,1205 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * 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 <folly/Conv.h>
+
+ #include <array>
+ #include <istream>
+ 
+ #include <folly/lang/SafeAssert.h>
+ 
+ #include <fast_float/fast_float.h> // @manual=fbsource//third-party/fast_float:fast_float
+ 
+ namespace folly {
+ namespace detail {
+ 
+ namespace {
+ 
+ /**
+  * Finds the first non-digit in a string. The number of digits
+  * searched depends on the precision of the Tgt integral. Assumes the
+  * string starts with NO whitespace and NO sign.
+  *
+  * The semantics of the routine is:
+  *   for (;; ++b) {
+  *     if (b >= e || !isdigit(*b)) return b;
+  *   }
+  *
+  *  Complete unrolling marks bottom-line (i.e. entire conversion)
+  *  improvements of 20%.
+  */
+ inline const char* findFirstNonDigit(const char* b, const char* e) {
+   for (; b < e; ++b) {
+     auto const c = static_cast<unsigned>(*b) - '0';
+     if (c >= 10) {
+       break;
+     }
+   }
+   return b;
+ }
+ 
+ // Maximum value of number when represented as a string
+ template <class T>
+ struct MaxString {
+   static const char* const value;
+ };
+ 
+ template <>
+ const char* const MaxString<uint8_t>::value = "255";
+ template <>
+ const char* const MaxString<uint16_t>::value = "65535";
+ template <>
+ const char* const MaxString<uint32_t>::value = "4294967295";
+ #if __SIZEOF_LONG__ == 4
+ template <>
+ const char* const MaxString<unsigned long>::value = "4294967295";
+ #else
+ template <>
+ const char* const MaxString<unsigned long>::value = "18446744073709551615";
+ #endif
+ static_assert(
+     sizeof(unsigned long) >= 4,
+     "Wrong value for MaxString<unsigned long>::value,"
+     " please update.");
+ template <>
+ const char* const MaxString<unsigned long long>::value = "18446744073709551615";
+ static_assert(
+     sizeof(unsigned long long) >= 8,
+     "Wrong value for MaxString<unsigned long long>::value"
+     ", please update.");
+ 
+ #if FOLLY_HAVE_INT128_T
+ template <>
+ const char* const MaxString<__uint128_t>::value =
+     "340282366920938463463374607431768211455";
+ #endif
+ 
+ /*
+  * Lookup tables that converts from a decimal character value to an integral
+  * binary value, shifted by a decimal "shift" multiplier.
+  * For all character values in the range '0'..'9', the table at those
+  * index locations returns the actual decimal value shifted by the multiplier.
+  * For all other values, the lookup table returns an invalid OOR value.
+  */
+ // Out-of-range flag value, larger than the largest value that can fit in
+ // four decimal bytes (9999), but four of these added up together should
+ // still not overflow uint16_t.
+ constexpr int32_t OOR = 10000;
+ 
+ alignas(16) constexpr uint16_t shift1[] = {
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 0-9
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  10
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  20
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  30
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, 0,   1, //  40
+     2,   3,   4,   5,   6,   7,   8,   9,   OOR, OOR,
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  60
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  70
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  80
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  90
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 100
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 110
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 120
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 130
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 140
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 150
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 160
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 170
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 180
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 190
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 200
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 210
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 220
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 230
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 240
+     OOR, OOR, OOR, OOR, OOR, OOR // 250
+ };
+ 
+ alignas(16) constexpr uint16_t shift10[] = {
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 0-9
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  10
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  20
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  30
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, 0,   10, //  40
+     20,  30,  40,  50,  60,  70,  80,  90,  OOR, OOR,
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  60
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  70
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  80
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  90
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 100
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 110
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 120
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 130
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 140
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 150
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 160
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 170
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 180
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 190
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 200
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 210
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 220
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 230
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 240
+     OOR, OOR, OOR, OOR, OOR, OOR // 250
+ };
+ 
+ alignas(16) constexpr uint16_t shift100[] = {
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 0-9
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  10
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  20
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  30
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, 0,   100, //  40
+     200, 300, 400, 500, 600, 700, 800, 900, OOR, OOR,
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  60
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  70
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  80
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  90
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 100
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 110
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 120
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 130
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 140
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 150
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 160
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 170
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 180
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 190
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 200
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 210
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 220
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 230
+     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 240
+     OOR, OOR, OOR, OOR, OOR, OOR // 250
+ };
+ 
+ alignas(16) constexpr uint16_t shift1000[] = {
+     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 0-9
+     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, //  10
+     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, //  20
+     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, //  30
+     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  0,   1000, //  40
+     2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, OOR, OOR,
+     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, //  60
+     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, //  70
+     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, //  80
+     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, //  90
+     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 100
+     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 110
+     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 120
+     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 130
+     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 140
+     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 150
+     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 160
+     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 170
+     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 180
+     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 190
+     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 200
+     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 210
+     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 220
+     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 230
+     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 240
+     OOR,  OOR,  OOR,  OOR,  OOR,  OOR // 250
+ };
+ 
+ struct ErrorString {
+   const char* string;
+   bool quote;
+ };
+ 
+ // Keep this in sync with ConversionCode in Conv.h
+ constexpr const std::array<
+     ErrorString,
+     static_cast<std::size_t>(ConversionCode::NUM_ERROR_CODES)>
+     kErrorStrings{{
+         {"Success", true},
+         {"Empty input string", true},
+         {"No digits found in input string", true},
+         {"Integer overflow when parsing bool (must be 0 or 1)", true},
+         {"Invalid value for bool", true},
+         {"Non-digit character found", true},
+         {"Invalid leading character", true},
+         {"Overflow during conversion", true},
+         {"Negative overflow during conversion", true},
+         {"Unable to convert string to floating point value", true},
+         {"Non-whitespace character found after end of conversion", true},
+         {"Overflow during arithmetic conversion", false},
+         {"Negative overflow during arithmetic conversion", false},
+         {"Loss of precision during arithmetic conversion", false},
+     }};
+ 
+ // Check if ASCII is really ASCII
+ using IsAscii =
+     std::bool_constant<'A' == 65 && 'Z' == 90 && 'a' == 97 && 'z' == 122>;
+ 
+ // The code in this file that uses tolower() really only cares about
+ // 7-bit ASCII characters, so we can take a nice shortcut here.
+ inline char tolower_ascii(char in) {
+   return IsAscii::value ? in | 0x20 : char(std::tolower(in));
+ }
+ 
+ inline bool bool_str_cmp(const char** b, size_t len, const char* value) {
+   // Can't use strncasecmp, since we want to ensure that the full value matches
+   const char* p = *b;
+   const char* e = *b + len;
+   const char* v = value;
+   while (*v != '\0') {
+     if (p == e || tolower_ascii(*p) != *v) { // value is already lowercase
+       return false;
+     }
+     ++p;
+     ++v;
+   }
+ 
+   *b = p;
+   return true;
+ }
+ 
+ } // namespace
+ 
+ Expected<bool, ConversionCode> str_to_bool(StringPiece* src) noexcept {
+   auto b = src->begin(), e = src->end();
+   for (;; ++b) {
+     if (b >= e) {
+       return makeUnexpected(ConversionCode::EMPTY_INPUT_STRING);
+     }
+     if ((*b < '\t' || *b > '\r') && *b != ' ') {
+       break;
+     }
+   }
+ 
+   bool result;
+   auto len = size_t(e - b);
+   switch (*b) {
+     case '0':
+     case '1': {
+       result = false;
+       for (; b < e && isdigit(*b); ++b) {
+         if (result || (*b != '0' && *b != '1')) {
+           return makeUnexpected(ConversionCode::BOOL_OVERFLOW);
+         }
+         result = (*b == '1');
+       }
+       break;
+     }
+     case 'y':
+     case 'Y':
+       result = true;
+       if (!bool_str_cmp(&b, len, "yes")) {
+         ++b; // accept the single 'y' character
+       }
+       break;
+     case 'n':
+     case 'N':
+       result = false;
+       if (!bool_str_cmp(&b, len, "no")) {
+         ++b;
+       }
+       break;
+     case 't':
+     case 'T':
+       result = true;
+       if (!bool_str_cmp(&b, len, "true")) {
+         ++b;
+       }
+       break;
+     case 'f':
+     case 'F':
+       result = false;
+       if (!bool_str_cmp(&b, len, "false")) {
+         ++b;
+       }
+       break;
+     case 'o':
+     case 'O':
+       if (bool_str_cmp(&b, len, "on")) {
+         result = true;
+       } else if (bool_str_cmp(&b, len, "off")) {
+         result = false;
+       } else {
+         return makeUnexpected(ConversionCode::BOOL_INVALID_VALUE);
+       }
+       break;
+     default:
+       return makeUnexpected(ConversionCode::BOOL_INVALID_VALUE);
+   }
+ 
+   src->assign(b, e);
+ 
+   return result;
+ }
+ 
+ /// Uses `double_conversion` library to convert from string to a floating
+ /// point.
+ template <class Tgt>
+ Expected<Tgt, ConversionCode> str_to_floating_double_conversion(
+     StringPiece* src) noexcept {
+   using namespace double_conversion;
+   static StringToDoubleConverter conv(
+       StringToDoubleConverter::ALLOW_TRAILING_JUNK |
+           StringToDoubleConverter::ALLOW_LEADING_SPACES,
+       0.0,
+       // return this for junk input string
+       std::numeric_limits<Tgt>::quiet_NaN(),
+       nullptr,
+       nullptr);
+ 
+   if (src->empty()) {
+     return makeUnexpected(ConversionCode::EMPTY_INPUT_STRING);
+   }
+ 
+   int length; // processed char count
+   auto result = std::is_same<Tgt, float>::value
+       ? conv.StringToFloat(src->data(), static_cast<int>(src->size()), &length)
+       : static_cast<Tgt>(conv.StringToDouble(
+             src->data(), static_cast<int>(src->size()), &length));
+ 
+   if (!std::isnan(result)) {
+     // If we get here with length = 0, the input string is empty.
+     // If we get here with result = 0.0, it's either because the string
+     // contained only whitespace, or because we had an actual zero value
+     // (with potential trailing junk). If it was only whitespace, we
+     // want to raise an error; length will point past the last character
+     // that was processed, so we need to check if that character was
+     // whitespace or not.
+     if (length == 0 ||
+         (result == 0.0 && std::isspace((*src)[size_t(length) - 1]))) {
+       return makeUnexpected(ConversionCode::EMPTY_INPUT_STRING);
+     }
+     if (length >= 2) {
+       const char* suffix = src->data() + length - 1;
+       // double_conversion doesn't update length correctly when there is an
+       // incomplete exponent specifier. Converting "12e-f-g" shouldn't consume
+       // any more than "12", but it will consume "12e-".
+ 
+       // "123-" should only parse "123"
+       if (*suffix == '-' || *suffix == '+') {
+         --suffix;
+         --length;
+       }
+       // "12e-f-g" or "12euro" should only parse "12"
+       if (*suffix == 'e' || *suffix == 'E') {
+         --length;
+       }
+     }
+     src->advance(size_t(length));
+     return Tgt(result);
+   }
+ 
+   auto* e = src->end();
+   auto* b = std::find_if_not(src->begin(), e, [](char c) {
+     return (c >= '\t' && c <= '\r') || c == ' ';
+   });
+   if (b == e) {
+     return makeUnexpected(ConversionCode::EMPTY_INPUT_STRING);
+   }
+   auto size = size_t(e - b);
+ 
+   bool negative = false;
+   if (*b == '-') {
+     negative = true;
+     ++b;
+     --size;
+     if (size == 0) {
+       return makeUnexpected(ConversionCode::STRING_TO_FLOAT_ERROR);
+     }
+   }
+   assert(size > 0);
+ 
+   result = 0.0;
+ 
+   switch (tolower_ascii(*b)) {
+     case 'i':
+       if (size >= 3 && tolower_ascii(b[1]) == 'n' &&
+           tolower_ascii(b[2]) == 'f') {
+         if (size >= 8 && tolower_ascii(b[3]) == 'i' &&
+             tolower_ascii(b[4]) == 'n' && tolower_ascii(b[5]) == 'i' &&
+             tolower_ascii(b[6]) == 't' && tolower_ascii(b[7]) == 'y') {
+           b += 8;
+         } else {
+           b += 3;
+         }
+         result = std::numeric_limits<Tgt>::infinity();
+       }
+       break;
+ 
+     case 'n':
+       if (size >= 3 && tolower_ascii(b[1]) == 'a' &&
+           tolower_ascii(b[2]) == 'n') {
+         b += 3;
+         result = std::numeric_limits<Tgt>::quiet_NaN();
+       }
+       break;
+ 
+     default:
+       break;
+   }
+ 
+   if (result == 0.0) {
+     // All bets are off
+     return makeUnexpected(ConversionCode::STRING_TO_FLOAT_ERROR);
+   }
+ 
+   if (negative) {
+     result = -result;
+   }
+ 
+   src->assign(b, e);
+ 
+   return Tgt(result);
+ }
+ 
+ /// Uses `fast_float::from_chars` to convert from string to an integer.
+ template <class Tgt>
+ Expected<Tgt, ConversionCode> str_to_floating_fast_float_from_chars(
+     StringPiece* src) noexcept {
+   if (src->empty()) {
+     return makeUnexpected(ConversionCode::EMPTY_INPUT_STRING);
+   }
+ 
+   // move through leading whitespace characters
+   auto* e = src->end();
+   auto* b = std::find_if_not(src->begin(), e, [](char c) {
+     return (c >= '\t' && c <= '\r') || c == ' ';
+   });
+   if (b == e) {
+     return makeUnexpected(ConversionCode::EMPTY_INPUT_STRING);
+   }
+ 
+   Tgt result;
+   auto [ptr, ec] = fast_float::from_chars(b, e, result);
+   bool isOutOfRange{ec == std::errc::result_out_of_range};
+   bool isOk{ec == std::errc()};
+   if (!isOk && !isOutOfRange) {
+     return makeUnexpected(ConversionCode::STRING_TO_FLOAT_ERROR);
+   }
+ 
+   auto numMatchedChars = ptr - src->data();
+   src->advance(numMatchedChars);
+ 
+   if (isOutOfRange) {
+     if (*b == '-') {
+       return -std::numeric_limits<Tgt>::infinity();
+     } else {
+       return std::numeric_limits<Tgt>::infinity();
+     }
+   }
+ 
+   return result;
+ }
+ 
+ template Expected<float, ConversionCode>
+ str_to_floating_fast_float_from_chars<float>(StringPiece* src) noexcept;
+ template Expected<double, ConversionCode>
+ str_to_floating_fast_float_from_chars<double>(StringPiece* src) noexcept;
+ 
+ /**
+  * StringPiece to double, with progress information. Alters the
+  * StringPiece parameter to munch the already-parsed characters.
+  */
+ template <class Tgt>
+ Expected<Tgt, ConversionCode> str_to_floating(StringPiece* src) noexcept {
+ #if defined(FOLLY_CONV_ATOD_MODE) && FOLLY_CONV_ATOD_MODE == 1
+   return detail::str_to_floating_fast_float_from_chars<Tgt>(src);
+ #else
+   return detail::str_to_floating_double_conversion<Tgt>(src);
+ #endif
+ }
+ 
+ template Expected<float, ConversionCode> str_to_floating<float>(
+     StringPiece* src) noexcept;
+ template Expected<double, ConversionCode> str_to_floating<double>(
+     StringPiece* src) noexcept;
+ 
+ namespace {
+ 
+ /**
+  * This class takes care of additional processing needed for signed values,
+  * like leading sign character and overflow checks.
+  */
+ template <typename T, bool IsSigned = is_signed_v<T>>
+ class SignedValueHandler;
+ 
+ template <typename T>
+ class SignedValueHandler<T, true> {
+  public:
+   ConversionCode init(const char*& b) {
+     negative_ = false;
+     if (!std::isdigit(*b)) {
+       if (*b == '-') {
+         negative_ = true;
+       } else if (FOLLY_UNLIKELY(*b != '+')) {
+         return ConversionCode::INVALID_LEADING_CHAR;
+       }
+       ++b;
+     }
+     return ConversionCode::SUCCESS;
+   }
+ 
+   ConversionCode overflow() {
+     return negative_ ? ConversionCode::NEGATIVE_OVERFLOW
+                      : ConversionCode::POSITIVE_OVERFLOW;
+   }
+ 
+   template <typename U>
+   Expected<T, ConversionCode> finalize(U value) {
+     T rv;
+     if (negative_) {
+       FOLLY_PUSH_WARNING
+       FOLLY_MSVC_DISABLE_WARNING(4146)
+ 
+       // unary minus operator applied to unsigned type, result still unsigned
+       rv = T(-value);
+ 
+       FOLLY_POP_WARNING
+ 
+       if (FOLLY_UNLIKELY(rv > 0)) {
+         return makeUnexpected(ConversionCode::NEGATIVE_OVERFLOW);
+       }
+     } else {
+       rv = T(value);
+       if (FOLLY_UNLIKELY(rv < 0)) {
+         return makeUnexpected(ConversionCode::POSITIVE_OVERFLOW);
+       }
+     }
+     return rv;
+   }
+ 
+  private:
+   bool negative_;
+ };
+ 
+ // For unsigned types, we don't need any extra processing
+ template <typename T>
+ class SignedValueHandler<T, false> {
+  public:
+   ConversionCode init(const char*&) { return ConversionCode::SUCCESS; }
+ 
+   ConversionCode overflow() { return ConversionCode::POSITIVE_OVERFLOW; }
+ 
+   Expected<T, ConversionCode> finalize(T value) { return value; }
+ };
+ 
+ } // namespace
+ 
+ /**
+  * String represented as a pair of pointers to char to signed/unsigned
+  * integrals. Assumes NO whitespace before or after, and also that the
+  * string is composed entirely of digits (and an optional sign only for
+  * signed types). String may be empty, in which case digits_to returns
+  * an appropriate error.
+  */
+ template <class Tgt>
+ inline Expected<Tgt, ConversionCode> digits_to(
+     const char* b, const char* const e) noexcept {
+   using UT = make_unsigned_t<Tgt>;
+   assert(b <= e);
+ 
+   SignedValueHandler<Tgt> sgn;
+ 
+   auto err = sgn.init(b);
+   if (FOLLY_UNLIKELY(err != ConversionCode::SUCCESS)) {
+     return makeUnexpected(err);
+   }
+ 
+   auto size = size_t(e - b);
+ 
+   /* Although the string is entirely made of digits, we still need to
+    * check for overflow.
+    */
+   if (size > std::numeric_limits<UT>::digits10) {
+     // Leading zeros?
+     if (b < e && *b == '0') {
+       for (++b;; ++b) {
+         if (b == e) {
+           return Tgt(0); // just zeros, e.g. "0000"
+         }
+         if (*b != '0') {
+           size = size_t(e - b);
+           break;
+         }
+       }
+     }
+     if (size > std::numeric_limits<UT>::digits10 &&
+         (size != std::numeric_limits<UT>::digits10 + 1 ||
+          strncmp(b, MaxString<UT>::value, size) > 0)) {
+       return makeUnexpected(sgn.overflow());
+     }
+   }
+ 
+   // Here we know that the number won't overflow when
+   // converted. Proceed without checks.
+ 
+   UT result = 0;
+ 
+   for (; e - b >= 4; b += 4) {
+     result *= UT(10000);
+     const int32_t r0 = shift1000[static_cast<size_t>(b[0])];
+     const int32_t r1 = shift100[static_cast<size_t>(b[1])];
+     const int32_t r2 = shift10[static_cast<size_t>(b[2])];
+     const int32_t r3 = shift1[static_cast<size_t>(b[3])];
+     const auto sum = r0 + r1 + r2 + r3;
+     if (sum >= OOR) {
+       goto outOfRange;
+     }
+     result += UT(sum);
+   }
+ 
+   switch (e - b) {
+     case 3: {
+       const int32_t r0 = shift100[static_cast<size_t>(b[0])];
+       const int32_t r1 = shift10[static_cast<size_t>(b[1])];
+       const int32_t r2 = shift1[static_cast<size_t>(b[2])];
+       const auto sum = r0 + r1 + r2;
+       if (sum >= OOR) {
+         goto outOfRange;
+       }
+       result = UT(1000 * result + sum);
+       break;
+     }
+     case 2: {
+       const int32_t r0 = shift10[static_cast<size_t>(b[0])];
+       const int32_t r1 = shift1[static_cast<size_t>(b[1])];
+       const auto sum = r0 + r1;
+       if (sum >= OOR) {
+         goto outOfRange;
+       }
+       result = UT(100 * result + sum);
+       break;
+     }
+     case 1: {
+       const int32_t sum = shift1[static_cast<size_t>(b[0])];
+       if (sum >= OOR) {
+         goto outOfRange;
+       }
+       result = UT(10 * result + sum);
+       break;
+     }
+     default:
+       assert(b == e);
+       if (size == 0) {
+         return makeUnexpected(ConversionCode::NO_DIGITS);
+       }
+       break;
+   }
+ 
+   return sgn.finalize(result);
+ 
+ outOfRange:
+   return makeUnexpected(ConversionCode::NON_DIGIT_CHAR);
+ }
+ 
+ template Expected<char, ConversionCode> digits_to<char>(
+     const char*, const char*) noexcept;
+ template Expected<signed char, ConversionCode> digits_to<signed char>(
+     const char*, const char*) noexcept;
+ template Expected<unsigned char, ConversionCode> digits_to<unsigned char>(
+     const char*, const char*) noexcept;
+ 
+ template Expected<short, ConversionCode> digits_to<short>(
+     const char*, const char*) noexcept;
+ template Expected<unsigned short, ConversionCode> digits_to<unsigned short>(
+     const char*, const char*) noexcept;
+ 
+ template Expected<int, ConversionCode> digits_to<int>(
+     const char*, const char*) noexcept;
+ template Expected<unsigned int, ConversionCode> digits_to<unsigned int>(
+     const char*, const char*) noexcept;
+ 
+ template Expected<long, ConversionCode> digits_to<long>(
+     const char*, const char*) noexcept;
+ template Expected<unsigned long, ConversionCode> digits_to<unsigned long>(
+     const char*, const char*) noexcept;
+ 
+ template Expected<long long, ConversionCode> digits_to<long long>(
+     const char*, const char*) noexcept;
+ template Expected<unsigned long long, ConversionCode>
+ digits_to<unsigned long long>(const char*, const char*) noexcept;
+ 
+ #if FOLLY_HAVE_INT128_T
+ template Expected<__int128, ConversionCode> digits_to<__int128>(
+     const char*, const char*) noexcept;
+ template Expected<unsigned __int128, ConversionCode>
+ digits_to<unsigned __int128>(const char*, const char*) noexcept;
+ #endif
+ 
+ /**
+  * StringPiece to integrals, with progress information. Alters the
+  * StringPiece parameter to munch the already-parsed characters.
+  */
+ template <class Tgt>
+ Expected<Tgt, ConversionCode> str_to_integral(StringPiece* src) noexcept {
+   using UT = make_unsigned_t<Tgt>;
+ 
+   auto b = src->data(), past = src->data() + src->size();
+ 
+   for (;; ++b) {
+     if (FOLLY_UNLIKELY(b >= past)) {
+       return makeUnexpected(ConversionCode::EMPTY_INPUT_STRING);
+     }
+     if ((*b < '\t' || *b > '\r') && *b != ' ') {
+       break;
+     }
+   }
+ 
+   SignedValueHandler<Tgt> sgn;
+   auto err = sgn.init(b);
+ 
+   if (FOLLY_UNLIKELY(err != ConversionCode::SUCCESS)) {
+     return makeUnexpected(err);
+   }
+   if (is_signed_v<Tgt> && FOLLY_UNLIKELY(b >= past)) {
+     return makeUnexpected(ConversionCode::NO_DIGITS);
+   }
+   if (FOLLY_UNLIKELY(!isdigit(*b))) {
+     return makeUnexpected(ConversionCode::NON_DIGIT_CHAR);
+   }
+ 
+   auto m = findFirstNonDigit(b + 1, past);
+ 
+   auto tmp = digits_to<UT>(b, m);
+ 
+   if (FOLLY_UNLIKELY(!tmp.hasValue())) {
+     return makeUnexpected(
+         tmp.error() == ConversionCode::POSITIVE_OVERFLOW ? sgn.overflow()
+                                                          : tmp.error());
+   }
+ 
+   auto res = sgn.finalize(tmp.value());
+ 
+   if (res.hasValue()) {
+     src->advance(size_t(m - src->data()));
+   }
+ 
+   return res;
+ }
+ 
+ template Expected<char, ConversionCode> str_to_integral<char>(
+     StringPiece* src) noexcept;
+ template Expected<signed char, ConversionCode> str_to_integral<signed char>(
+     StringPiece* src) noexcept;
+ template Expected<unsigned char, ConversionCode> str_to_integral<unsigned char>(
+     StringPiece* src) noexcept;
+ 
+ template Expected<short, ConversionCode> str_to_integral<short>(
+     StringPiece* src) noexcept;
+ template Expected<unsigned short, ConversionCode>
+ str_to_integral<unsigned short>(StringPiece* src) noexcept;
+ 
+ template Expected<int, ConversionCode> str_to_integral<int>(
+     StringPiece* src) noexcept;
+ template Expected<unsigned int, ConversionCode> str_to_integral<unsigned int>(
+     StringPiece* src) noexcept;
+ 
+ template Expected<long, ConversionCode> str_to_integral<long>(
+     StringPiece* src) noexcept;
+ template Expected<unsigned long, ConversionCode> str_to_integral<unsigned long>(
+     StringPiece* src) noexcept;
+ 
+ template Expected<long long, ConversionCode> str_to_integral<long long>(
+     StringPiece* src) noexcept;
+ template Expected<unsigned long long, ConversionCode>
+ str_to_integral<unsigned long long>(StringPiece* src) noexcept;
+ 
+ #if FOLLY_HAVE_INT128_T
+ template Expected<__int128, ConversionCode> str_to_integral<__int128>(
+     StringPiece* src) noexcept;
+ template Expected<unsigned __int128, ConversionCode>
+ str_to_integral<unsigned __int128>(StringPiece* src) noexcept;
+ #endif
+ 
+ #if defined(FOLLY_CONV_AVALIABILITY_TO_CHARS_FLOATING_POINT) && \
+     FOLLY_CONV_AVALIABILITY_TO_CHARS_FLOATING_POINT == 1
+ DtoaFlagsSet::DtoaFlagsSet(DtoaFlags flags) : flags_(flags) {}
+ 
+ bool DtoaFlagsSet::isSet(DtoaFlags flag) const {
+   return (flags_ & flag) == flag;
+ }
+ 
+ bool DtoaFlagsSet::emitPositiveExponentSign() const {
+   return isSet(DtoaFlags::EMIT_POSITIVE_EXPONENT_SIGN);
+ }
+ 
+ bool DtoaFlagsSet::emitTrailingDecimalPoint() const {
+   return isSet(DtoaFlags::EMIT_TRAILING_DECIMAL_POINT);
+ }
+ 
+ bool DtoaFlagsSet::emitTrailingZeroAfterPoint() const {
+   return isSet(DtoaFlags::EMIT_TRAILING_ZERO_AFTER_POINT);
+ }
+ 
+ bool DtoaFlagsSet::uniqueZero() const {
+   return isSet(DtoaFlags::UNIQUE_ZERO);
+ }
+ 
+ bool DtoaFlagsSet::noTrailingZero() const {
+   return isSet(DtoaFlags::NO_TRAILING_ZERO);
+ }
+ 
+ int ParsedDecimal::numPrecisionFigures() const {
+   int numInts = 0;
+ 
+   bool intIsZero = true;
+   int numLeadingIntZeros = 0;
+   bool isLeadingIntZero = true;
+   for (char* p = integerBegin; p && p != integerEnd; p++) {
+     if (*p == '0') {
+       if (isLeadingIntZero) {
+         numLeadingIntZeros += 1;
+       } else {
+         numInts += 1;
+       }
+     } else if (std::isdigit(*p)) {
+       intIsZero = false;
+       isLeadingIntZero = false;
+       numInts += 1;
+     } else {
+       folly::throw_exception<std::runtime_error>("non-numeric int");
+     }
+   }
+ 
+   bool fractionalIsZero = true;
+   int numFractional = 0;
+   int numLeadingFractionalZeros = 0;
+   bool isLeadingFractionalZero = true;
+   for (char* p = fractionalBegin; p && p != fractionalEnd; p++) {
+     if (*p == '0') {
+       if (isLeadingFractionalZero) {
+         numLeadingFractionalZeros += 1;
+       } else {
+         numFractional += 1;
+       }
+     } else if (std::isdigit(*p)) {
+       fractionalIsZero = false;
+       isLeadingFractionalZero = false;
+       numFractional += 1;
+     } else {
+       folly::throw_exception<std::runtime_error>("non-numeric frac");
+     }
+   }
+ 
+   if (intIsZero && fractionalIsZero) {
+     return numLeadingIntZeros + numLeadingFractionalZeros;
+   } else if (intIsZero) {
+     return numLeadingFractionalZeros + numFractional;
+   } else if (fractionalIsZero) {
+     return numInts + numLeadingFractionalZeros + numFractional;
+   } else {
+     return numInts + numLeadingFractionalZeros + numFractional;
+   }
+ }
+ 
+ std::optional<detail::ParsedDecimal::FractionalSuffix>
+ ParsedDecimal::fractionalSuffix() const {
+   if (exponentSymbol) {
+     if (exponentEnd) {
+       return std::make_pair(exponentSymbol, exponentEnd);
+     } else if (exponentSign) {
+       return std::make_pair(exponentSymbol, exponentSign);
+     } else {
+       return std::make_pair(exponentSymbol, exponentSymbol + 1);
+     }
+   } else if (exponentSign) {
+     if (exponentEnd) {
+       return std::make_pair(exponentSign, exponentEnd);
+     } else {
+       return std::make_pair(exponentSign, exponentSign + 1);
+     }
+   } else if (exponentBegin) {
+     if (exponentEnd) {
+       return std::make_pair(exponentEnd, exponentEnd);
+     } else {
+       return std::make_pair(exponentBegin, exponentSign + 1);
+     }
+   } else {
+     return std::nullopt;
+   }
+ }
+ 
+ void ParsedDecimal::shiftFractionalSuffixPtrs(size_t amount) {
+   if (exponentSymbol) {
+     exponentSymbol += amount;
+   }
+   if (exponentSign) {
+     exponentSign += amount;
+   }
+   if (exponentBegin) {
+     exponentBegin += amount;
+   }
+   if (exponentEnd) {
+     exponentEnd += amount;
+   }
+ }
+ 
+ namespace {
+ 
+ struct Stream : std::istream {
+   struct CharBuf : std::streambuf {
+     CharBuf(char* begin, char* end) { setg(begin, begin, end); }
+ 
+     char* pos() const { return gptr(); }
+   };
+   CharBuf& buf_;
+ 
+   explicit Stream(CharBuf& buf) : std::istream(&buf), buf_(buf) {}
+ 
+   char* pos() { return buf_.pos(); }
+ 
+   void advance() { get(); }
+ };
+ 
+ } // namespace
+ 
+ ParsedDecimal::ParsedDecimal(char* begin, char* end) {
+   if (!begin || !end || begin >= end) {
+     folly::throw_exception<std::invalid_argument>("invalid args");
+   }
+ 
+   Stream::CharBuf buf(begin, end);
+   Stream stream(buf);
+   if (stream.peek() == '-') {
+     negativeSign = stream.pos();
+     stream.advance();
+   }
+ 
+   if (char c = static_cast<unsigned char>(stream.peek()); std::isdigit(c)) { // [Windows - fix conversion from 'int' to 'char']
+     integerBegin = stream.pos();
+ 
+     while (!stream.eof() && std::isdigit(stream.peek())) {
+       stream.advance();
+     }
+ 
+     integerEnd = stream.pos();
+   }
+ 
+   if (stream.eof()) {
+     if (!integerBegin) {
+       folly::throw_exception<std::invalid_argument>("no int part");
+     }
+ 
+     return;
+   }
+ 
+   if (stream.peek() == '.') {
+     decimalPoint = stream.pos();
+     stream.advance();
+   }
+ 
+   if (stream.eof()) {
+     if (!integerBegin) {
+       folly::throw_exception<std::invalid_argument>("no int part");
+     }
+     return;
+   }
+ 
+   if (char c = static_cast<unsigned char>(stream.peek()); std::isdigit(c)) { // [Windows - fix conversion from 'int' to 'char']
+     fractionalBegin = stream.pos();
+ 
+     while (!stream.eof() && std::isdigit(stream.peek())) {
+       stream.advance();
+     }
+ 
+     fractionalEnd = stream.pos();
+   }
+ 
+   if (!integerBegin && !fractionalBegin) {
+     // there was no integer or fractional part.
+     folly::throw_exception<std::invalid_argument>("no int or frac part");
+   }
+ 
+   if (stream.eof()) {
+     return;
+   }
+ 
+   if (stream.peek() == 'e') {
+     exponentSymbol = stream.pos();
+     stream.advance();
+ 
+     if (stream.eof()) {
+       return;
+     }
+ 
+     if (char c = static_cast<unsigned char>(stream.peek()); c == '-' || c == '+') { // [Windows - fix conversion from 'int' to 'char']
+       exponentSign = stream.pos();
+       stream.advance();
+     }
+ 
+     if (char c = static_cast<unsigned char>(stream.peek()); std::isdigit(c)) { // [Windows - fix conversion from 'int' to 'char']
+       exponentBegin = stream.pos();
+       while (!stream.eof() && std::isdigit(stream.peek())) {
+         stream.advance();
+       }
+ 
+       exponentEnd = stream.pos();
+     }
+   }
+ 
+   while (!stream.eof()) {
+     int c = stream.get();
+     if (c != '\0' && !std::isspace(c)) {
+       folly::throw_exception<std::invalid_argument>("unexpected chars");
+     }
+   }
+ }
+ 
+ std::pair<char*, char*> formatAsDoubleConversion(
+     bool valueIsZero,
+     DtoaMode mode,
+     unsigned int numDigits,
+     DtoaFlags flags,
+     char* resultBegin,
+     char* resultEnd,
+     char* bufferEnd) {
+   detail::ParsedDecimal parsedDecimal(resultBegin, resultEnd);
+   detail::DtoaFlagsSet flagsSet{flags};
+   if (parsedDecimal.negativeSign && flagsSet.uniqueZero() && valueIsZero) {
+     // skip the negative sign (-) if it's a zero and UNIQUE_ZERO is set
+     resultBegin += 1;
+   }
+ 
+   unsigned int numTrailingZerosToAdd = 0;
+   if (!flagsSet.noTrailingZero() && mode == DtoaMode::PRECISION) {
+     // std::to_chars outputs no trailing zeros, so if it's not set, add
+     // trailing zeros
+     unsigned int numPrecisionFigures = parsedDecimal.numPrecisionFigures();
+     if (numDigits > numPrecisionFigures) {
+       numTrailingZerosToAdd = numDigits - numPrecisionFigures;
+     }
+   }
+ 
+   bool insertDecimalPoint = false;
+   char* insertionPoint;
+   if (parsedDecimal.fractionalEnd) {
+     insertionPoint = parsedDecimal.fractionalEnd;
+   } else if (parsedDecimal.decimalPoint) {
+     insertionPoint = parsedDecimal.decimalPoint + 1;
+   } else {
+     insertionPoint = parsedDecimal.integerEnd;
+     if (flagsSet.emitTrailingDecimalPoint() || numTrailingZerosToAdd > 0) {
+       insertDecimalPoint = true;
+     }
+ 
+     if (flagsSet.emitTrailingZeroAfterPoint()) {
+       numTrailingZerosToAdd += 1;
+     }
+   }
+ 
+   unsigned int numCharsToInsert =
+       numTrailingZerosToAdd + (insertDecimalPoint ? 1 : 0);
+ 
+   if (numCharsToInsert > 0) {
+     if (resultEnd + numCharsToInsert > bufferEnd) {
+       folly::throw_exception<std::invalid_argument>("buffer too small");
+     }
+ 
+     std::optional<detail::ParsedDecimal::FractionalSuffix> fractionalsuffix =
+         parsedDecimal.fractionalSuffix();
+     if (fractionalsuffix.has_value()) {
+       auto [fractionalSuffixBegin, fractionalSuffixEnd] = *fractionalsuffix;
+       std::memmove(
+           insertionPoint + numCharsToInsert,
+           fractionalSuffixBegin,
+           fractionalSuffixEnd - fractionalSuffixBegin);
+       parsedDecimal.shiftFractionalSuffixPtrs(numCharsToInsert);
+     }
+ 
+     resultEnd += numCharsToInsert;
+   }
+ 
+   if (insertDecimalPoint) {
+     *insertionPoint++ = '.';
+   }
+ 
+   while (numTrailingZerosToAdd) {
+     *insertionPoint++ = '0';
+     numTrailingZerosToAdd -= 1;
+   }
+ 
+   if (parsedDecimal.exponentSymbol) {
+     // std::tochars outputs a lowercase e and it needs to be uppercase.
+     *parsedDecimal.exponentSymbol = 'E';
+   }
+ 
+   size_t charsToRemove = 0;
+   char* removalBegin = nullptr;
+   if (!flagsSet.emitPositiveExponentSign() && parsedDecimal.exponentSign &&
+       *parsedDecimal.exponentSign == '+') {
+     // std::to_chars outputs a + sign, remove it if the flag wasn't set.
+     // e.g., 1.23e+45 -> 1.23e45
+     removalBegin = parsedDecimal.exponentSign;
+     charsToRemove += 1;
+   }
+ 
+   if (char* p = parsedDecimal.exponentBegin; p && *p == '0') {
+     // std::to_chars outputs a leading zero, remove it to match
+     // double_conversion formating. e.g., 1.23e+04 -> 1.23e4
+     if (!removalBegin) {
+       removalBegin = p;
+     }
+ 
+     while (p != parsedDecimal.exponentEnd && *p == '0') {
+       charsToRemove += 1;
+       p += 1;
+     }
+ 
+     if (p == parsedDecimal.exponentEnd) {
+       // they all were 0 digits. keep a single 0.
+       charsToRemove -= 1;
+       p -= 1;
+       if (p == removalBegin) {
+         // there was only one 0, keep it.
+         removalBegin = nullptr;
+       }
+     }
+   }
+ 
+   if (charsToRemove && removalBegin) {
+     size_t len = resultEnd - (removalBegin + charsToRemove);
+     std::memmove(removalBegin, removalBegin + charsToRemove, len);
+     resultEnd -= charsToRemove;
+   }
+ 
+   return std::pair{resultBegin, resultEnd};
+ }
+ #endif // FOLLY_CONV_AVALIABILITY_TO_CHARS_FLOATING_POINT
+ } // namespace detail
+ 
+ ConversionError makeConversionError(ConversionCode code, StringPiece input) {
+   using namespace detail;
+   static_assert(
+       std::is_unsigned<std::underlying_type<ConversionCode>::type>::value,
+       "ConversionCode should be unsigned");
+   auto index = static_cast<std::size_t>(code);
+   FOLLY_SAFE_CHECK(index < kErrorStrings.size(), "code=", uint64_t(index));
+   const ErrorString& err = kErrorStrings[index];
+   if (code == ConversionCode::EMPTY_INPUT_STRING && input.empty()) {
+     return {err.string, code};
+   }
+   std::string tmp(err.string);
+   tmp.append(": ");
+   if (err.quote) {
+     tmp.append(1, '"');
+   }
+   if (!input.empty()) {
+     tmp.append(input.data(), input.size());
+   }
+   if (err.quote) {
+     tmp.append(1, '"');
+   }
+   return {tmp, code};
+ }
+ 
+ } // namespace folly
\ No newline at end of file

From 4742a3fdd3c18ffb89a9fe9512cbfec458f69fe0 Mon Sep 17 00:00:00 2001
From: Tatiana Kapos <tatianakapos@microsoft.com>
Date: Mon, 14 Apr 2025 17:26:49 -0700
Subject: [PATCH 03/13] Change files

---
 ...ative-windows-4080fb51-cbec-4c0c-b2e6-3a14a8be8965.json | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 change/react-native-windows-4080fb51-cbec-4c0c-b2e6-3a14a8be8965.json

diff --git a/change/react-native-windows-4080fb51-cbec-4c0c-b2e6-3a14a8be8965.json b/change/react-native-windows-4080fb51-cbec-4c0c-b2e6-3a14a8be8965.json
new file mode 100644
index 00000000000..712e44dc708
--- /dev/null
+++ b/change/react-native-windows-4080fb51-cbec-4c0c-b2e6-3a14a8be8965.json
@@ -0,0 +1,7 @@
+{
+  "type": "prerelease",
+  "comment": "merge in folly 2024.10.14.00",
+  "packageName": "react-native-windows",
+  "email": "tatianakapos@microsoft.com",
+  "dependentChangeType": "patch"
+}

From d75ac23178b67c9cb39c04a45b3c04573dd2fae9 Mon Sep 17 00:00:00 2001
From: Tatiana Kapos <tatianakapos@microsoft.com>
Date: Mon, 14 Apr 2025 18:10:32 -0700
Subject: [PATCH 04/13] fix includes

---
 .../windows/playground/packages.lock.json     | 154 ++----------------
 vnext/Folly/Folly.vcxproj                     |   7 +
 vnext/Folly/Folly.vcxproj.filters             |   9 +
 .../Base/FollyIncludes.h                      |   1 +
 vnext/Microsoft.ReactNative/ReactSupport.cpp  |  55 +++++--
 vnext/Shared/Shared.vcxitems.filters          |   4 +-
 6 files changed, 77 insertions(+), 153 deletions(-)

diff --git a/packages/playground/windows/playground/packages.lock.json b/packages/playground/windows/playground/packages.lock.json
index 6694b7d65af..ce8abc99a51 100644
--- a/packages/playground/windows/playground/packages.lock.json
+++ b/packages/playground/windows/playground/packages.lock.json
@@ -2,153 +2,29 @@
   "version": 1,
   "dependencies": {
     "native,Version=v0.0": {
-      "Microsoft.JavaScript.Hermes": {
+      "Microsoft.Windows.CppWinRT": {
         "type": "Direct",
-        "requested": "[0.1.23, )",
-        "resolved": "0.1.23",
-        "contentHash": "cA9t1GjY4Yo0JD1AfA//e1lOwk48hLANfuX6GXrikmEBNZVr2TIX5ONJt5tqCnpZyLz6xGiPDgTfFNKbSfb21g=="
+        "requested": "[2.0.210312.4, 2.0.210312.4]",
+        "resolved": "2.0.210312.4",
+        "contentHash": "uRxz7Z8Scm7A2JjaaxCzQWTMrQC9RvXYhb7RU8pSqGo/0i0aPJszUeA3N6EhcJU5+FsDr2xzk2iln0x2Lwa6AA=="
       },
       "Microsoft.UI.Xaml": {
         "type": "Direct",
-        "requested": "[2.8.0, )",
+        "requested": "[2.8.0, 2.8.0]",
         "resolved": "2.8.0",
-        "contentHash": "vxdHxTr63s5KVtNddMFpgvjBjUH50z7seq/5jLWmmSuf8poxg+sXrywkofUdE8ZstbpO9y3FL/IXXUcPYbeesA==",
-        "dependencies": {
-          "Microsoft.Web.WebView2": "1.0.1264.42"
-        }
+        "contentHash": "vxdHxTr63s5KVtNddMFpgvjBjUH50z7seq/5jLWmmSuf8poxg+sXrywkofUdE8ZstbpO9y3FL/IXXUcPYbeesA=="
       },
-      "Microsoft.Windows.CppWinRT": {
+      "Microsoft.WinUI": {
         "type": "Direct",
-        "requested": "[2.0.230706.1, )",
-        "resolved": "2.0.230706.1",
-        "contentHash": "l0D7oCw/5X+xIKHqZTi62TtV+1qeSz7KVluNFdrJ9hXsst4ghvqQ/Yhura7JqRdZWBXAuDS0G0KwALptdoxweQ=="
-      },
-      "boost": {
-        "type": "Transitive",
-        "resolved": "1.83.0",
-        "contentHash": "cy53VNMzysEMvhBixDe8ujPk67Fcj3v6FPHQnH91NYJNLHpc6jxa2xq9ruCaaJjE4M3YrGSHDi4uUSTGBWw6EQ=="
-      },
-      "Microsoft.Build.Tasks.Git": {
-        "type": "Transitive",
-        "resolved": "1.1.1",
-        "contentHash": "AT3HlgTjsqHnWpBHSNeR0KxbLZD7bztlZVj7I8vgeYG9SYqbeFGh0TM/KVtC6fg53nrWHl3VfZFvb5BiQFcY6Q=="
-      },
-      "Microsoft.SourceLink.Common": {
-        "type": "Transitive",
-        "resolved": "1.1.1",
-        "contentHash": "WMcGpWKrmJmzrNeuaEb23bEMnbtR/vLmvZtkAP5qWu7vQsY59GqfRJd65sFpBszbd2k/bQ8cs8eWawQKAabkVg=="
-      },
-      "Microsoft.SourceLink.GitHub": {
-        "type": "Transitive",
-        "resolved": "1.1.1",
-        "contentHash": "IaJGnOv/M7UQjRJks7B6p7pbPnOwisYGOIzqCz5ilGFTApZ3ktOR+6zJ12ZRPInulBmdAf1SrGdDG2MU8g6XTw==",
-        "dependencies": {
-          "Microsoft.Build.Tasks.Git": "1.1.1",
-          "Microsoft.SourceLink.Common": "1.1.1"
-        }
-      },
-      "Microsoft.Web.WebView2": {
-        "type": "Transitive",
-        "resolved": "1.0.1264.42",
-        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
-      },
-      "common": {
-        "type": "Project",
-        "dependencies": {
-          "boost": "[1.83.0, )"
-        }
-      },
-      "fmt": {
-        "type": "Project"
-      },
-      "folly": {
-        "type": "Project",
-        "dependencies": {
-          "boost": "[1.83.0, )",
-          "fmt": "[1.0.0, )"
-        }
-      },
-      "microsoft.reactnative": {
-        "type": "Project",
-        "dependencies": {
-          "Common": "[1.0.0, )",
-          "Folly": "[1.0.0, )",
-          "Microsoft.JavaScript.Hermes": "[0.1.23, )",
-          "Microsoft.SourceLink.GitHub": "[1.1.1, )",
-          "Microsoft.UI.Xaml": "[2.8.0, )",
-          "ReactCommon": "[1.0.0, )",
-          "boost": "[1.83.0, )"
-        }
+        "requested": "[3.0.0-preview4.210210.4, 3.0.0-preview4.210210.4]",
+        "resolved": "3.0.0-preview4.210210.4",
+        "contentHash": "fMo1Llbprv3+7nVyUvBxc/lQtMmwBFCGHdeH7sTPIeFKPneNOs0qW2XqnYBorGRRitbPUxxmLKgxOM8zR5dAgA=="
       },
-      "playgroundnativemodules": {
-        "type": "Project",
-        "dependencies": {
-          "Microsoft.ReactNative": "[1.0.0, )",
-          "Microsoft.UI.Xaml": "[2.8.0, )"
-        }
-      },
-      "reactcommon": {
-        "type": "Project",
-        "dependencies": {
-          "Folly": "[1.0.0, )",
-          "boost": "[1.83.0, )"
-        }
-      },
-      "reactnativepicker": {
-        "type": "Project",
-        "dependencies": {
-          "Microsoft.ReactNative": "[1.0.0, )",
-          "Microsoft.UI.Xaml": "[2.8.0, )"
-        }
-      }
-    },
-    "native,Version=v0.0/win10-arm": {
-      "Microsoft.Web.WebView2": {
-        "type": "Transitive",
-        "resolved": "1.0.1264.42",
-        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
-      }
-    },
-    "native,Version=v0.0/win10-arm-aot": {
-      "Microsoft.Web.WebView2": {
-        "type": "Transitive",
-        "resolved": "1.0.1264.42",
-        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
-      }
-    },
-    "native,Version=v0.0/win10-arm64-aot": {
-      "Microsoft.Web.WebView2": {
-        "type": "Transitive",
-        "resolved": "1.0.1264.42",
-        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
-      }
-    },
-    "native,Version=v0.0/win10-x64": {
-      "Microsoft.Web.WebView2": {
-        "type": "Transitive",
-        "resolved": "1.0.1264.42",
-        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
-      }
-    },
-    "native,Version=v0.0/win10-x64-aot": {
-      "Microsoft.Web.WebView2": {
-        "type": "Transitive",
-        "resolved": "1.0.1264.42",
-        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
-      }
-    },
-    "native,Version=v0.0/win10-x86": {
-      "Microsoft.Web.WebView2": {
-        "type": "Transitive",
-        "resolved": "1.0.1264.42",
-        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
-      }
-    },
-    "native,Version=v0.0/win10-x86-aot": {
-      "Microsoft.Web.WebView2": {
-        "type": "Transitive",
-        "resolved": "1.0.1264.42",
-        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
+      "Microsoft.JavaScript.Hermes": {
+        "type": "Direct",
+        "requested": "[0.1.15, 0.1.15]",
+        "resolved": "0.1.15",
+        "contentHash": "My/u5RvxoymtwWokoweU6iVpuP79w271UjadcmSNqnQ9ESIv00tlVP4sHnIiN3t2lJNDeciyE1EVF4swGPECKQ=="
       }
     }
   }
diff --git a/vnext/Folly/Folly.vcxproj b/vnext/Folly/Folly.vcxproj
index 2917eb7e6bc..d080d8283bc 100644
--- a/vnext/Folly/Folly.vcxproj
+++ b/vnext/Folly/Folly.vcxproj
@@ -126,6 +126,9 @@
     <ClInclude Include="$(FollyDir)\folly\dynamic-inl.h" />
     <ClInclude Include="$(FollyDir)\folly\dynamic.h" />
     <ClInclude Include="$(FollyDir)\folly\DynamicConverter.h" />
+    <ClInclude Include="$(FollyDir)\folly\json\dynamic-inl.h" />
+    <ClInclude Include="$(FollyDir)\folly\json\dynamic.h" />
+    <ClInclude Include="$(FollyDir)\folly\json\DynamicConverter.h" />
     <ClInclude Include="$(FollyDir)\folly\Exception.h" />
     <ClInclude Include="$(FollyDir)\folly\ExceptionString.h" />
     <ClInclude Include="$(FollyDir)\folly\ExceptionWrapper.h" />
@@ -220,6 +223,9 @@
     <ClInclude Include="$(FollyDir)\folly\stop_watch.h" />
     <ClInclude Include="$(FollyDir)\folly\String-inl.h" />
     <ClInclude Include="$(FollyDir)\hash\MurmurHash.h" />
+    <ClInclude Include="$(FollyDir)\hash\SpookyHashV1.h" />
+    <ClInclude Include="$(FollyDir)\hash\SpookyHashV2.h" />
+    <ClInclude Include="$(FollyDir)\functional\ApplyTuple.h" />
     <ClInclude Include="$(FollyDir)\folly\String.h" />
     <ClInclude Include="$(FollyDir)\folly\Subprocess.h" />
     <ClInclude Include="$(FollyDir)\folly\Synchronized.h" />
@@ -234,6 +240,7 @@
     <ClInclude Include="$(FollyDir)\folly\Unit.h" />
     <ClInclude Include="$(FollyDir)\folly\Uri-inl.h" />
     <ClInclude Include="$(FollyDir)\folly\Uri.h" />
+    <ClInclude Include="$(FollyDir)\folly\Utility.h" />
     <ClInclude Include="$(FollyDir)\folly\Varint.h" />
     <ClInclude Include="$(FollyDir)\..\fast_float-6.1.4\include\fast_float\fast_float.h" />
     <ClInclude Include="pch.h" />
diff --git a/vnext/Folly/Folly.vcxproj.filters b/vnext/Folly/Folly.vcxproj.filters
index a563aa172f7..f1500c42f01 100644
--- a/vnext/Folly/Folly.vcxproj.filters
+++ b/vnext/Folly/Folly.vcxproj.filters
@@ -186,10 +186,19 @@
     </ClInclude>
     <ClInclude Include="$(FollyDir)\folly\dynamic-inl.h">
       <Filter>Header Files</Filter>
+    </ClInclude>
+     <ClInclude Include="$(FollyDir)\folly\json\dynamic.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="$(FollyDir)\folly\json\dynamic-inl.h">
+      <Filter>Header Files</Filter>
     </ClInclude>
     <ClInclude Include="$(FollyDir)\folly\DynamicConverter.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="$(FollyDir)\folly\json\DynamicConverter.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
     <ClInclude Include="$(FollyDir)\folly\portability\Event.h">
       <Filter>Header Files\portability</Filter>
     </ClInclude>
diff --git a/vnext/Microsoft.ReactNative/Base/FollyIncludes.h b/vnext/Microsoft.ReactNative/Base/FollyIncludes.h
index 51d53c05e08..0080199ffd1 100644
--- a/vnext/Microsoft.ReactNative/Base/FollyIncludes.h
+++ b/vnext/Microsoft.ReactNative/Base/FollyIncludes.h
@@ -23,4 +23,5 @@
 #include <folly/Memory.h>
 #include <folly/Optional.h>
 #include <folly/dynamic.h>
+#include <folly/json/dynamic.h>
 #include <folly/json.h>
diff --git a/vnext/Microsoft.ReactNative/ReactSupport.cpp b/vnext/Microsoft.ReactNative/ReactSupport.cpp
index 7e0c7b39212..e47d87aaa12 100644
--- a/vnext/Microsoft.ReactNative/ReactSupport.cpp
+++ b/vnext/Microsoft.ReactNative/ReactSupport.cpp
@@ -82,21 +82,30 @@ folly::dynamic ConvertToDynamic(IInspectable const &object) {
     case PropertyType::BooleanArray: {
       com_array<bool> tmpArray;
       propValue.GetBooleanArray(tmpArray);
-      folly::dynamic d(tmpArray.begin(), tmpArray.end());
+      folly::dynamic d = folly::dynamic::array();
+      for (bool b : tmpArray) {
+        d.push_back(folly::dynamic(b));
+      }
       value = d;
       break;
     }
     case PropertyType::Char16Array: {
       com_array<char16_t> tmpArray;
       propValue.GetChar16Array(tmpArray);
-      folly::dynamic d(tmpArray.begin(), tmpArray.end());
+      folly::dynamic d = folly::dynamic::array();
+      for (bool b : tmpArray) {
+        d.push_back(folly::dynamic(b));
+      }
       value = d;
       break;
     }
     case PropertyType::DoubleArray: {
       com_array<double_t> tmpArray;
       propValue.GetDoubleArray(tmpArray);
-      folly::dynamic d(tmpArray.begin(), tmpArray.end());
+      folly::dynamic d = folly::dynamic::array();
+      for (bool b : tmpArray) {
+        d.push_back(folly::dynamic(b));
+      }
       value = d;
       break;
     }
@@ -113,28 +122,40 @@ folly::dynamic ConvertToDynamic(IInspectable const &object) {
     case PropertyType::Int16Array: {
       com_array<int16_t> tmpArray;
       propValue.GetInt16Array(tmpArray);
-      folly::dynamic d(tmpArray.begin(), tmpArray.end());
+      folly::dynamic d = folly::dynamic::array();
+      for (bool b : tmpArray) {
+        d.push_back(folly::dynamic(b));
+      }
       value = d;
       break;
     }
     case PropertyType::Int32Array: {
       com_array<int32_t> tmpArray;
       propValue.GetInt32Array(tmpArray);
-      folly::dynamic d(tmpArray.begin(), tmpArray.end());
+      folly::dynamic d = folly::dynamic::array();
+      for (bool b : tmpArray) {
+        d.push_back(folly::dynamic(b));
+      }
       value = d;
       break;
     }
     case PropertyType::Int64Array: {
       com_array<int64_t> tmpArray;
       propValue.GetInt64Array(tmpArray);
-      folly::dynamic d(tmpArray.begin(), tmpArray.end());
+      folly::dynamic d = folly::dynamic::array();
+      for (bool b : tmpArray) {
+        d.push_back(folly::dynamic(b));
+      }
       value = d;
       break;
     }
     case PropertyType::SingleArray: {
       com_array<float> tmpArray;
       propValue.GetSingleArray(tmpArray);
-      folly::dynamic d(tmpArray.begin(), tmpArray.end());
+      folly::dynamic d = folly::dynamic::array();
+      for (bool b : tmpArray) {
+        d.push_back(folly::dynamic(b));
+      }
       value = d;
       break;
     }
@@ -151,28 +172,40 @@ folly::dynamic ConvertToDynamic(IInspectable const &object) {
     case PropertyType::UInt8Array: {
       com_array<uint8_t> tmpArray;
       propValue.GetUInt8Array(tmpArray);
-      folly::dynamic d(tmpArray.begin(), tmpArray.end());
+      folly::dynamic d = folly::dynamic::array();
+      for (bool b : tmpArray) {
+        d.push_back(folly::dynamic(b));
+      }
       value = d;
       break;
     }
     case PropertyType::UInt16Array: {
       com_array<uint16_t> tmpArray;
       propValue.GetUInt16Array(tmpArray);
-      folly::dynamic d(tmpArray.begin(), tmpArray.end());
+      folly::dynamic d = folly::dynamic::array();
+      for (bool b : tmpArray) {
+        d.push_back(folly::dynamic(b));
+      }
       value = d;
       break;
     }
     case PropertyType::UInt32Array: {
       com_array<uint32_t> tmpArray;
       propValue.GetUInt32Array(tmpArray);
-      folly::dynamic d(tmpArray.begin(), tmpArray.end());
+      folly::dynamic d = folly::dynamic::array();
+      for (bool b : tmpArray) {
+        d.push_back(folly::dynamic(b));
+      }
       value = d;
       break;
     }
     case PropertyType::UInt64Array: {
       com_array<uint64_t> tmpArray;
       propValue.GetUInt64Array(tmpArray);
-      folly::dynamic d(tmpArray.begin(), tmpArray.end());
+      folly::dynamic d = folly::dynamic::array();
+      for (bool b : tmpArray) {
+        d.push_back(folly::dynamic(b));
+      }
       value = d;
       break;
     }
diff --git a/vnext/Shared/Shared.vcxitems.filters b/vnext/Shared/Shared.vcxitems.filters
index 986ffc77b90..268f2b929ed 100644
--- a/vnext/Shared/Shared.vcxitems.filters
+++ b/vnext/Shared/Shared.vcxitems.filters
@@ -155,9 +155,6 @@
     <ClCompile Include="$(MSBuildThisFileDirectory)..\Microsoft.ReactNative\Fabric\WindowsImageManager.cpp">
       <Filter>Source Files\Fabric</Filter>
     </ClCompile>
-    <ClInclude Include="$(MSBuildThisFileDirectory)..\Microsoft.ReactNative\Fabric\ImageRequestParams.cpp">
-      <Filter>Source Files\Fabric</Filter>
-    </ClInclude>
     <ClCompile Include="$(MSBuildThisFileDirectory)..\Microsoft.ReactNative\SchedulerSettings.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -341,6 +338,7 @@
     <ClCompile Include="$(ReactNativeDir)\ReactCommon\jsinspector-modern\tracing\PerformanceTracer.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)..\Microsoft.ReactNative\Fabric\Composition\CompositionTextProvider.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)..\Microsoft.ReactNative\Fabric\Composition\CompositionTextRangeProvider.cpp" />
+    <ClCompile Include="$(MSBuildThisFileDirectory)..\Microsoft.ReactNative\Fabric\ImageRequestParams.cpp" />
   </ItemGroup>
   <ItemGroup>
     <Filter Include="Source Files">

From 6665010c36f9f2a4313ef9557b9f8d1b2111b033 Mon Sep 17 00:00:00 2001
From: Tatiana Kapos <tatianakapos@microsoft.com>
Date: Tue, 15 Apr 2025 12:34:02 -0700
Subject: [PATCH 05/13] fix cachelocality

---
 vnext/Folly/Folly.vcxproj                     |   2 +-
 .../concurrency/CacheLocality.cpp             | 633 ++++++++++++++++++
 2 files changed, 634 insertions(+), 1 deletion(-)
 create mode 100644 vnext/Folly/TEMP_UntilFollyUpdate/concurrency/CacheLocality.cpp

diff --git a/vnext/Folly/Folly.vcxproj b/vnext/Folly/Folly.vcxproj
index d080d8283bc..3adbb0b74b9 100644
--- a/vnext/Folly/Folly.vcxproj
+++ b/vnext/Folly/Folly.vcxproj
@@ -105,7 +105,7 @@
     <ClInclude Include="$(FollyDir)\folly\Demangle.h" />
     <ClInclude Include="$(FollyDir)\folly\detail\AtomicHashUtils.h" />
     <ClInclude Include="$(FollyDir)\folly\detail\AtomicUnorderedMapUtils.h" />
-    <ClInclude Include="$(FollyDir)\folly\detail\CacheLocality.h" />
+    <ClInclude Include="$(FollyDir)\folly\concurrency\CacheLocality.h" />
     <ClInclude Include="$(FollyDir)\folly\detail\DiscriminatedPtrDetail.h" />
     <ClInclude Include="$(FollyDir)\folly\detail\FileUtilDetail.h" />
     <ClInclude Include="$(FollyDir)\folly\detail\FingerprintPolynomial.h" />
diff --git a/vnext/Folly/TEMP_UntilFollyUpdate/concurrency/CacheLocality.cpp b/vnext/Folly/TEMP_UntilFollyUpdate/concurrency/CacheLocality.cpp
new file mode 100644
index 00000000000..633230f406e
--- /dev/null
+++ b/vnext/Folly/TEMP_UntilFollyUpdate/concurrency/CacheLocality.cpp
@@ -0,0 +1,633 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * 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 <folly/concurrency/CacheLocality.h>
+
+ #ifndef _MSC_VER
+ #define _GNU_SOURCE 1 // for RTLD_NOLOAD
+ #include <dlfcn.h>
+ #endif
+ #include <fstream>
+ #include <mutex>
+ #include <numeric>
+ #include <optional>
+ 
+ #include <fmt/core.h>
+ #include <glog/logging.h>
+ #include <folly/Indestructible.h>
+ #include <folly/Memory.h>
+ #include <folly/ScopeGuard.h>
+ #include <folly/detail/StaticSingletonManager.h>
+ #include <folly/hash/Hash.h>
+ #include <folly/lang/Exception.h>
+ #include <folly/portability/Unistd.h>
+ #include <folly/system/ThreadId.h>
+ 
+ namespace folly {
+ 
+ ///////////// CacheLocality
+ 
+ /// Returns the CacheLocality information best for this machine
+ static CacheLocality getSystemLocalityInfo() {
+   if (kIsLinux) {
+     // First try to parse /proc/cpuinfo.
+     // If that fails, then try to parse /sys/devices/.
+     // The latter is slower but more accurate.
+     try {
+       return CacheLocality::readFromProcCpuinfo();
+     } catch (...) {
+       // /proc/cpuinfo might be non-standard
+       // lets try with sysfs /sys/devices/cpu
+     }
+ 
+     try {
+       return CacheLocality::readFromSysfs();
+     } catch (...) {
+       // keep trying
+     }
+   }
+ 
+   long numCpus = sysconf(_SC_NPROCESSORS_CONF);
+   if (numCpus <= 0) {
+     // This shouldn't happen, but if it does we should try to keep
+     // going.  We are probably not going to be able to parse /sys on
+     // this box either (although we will try), which means we are going
+     // to fall back to the SequentialThreadId splitter.  On my 16 core
+     // (x hyperthreading) dev box 16 stripes is enough to get pretty good
+     // contention avoidance with SequentialThreadId, and there is little
+     // improvement from going from 32 to 64.  This default gives us some
+     // wiggle room
+     numCpus = 32;
+   }
+   return CacheLocality::uniform(size_t(numCpus));
+ }
+ 
+ template <>
+ const CacheLocality& CacheLocality::system<std::atomic>() {
+   static std::atomic<const CacheLocality*> cache;
+   auto value = cache.load(std::memory_order_acquire);
+   if (value != nullptr) {
+     return *value;
+   }
+   auto next = new CacheLocality(getSystemLocalityInfo());
+   if (cache.compare_exchange_strong(value, next, std::memory_order_acq_rel)) {
+     return *next;
+   }
+   delete next;
+   return *value;
+ }
+ 
+ CacheLocality::CacheLocality(std::vector<std::vector<size_t>> equivClasses) {
+   numCpus = equivClasses.size();
+ 
+   for (size_t cpu = 0; cpu < numCpus; ++cpu) {
+     for (size_t level = 0; level < equivClasses[cpu].size(); ++level) {
+       if (equivClasses[cpu][level] == cpu) {
+         // we only want to count the equiv classes once, so we do it when we
+         // are processing their representative.
+         while (numCachesByLevel.size() <= level) {
+           numCachesByLevel.push_back(0);
+         }
+         numCachesByLevel[level]++;
+       }
+     }
+   }
+ 
+   std::vector<size_t> cpus(numCpus);
+   std::iota(cpus.begin(), cpus.end(), 0);
+ 
+   std::sort(cpus.begin(), cpus.end(), [&](size_t lhs, size_t rhs) -> bool {
+     auto& lhsEquiv = equivClasses[lhs];
+     auto& rhsEquiv = equivClasses[rhs];
+ 
+     // If different cpus have different numbers of caches group first by number
+     // of caches to guarantee strict weak ordering, even though the resulting
+     // order may be sub-optimal.
+     if (lhsEquiv.size() != rhsEquiv.size()) {
+       return lhsEquiv.size() < rhsEquiv.size();
+     }
+ 
+     // Order by equiv class of cache with highest index, direction doesn't
+     // matter.
+     for (size_t i = lhsEquiv.size(); i > 0; --i) {
+       auto idx = i - 1;
+       if (lhsEquiv[idx] != rhsEquiv[idx]) {
+         return lhsEquiv[idx] < rhsEquiv[idx];
+       }
+     }
+ 
+     // Break ties deterministically by cpu.
+     return lhs < rhs;
+   });
+ 
+   // The cpus are now sorted by locality, with neighboring entries closer
+   // to each other than entries that are far away.  For striping we want
+   // the inverse map, since we are starting with the cpu.
+   localityIndexByCpu.resize(numCpus);
+   for (size_t i = 0; i < cpus.size(); ++i) {
+     localityIndexByCpu[cpus[i]] = i;
+   }
+ 
+   equivClassesByCpu = std::move(equivClasses);
+ }
+ 
+ // Each level of cache has sharing sets, which are the set of cpus that share a
+ // common cache at that level.  These are available in a hex bitset form
+ // (/sys/devices/system/cpu/cpu0/cache/index0/shared_cpu_map, for example).
+ // They are also available in human-readable form in the shared_cpu_list file in
+ // the same directory.  The list is a comma-separated list of numbers and
+ // ranges, where the ranges are pairs of decimal numbers separated by a '-'.
+ //
+ // To sort the cpus for optimum locality we don't really need to parse the
+ // sharing sets, we just need a unique representative from the equivalence
+ // class.  The smallest value works fine, and happens to be the first decimal
+ // number in the file.  We load all of the equivalence class information from
+ // all of the cpu*/index* directories, order the cpus first by increasing
+ // last-level cache equivalence class, then by the smaller caches.  Finally, we
+ // break ties with the cpu number itself.
+ 
+ /// Returns the first decimal number in the line, or throws an exception if the
+ /// line does not start with a number terminated by ',', '-', '\n', or EOS.
+ static size_t parseLeadingNumber(const std::string& line) {
+   auto raw = line.c_str();
+   char* end;
+   unsigned long val = strtoul(raw, &end, 10);
+   if (end == raw || (*end != ',' && *end != '-' && *end != '\n' && *end != 0)) {
+     throw std::runtime_error(fmt::format("error parsing list '{}'", line));
+   }
+   return val;
+ }
+ 
+ CacheLocality CacheLocality::readFromSysfsTree(
+     const std::function<std::string(std::string const&)>& mapping) {
+   // the list of cache equivalence classes, where equivalence classes
+   // are named by the smallest cpu in the class
+   std::vector<std::vector<size_t>> equivClassesByCpu;
+ 
+   for (size_t cpu = 0;; ++cpu) {
+     std::vector<size_t> levels;
+     for (size_t index = 0;; ++index) {
+       auto dir = fmt::format(
+           "/sys/devices/system/cpu/cpu{}/cache/index{}/", cpu, index);
+       auto cacheType = mapping(dir + "type");
+       auto equivStr = mapping(dir + "shared_cpu_list");
+       if (cacheType.empty() || equivStr.empty()) {
+         // no more caches
+         break;
+       }
+       if (cacheType[0] == 'I') {
+         // cacheType in { "Data", "Instruction", "Unified" }. skip icache
+         continue;
+       }
+       auto equiv = parseLeadingNumber(equivStr);
+       levels.push_back(equiv);
+     }
+ 
+     if (levels.empty()) {
+       // no levels at all for this cpu, we must be done
+       break;
+     }
+     equivClassesByCpu.emplace_back(std::move(levels));
+   }
+ 
+   if (equivClassesByCpu.empty()) {
+     throw std::runtime_error("unable to load cache sharing info");
+   }
+ 
+   return CacheLocality{std::move(equivClassesByCpu)};
+ }
+ 
+ CacheLocality CacheLocality::readFromSysfs() {
+   return readFromSysfsTree([](std::string const& name) {
+     std::ifstream xi(name.c_str());
+     std::string rv;
+     std::getline(xi, rv);
+     return rv;
+   });
+ }
+ 
+ namespace {
+ 
+ static bool procCpuinfoLineRelevant(std::string const& line) {
+   return line.size() > 4 && (line[0] == 'p' || line[0] == 'c');
+ }
+ 
+ std::vector<std::tuple<size_t, size_t, size_t>> parseProcCpuinfoLines(
+     std::vector<std::string> const& lines) {
+   std::vector<std::tuple<size_t, size_t, size_t>> cpus;
+   size_t physicalId = 0;
+   size_t coreId = 0;
+   size_t maxCpu = 0;
+   size_t numberOfPhysicalIds = 0;
+   size_t numberOfCoreIds = 0;
+   for (auto iter = lines.rbegin(); iter != lines.rend(); ++iter) {
+     auto& line = *iter;
+     if (!procCpuinfoLineRelevant(line)) {
+       continue;
+     }
+ 
+     auto sepIndex = line.find(':');
+     if (sepIndex == std::string::npos || sepIndex + 2 > line.size()) {
+       continue;
+     }
+     auto arg = line.substr(sepIndex + 2);
+ 
+     // "physical id" is socket, which is the most important locality
+     // context.  "core id" is a real core, so two "processor" entries with
+     // the same physical id and core id are hyperthreads of each other.
+     // "processor" is the top line of each record, so when we hit it in
+     // the reverse order then we can emit a record.
+     if (line.find("physical id") == 0) {
+       physicalId = parseLeadingNumber(arg);
+       ++numberOfPhysicalIds;
+     } else if (line.find("core id") == 0) {
+       coreId = parseLeadingNumber(arg);
+       ++numberOfCoreIds;
+     } else if (line.find("processor") == 0) {
+       auto cpu = parseLeadingNumber(arg);
+       maxCpu = std::max(cpu, maxCpu);
+       cpus.emplace_back(physicalId, coreId, cpu);
+     }
+   }
+ 
+   if (cpus.empty()) {
+     throw std::runtime_error("no CPUs parsed from /proc/cpuinfo");
+   }
+   if (maxCpu != cpus.size() - 1) {
+     throw std::runtime_error(
+         "offline CPUs not supported for /proc/cpuinfo cache locality source");
+   }
+   if (numberOfPhysicalIds == 0) {
+     throw std::runtime_error("no physical ids found");
+   }
+   if (numberOfCoreIds == 0) {
+     throw std::runtime_error("no core ids found");
+   }
+ 
+   return cpus;
+ }
+ 
+ } // namespace
+ 
+ CacheLocality CacheLocality::readFromProcCpuinfoLines(
+     std::vector<std::string> const& lines) {
+   // (physicalId, coreId, cpu)
+   std::vector<std::tuple<size_t, size_t, size_t>> cpus =
+       parseProcCpuinfoLines(lines);
+   // Sort to make equivalence classes contiguous.
+   std::sort(cpus.begin(), cpus.end());
+ 
+   // We can't tell the real cache hierarchy from /proc/cpuinfo, but it works
+   // well enough to assume there are 3 levels, L1 and L2 per-core and L3 per
+   // socket.
+   std::vector<std::vector<size_t>> equivClassesByCpu(cpus.size());
+   size_t l1Equiv = 0;
+   size_t l3Equiv = 0;
+   for (size_t i = 0; i < cpus.size(); ++i) {
+     auto [physicalId, coreId, cpu] = cpus[i];
+     // The representative for each L1 and L3 equivalence class is the first cpu
+     // in the class.
+     if (i == 0 || physicalId != std::get<0>(cpus[i - 1]) ||
+         coreId != std::get<1>(cpus[i - 1])) {
+       l1Equiv = cpu;
+     }
+     if (i == 0 || physicalId != std::get<0>(cpus[i - 1])) {
+       l3Equiv = cpu;
+     }
+     equivClassesByCpu[cpu] = {l1Equiv, l1Equiv, l3Equiv};
+   }
+ 
+   return CacheLocality{std::move(equivClassesByCpu)};
+ }
+ 
+ CacheLocality CacheLocality::readFromProcCpuinfo() {
+   std::vector<std::string> lines;
+   {
+     std::ifstream xi("/proc/cpuinfo");
+     if (xi.fail()) {
+       throw std::runtime_error("unable to open /proc/cpuinfo");
+     }
+     char buf[8192];
+     while (xi.good() && lines.size() < 20000) {
+       xi.getline(buf, sizeof(buf));
+       std::string str(buf);
+       if (procCpuinfoLineRelevant(str)) {
+         lines.emplace_back(std::move(str));
+       }
+     }
+   }
+   return readFromProcCpuinfoLines(lines);
+ }
+ 
+ CacheLocality CacheLocality::uniform(size_t numCpus) {
+   // One cache shared by all cpus.
+   std::vector<std::vector<size_t>> equivClassesByCpu(numCpus, {0});
+   return CacheLocality{std::move(equivClassesByCpu)};
+ }
+ 
+ ////////////// Getcpu
+ 
+ Getcpu::Func Getcpu::resolveVdsoFunc() {
+ #if !defined(FOLLY_HAVE_LINUX_VDSO) || defined(FOLLY_SANITIZE_MEMORY)
+   return nullptr;
+ #else
+   void* h = dlopen("linux-vdso.so.1", RTLD_LAZY | RTLD_LOCAL | RTLD_NOLOAD);
+   if (h == nullptr) {
+     return nullptr;
+   }
+ 
+   auto func = Getcpu::Func(dlsym(h, "__vdso_getcpu"));
+   if (func == nullptr) {
+     // technically a null result could either be a failure or a successful
+     // lookup of a symbol with the null value, but the second can't actually
+     // happen for this symbol.  No point holding the handle forever if
+     // we don't need the code
+     dlclose(h);
+   }
+ 
+   return func;
+ #endif
+ }
+ 
+ /////////////// SequentialThreadId
+ unsigned SequentialThreadId::get() {
+   static std::atomic<unsigned> global{0};
+   static thread_local unsigned local{0};
+   return FOLLY_LIKELY(local) ? local : (local = ++global);
+ }
+ 
+ /////////////// HashingThreadId
+ unsigned HashingThreadId::get() {
+   return hash::twang_32from64(getCurrentThreadID());
+ }
+ 
+ namespace detail {
+ 
+ int AccessSpreaderBase::degenerateGetcpu(unsigned* cpu, unsigned* node, void*) {
+   if (cpu != nullptr) {
+     *cpu = 0;
+   }
+   if (node != nullptr) {
+     *node = 0;
+   }
+   return 0;
+ }
+ 
+ struct AccessSpreaderStaticInit {
+   static AccessSpreaderStaticInit instance;
+   AccessSpreaderStaticInit() { (void)AccessSpreader<>::current(~size_t(0)); }
+ };
+ AccessSpreaderStaticInit AccessSpreaderStaticInit::instance;
+ 
+ bool AccessSpreaderBase::initialize(
+     GlobalState& state,
+     Getcpu::Func (&pickGetcpuFunc)(),
+     const CacheLocality& (&system)()) {
+   (void)AccessSpreaderStaticInit::instance; // ODR-use it so it is not dropped
+   constexpr auto relaxed = std::memory_order_relaxed;
+   auto& cacheLocality = system();
+   auto n = cacheLocality.numCpus;
+   for (size_t width = 0; width <= kMaxCpus; ++width) {
+     auto& row = state.table[width];
+     auto numStripes = std::max(size_t{1}, width);
+     for (size_t cpu = 0; cpu < kMaxCpus && cpu < n; ++cpu) {
+       auto index = cacheLocality.localityIndexByCpu[cpu];
+       assert(index < n);
+       // as index goes from 0..n, post-transform value goes from
+       // 0..numStripes
+       make_atomic_ref(row[cpu]).store(
+           static_cast<CompactStripe>((index * numStripes) / n), relaxed);
+       assert(make_atomic_ref(row[cpu]).load(relaxed) < numStripes);
+     }
+     size_t filled = n;
+     while (filled < kMaxCpus) {
+       size_t len = std::min(filled, kMaxCpus - filled);
+       for (size_t i = 0; i < len; ++i) {
+         make_atomic_ref(row[filled + i])
+             .store(make_atomic_ref(row[i]).load(relaxed), relaxed);
+       }
+       filled += len;
+     }
+     for (size_t cpu = n; cpu < kMaxCpus; ++cpu) {
+       assert(
+           make_atomic_ref(row[cpu]).load(relaxed) ==
+           make_atomic_ref(row[cpu - n]).load(relaxed));
+     }
+   }
+   state.getcpu.exchange(pickGetcpuFunc(), std::memory_order_acq_rel);
+   return true;
+ }
+ 
+ } // namespace detail
+ 
+ namespace {
+ 
+ /**
+  * A simple freelist allocator.  Allocates things of size sz, from slabs of size
+  * kAllocSize.  Takes a lock on each allocation/deallocation.
+  */
+ class SimpleAllocator {
+  public:
+   // To support array aggregate initialization without an implicit constructor.
+   struct Ctor {};
+ 
+   SimpleAllocator(Ctor, size_t sz) : sz_(sz) {}
+   ~SimpleAllocator() {
+     std::lock_guard<std::mutex> g(m_);
+     for (auto& block : blocks_) {
+       folly::aligned_free(block);
+     }
+   }
+ 
+   void* allocate() {
+     std::lock_guard<std::mutex> g(m_);
+     // Freelist allocation.
+     if (freelist_) {
+       auto mem = freelist_;
+       freelist_ = *static_cast<void**>(freelist_);
+       return mem;
+     }
+ 
+     if (mem_) {
+       // Bump-ptr allocation.
+       if (intptr_t(mem_) % kMallocAlign == 0) {
+         // Avoid allocating pointers that may look like malloc
+         // pointers.
+         mem_ += std::min(sz_, max_align_v);
+       }
+       if (mem_ + sz_ <= end_) {
+         auto mem = mem_;
+         mem_ += sz_;
+ 
+         assert(intptr_t(mem) % kMallocAlign != 0);
+         return mem;
+       }
+     }
+ 
+     return allocateHard();
+   }
+ 
+   static void deallocate(void* ptr) {
+     assert(intptr_t(ptr) % kMallocAlign != 0);
+     // Find the allocator instance.
+     auto addr =
+         reinterpret_cast<void*>(intptr_t(ptr) & ~intptr_t(kAllocSize - 1));
+     auto allocator = *static_cast<SimpleAllocator**>(addr);
+ 
+     std::lock_guard<std::mutex> g(allocator->m_);
+     *static_cast<void**>(ptr) = allocator->freelist_;
+     if constexpr (kIsSanitizeAddress) {
+       // If running under ASAN, scrub the memory on deallocation, so we don't
+       // leave pointers that could hide leaks at shutdown, since the backing
+       // slabs may not be deallocated if the instance is a leaky singleton.
+       auto* base = static_cast<char*>(ptr);
+       std::fill(
+           base + sizeof(void*), base + allocator->sz_, static_cast<char>(0));
+     }
+     allocator->freelist_ = ptr;
+   }
+ 
+   constexpr static size_t kMallocAlign = 128;
+   static_assert(
+       kMallocAlign % hardware_destructive_interference_size == 0,
+       "Large allocations should be cacheline-aligned");
+ 
+  private:
+   constexpr static size_t kAllocSize = 4096;
+ 
+   void* allocateHard() {
+     // Allocate a new slab.
+     mem_ = static_cast<uint8_t*>(folly::aligned_malloc(kAllocSize, kAllocSize));
+     if (!mem_) {
+       throw_exception<std::bad_alloc>();
+     }
+     end_ = mem_ + kAllocSize;
+     blocks_.push_back(mem_);
+ 
+     // Install a pointer to ourselves as the allocator.
+     *reinterpret_cast<SimpleAllocator**>(mem_) = this;
+     static_assert(
+         max_align_v >= sizeof(SimpleAllocator*), "alignment too small");
+     mem_ += std::min(sz_, max_align_v);
+ 
+     // New allocation.
+     auto mem = mem_;
+     mem_ += sz_;
+     assert(intptr_t(mem) % kMallocAlign != 0);
+     return mem;
+   }
+ 
+   std::mutex m_;
+   uint8_t* mem_{nullptr};
+   uint8_t* end_{nullptr};
+   void* freelist_{nullptr};
+   size_t sz_;
+   std::vector<void*> blocks_;
+ };
+ 
+ class Allocator {
+  public:
+   void* allocate(size_t size) {
+     if (auto cl = sizeClass(size)) {
+       return allocators_[*cl].allocate();
+     }
+ 
+     // Fall back to malloc, returning a kMallocAlign-aligned allocation so it
+     // can be distinguished from SimpleAllocator allocations.
+     size = size + (SimpleAllocator::kMallocAlign - 1);
+     size &= ~size_t(SimpleAllocator::kMallocAlign - 1);
+     void* mem = aligned_malloc(size, SimpleAllocator::kMallocAlign);
+     if (!mem) {
+       throw_exception<std::bad_alloc>();
+     }
+     return mem;
+   }
+ 
+   static void deallocate(void* ptr) {
+     if (!ptr) {
+       return;
+     }
+ 
+     // See if it came from SimpleAllocator or malloc.
+     if (intptr_t(ptr) % SimpleAllocator::kMallocAlign != 0) {
+       SimpleAllocator::deallocate(ptr);
+     } else {
+       aligned_free(ptr);
+     }
+   }
+ 
+  private:
+   std::optional<uint8_t> sizeClass(size_t size) {
+     if (size <= 8) {
+       return static_cast<uint8_t>(0); // [Windows]
+     } else if (size <= 16) {
+       return static_cast<uint8_t>(1); // [Windows]
+     } else if (size <= 32) {
+       return static_cast<uint8_t>(2); // [Windows]
+     } else if (size <= 64) {
+       return static_cast<uint8_t>(3); // [Windows]
+     } else {
+       return std::nullopt;
+     }
+   }
+ 
+   std::array<SimpleAllocator, 4> allocators_{
+       {{SimpleAllocator::Ctor{}, 8},
+        {SimpleAllocator::Ctor{}, 16},
+        {SimpleAllocator::Ctor{}, 32},
+        {SimpleAllocator::Ctor{}, 64}}};
+ };
+ 
+ } // namespace
+ 
+ void* coreMalloc(size_t size, size_t numStripes, size_t stripe) {
+   static folly::Indestructible<Allocator>
+       allocators[AccessSpreader<>::maxLocalityIndexValue()];
+   auto index = AccessSpreader<>::localityIndexForStripe(numStripes, stripe);
+   return allocators[index]->allocate(size);
+ }
+ 
+ void coreFree(void* ptr) {
+   Allocator::deallocate(ptr);
+ }
+ 
+ namespace {
+ thread_local CoreAllocatorGuard* gCoreAllocatorGuard = nullptr;
+ }
+ 
+ CoreAllocatorGuard::CoreAllocatorGuard(size_t numStripes, size_t stripe)
+     : numStripes_(numStripes), stripe_(stripe) {
+   CHECK(gCoreAllocatorGuard == nullptr)
+       << "CoreAllocator::Guard cannot be used recursively";
+   gCoreAllocatorGuard = this;
+ }
+ 
+ CoreAllocatorGuard::~CoreAllocatorGuard() {
+   gCoreAllocatorGuard = nullptr;
+ }
+ 
+ namespace detail {
+ 
+ void* coreMallocFromGuard(size_t size) {
+   CHECK(gCoreAllocatorGuard != nullptr)
+       << "CoreAllocator::allocator called without an active Guard";
+   return coreMalloc(
+       size, gCoreAllocatorGuard->numStripes_, gCoreAllocatorGuard->stripe_);
+ }
+ 
+ } // namespace detail
+ 
+ } // namespace folly
\ No newline at end of file

From c8079ad6673a78d56658c7e183d973c6cde6ac3c Mon Sep 17 00:00:00 2001
From: Tatiana Kapos <tatianakapos@microsoft.com>
Date: Tue, 15 Apr 2025 16:29:54 -0700
Subject: [PATCH 06/13] fix desktop.dll

---
 vnext/Desktop.DLL/react-native-win32.x64.def | 6 ------
 vnext/Desktop.DLL/react-native-win32.x86.def | 6 ------
 2 files changed, 12 deletions(-)

diff --git a/vnext/Desktop.DLL/react-native-win32.x64.def b/vnext/Desktop.DLL/react-native-win32.x64.def
index 9c2f22b9a29..95ce42f28f0 100644
--- a/vnext/Desktop.DLL/react-native-win32.x64.def
+++ b/vnext/Desktop.DLL/react-native-win32.x64.def
@@ -5,12 +5,9 @@
 ; **************************************************************************************************
 
 EXPORTS
-??0dynamic@folly@@QEAA@$$QEAU01@@Z
 ??8folly@@YA_NAEBUdynamic@0@0@Z
 ??4dynamic@folly@@QEAAAEAU01@$$QEAU01@@Z
-?hash@dynamic@folly@@QEBA_KXZ
 ??Mfolly@@YA_NAEBUdynamic@0@0@Z
-?destroy@dynamic@folly@@AEAAXXZ
 ??0TypeError@folly@@QEAA@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@W4Type@dynamic@1@@Z
 ??0dynamic@folly@@QEAA@AEBU01@@Z
 ??$safe_assert_terminate@$0A@@detail@folly@@YAXPEBUsafe_assert_arg@01@ZZ
@@ -29,7 +26,6 @@ EXPORTS
 ?Make@IWebSocketResource@Networking@React@Microsoft@@SA?AV?$shared_ptr@UIWebSocketResource@Networking@React@Microsoft@@@std@@XZ
 ?Make@JSBigAbiString@react@facebook@@SA?AV?$unique_ptr@$$CBUJSBigAbiString@react@facebook@@U?$default_delete@$$CBUJSBigAbiString@react@facebook@@@std@@@std@@$$QEAV?$unique_ptr@U?$IAbiArray@D@AbiSafe@@UAbiObjectDeleter@2@@5@@Z
 ?at@dynamic@folly@@QEGBAAEBU12@V?$Range@PEBD@2@@Z
-?atImpl@dynamic@folly@@AEGBAAEBU12@AEBU12@@Z
 ?getRuntimeExecutor@Instance@react@facebook@@QEAA?AV?$function@$$A6AX$$QEAV?$function@$$A6AXAEAVRuntime@jsi@facebook@@@Z@std@@@Z@std@@XZ
 ?callJSFunction@Instance@react@facebook@@QEAAX$$QEAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@0$$QEAUdynamic@folly@@@Z
 ?createI18nModule@windows@react@@YA?AV?$unique_ptr@VCxxModule@module@xplat@facebook@@U?$default_delete@VCxxModule@module@xplat@facebook@@@std@@@std@@V?$unique_ptr@UII18nModule@windows@react@@U?$default_delete@UII18nModule@windows@react@@@std@@@4@@Z
@@ -40,13 +36,11 @@ EXPORTS
 ?get_ptr@dynamic@folly@@QEGBAPEBU12@V?$Range@PEBD@2@@Z
 ?get_ptrImpl@dynamic@folly@@AEGBAPEBU12@AEBU12@@Z
 ?loadScriptFromString@Instance@react@facebook@@QEAAXV?$unique_ptr@$$CBVJSBigString@react@facebook@@U?$default_delete@$$CBVJSBigString@react@facebook@@@std@@@std@@V?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@5@_N@Z
-?makeConversionError@folly@@YA?AVConversionError@1@W4ConversionCode@1@V?$Range@PEBD@1@@Z
 ?moduleNames@ModuleRegistry@react@facebook@@QEAA?AV?$vector@V?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@V?$allocator@V?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@2@@std@@XZ
 ?assertionFailure@detail@folly@@YAXPEBD00I0H@Z
 ?parseJson@folly@@YA?AUdynamic@1@V?$Range@PEBD@1@@Z
 ?setGlobalVariable@Instance@react@facebook@@QEAAXV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@V?$unique_ptr@$$CBVJSBigString@react@facebook@@U?$default_delete@$$CBVJSBigString@react@facebook@@@std@@@5@@Z
 ?size@dynamic@folly@@QEBA_KXZ
-?str_to_bool@detail@folly@@YA?AV?$Expected@_NW4ConversionCode@folly@@@2@PEAV?$Range@PEBD@2@@Z
 ?toJson@folly@@YA?AV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEBUdynamic@1@@Z
 ?typeName@dynamic@folly@@QEBAPEBDXZ
 ?Utf16ToUtf8@Unicode@Common@Microsoft@@YA?AV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEBV?$basic_string@_WU?$char_traits@_W@std@@V?$allocator@_W@2@@5@@Z
diff --git a/vnext/Desktop.DLL/react-native-win32.x86.def b/vnext/Desktop.DLL/react-native-win32.x86.def
index 4cd8ba317cc..68547f272f0 100644
--- a/vnext/Desktop.DLL/react-native-win32.x86.def
+++ b/vnext/Desktop.DLL/react-native-win32.x86.def
@@ -5,12 +5,9 @@
 ; **************************************************************************************************
 
 EXPORTS
-??0dynamic@folly@@QAE@$$QAU01@@Z
 ??8folly@@YG_NABUdynamic@0@0@Z
 ??Mfolly@@YG_NABUdynamic@0@0@Z
 ??4dynamic@folly@@QAEAAU01@$$QAU01@@Z
-?hash@dynamic@folly@@QBEIXZ
-?destroy@dynamic@folly@@AAEXXZ
 ??0TypeError@folly@@QAE@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@W4Type@dynamic@1@@Z
 ??0dynamic@folly@@QAE@ABU01@@Z
 ??4dynamic@folly@@QAEAAU01@ABU01@@Z
@@ -30,7 +27,6 @@ EXPORTS
 ?Make@JSBigAbiString@react@facebook@@SG?AV?$unique_ptr@$$CBUJSBigAbiString@react@facebook@@U?$default_delete@$$CBUJSBigAbiString@react@facebook@@@std@@@std@@$$QAV?$unique_ptr@U?$IAbiArray@D@AbiSafe@@UAbiObjectDeleter@2@@5@@Z
 ?moduleNames@ModuleRegistry@react@facebook@@QAE?AV?$vector@V?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@V?$allocator@V?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@2@@std@@XZ
 ?at@dynamic@folly@@QGBEABU12@V?$Range@PBD@2@@Z
-?atImpl@dynamic@folly@@AGBEABU12@ABU12@@Z
 ?getRuntimeExecutor@Instance@react@facebook@@QAE?AV?$function@$$A6GX$$QAV?$function@$$A6GXAAVRuntime@jsi@facebook@@@Z@std@@@Z@std@@XZ
 ?callJSFunction@Instance@react@facebook@@QAEX$$QAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@0$$QAUdynamic@folly@@@Z
 ?createI18nModule@windows@react@@YG?AV?$unique_ptr@VCxxModule@module@xplat@facebook@@U?$default_delete@VCxxModule@module@xplat@facebook@@@std@@@std@@V?$unique_ptr@UII18nModule@windows@react@@U?$default_delete@UII18nModule@windows@react@@@std@@@4@@Z
@@ -40,11 +36,9 @@ EXPORTS
 ?get_ptr@dynamic@folly@@QGBEPBU12@V?$Range@PBD@2@@Z
 ?get_ptrImpl@dynamic@folly@@AGBEPBU12@ABU12@@Z
 ?loadScriptFromString@Instance@react@facebook@@QAEXV?$unique_ptr@$$CBVJSBigString@react@facebook@@U?$default_delete@$$CBVJSBigString@react@facebook@@@std@@@std@@V?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@5@_N@Z
-?makeConversionError@folly@@YG?AVConversionError@1@W4ConversionCode@1@V?$Range@PBD@1@@Z
 ?parseJson@folly@@YG?AUdynamic@1@V?$Range@PBD@1@@Z
 ?setGlobalVariable@Instance@react@facebook@@QAEXV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@V?$unique_ptr@$$CBVJSBigString@react@facebook@@U?$default_delete@$$CBVJSBigString@react@facebook@@@std@@@5@@Z
 ?size@dynamic@folly@@QBEIXZ
-?str_to_bool@detail@folly@@YG?AV?$Expected@_NW4ConversionCode@folly@@@2@PAV?$Range@PBD@2@@Z
 ?toJson@folly@@YG?AV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@ABUdynamic@1@@Z
 ?typeName@dynamic@folly@@QBEPBDXZ
 ?Utf16ToUtf8@Unicode@Common@Microsoft@@YG?AV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@ABV?$basic_string@_WU?$char_traits@_W@std@@V?$allocator@_W@2@@5@@Z

From 1114ff4f4b109b1806fa9290a4e4117ea8a8bde3 Mon Sep 17 00:00:00 2001
From: Tatiana Kapos <tatianakapos@microsoft.com>
Date: Tue, 15 Apr 2025 17:16:12 -0700
Subject: [PATCH 07/13] clean paths and fix ARM64EC

---
 vnext/Directory.Build.props                   |   3 +-
 vnext/Folly/Folly.vcxproj                     |  18 +-
 .../TEMP_UntilFollyUpdate/chrono/Hardware.h   | 155 +++++++++++++++
 .../packages.lock.json                        | 180 ++++++++++++++----
 .../Base/FollyIncludes.h                      |   2 +-
 5 files changed, 308 insertions(+), 50 deletions(-)
 create mode 100644 vnext/Folly/TEMP_UntilFollyUpdate/chrono/Hardware.h

diff --git a/vnext/Directory.Build.props b/vnext/Directory.Build.props
index eede3d0724b..f53408e9437 100644
--- a/vnext/Directory.Build.props
+++ b/vnext/Directory.Build.props
@@ -19,8 +19,9 @@
     -->
     <EnableSourceLink Condition="'$(EnableSourceLink)' == '' AND '$(BuildingInRnwRepo)' == 'true'">true</EnableSourceLink>
     <EnableSourceLink Condition="'$(EnableSourceLink)' == ''">false</EnableSourceLink>
-    <!-- When bumping the Folly version, be sure to bump the git hash of that version's commit and build Folly.vcxproj (to update its cgmanifest.json) too. -->
+    <!-- When bumping the Folly version, be sure to bump the git hash of that version's commit, find the matching fastfloat dependency and build Folly.vcxproj (to update its cgmanifest.json) too. -->
     <FollyVersion>2024.10.14.00</FollyVersion>
+    <FastFloatVersion>6.1.4</FastFloatVersion>
     <FollyCommitHash>ad90720829db5ba0c3d0e44994856dcce33d7940</FollyCommitHash>
     <!-- When bumping the fmt version, be sure to bump the git hash of that version's commit and build fmt.vcxproj (to update its cgmanifest.json) too. -->
     <FmtVersion>10.1.0</FmtVersion>
diff --git a/vnext/Folly/Folly.vcxproj b/vnext/Folly/Folly.vcxproj
index 3adbb0b74b9..cf8b62c28ac 100644
--- a/vnext/Folly/Folly.vcxproj
+++ b/vnext/Folly/Folly.vcxproj
@@ -290,6 +290,10 @@
     <FollyZipFile>$(FollyZipDir)\folly-$(FollyVersion).zip</FollyZipFile>
     <CGManifestFile>$(MSBuildThisFileDirectory)cgmanifest.json</CGManifestFile>
   </PropertyGroup>
+  <PropertyGroup>
+    <FastFloatZipDir>$(FollyDir)..\.fastfloatzip</FastFloatZipDir>
+    <FastFloatZipFile>$(FollyDir)..\.fastfloatzip\fastfloat.zip</FastFloatZipFile>
+  </PropertyGroup>
   <Target Name="DownloadFolly" BeforeTargets="PrepareForBuild" Inputs="$(FollyZipFile)" Outputs="$(FollyZipFile)">
     <Message Importance="High" Text="Downloading folly..." />
     <DownloadFile
@@ -298,12 +302,12 @@
       DestinationFolder="$(FollyZipDir)"
       Retries="10" />
   </Target>
-  <Target Name="DownloadFastFloat" BeforeTargets="PrepareForBuild" Inputs="$(FollyDir)..\.fastfloatzip\fastfloat.zip" Outputs="$(FollyDir)..\.fastfloatzip\fastfloat.zip">
+  <Target Name="DownloadFastFloat" BeforeTargets="PrepareForBuild" Inputs="$(FastFloatZipFile)" Outputs="$(FastFloatZipFile)">
     <Message Importance="High" Text="Downloading FastFloat (folly dependency)..." />
     <DownloadFile
-      SourceUrl="https://github.com/fastfloat/fast_float/archive/refs/tags/v6.1.4.zip"
-      DestinationFileName="$(FollyDir)..\.fastfloatzip\fastfloat.zip"
-      DestinationFolder="$(FollyDir)..\.fastfloatzip"
+      SourceUrl="https://github.com/fastfloat/fast_float/archive/refs/tags/v$(FastFloatVersion).zip"
+      DestinationFileName="$(FastFloatZipFile)"
+      DestinationFolder="$(FastFloatZipDir)"
       Retries="10" />
   </Target>
   <Target Name="UnzipFolly" BeforeTargets="PrepareForBuild" DependsOnTargets="DownloadFolly">
@@ -315,10 +319,10 @@
       OverwriteReadOnlyFiles="true" />
   </Target>
   <Target Name="UnzipFastFloat" BeforeTargets="PrepareForBuild" DependsOnTargets="DownloadFastFloat">
-    <Message Condition="!Exists('$(FollyDir)..\.fastfloatzip\dynamic.h')" Importance="High" Text="Unzipping FastFloat to $([MSBuild]::NormalizePath($(FollyDir)..))." />
+    <Message Condition="!Exists('$(FastFloatZipDir)\include\fast_float.h')" Importance="High" Text="Unzipping FastFloat to $([MSBuild]::NormalizePath($(FastFloatZipDir)..))." />
     <Unzip
-      Condition="!Exists('$(FollyDir)..\.fastfloatzip\dynamic.h')"
-      SourceFiles="$(FollyDir)..\.fastfloatzip\fastfloat.zip"
+      Condition="!Exists('$(FastFloatZipDir)\include\fast_float.h')"
+      SourceFiles="$(FastFloatZipFile)"
       DestinationFolder="$([MSBuild]::NormalizePath($(FollyDir)..))"
       OverwriteReadOnlyFiles="true" />
   </Target>
diff --git a/vnext/Folly/TEMP_UntilFollyUpdate/chrono/Hardware.h b/vnext/Folly/TEMP_UntilFollyUpdate/chrono/Hardware.h
new file mode 100644
index 00000000000..87473f1a737
--- /dev/null
+++ b/vnext/Folly/TEMP_UntilFollyUpdate/chrono/Hardware.h
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * 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.
+ */
+
+ #pragma once
+
+ #include <folly/Portability.h>
+ 
+ #include <chrono>
+ #include <cstdint>
+ 
+ //  Description of and implementation of sequences for precise measurement:
+ //    https://github.com/abseil/abseil-cpp/blob/20240116.2/absl/random/internal/nanobenchmark.cc#L164-L277
+ 
+ #if defined(_MSC_VER) && !defined(__clang__) && \
+ (defined(_M_IX86) || defined(_M_X64)) && !defined(_M_ARM64EC) // [Windows]
+extern "C" std::uint64_t __rdtsc();
+extern "C" std::uint64_t __rdtscp(unsigned int*);
+extern "C" void _ReadWriteBarrier();
+extern "C" void _mm_lfence();
+#pragma intrinsic(__rdtsc)
+#pragma intrinsic(__rdtscp)
+#pragma intrinsic(_ReadWriteBarrier)
+#pragma intrinsic(_mm_lfence)
+#endif
+ 
+ namespace folly {
+ 
+ inline std::uint64_t hardware_timestamp() {
+ #if defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64))
+   return __rdtsc();
+ #elif defined(__GNUC__) && (defined(__i386__) || FOLLY_X64)
+   return __builtin_ia32_rdtsc();
+ #elif FOLLY_AARCH64 && !FOLLY_MOBILE
+   uint64_t cval;
+   asm volatile("mrs %0, cntvct_el0" : "=r"(cval));
+   return cval;
+ #else
+   // use steady_clock::now() as an approximation for the timestamp counter on
+   // non-x86 systems
+   return std::chrono::steady_clock::now().time_since_epoch().count();
+ #endif
+ }
+ 
+ /// hardware_timestamp_measurement_start
+ /// hardware_timestamp_measurement_stop
+ ///
+ /// Suitable for beginning precise measurement of a region of code.
+ ///
+ /// Prevents the compiler from reordering instructions across the call. This is
+ /// in contrast with hardware_timestamp(), which may not prevent the compiler
+ /// from reordering instructions across the call.
+ ///
+ /// Prevents the processor from pipelining the call with loads. This is in
+ /// contrast with hardware_timestamp(), which allows the processor to pipeline
+ /// the call with surrounding loads.
+ ///
+ /// Does not prevent instruction pipelines from continuing execution across the
+ /// call. For example, does not prevent a store issued before the call from
+ /// continuing execution (becoming globally visible) across the call. This means
+ /// that this form may not be suitable for certain measurement use-cases which
+ /// would require such prevention. However, this would be suitable for typical
+ /// measurement use-cases which do not specifically need to measure background
+ /// work such as store execution.
+ std::uint64_t hardware_timestamp_measurement_start() noexcept;
+ std::uint64_t hardware_timestamp_measurement_stop() noexcept;
+ 
+ inline std::uint64_t hardware_timestamp_measurement_start() noexcept {
+ #if defined(_MSC_VER) && !defined(__clang__) && \
+     (defined(_M_IX86) || defined(_M_X64))
+   // msvc does not have embedded assembly
+   _ReadWriteBarrier();
+   _mm_lfence();
+   _ReadWriteBarrier();
+   auto const ret = __rdtsc();
+   _ReadWriteBarrier();
+   _mm_lfence();
+   _ReadWriteBarrier();
+   return ret;
+ #elif defined(__GNUC__) && FOLLY_X64
+   uint64_t ret = 0;
+ #if !defined(__clang_major__) || __clang_major__ >= 11
+   asm volatile inline(
+ #else
+   asm volatile(
+ #endif
+       "lfence\n"
+       "rdtsc\n" // loads 64-bit tsc into edx:eax
+       "shl $32, %%rdx\n" // prep rdx for combine into rax
+       "or %%rdx, %[ret]\n" // combine rdx into rax
+       "lfence\n"
+       : [ret] "=a"(ret) // bind ret to rax for output
+       : // no inputs
+       : "rdx", // rdtsc loads into edx:eax
+         "cc", // shl clobbers condition-code
+         "memory" // memory clobber asks gcc/clang not to reorder
+   );
+   return ret;
+ #else
+   // use steady_clock::now() as an approximation for the timestamp counter on
+   // non-x64 systems
+   return std::chrono::steady_clock::now().time_since_epoch().count();
+ #endif
+ }
+ 
+ inline std::uint64_t hardware_timestamp_measurement_stop() noexcept {
+ #if defined(_MSC_VER) && !defined(__clang__) && \
+     (defined(_M_IX86) || defined(_M_X64))
+   // msvc does not have embedded assembly
+   _ReadWriteBarrier();
+   unsigned int aux;
+   auto const ret = __rdtscp(&aux);
+   _ReadWriteBarrier();
+   _mm_lfence();
+   _ReadWriteBarrier();
+   return ret;
+ #elif defined(__GNUC__) && FOLLY_X64
+   uint64_t ret = 0;
+ #if !defined(__clang_major__) || __clang_major__ >= 11
+   asm volatile inline(
+ #else
+   asm volatile(
+ #endif
+       "rdtscp\n" // loads 64-bit tsc into edx:eax, clobbers ecx
+       "shl $32, %%rdx\n" // prep rdx for combine into rax
+       "or %%rdx, %[ret]\n" // combine rdx into rax
+       "lfence\n"
+       : [ret] "=a"(ret) // bind ret to rax for output
+       : // no inputs
+       : "rdx", // rdtscp loads into edx:eax
+         "rcx", // rdtscp clobbers rcx
+         "cc", // shl clobbers condition-code
+         "memory" // memory clobber asks gcc/clang not to reorder
+   );
+   return ret;
+ #else
+   // use steady_clock::now() as an approximation for the timestamp counter on
+   // non-x64 systems
+   return std::chrono::steady_clock::now().time_since_epoch().count();
+ #endif
+ }
+ 
+ } // namespace folly
\ No newline at end of file
diff --git a/vnext/Microsoft.ReactNative.CsWinRT/packages.lock.json b/vnext/Microsoft.ReactNative.CsWinRT/packages.lock.json
index 2b43c083b7f..1a826453e68 100644
--- a/vnext/Microsoft.ReactNative.CsWinRT/packages.lock.json
+++ b/vnext/Microsoft.ReactNative.CsWinRT/packages.lock.json
@@ -18,35 +18,6 @@
           "Microsoft.Windows.SDK.BuildTools": "10.0.22621.756"
         }
       },
-      "boost": {
-        "type": "Transitive",
-        "resolved": "1.83.0",
-        "contentHash": "cy53VNMzysEMvhBixDe8ujPk67Fcj3v6FPHQnH91NYJNLHpc6jxa2xq9ruCaaJjE4M3YrGSHDi4uUSTGBWw6EQ=="
-      },
-      "Microsoft.Build.Tasks.Git": {
-        "type": "Transitive",
-        "resolved": "1.1.1",
-        "contentHash": "AT3HlgTjsqHnWpBHSNeR0KxbLZD7bztlZVj7I8vgeYG9SYqbeFGh0TM/KVtC6fg53nrWHl3VfZFvb5BiQFcY6Q=="
-      },
-      "Microsoft.JavaScript.Hermes": {
-        "type": "Transitive",
-        "resolved": "0.1.23",
-        "contentHash": "cA9t1GjY4Yo0JD1AfA//e1lOwk48hLANfuX6GXrikmEBNZVr2TIX5ONJt5tqCnpZyLz6xGiPDgTfFNKbSfb21g=="
-      },
-      "Microsoft.SourceLink.Common": {
-        "type": "Transitive",
-        "resolved": "1.1.1",
-        "contentHash": "WMcGpWKrmJmzrNeuaEb23bEMnbtR/vLmvZtkAP5qWu7vQsY59GqfRJd65sFpBszbd2k/bQ8cs8eWawQKAabkVg=="
-      },
-      "Microsoft.SourceLink.GitHub": {
-        "type": "Transitive",
-        "resolved": "1.1.1",
-        "contentHash": "IaJGnOv/M7UQjRJks7B6p7pbPnOwisYGOIzqCz5ilGFTApZ3ktOR+6zJ12ZRPInulBmdAf1SrGdDG2MU8g6XTw==",
-        "dependencies": {
-          "Microsoft.Build.Tasks.Git": "1.1.1",
-          "Microsoft.SourceLink.Common": "1.1.1"
-        }
-      },
       "Microsoft.Web.WebView2": {
         "type": "Transitive",
         "resolved": "1.0.2651.64",
@@ -58,10 +29,7 @@
         "contentHash": "7ZL2sFSioYm1Ry067Kw1hg0SCcW5kuVezC2SwjGbcPE61Nn+gTbH86T73G3LcEOVj0S3IZzNuE/29gZvOLS7VA=="
       },
       "common": {
-        "type": "Project",
-        "dependencies": {
-          "boost": "[1.83.0, )"
-        }
+        "type": "Project"
       },
       "fmt": {
         "type": "Project"
@@ -69,7 +37,6 @@
       "folly": {
         "type": "Project",
         "dependencies": {
-          "boost": "[1.83.0, )",
           "fmt": "[1.0.0, )"
         }
       },
@@ -78,20 +45,151 @@
         "dependencies": {
           "Common": "[1.0.0, )",
           "Folly": "[1.0.0, )",
-          "Microsoft.JavaScript.Hermes": "[0.1.23, )",
-          "Microsoft.SourceLink.GitHub": "[1.1.1, )",
-          "Microsoft.WindowsAppSDK": "[1.6.240923002, )",
-          "ReactCommon": "[1.0.0, )",
-          "boost": "[1.83.0, )"
+          "ReactCommon": "[1.0.0, )"
         }
       },
       "reactcommon": {
         "type": "Project",
         "dependencies": {
-          "Folly": "[1.0.0, )",
-          "boost": "[1.83.0, )"
+          "Folly": "[1.0.0, )"
         }
       }
+    },
+    "net6.0-windows10.0.22621/win10-arm": {
+      "Microsoft.WindowsAppSDK": {
+        "type": "Direct",
+        "requested": "[1.6.240923002, )",
+        "resolved": "1.6.240923002",
+        "contentHash": "7PfOz2scXU+AAM/GYge+f6s7k3DVI+R1P8MNPZQr56GOPCGw+csvcg3S5KZg47z/o04kNvWH3GKtWT1ML9tpZw==",
+        "dependencies": {
+          "Microsoft.Web.WebView2": "1.0.2651.64",
+          "Microsoft.Windows.SDK.BuildTools": "10.0.22621.756"
+        }
+      },
+      "Microsoft.Web.WebView2": {
+        "type": "Transitive",
+        "resolved": "1.0.2651.64",
+        "contentHash": "f5sc/vcAoTCTEW7Nqzp4galAuTRguZViw8ksn+Nx2uskEBPm0/ubzy6gVjvXS/P96jLS89C8T9I0hPc417xpNg=="
+      }
+    },
+    "net6.0-windows10.0.22621/win10-arm-aot": {
+      "Microsoft.WindowsAppSDK": {
+        "type": "Direct",
+        "requested": "[1.6.240923002, )",
+        "resolved": "1.6.240923002",
+        "contentHash": "7PfOz2scXU+AAM/GYge+f6s7k3DVI+R1P8MNPZQr56GOPCGw+csvcg3S5KZg47z/o04kNvWH3GKtWT1ML9tpZw==",
+        "dependencies": {
+          "Microsoft.Web.WebView2": "1.0.2651.64",
+          "Microsoft.Windows.SDK.BuildTools": "10.0.22621.756"
+        }
+      },
+      "Microsoft.Web.WebView2": {
+        "type": "Transitive",
+        "resolved": "1.0.2651.64",
+        "contentHash": "f5sc/vcAoTCTEW7Nqzp4galAuTRguZViw8ksn+Nx2uskEBPm0/ubzy6gVjvXS/P96jLS89C8T9I0hPc417xpNg=="
+      }
+    },
+    "net6.0-windows10.0.22621/win10-arm64": {
+      "Microsoft.WindowsAppSDK": {
+        "type": "Direct",
+        "requested": "[1.6.240923002, )",
+        "resolved": "1.6.240923002",
+        "contentHash": "7PfOz2scXU+AAM/GYge+f6s7k3DVI+R1P8MNPZQr56GOPCGw+csvcg3S5KZg47z/o04kNvWH3GKtWT1ML9tpZw==",
+        "dependencies": {
+          "Microsoft.Web.WebView2": "1.0.2651.64",
+          "Microsoft.Windows.SDK.BuildTools": "10.0.22621.756"
+        }
+      },
+      "Microsoft.Web.WebView2": {
+        "type": "Transitive",
+        "resolved": "1.0.2651.64",
+        "contentHash": "f5sc/vcAoTCTEW7Nqzp4galAuTRguZViw8ksn+Nx2uskEBPm0/ubzy6gVjvXS/P96jLS89C8T9I0hPc417xpNg=="
+      }
+    },
+    "net6.0-windows10.0.22621/win10-arm64-aot": {
+      "Microsoft.WindowsAppSDK": {
+        "type": "Direct",
+        "requested": "[1.6.240923002, )",
+        "resolved": "1.6.240923002",
+        "contentHash": "7PfOz2scXU+AAM/GYge+f6s7k3DVI+R1P8MNPZQr56GOPCGw+csvcg3S5KZg47z/o04kNvWH3GKtWT1ML9tpZw==",
+        "dependencies": {
+          "Microsoft.Web.WebView2": "1.0.2651.64",
+          "Microsoft.Windows.SDK.BuildTools": "10.0.22621.756"
+        }
+      },
+      "Microsoft.Web.WebView2": {
+        "type": "Transitive",
+        "resolved": "1.0.2651.64",
+        "contentHash": "f5sc/vcAoTCTEW7Nqzp4galAuTRguZViw8ksn+Nx2uskEBPm0/ubzy6gVjvXS/P96jLS89C8T9I0hPc417xpNg=="
+      }
+    },
+    "net6.0-windows10.0.22621/win10-x64": {
+      "Microsoft.WindowsAppSDK": {
+        "type": "Direct",
+        "requested": "[1.6.240923002, )",
+        "resolved": "1.6.240923002",
+        "contentHash": "7PfOz2scXU+AAM/GYge+f6s7k3DVI+R1P8MNPZQr56GOPCGw+csvcg3S5KZg47z/o04kNvWH3GKtWT1ML9tpZw==",
+        "dependencies": {
+          "Microsoft.Web.WebView2": "1.0.2651.64",
+          "Microsoft.Windows.SDK.BuildTools": "10.0.22621.756"
+        }
+      },
+      "Microsoft.Web.WebView2": {
+        "type": "Transitive",
+        "resolved": "1.0.2651.64",
+        "contentHash": "f5sc/vcAoTCTEW7Nqzp4galAuTRguZViw8ksn+Nx2uskEBPm0/ubzy6gVjvXS/P96jLS89C8T9I0hPc417xpNg=="
+      }
+    },
+    "net6.0-windows10.0.22621/win10-x64-aot": {
+      "Microsoft.WindowsAppSDK": {
+        "type": "Direct",
+        "requested": "[1.6.240923002, )",
+        "resolved": "1.6.240923002",
+        "contentHash": "7PfOz2scXU+AAM/GYge+f6s7k3DVI+R1P8MNPZQr56GOPCGw+csvcg3S5KZg47z/o04kNvWH3GKtWT1ML9tpZw==",
+        "dependencies": {
+          "Microsoft.Web.WebView2": "1.0.2651.64",
+          "Microsoft.Windows.SDK.BuildTools": "10.0.22621.756"
+        }
+      },
+      "Microsoft.Web.WebView2": {
+        "type": "Transitive",
+        "resolved": "1.0.2651.64",
+        "contentHash": "f5sc/vcAoTCTEW7Nqzp4galAuTRguZViw8ksn+Nx2uskEBPm0/ubzy6gVjvXS/P96jLS89C8T9I0hPc417xpNg=="
+      }
+    },
+    "net6.0-windows10.0.22621/win10-x86": {
+      "Microsoft.WindowsAppSDK": {
+        "type": "Direct",
+        "requested": "[1.6.240923002, )",
+        "resolved": "1.6.240923002",
+        "contentHash": "7PfOz2scXU+AAM/GYge+f6s7k3DVI+R1P8MNPZQr56GOPCGw+csvcg3S5KZg47z/o04kNvWH3GKtWT1ML9tpZw==",
+        "dependencies": {
+          "Microsoft.Web.WebView2": "1.0.2651.64",
+          "Microsoft.Windows.SDK.BuildTools": "10.0.22621.756"
+        }
+      },
+      "Microsoft.Web.WebView2": {
+        "type": "Transitive",
+        "resolved": "1.0.2651.64",
+        "contentHash": "f5sc/vcAoTCTEW7Nqzp4galAuTRguZViw8ksn+Nx2uskEBPm0/ubzy6gVjvXS/P96jLS89C8T9I0hPc417xpNg=="
+      }
+    },
+    "net6.0-windows10.0.22621/win10-x86-aot": {
+      "Microsoft.WindowsAppSDK": {
+        "type": "Direct",
+        "requested": "[1.6.240923002, )",
+        "resolved": "1.6.240923002",
+        "contentHash": "7PfOz2scXU+AAM/GYge+f6s7k3DVI+R1P8MNPZQr56GOPCGw+csvcg3S5KZg47z/o04kNvWH3GKtWT1ML9tpZw==",
+        "dependencies": {
+          "Microsoft.Web.WebView2": "1.0.2651.64",
+          "Microsoft.Windows.SDK.BuildTools": "10.0.22621.756"
+        }
+      },
+      "Microsoft.Web.WebView2": {
+        "type": "Transitive",
+        "resolved": "1.0.2651.64",
+        "contentHash": "f5sc/vcAoTCTEW7Nqzp4galAuTRguZViw8ksn+Nx2uskEBPm0/ubzy6gVjvXS/P96jLS89C8T9I0hPc417xpNg=="
+      }
     }
   }
 }
\ No newline at end of file
diff --git a/vnext/Microsoft.ReactNative/Base/FollyIncludes.h b/vnext/Microsoft.ReactNative/Base/FollyIncludes.h
index 0080199ffd1..38daf68f03a 100644
--- a/vnext/Microsoft.ReactNative/Base/FollyIncludes.h
+++ b/vnext/Microsoft.ReactNative/Base/FollyIncludes.h
@@ -23,5 +23,5 @@
 #include <folly/Memory.h>
 #include <folly/Optional.h>
 #include <folly/dynamic.h>
-#include <folly/json/dynamic.h>
 #include <folly/json.h>
+#include <folly/json/dynamic.h>

From a06c72344ca69214414b3f7b7cba16c51cc98d68 Mon Sep 17 00:00:00 2001
From: Tatiana Kapos <tatianakapos@microsoft.com>
Date: Wed, 16 Apr 2025 14:53:51 -0700
Subject: [PATCH 08/13] add FastFloatCommitHash to folly CGManifest

---
 vnext/Directory.Build.props |  1 +
 vnext/Folly/Folly.vcxproj   | 10 ++++++++++
 2 files changed, 11 insertions(+)

diff --git a/vnext/Directory.Build.props b/vnext/Directory.Build.props
index f53408e9437..03dece2f83e 100644
--- a/vnext/Directory.Build.props
+++ b/vnext/Directory.Build.props
@@ -23,6 +23,7 @@
     <FollyVersion>2024.10.14.00</FollyVersion>
     <FastFloatVersion>6.1.4</FastFloatVersion>
     <FollyCommitHash>ad90720829db5ba0c3d0e44994856dcce33d7940</FollyCommitHash>
+    <FastFloatCommitHash>ad90720829db5ba0c3d0e44994856dcce33d7940</FastFloatCommitHash>
     <!-- When bumping the fmt version, be sure to bump the git hash of that version's commit and build fmt.vcxproj (to update its cgmanifest.json) too. -->
     <FmtVersion>10.1.0</FmtVersion>
     <FmtCommitHash>ca2e3685b160617d3d95fcd9e789c4e06ca88</FmtCommitHash>
diff --git a/vnext/Folly/Folly.vcxproj b/vnext/Folly/Folly.vcxproj
index cf8b62c28ac..1475f4c1978 100644
--- a/vnext/Folly/Folly.vcxproj
+++ b/vnext/Folly/Folly.vcxproj
@@ -341,6 +341,16 @@
             },
             "DevelopmentDependency": false
         }
+        {
+            "Component": {
+                "Type": "git",
+                "Git": {
+                  "RepositoryUrl": "https://github.com/fastfloat/fast_float",
+                  "CommitHash": "$(FastFloatCommitHash)"
+                }
+            },
+            "DevelopmentDependency": false
+        }
     ]
 }</CGManifestText>
     </PropertyGroup>

From 8f873e7f2636ec73f5b358b7ca3a184641c6025b Mon Sep 17 00:00:00 2001
From: Tatiana Kapos <tatianakapos@microsoft.com>
Date: Wed, 16 Apr 2025 14:58:22 -0700
Subject: [PATCH 09/13] fix types

---
 vnext/Microsoft.ReactNative/ReactSupport.cpp | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/vnext/Microsoft.ReactNative/ReactSupport.cpp b/vnext/Microsoft.ReactNative/ReactSupport.cpp
index e47d87aaa12..91d346e24d5 100644
--- a/vnext/Microsoft.ReactNative/ReactSupport.cpp
+++ b/vnext/Microsoft.ReactNative/ReactSupport.cpp
@@ -93,7 +93,7 @@ folly::dynamic ConvertToDynamic(IInspectable const &object) {
       com_array<char16_t> tmpArray;
       propValue.GetChar16Array(tmpArray);
       folly::dynamic d = folly::dynamic::array();
-      for (bool b : tmpArray) {
+      for (char16_t b : tmpArray) {
         d.push_back(folly::dynamic(b));
       }
       value = d;
@@ -103,7 +103,7 @@ folly::dynamic ConvertToDynamic(IInspectable const &object) {
       com_array<double_t> tmpArray;
       propValue.GetDoubleArray(tmpArray);
       folly::dynamic d = folly::dynamic::array();
-      for (bool b : tmpArray) {
+      for (double_t b : tmpArray) {
         d.push_back(folly::dynamic(b));
       }
       value = d;
@@ -123,7 +123,7 @@ folly::dynamic ConvertToDynamic(IInspectable const &object) {
       com_array<int16_t> tmpArray;
       propValue.GetInt16Array(tmpArray);
       folly::dynamic d = folly::dynamic::array();
-      for (bool b : tmpArray) {
+      for (int16_t b : tmpArray) {
         d.push_back(folly::dynamic(b));
       }
       value = d;
@@ -133,7 +133,7 @@ folly::dynamic ConvertToDynamic(IInspectable const &object) {
       com_array<int32_t> tmpArray;
       propValue.GetInt32Array(tmpArray);
       folly::dynamic d = folly::dynamic::array();
-      for (bool b : tmpArray) {
+      for (int32_t b : tmpArray) {
         d.push_back(folly::dynamic(b));
       }
       value = d;
@@ -143,7 +143,7 @@ folly::dynamic ConvertToDynamic(IInspectable const &object) {
       com_array<int64_t> tmpArray;
       propValue.GetInt64Array(tmpArray);
       folly::dynamic d = folly::dynamic::array();
-      for (bool b : tmpArray) {
+      for (int64_t b : tmpArray) {
         d.push_back(folly::dynamic(b));
       }
       value = d;
@@ -153,7 +153,7 @@ folly::dynamic ConvertToDynamic(IInspectable const &object) {
       com_array<float> tmpArray;
       propValue.GetSingleArray(tmpArray);
       folly::dynamic d = folly::dynamic::array();
-      for (bool b : tmpArray) {
+      for (float b : tmpArray) {
         d.push_back(folly::dynamic(b));
       }
       value = d;
@@ -173,7 +173,7 @@ folly::dynamic ConvertToDynamic(IInspectable const &object) {
       com_array<uint8_t> tmpArray;
       propValue.GetUInt8Array(tmpArray);
       folly::dynamic d = folly::dynamic::array();
-      for (bool b : tmpArray) {
+      for (uint8_t b : tmpArray) {
         d.push_back(folly::dynamic(b));
       }
       value = d;
@@ -183,7 +183,7 @@ folly::dynamic ConvertToDynamic(IInspectable const &object) {
       com_array<uint16_t> tmpArray;
       propValue.GetUInt16Array(tmpArray);
       folly::dynamic d = folly::dynamic::array();
-      for (bool b : tmpArray) {
+      for (uint16_t b : tmpArray) {
         d.push_back(folly::dynamic(b));
       }
       value = d;
@@ -193,7 +193,7 @@ folly::dynamic ConvertToDynamic(IInspectable const &object) {
       com_array<uint32_t> tmpArray;
       propValue.GetUInt32Array(tmpArray);
       folly::dynamic d = folly::dynamic::array();
-      for (bool b : tmpArray) {
+      for (uint32_t b : tmpArray) {
         d.push_back(folly::dynamic(b));
       }
       value = d;
@@ -203,7 +203,7 @@ folly::dynamic ConvertToDynamic(IInspectable const &object) {
       com_array<uint64_t> tmpArray;
       propValue.GetUInt64Array(tmpArray);
       folly::dynamic d = folly::dynamic::array();
-      for (bool b : tmpArray) {
+      for (uint64_t b : tmpArray) {
         d.push_back(folly::dynamic(b));
       }
       value = d;

From d53189d76ea3f642ad100931a084f70e0088e486 Mon Sep 17 00:00:00 2001
From: Tatiana Kapos <tatianakapos@microsoft.com>
Date: Mon, 21 Apr 2025 16:52:01 -0700
Subject: [PATCH 10/13] revert package.lock and fix json file path

---
 .../windows/playground/packages.lock.json     | 154 +++++++++++++--
 vnext/Folly/Folly.vcxproj                     |   6 +-
 vnext/Folly/Folly.vcxproj.filters             |   4 +-
 .../{ => json}/dynamic-inl.h                  |   0
 .../packages.lock.json                        | 180 ++++--------------
 5 files changed, 185 insertions(+), 159 deletions(-)
 rename vnext/Folly/TEMP_UntilFollyUpdate/{ => json}/dynamic-inl.h (100%)

diff --git a/packages/playground/windows/playground/packages.lock.json b/packages/playground/windows/playground/packages.lock.json
index ce8abc99a51..6694b7d65af 100644
--- a/packages/playground/windows/playground/packages.lock.json
+++ b/packages/playground/windows/playground/packages.lock.json
@@ -2,29 +2,153 @@
   "version": 1,
   "dependencies": {
     "native,Version=v0.0": {
-      "Microsoft.Windows.CppWinRT": {
+      "Microsoft.JavaScript.Hermes": {
         "type": "Direct",
-        "requested": "[2.0.210312.4, 2.0.210312.4]",
-        "resolved": "2.0.210312.4",
-        "contentHash": "uRxz7Z8Scm7A2JjaaxCzQWTMrQC9RvXYhb7RU8pSqGo/0i0aPJszUeA3N6EhcJU5+FsDr2xzk2iln0x2Lwa6AA=="
+        "requested": "[0.1.23, )",
+        "resolved": "0.1.23",
+        "contentHash": "cA9t1GjY4Yo0JD1AfA//e1lOwk48hLANfuX6GXrikmEBNZVr2TIX5ONJt5tqCnpZyLz6xGiPDgTfFNKbSfb21g=="
       },
       "Microsoft.UI.Xaml": {
         "type": "Direct",
-        "requested": "[2.8.0, 2.8.0]",
+        "requested": "[2.8.0, )",
         "resolved": "2.8.0",
-        "contentHash": "vxdHxTr63s5KVtNddMFpgvjBjUH50z7seq/5jLWmmSuf8poxg+sXrywkofUdE8ZstbpO9y3FL/IXXUcPYbeesA=="
+        "contentHash": "vxdHxTr63s5KVtNddMFpgvjBjUH50z7seq/5jLWmmSuf8poxg+sXrywkofUdE8ZstbpO9y3FL/IXXUcPYbeesA==",
+        "dependencies": {
+          "Microsoft.Web.WebView2": "1.0.1264.42"
+        }
       },
-      "Microsoft.WinUI": {
+      "Microsoft.Windows.CppWinRT": {
         "type": "Direct",
-        "requested": "[3.0.0-preview4.210210.4, 3.0.0-preview4.210210.4]",
-        "resolved": "3.0.0-preview4.210210.4",
-        "contentHash": "fMo1Llbprv3+7nVyUvBxc/lQtMmwBFCGHdeH7sTPIeFKPneNOs0qW2XqnYBorGRRitbPUxxmLKgxOM8zR5dAgA=="
+        "requested": "[2.0.230706.1, )",
+        "resolved": "2.0.230706.1",
+        "contentHash": "l0D7oCw/5X+xIKHqZTi62TtV+1qeSz7KVluNFdrJ9hXsst4ghvqQ/Yhura7JqRdZWBXAuDS0G0KwALptdoxweQ=="
       },
-      "Microsoft.JavaScript.Hermes": {
-        "type": "Direct",
-        "requested": "[0.1.15, 0.1.15]",
-        "resolved": "0.1.15",
-        "contentHash": "My/u5RvxoymtwWokoweU6iVpuP79w271UjadcmSNqnQ9ESIv00tlVP4sHnIiN3t2lJNDeciyE1EVF4swGPECKQ=="
+      "boost": {
+        "type": "Transitive",
+        "resolved": "1.83.0",
+        "contentHash": "cy53VNMzysEMvhBixDe8ujPk67Fcj3v6FPHQnH91NYJNLHpc6jxa2xq9ruCaaJjE4M3YrGSHDi4uUSTGBWw6EQ=="
+      },
+      "Microsoft.Build.Tasks.Git": {
+        "type": "Transitive",
+        "resolved": "1.1.1",
+        "contentHash": "AT3HlgTjsqHnWpBHSNeR0KxbLZD7bztlZVj7I8vgeYG9SYqbeFGh0TM/KVtC6fg53nrWHl3VfZFvb5BiQFcY6Q=="
+      },
+      "Microsoft.SourceLink.Common": {
+        "type": "Transitive",
+        "resolved": "1.1.1",
+        "contentHash": "WMcGpWKrmJmzrNeuaEb23bEMnbtR/vLmvZtkAP5qWu7vQsY59GqfRJd65sFpBszbd2k/bQ8cs8eWawQKAabkVg=="
+      },
+      "Microsoft.SourceLink.GitHub": {
+        "type": "Transitive",
+        "resolved": "1.1.1",
+        "contentHash": "IaJGnOv/M7UQjRJks7B6p7pbPnOwisYGOIzqCz5ilGFTApZ3ktOR+6zJ12ZRPInulBmdAf1SrGdDG2MU8g6XTw==",
+        "dependencies": {
+          "Microsoft.Build.Tasks.Git": "1.1.1",
+          "Microsoft.SourceLink.Common": "1.1.1"
+        }
+      },
+      "Microsoft.Web.WebView2": {
+        "type": "Transitive",
+        "resolved": "1.0.1264.42",
+        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
+      },
+      "common": {
+        "type": "Project",
+        "dependencies": {
+          "boost": "[1.83.0, )"
+        }
+      },
+      "fmt": {
+        "type": "Project"
+      },
+      "folly": {
+        "type": "Project",
+        "dependencies": {
+          "boost": "[1.83.0, )",
+          "fmt": "[1.0.0, )"
+        }
+      },
+      "microsoft.reactnative": {
+        "type": "Project",
+        "dependencies": {
+          "Common": "[1.0.0, )",
+          "Folly": "[1.0.0, )",
+          "Microsoft.JavaScript.Hermes": "[0.1.23, )",
+          "Microsoft.SourceLink.GitHub": "[1.1.1, )",
+          "Microsoft.UI.Xaml": "[2.8.0, )",
+          "ReactCommon": "[1.0.0, )",
+          "boost": "[1.83.0, )"
+        }
+      },
+      "playgroundnativemodules": {
+        "type": "Project",
+        "dependencies": {
+          "Microsoft.ReactNative": "[1.0.0, )",
+          "Microsoft.UI.Xaml": "[2.8.0, )"
+        }
+      },
+      "reactcommon": {
+        "type": "Project",
+        "dependencies": {
+          "Folly": "[1.0.0, )",
+          "boost": "[1.83.0, )"
+        }
+      },
+      "reactnativepicker": {
+        "type": "Project",
+        "dependencies": {
+          "Microsoft.ReactNative": "[1.0.0, )",
+          "Microsoft.UI.Xaml": "[2.8.0, )"
+        }
+      }
+    },
+    "native,Version=v0.0/win10-arm": {
+      "Microsoft.Web.WebView2": {
+        "type": "Transitive",
+        "resolved": "1.0.1264.42",
+        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
+      }
+    },
+    "native,Version=v0.0/win10-arm-aot": {
+      "Microsoft.Web.WebView2": {
+        "type": "Transitive",
+        "resolved": "1.0.1264.42",
+        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
+      }
+    },
+    "native,Version=v0.0/win10-arm64-aot": {
+      "Microsoft.Web.WebView2": {
+        "type": "Transitive",
+        "resolved": "1.0.1264.42",
+        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
+      }
+    },
+    "native,Version=v0.0/win10-x64": {
+      "Microsoft.Web.WebView2": {
+        "type": "Transitive",
+        "resolved": "1.0.1264.42",
+        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
+      }
+    },
+    "native,Version=v0.0/win10-x64-aot": {
+      "Microsoft.Web.WebView2": {
+        "type": "Transitive",
+        "resolved": "1.0.1264.42",
+        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
+      }
+    },
+    "native,Version=v0.0/win10-x86": {
+      "Microsoft.Web.WebView2": {
+        "type": "Transitive",
+        "resolved": "1.0.1264.42",
+        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
+      }
+    },
+    "native,Version=v0.0/win10-x86-aot": {
+      "Microsoft.Web.WebView2": {
+        "type": "Transitive",
+        "resolved": "1.0.1264.42",
+        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
       }
     }
   }
diff --git a/vnext/Folly/Folly.vcxproj b/vnext/Folly/Folly.vcxproj
index 1475f4c1978..7f48c328a43 100644
--- a/vnext/Folly/Folly.vcxproj
+++ b/vnext/Folly/Folly.vcxproj
@@ -73,7 +73,7 @@
     </ClCompile>
     <ClCompile Include="$(FollyDir)\folly\Demangle.cpp" />
     <ClCompile Include="$(FollyDir)\folly\json\dynamic.cpp" />
-    <ClCompile Include="$(FollyDir)\folly\json.cpp" />
+    <ClCompile Include="$(FollyDir)\folly\json\json.cpp" />
     <ClCompile Include="$(FollyDir)\folly\hash\SpookyHashV2.cpp" />
     <ClCompile Include="$(FollyDir)\folly\ScopeGuard.cpp" />
     <ClCompile Include="$(FollyDir)\folly\Unicode.cpp" />
@@ -153,7 +153,7 @@
     <ClInclude Include="$(FollyDir)\folly\IPAddressException.h" />
     <ClInclude Include="$(FollyDir)\folly\IPAddressV4.h" />
     <ClInclude Include="$(FollyDir)\folly\IPAddressV6.h" />
-    <ClInclude Include="$(FollyDir)\folly\json.h" />
+    <ClInclude Include="$(FollyDir)\folly\json\json.h" />
     <ClInclude Include="$(FollyDir)\folly\lang\ToAscii.h" />
     <ClInclude Include="$(FollyDir)\folly\Lazy.h" />
     <ClInclude Include="$(FollyDir)\folly\Likely.h" />
@@ -340,7 +340,7 @@
                 }
             },
             "DevelopmentDependency": false
-        }
+        },
         {
             "Component": {
                 "Type": "git",
diff --git a/vnext/Folly/Folly.vcxproj.filters b/vnext/Folly/Folly.vcxproj.filters
index f1500c42f01..67f1bd0e4a1 100644
--- a/vnext/Folly/Folly.vcxproj.filters
+++ b/vnext/Folly/Folly.vcxproj.filters
@@ -57,7 +57,7 @@
     <ClCompile Include="$(FollyDir)\folly\json\json_pointer.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="$(FollyDir)\folly\json.cpp">
+    <ClCompile Include="$(FollyDir)\folly\json\json.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
     <ClCompile Include="$(FollyDir)\folly\Format.cpp">
@@ -280,7 +280,7 @@
     <ClInclude Include="$(FollyDir)\folly\IPAddressV6.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="$(FollyDir)\folly\json.h">
+    <ClInclude Include="$(FollyDir)\folly\json\json.h">
       <Filter>Header Files</Filter>
     </ClInclude>
     <ClInclude Include="$(FollyDir)\folly\Lazy.h">
diff --git a/vnext/Folly/TEMP_UntilFollyUpdate/dynamic-inl.h b/vnext/Folly/TEMP_UntilFollyUpdate/json/dynamic-inl.h
similarity index 100%
rename from vnext/Folly/TEMP_UntilFollyUpdate/dynamic-inl.h
rename to vnext/Folly/TEMP_UntilFollyUpdate/json/dynamic-inl.h
diff --git a/vnext/Microsoft.ReactNative.CsWinRT/packages.lock.json b/vnext/Microsoft.ReactNative.CsWinRT/packages.lock.json
index 1a826453e68..2b43c083b7f 100644
--- a/vnext/Microsoft.ReactNative.CsWinRT/packages.lock.json
+++ b/vnext/Microsoft.ReactNative.CsWinRT/packages.lock.json
@@ -18,6 +18,35 @@
           "Microsoft.Windows.SDK.BuildTools": "10.0.22621.756"
         }
       },
+      "boost": {
+        "type": "Transitive",
+        "resolved": "1.83.0",
+        "contentHash": "cy53VNMzysEMvhBixDe8ujPk67Fcj3v6FPHQnH91NYJNLHpc6jxa2xq9ruCaaJjE4M3YrGSHDi4uUSTGBWw6EQ=="
+      },
+      "Microsoft.Build.Tasks.Git": {
+        "type": "Transitive",
+        "resolved": "1.1.1",
+        "contentHash": "AT3HlgTjsqHnWpBHSNeR0KxbLZD7bztlZVj7I8vgeYG9SYqbeFGh0TM/KVtC6fg53nrWHl3VfZFvb5BiQFcY6Q=="
+      },
+      "Microsoft.JavaScript.Hermes": {
+        "type": "Transitive",
+        "resolved": "0.1.23",
+        "contentHash": "cA9t1GjY4Yo0JD1AfA//e1lOwk48hLANfuX6GXrikmEBNZVr2TIX5ONJt5tqCnpZyLz6xGiPDgTfFNKbSfb21g=="
+      },
+      "Microsoft.SourceLink.Common": {
+        "type": "Transitive",
+        "resolved": "1.1.1",
+        "contentHash": "WMcGpWKrmJmzrNeuaEb23bEMnbtR/vLmvZtkAP5qWu7vQsY59GqfRJd65sFpBszbd2k/bQ8cs8eWawQKAabkVg=="
+      },
+      "Microsoft.SourceLink.GitHub": {
+        "type": "Transitive",
+        "resolved": "1.1.1",
+        "contentHash": "IaJGnOv/M7UQjRJks7B6p7pbPnOwisYGOIzqCz5ilGFTApZ3ktOR+6zJ12ZRPInulBmdAf1SrGdDG2MU8g6XTw==",
+        "dependencies": {
+          "Microsoft.Build.Tasks.Git": "1.1.1",
+          "Microsoft.SourceLink.Common": "1.1.1"
+        }
+      },
       "Microsoft.Web.WebView2": {
         "type": "Transitive",
         "resolved": "1.0.2651.64",
@@ -29,7 +58,10 @@
         "contentHash": "7ZL2sFSioYm1Ry067Kw1hg0SCcW5kuVezC2SwjGbcPE61Nn+gTbH86T73G3LcEOVj0S3IZzNuE/29gZvOLS7VA=="
       },
       "common": {
-        "type": "Project"
+        "type": "Project",
+        "dependencies": {
+          "boost": "[1.83.0, )"
+        }
       },
       "fmt": {
         "type": "Project"
@@ -37,6 +69,7 @@
       "folly": {
         "type": "Project",
         "dependencies": {
+          "boost": "[1.83.0, )",
           "fmt": "[1.0.0, )"
         }
       },
@@ -45,150 +78,19 @@
         "dependencies": {
           "Common": "[1.0.0, )",
           "Folly": "[1.0.0, )",
-          "ReactCommon": "[1.0.0, )"
+          "Microsoft.JavaScript.Hermes": "[0.1.23, )",
+          "Microsoft.SourceLink.GitHub": "[1.1.1, )",
+          "Microsoft.WindowsAppSDK": "[1.6.240923002, )",
+          "ReactCommon": "[1.0.0, )",
+          "boost": "[1.83.0, )"
         }
       },
       "reactcommon": {
         "type": "Project",
         "dependencies": {
-          "Folly": "[1.0.0, )"
-        }
-      }
-    },
-    "net6.0-windows10.0.22621/win10-arm": {
-      "Microsoft.WindowsAppSDK": {
-        "type": "Direct",
-        "requested": "[1.6.240923002, )",
-        "resolved": "1.6.240923002",
-        "contentHash": "7PfOz2scXU+AAM/GYge+f6s7k3DVI+R1P8MNPZQr56GOPCGw+csvcg3S5KZg47z/o04kNvWH3GKtWT1ML9tpZw==",
-        "dependencies": {
-          "Microsoft.Web.WebView2": "1.0.2651.64",
-          "Microsoft.Windows.SDK.BuildTools": "10.0.22621.756"
-        }
-      },
-      "Microsoft.Web.WebView2": {
-        "type": "Transitive",
-        "resolved": "1.0.2651.64",
-        "contentHash": "f5sc/vcAoTCTEW7Nqzp4galAuTRguZViw8ksn+Nx2uskEBPm0/ubzy6gVjvXS/P96jLS89C8T9I0hPc417xpNg=="
-      }
-    },
-    "net6.0-windows10.0.22621/win10-arm-aot": {
-      "Microsoft.WindowsAppSDK": {
-        "type": "Direct",
-        "requested": "[1.6.240923002, )",
-        "resolved": "1.6.240923002",
-        "contentHash": "7PfOz2scXU+AAM/GYge+f6s7k3DVI+R1P8MNPZQr56GOPCGw+csvcg3S5KZg47z/o04kNvWH3GKtWT1ML9tpZw==",
-        "dependencies": {
-          "Microsoft.Web.WebView2": "1.0.2651.64",
-          "Microsoft.Windows.SDK.BuildTools": "10.0.22621.756"
-        }
-      },
-      "Microsoft.Web.WebView2": {
-        "type": "Transitive",
-        "resolved": "1.0.2651.64",
-        "contentHash": "f5sc/vcAoTCTEW7Nqzp4galAuTRguZViw8ksn+Nx2uskEBPm0/ubzy6gVjvXS/P96jLS89C8T9I0hPc417xpNg=="
-      }
-    },
-    "net6.0-windows10.0.22621/win10-arm64": {
-      "Microsoft.WindowsAppSDK": {
-        "type": "Direct",
-        "requested": "[1.6.240923002, )",
-        "resolved": "1.6.240923002",
-        "contentHash": "7PfOz2scXU+AAM/GYge+f6s7k3DVI+R1P8MNPZQr56GOPCGw+csvcg3S5KZg47z/o04kNvWH3GKtWT1ML9tpZw==",
-        "dependencies": {
-          "Microsoft.Web.WebView2": "1.0.2651.64",
-          "Microsoft.Windows.SDK.BuildTools": "10.0.22621.756"
-        }
-      },
-      "Microsoft.Web.WebView2": {
-        "type": "Transitive",
-        "resolved": "1.0.2651.64",
-        "contentHash": "f5sc/vcAoTCTEW7Nqzp4galAuTRguZViw8ksn+Nx2uskEBPm0/ubzy6gVjvXS/P96jLS89C8T9I0hPc417xpNg=="
-      }
-    },
-    "net6.0-windows10.0.22621/win10-arm64-aot": {
-      "Microsoft.WindowsAppSDK": {
-        "type": "Direct",
-        "requested": "[1.6.240923002, )",
-        "resolved": "1.6.240923002",
-        "contentHash": "7PfOz2scXU+AAM/GYge+f6s7k3DVI+R1P8MNPZQr56GOPCGw+csvcg3S5KZg47z/o04kNvWH3GKtWT1ML9tpZw==",
-        "dependencies": {
-          "Microsoft.Web.WebView2": "1.0.2651.64",
-          "Microsoft.Windows.SDK.BuildTools": "10.0.22621.756"
-        }
-      },
-      "Microsoft.Web.WebView2": {
-        "type": "Transitive",
-        "resolved": "1.0.2651.64",
-        "contentHash": "f5sc/vcAoTCTEW7Nqzp4galAuTRguZViw8ksn+Nx2uskEBPm0/ubzy6gVjvXS/P96jLS89C8T9I0hPc417xpNg=="
-      }
-    },
-    "net6.0-windows10.0.22621/win10-x64": {
-      "Microsoft.WindowsAppSDK": {
-        "type": "Direct",
-        "requested": "[1.6.240923002, )",
-        "resolved": "1.6.240923002",
-        "contentHash": "7PfOz2scXU+AAM/GYge+f6s7k3DVI+R1P8MNPZQr56GOPCGw+csvcg3S5KZg47z/o04kNvWH3GKtWT1ML9tpZw==",
-        "dependencies": {
-          "Microsoft.Web.WebView2": "1.0.2651.64",
-          "Microsoft.Windows.SDK.BuildTools": "10.0.22621.756"
-        }
-      },
-      "Microsoft.Web.WebView2": {
-        "type": "Transitive",
-        "resolved": "1.0.2651.64",
-        "contentHash": "f5sc/vcAoTCTEW7Nqzp4galAuTRguZViw8ksn+Nx2uskEBPm0/ubzy6gVjvXS/P96jLS89C8T9I0hPc417xpNg=="
-      }
-    },
-    "net6.0-windows10.0.22621/win10-x64-aot": {
-      "Microsoft.WindowsAppSDK": {
-        "type": "Direct",
-        "requested": "[1.6.240923002, )",
-        "resolved": "1.6.240923002",
-        "contentHash": "7PfOz2scXU+AAM/GYge+f6s7k3DVI+R1P8MNPZQr56GOPCGw+csvcg3S5KZg47z/o04kNvWH3GKtWT1ML9tpZw==",
-        "dependencies": {
-          "Microsoft.Web.WebView2": "1.0.2651.64",
-          "Microsoft.Windows.SDK.BuildTools": "10.0.22621.756"
-        }
-      },
-      "Microsoft.Web.WebView2": {
-        "type": "Transitive",
-        "resolved": "1.0.2651.64",
-        "contentHash": "f5sc/vcAoTCTEW7Nqzp4galAuTRguZViw8ksn+Nx2uskEBPm0/ubzy6gVjvXS/P96jLS89C8T9I0hPc417xpNg=="
-      }
-    },
-    "net6.0-windows10.0.22621/win10-x86": {
-      "Microsoft.WindowsAppSDK": {
-        "type": "Direct",
-        "requested": "[1.6.240923002, )",
-        "resolved": "1.6.240923002",
-        "contentHash": "7PfOz2scXU+AAM/GYge+f6s7k3DVI+R1P8MNPZQr56GOPCGw+csvcg3S5KZg47z/o04kNvWH3GKtWT1ML9tpZw==",
-        "dependencies": {
-          "Microsoft.Web.WebView2": "1.0.2651.64",
-          "Microsoft.Windows.SDK.BuildTools": "10.0.22621.756"
-        }
-      },
-      "Microsoft.Web.WebView2": {
-        "type": "Transitive",
-        "resolved": "1.0.2651.64",
-        "contentHash": "f5sc/vcAoTCTEW7Nqzp4galAuTRguZViw8ksn+Nx2uskEBPm0/ubzy6gVjvXS/P96jLS89C8T9I0hPc417xpNg=="
-      }
-    },
-    "net6.0-windows10.0.22621/win10-x86-aot": {
-      "Microsoft.WindowsAppSDK": {
-        "type": "Direct",
-        "requested": "[1.6.240923002, )",
-        "resolved": "1.6.240923002",
-        "contentHash": "7PfOz2scXU+AAM/GYge+f6s7k3DVI+R1P8MNPZQr56GOPCGw+csvcg3S5KZg47z/o04kNvWH3GKtWT1ML9tpZw==",
-        "dependencies": {
-          "Microsoft.Web.WebView2": "1.0.2651.64",
-          "Microsoft.Windows.SDK.BuildTools": "10.0.22621.756"
+          "Folly": "[1.0.0, )",
+          "boost": "[1.83.0, )"
         }
-      },
-      "Microsoft.Web.WebView2": {
-        "type": "Transitive",
-        "resolved": "1.0.2651.64",
-        "contentHash": "f5sc/vcAoTCTEW7Nqzp4galAuTRguZViw8ksn+Nx2uskEBPm0/ubzy6gVjvXS/P96jLS89C8T9I0hPc417xpNg=="
       }
     }
   }

From 285eedbd98c0dc77cee50e0f4892ab06d3da8948 Mon Sep 17 00:00:00 2001
From: Tatiana Kapos <tatianakapos@microsoft.com>
Date: Mon, 21 Apr 2025 17:07:12 -0700
Subject: [PATCH 11/13] manually fix spacing

---
 .../TEMP_UntilFollyUpdate/ConstexprMath.h     | 1952 +++++------
 vnext/Folly/TEMP_UntilFollyUpdate/Conv.cpp    | 2406 +++++++-------
 .../TEMP_UntilFollyUpdate/chrono/Hardware.h   |  286 +-
 .../concurrency/CacheLocality.cpp             | 1264 ++++----
 vnext/Folly/TEMP_UntilFollyUpdate/json.cpp    | 1117 -------
 .../TEMP_UntilFollyUpdate/json/dynamic-inl.h  | 2850 ++++++++---------
 .../Folly/TEMP_UntilFollyUpdate/json/json.cpp | 1117 +++++++
 .../TEMP_UntilFollyUpdate/lang/SafeAssert.h   |  356 +-
 .../TEMP_UntilFollyUpdate/lang/ToAscii.h      |   66 +-
 9 files changed, 5707 insertions(+), 5707 deletions(-)
 delete mode 100644 vnext/Folly/TEMP_UntilFollyUpdate/json.cpp
 create mode 100644 vnext/Folly/TEMP_UntilFollyUpdate/json/json.cpp

diff --git a/vnext/Folly/TEMP_UntilFollyUpdate/ConstexprMath.h b/vnext/Folly/TEMP_UntilFollyUpdate/ConstexprMath.h
index 3eeacc95f8b..428849f451f 100644
--- a/vnext/Folly/TEMP_UntilFollyUpdate/ConstexprMath.h
+++ b/vnext/Folly/TEMP_UntilFollyUpdate/ConstexprMath.h
@@ -1,978 +1,978 @@
 /*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * 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.
- */
-
- #pragma once
-
- #include <cassert>
- #include <cstddef>
- #include <cstdint>
- #include <functional>
- #include <limits>
- #include <type_traits>
- 
- #include <folly/Portability.h>
- #include <folly/lang/CheckedMath.h>
- #include <folly/portability/Constexpr.h>
- 
- namespace folly {
- 
- /// numbers
- ///
- /// mimic: std::numbers, C++20 (partial)
- namespace numbers {
- 
- namespace detail {
- template <typename T>
- using enable_if_floating_t =
-     std::enable_if_t<std::is_floating_point<T>::value, T>;
- }
- 
- /// e_v
- ///
- /// mimic: std::numbers::e_v, C++20
- template <typename T>
- inline constexpr T e_v = detail::enable_if_floating_t<T>(
-     2.71828182845904523536028747135266249775724709369995L);
- 
- /// ln2_v
- ///
- /// mimic: std::numbers::ln2_v, C++20
- template <typename T>
- inline constexpr T ln2_v = detail::enable_if_floating_t<T>(
-     0.69314718055994530941723212145817656807550013436025L);
- 
- /// e
- ///
- /// mimic: std::numbers::e, C++20
- inline constexpr double e = e_v<double>;
- 
- /// ln2
- ///
- /// mimic: std::numbers::ln2, C++20
- inline constexpr double ln2 = ln2_v<double>;
- 
- } // namespace numbers
- 
- /// floating_point_integral_constant
- ///
- /// Like std::integral_constant but for floating-point types holding integral
- /// values representable in an integral type.
- template <typename T, typename S, S Value>
- struct floating_point_integral_constant {
-   using value_type = T;
-   static constexpr value_type value = static_cast<value_type>(Value);
-   constexpr operator value_type() const noexcept { return value; }
-   constexpr value_type operator()() const noexcept { return value; }
- };
- 
- //  ----
- 
- namespace detail {
- 
- template <typename T>
- constexpr size_t constexpr_iterated_squares_desc_size_(T const base) {
-   using lim = std::numeric_limits<T>;
-   size_t s = 1;
-   auto r = base;
-   while (r <= lim::max() / r) {
-     ++s;
-     r *= r;
-   }
-   return s;
- }
- 
- } // namespace detail
- 
- /// constexpr_iterated_squares_desc_size_v
- ///
- /// Effectively calculates: floor(log(max_exponent)/log(base))
- ///
- /// For use with constexpr_iterated_squares_desc below.
- template <typename Base>
- inline constexpr size_t constexpr_iterated_squares_desc_size_v =
-     detail::constexpr_iterated_squares_desc_size_(Base::value);
- 
- /// constexpr_iterated_squares_desc
- ///
- /// A constexpr scaling array of integer powers-of-powers-of-two, descending,
- /// with the associated powers-of-two.
- ///
- /// scaling = [..., {8, b^8}, {4, b^4}, {2, b^2}, {1, b^1}] for b = base
- ///
- /// Includes select constexpr scaling algorithms based on the scaling array.
- ///
- /// The scaling array and the scaling algorithms are general-purpose, if niche.
- /// They may be used by other constexpr math functions (floating-point) either
- /// to improve runtime performance or to improve numerical approximations.
- ///
- /// Some compilers fail to support passing some types as non-type template
- /// params. In particular, long double is not universally supported. Therefore,
- /// this utility takes its base as a type rather than as a value. For floating-
- /// point integral bases, that is, bases of floating-point type but of integral
- /// value, floating_point_integral_constant is the easiest parameterization.
- template <typename T, std::size_t Size>
- struct constexpr_iterated_squares_desc {
-   static_assert(Size > 0, "requires non-zero size");
- 
-   using size_type = decltype(Size);
-   using base_type = T;
- 
-   struct item_type {
-     size_type power;
-     base_type scale;
-   };
- 
-   static constexpr size_type size = Size;
-   base_type base;
-   item_type scaling[size];
- 
-  private:
-   using lim = std::numeric_limits<base_type>;
- 
-   static_assert(
-       lim::max_exponent < std::numeric_limits<size_type>::max(),
-       "size_type too small for base_type");
- 
-  public:
-   explicit constexpr constexpr_iterated_squares_desc(base_type r) noexcept
-       : base{r}, scaling{} {
-     assert(size <= detail::constexpr_iterated_squares_desc_size_(base));
-     size_type i = 0;
-     size_type p = 1;
-     while (true) { // a for-loop might cause multiplication overflow below
-       scaling[size - 1 - i] = {p, r};
-       if (++i == size) {
-         break;
-       }
-       p *= 2;
-       r *= r;
-     }
-   }
- 
-   /// shrink
-   ///
-   /// Returns scaling params of the form:
-   ///   item_type{power, scale} with scale = base ^ power
-   /// With power the smallest nonnegative integer such that:
-   ///   abs(num) / scale <= max
-   constexpr item_type shrink(base_type const num, base_type const max) const {
-     assert(max > base_type(0));
-     auto const rmax = max / base;
-     auto const snum = num < base_type(0) ? -num : num;
-     auto power = size_type(0);
-     auto scale = base_type(1);
-     if (!(snum / scale <= max)) {
-       for (auto const& i : scaling) {
-         auto const next = scale * i.scale;
-         auto const div = snum / next;
-         if (div <= rmax) {
-           continue;
-         }
-         power += i.power;
-         scale = next;
-         if (div <= max) {
-           break;
-         }
-       }
-     }
-     assert(snum / scale <= max);
-     return {power, scale};
-   }
- 
-   /// growth
-   ///
-   /// Returns scaling params of the form:
-   ///   item_type{power, scale} with scale = base ^ power
-   /// With power the smallest nonnegative integer such that:
-   ///   abs(num) * scale >= min
-   constexpr item_type growth(base_type const num, base_type const min) const {
-     assert(min > base_type(0));
-     auto const rmin = min * base;
-     auto const snum = num < base_type(0) ? -num : num;
-     auto power = size_type(0);
-     auto scale = base_type(1);
-     if (!(snum * scale >= min)) {
-       for (auto const& i : scaling) {
-         auto const next = scale * i.scale;
-         auto const mul = snum * next;
-         if (mul >= rmin) {
-           continue;
-         }
-         power += i.power;
-         scale = next;
-         if (mul >= min) {
-           break;
-         }
-       }
-     }
-     assert(snum * scale >= min);
-     return {power, scale};
-   }
- };
- 
- /// constexpr_iterated_squares_desc_v
- ///
- /// An instance of constexpr_iterated_squares_desc of max size with the given
- /// base.
- template <typename Base>
- inline constexpr auto constexpr_iterated_squares_desc_v =
-     constexpr_iterated_squares_desc<
-         typename Base::value_type,
-         constexpr_iterated_squares_desc_size_v<Base>>{Base::value};
- 
- /// constexpr_iterated_squares_desc_2_v
- ///
- /// An alias for constexpr_iterated_squares_desc_v with base 2, which is the
- /// most common base to use with iterated-squares.
- template <typename T>
- constexpr auto& constexpr_iterated_squares_desc_2_v =
-     constexpr_iterated_squares_desc_v<
-         floating_point_integral_constant<T, int, 2>>;
- 
- // TLDR: Prefer using operator< for ordering. And when
- // a and b are equivalent objects, we return b to make
- // sorting stable.
- // See http://stepanovpapers.com/notes.pdf for details.
- template <typename T, typename... Ts>
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* 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.
+*/
+
+#pragma once
+
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <limits>
+#include <type_traits>
+
+#include <folly/Portability.h>
+#include <folly/lang/CheckedMath.h>
+#include <folly/portability/Constexpr.h>
+
+namespace folly {
+
+/// numbers
+///
+/// mimic: std::numbers, C++20 (partial)
+namespace numbers {
+
+namespace detail {
+template <typename T>
+using enable_if_floating_t =
+    std::enable_if_t<std::is_floating_point<T>::value, T>;
+}
+
+/// e_v
+///
+/// mimic: std::numbers::e_v, C++20
+template <typename T>
+inline constexpr T e_v = detail::enable_if_floating_t<T>(
+    2.71828182845904523536028747135266249775724709369995L);
+
+/// ln2_v
+///
+/// mimic: std::numbers::ln2_v, C++20
+template <typename T>
+inline constexpr T ln2_v = detail::enable_if_floating_t<T>(
+    0.69314718055994530941723212145817656807550013436025L);
+
+/// e
+///
+/// mimic: std::numbers::e, C++20
+inline constexpr double e = e_v<double>;
+
+/// ln2
+///
+/// mimic: std::numbers::ln2, C++20
+inline constexpr double ln2 = ln2_v<double>;
+
+} // namespace numbers
+
+/// floating_point_integral_constant
+///
+/// Like std::integral_constant but for floating-point types holding integral
+/// values representable in an integral type.
+template <typename T, typename S, S Value>
+struct floating_point_integral_constant {
+  using value_type = T;
+  static constexpr value_type value = static_cast<value_type>(Value);
+  constexpr operator value_type() const noexcept { return value; }
+  constexpr value_type operator()() const noexcept { return value; }
+};
+
+//  ----
+
+namespace detail {
+
+template <typename T>
+constexpr size_t constexpr_iterated_squares_desc_size_(T const base) {
+  using lim = std::numeric_limits<T>;
+  size_t s = 1;
+  auto r = base;
+  while (r <= lim::max() / r) {
+    ++s;
+    r *= r;
+  }
+  return s;
+}
+
+} // namespace detail
+
+/// constexpr_iterated_squares_desc_size_v
+///
+/// Effectively calculates: floor(log(max_exponent)/log(base))
+///
+/// For use with constexpr_iterated_squares_desc below.
+template <typename Base>
+inline constexpr size_t constexpr_iterated_squares_desc_size_v =
+    detail::constexpr_iterated_squares_desc_size_(Base::value);
+
+/// constexpr_iterated_squares_desc
+///
+/// A constexpr scaling array of integer powers-of-powers-of-two, descending,
+/// with the associated powers-of-two.
+///
+/// scaling = [..., {8, b^8}, {4, b^4}, {2, b^2}, {1, b^1}] for b = base
+///
+/// Includes select constexpr scaling algorithms based on the scaling array.
+///
+/// The scaling array and the scaling algorithms are general-purpose, if niche.
+/// They may be used by other constexpr math functions (floating-point) either
+/// to improve runtime performance or to improve numerical approximations.
+///
+/// Some compilers fail to support passing some types as non-type template
+/// params. In particular, long double is not universally supported. Therefore,
+/// this utility takes its base as a type rather than as a value. For floating-
+/// point integral bases, that is, bases of floating-point type but of integral
+/// value, floating_point_integral_constant is the easiest parameterization.
+template <typename T, std::size_t Size>
+struct constexpr_iterated_squares_desc {
+  static_assert(Size > 0, "requires non-zero size");
+
+  using size_type = decltype(Size);
+  using base_type = T;
+
+  struct item_type {
+    size_type power;
+    base_type scale;
+  };
+
+  static constexpr size_type size = Size;
+  base_type base;
+  item_type scaling[size];
+
+private:
+  using lim = std::numeric_limits<base_type>;
+
+  static_assert(
+      lim::max_exponent < std::numeric_limits<size_type>::max(),
+      "size_type too small for base_type");
+
+public:
+  explicit constexpr constexpr_iterated_squares_desc(base_type r) noexcept
+      : base{r}, scaling{} {
+    assert(size <= detail::constexpr_iterated_squares_desc_size_(base));
+    size_type i = 0;
+    size_type p = 1;
+    while (true) { // a for-loop might cause multiplication overflow below
+      scaling[size - 1 - i] = {p, r};
+      if (++i == size) {
+        break;
+      }
+      p *= 2;
+      r *= r;
+    }
+  }
+
+  /// shrink
+  ///
+  /// Returns scaling params of the form:
+  ///   item_type{power, scale} with scale = base ^ power
+  /// With power the smallest nonnegative integer such that:
+  ///   abs(num) / scale <= max
+  constexpr item_type shrink(base_type const num, base_type const max) const {
+    assert(max > base_type(0));
+    auto const rmax = max / base;
+    auto const snum = num < base_type(0) ? -num : num;
+    auto power = size_type(0);
+    auto scale = base_type(1);
+    if (!(snum / scale <= max)) {
+      for (auto const& i : scaling) {
+        auto const next = scale * i.scale;
+        auto const div = snum / next;
+        if (div <= rmax) {
+          continue;
+        }
+        power += i.power;
+        scale = next;
+        if (div <= max) {
+          break;
+        }
+      }
+    }
+    assert(snum / scale <= max);
+    return {power, scale};
+  }
+
+  /// growth
+  ///
+  /// Returns scaling params of the form:
+  ///   item_type{power, scale} with scale = base ^ power
+  /// With power the smallest nonnegative integer such that:
+  ///   abs(num) * scale >= min
+  constexpr item_type growth(base_type const num, base_type const min) const {
+    assert(min > base_type(0));
+    auto const rmin = min * base;
+    auto const snum = num < base_type(0) ? -num : num;
+    auto power = size_type(0);
+    auto scale = base_type(1);
+    if (!(snum * scale >= min)) {
+      for (auto const& i : scaling) {
+        auto const next = scale * i.scale;
+        auto const mul = snum * next;
+        if (mul >= rmin) {
+          continue;
+        }
+        power += i.power;
+        scale = next;
+        if (mul >= min) {
+          break;
+        }
+      }
+    }
+    assert(snum * scale >= min);
+    return {power, scale};
+  }
+};
+
+/// constexpr_iterated_squares_desc_v
+///
+/// An instance of constexpr_iterated_squares_desc of max size with the given
+/// base.
+template <typename Base>
+inline constexpr auto constexpr_iterated_squares_desc_v =
+    constexpr_iterated_squares_desc<
+        typename Base::value_type,
+        constexpr_iterated_squares_desc_size_v<Base>>{Base::value};
+
+/// constexpr_iterated_squares_desc_2_v
+///
+/// An alias for constexpr_iterated_squares_desc_v with base 2, which is the
+/// most common base to use with iterated-squares.
+template <typename T>
+constexpr auto& constexpr_iterated_squares_desc_2_v =
+    constexpr_iterated_squares_desc_v<
+        floating_point_integral_constant<T, int, 2>>;
+
+// TLDR: Prefer using operator< for ordering. And when
+// a and b are equivalent objects, we return b to make
+// sorting stable.
+// See http://stepanovpapers.com/notes.pdf for details.
+template <typename T, typename... Ts>
 constexpr T constexpr_max(T a, Ts... ts) {
-  T list[] = {ts..., a}; // 0-length arrays are illegal
-  // [Windows #12703 - Fix folly CodeQL issues]
-  for (size_t i = 0; i < sizeof...(Ts); ++i) {
-    a = list[i] < a ? a : list[i];
-  }
-  return a;
-}
- 
- // When a and b are equivalent objects, we return a to
- // make sorting stable.
- template <typename T, typename... Ts>
- constexpr T constexpr_min(T a, Ts... ts) {
-  T list[] = {ts..., a}; // 0-length arrays are illegal
-  // [Windows #12703 - Fix folly CodeQL issues]
-  for (size_t i = 0; i < sizeof...(Ts); ++i) {
-    a = list[i] < a ? list[i] : a;
-  }
-  return a;
- }
- 
- template <typename T, typename Less>
- constexpr T const& constexpr_clamp(
-     T const& v, T const& lo, T const& hi, Less less) {
-   T const& a = less(v, lo) ? lo : v;
-   T const& b = less(hi, a) ? hi : a;
-   return b;
- }
- template <typename T>
- constexpr T const& constexpr_clamp(T const& v, T const& lo, T const& hi) {
-   return constexpr_clamp(v, lo, hi, std::less<T>{});
- }
- 
- template <typename T>
- constexpr bool constexpr_isnan(T const t) {
-   return t != t; // NOLINT
- }
- 
- namespace detail {
- 
- template <typename T, typename = void>
- struct constexpr_abs_helper {};
- 
- template <typename T>
- struct constexpr_abs_helper<
-     T,
-     typename std::enable_if<std::is_floating_point<T>::value>::type> {
-   static constexpr T go(T t) { return t < static_cast<T>(0) ? -t : t; }
- };
- 
- template <typename T>
- struct constexpr_abs_helper<
-     T,
-     typename std::enable_if<
-         std::is_integral<T>::value && !std::is_same<T, bool>::value &&
-         std::is_unsigned<T>::value>::type> {
-   static constexpr T go(T t) { return t; }
- };
- 
- template <typename T>
- struct constexpr_abs_helper<
-     T,
-     typename std::enable_if<
-         std::is_integral<T>::value && !std::is_same<T, bool>::value &&
-         std::is_signed<T>::value>::type> {
-   static constexpr typename std::make_unsigned<T>::type go(T t) {
-     return typename std::make_unsigned<T>::type(t < static_cast<T>(0) ? -t : t);
-   }
- };
- 
- } // namespace detail
- 
- template <typename T>
- constexpr auto constexpr_abs(T t)
-     -> decltype(detail::constexpr_abs_helper<T>::go(t)) {
-   return detail::constexpr_abs_helper<T>::go(t);
- }
- 
- namespace detail {
- 
- template <typename T>
- constexpr T constexpr_log2_(T a, T e) {
-   return e == T(1) ? a : constexpr_log2_(a + T(1), e / T(2));
- }
- 
- template <typename T>
- constexpr T constexpr_log2_ceil_(T l2, T t) {
-   return l2 + T(T(1) << l2 < t ? 1 : 0);
- }
- 
- } // namespace detail
- 
- template <typename T>
- constexpr T constexpr_log2(T t) {
-   return detail::constexpr_log2_(T(0), t);
- }
- 
- template <typename T>
- constexpr T constexpr_log2_ceil(T t) {
-   return detail::constexpr_log2_ceil_(constexpr_log2(t), t);
- }
- 
- /// constexpr_trunc
- ///
- /// mimic: std::trunc (C++23)
- template <
-     typename T,
-     std::enable_if_t<std::is_floating_point<T>::value, int> = 0>
- constexpr T constexpr_trunc(T const t) {
-   using lim = std::numeric_limits<T>;
-   using int_type = std::uintmax_t;
-   using int_lim = std::numeric_limits<int_type>;
-   static_assert(lim::radix == 2, "non-binary radix");
-   static_assert(lim::digits <= int_lim::digits, "overwide mantissa");
-   constexpr auto bound = static_cast<T>(std::uintmax_t(1) << (lim::digits - 1));
-   auto const neg = !constexpr_isnan(t) && t < T(0);
-   auto const s = neg ? -t : t;
-   if (constexpr_isnan(t) || t == T(0) || !(s < bound)) {
-     return t;
-   }
-   if (s < T(1)) {
-     return neg ? -T(0) : T(0);
-   }
-   auto const r = static_cast<T>(static_cast<int_type>(s));
-   return neg ? -r : r;
- }
- 
- template <typename T, std::enable_if_t<std::is_integral<T>::value, int> = 0>
- constexpr T constexpr_trunc(T const t) {
-   return t;
- }
- 
- /// constexpr_round
- ///
- /// mimic: std::round (C++23)
- template <typename T>
- constexpr T constexpr_round(T const t) {
-   constexpr auto half = T(1) / T(2);
-   auto const same = constexpr_isnan(t) || t == T(0);
-   return same ? t : constexpr_trunc(t < T(0) ? t - half : t + half);
- }
- 
- /// constexpr_floor
- ///
- /// mimic: std::floor (C++23)
- template <typename T>
- constexpr T constexpr_floor(T const t) {
-   auto const s = constexpr_trunc(t);
-   return t < s ? s - T(1) : s;
- }
- 
- /// constexpr_ceil
- ///
- /// mimic: std::ceil (C++23)
- template <typename T>
- constexpr T constexpr_ceil(T const t) {
-   auto const s = constexpr_trunc(t);
-   return s < t ? s + T(1) : s;
- }
- 
- /// constexpr_ceil
- ///
- /// The least integer at least t that round divides.
- template <typename T>
- constexpr T constexpr_ceil(T t, T round) {
-   return round == T(0)
-       ? t
-       : ((t + (t <= T(0) ? T(0) : round - T(1))) / round) * round;
- }
- 
- /// constexpr_mult
- ///
- /// Multiply two values, allowing for constexpr floating-pooint overflow to
- /// infinity.
- template <typename T>
- constexpr T constexpr_mult(T const a, T const b) {
-   using lim = std::numeric_limits<T>;
-   if (constexpr_isnan(a) || constexpr_isnan(b)) {
-     return constexpr_isnan(a) ? a : b;
-   }
-   if (std::is_floating_point<T>::value) {
-     constexpr auto inf = lim::infinity();
-     auto const ax = constexpr_abs(a);
-     auto const bx = constexpr_abs(b);
-     if ((ax == T(0) && bx == inf) || (bx == T(0) && ax == inf)) {
-       return lim::quiet_NaN();
-     }
-     // floating-point multiplication overflow, ie where multiplication of two
-     // finite values overflows to infinity of either sign, is not constexpr per
-     // gcc
-     // floating-point division overflow, ie where division of two finite values
-     // overflows to infinity of either sign, is not constexpr per gcc
-     // floating-point division by zero is not constexpr per any compiler, but we
-     // use it in the checks for the other two conditions
-     if (ax != inf && bx != inf && T(1) < bx && lim::max() / bx < ax) {
-       auto const a_neg = static_cast<bool>(a < T(0));
-       auto const b_neg = static_cast<bool>(b < T(0));
-       auto const sign = a_neg == b_neg ? T(1) : T(-1);
-       return sign * inf;
-     }
-   }
-   return a * b;
- }
- 
- namespace detail {
- 
- template <
-     typename T,
-     typename E,
-     std::enable_if_t<std::is_signed<E>::value, int> = 1>
- constexpr T constexpr_ipow(T const base, E const exp) {
-   if (std::is_floating_point<T>::value) {
-     if (exp < E(0)) {
-       return T(1) / constexpr_ipow(base, -exp);
-     }
-     if (exp == E(0)) {
-       return T(1);
-     }
-     if (constexpr_isnan(base)) {
-       return base;
-     }
-   }
-   assert(!(exp < E(0)) && "negative exponent with integral base");
-   if (exp == E(0)) {
-     return T(1);
-   }
-   if (exp == E(1)) {
-     return base;
-   }
-   auto const hexp = constexpr_trunc(exp / E(2));
-   auto const div = constexpr_ipow(base, hexp);
-   auto const rem = hexp * E(2) == exp ? T(1) : base;
-   return constexpr_mult(constexpr_mult(div, div), rem);
- }
- 
- template <
-     typename T,
-     typename E,
-     std::enable_if_t<std::is_unsigned<E>::value, int> = 1>
- constexpr T constexpr_ipow(T const base, E const exp) {
-   if (std::is_floating_point<T>::value) {
-     if (exp == E(0)) {
-       return T(1);
-     }
-     if (constexpr_isnan(base)) {
-       return base;
-     }
-   }
-   if (exp == E(0)) {
-     return T(1);
-   }
-   if (exp == E(1)) {
-     return base;
-   }
-   auto const hexp = constexpr_trunc(exp / E(2));
-   auto const div = constexpr_ipow(base, hexp);
-   auto const rem = hexp * E(2) == exp ? T(1) : base;
-   return constexpr_mult(constexpr_mult(div, div), rem);
- }
- 
- } // namespace detail
- 
- /// constexpr_exp
- ///
- /// Calculates an approximation of the mathematical function exp(num). Usable in
- /// constant evaluations. Like std::exp, which becomes constexpr in C++26.
- ///
- /// The integer overload uses iterated squaring and multiplication. The
- /// floating-point overlaod naively evaluates the taylor series of exp(num)
- /// until approximate convergence.
- ///
- /// mimic: std::exp (C++23, C++26)
- template <
-     typename T,
-     typename N,
-     std::enable_if_t<
-         std::is_floating_point<T>::value && std::is_integral<N>::value &&
-             !std::is_same<N, bool>::value,
-         int> = 0>
- constexpr T constexpr_exp(N const power) {
-   auto const npower = constexpr_abs(power);
-   auto const result = detail::constexpr_ipow(numbers::e_v<T>, npower);
-   return power < N(0) ? T(1) / result : result;
- }
- template <
-     typename N,
-     std::enable_if_t<
-         std::is_integral<N>::value && !std::is_same<N, bool>::value,
-         int> = 0>
- constexpr double constexpr_exp(N const power) {
-   return constexpr_exp<double>(power);
- }
- template <
-     typename T,
-     std::enable_if_t<std::is_floating_point<T>::value, int> = 0>
- constexpr T constexpr_exp(T const power) {
-   using lim = std::numeric_limits<T>;
- 
-   // edge cases
-   if (constexpr_isnan(power)) {
-     return power;
-   }
-   if (power == -lim::infinity()) {
-     return +T(0);
-   }
-   if (power == +lim::infinity()) {
-     return power;
-   }
- 
-   // convergence works better with positive powers since signs do not alternate
-   auto const abspower = constexpr_abs(power);
-   // convergence must short-circuit when terms grow to floating-point infinity
-   auto const bound = T(1) < abspower ? lim::max() / abspower : lim::infinity();
- 
-   // term #index = power * coeff
-   auto index = size_t(0);
-   auto term = T(1);
-   // result = sum of terms
-   auto result = T(1);
-   // sum the terms until ~convergence
-   while (!(constexpr_abs(term) < lim::epsilon())) {
-     if (bound < term) {
-       return power < T(0) ? T(0) : lim::infinity();
-     }
-     index += 1;
-     term = term * abspower / index;
-     result += term;
-   }
-   return power < T(0) ? T(1) / result : result;
- }
- 
- /// constexpr_log
- ///
- /// Calculates an approximation of the natural logarithm ln(num).
- ///
- /// The implementation uses a quickly-converging, high-precision iterative
- /// technique as described in:
- ///   https://en.wikipedia.org/wiki/Natural_logarithm#High_precision
- ///
- /// The technique works best with numbers that are close enough to 1, so the
- /// implementation uses a quick shrink/growth technique as described in:
- ///   https://en.wikipedia.org/wiki/Natural_logarithm#Efficient_computation
- template <
-     typename T,
-     std::enable_if_t<std::is_floating_point<T>::value, int> = 0>
- constexpr T constexpr_log(T const num) {
-   using lim = std::numeric_limits<T>;
-   constexpr auto& isq = constexpr_iterated_squares_desc_2_v<T>;
- 
-   // edge cases
-   if (constexpr_isnan(num)) {
-     return num;
-   }
-   if (num < T(0)) {
-     return lim::quiet_NaN();
-   }
-   if (num == T(0)) {
-     return -lim::infinity();
-   }
-   if (num == lim::infinity()) {
-     return num;
-   }
- 
-   // compression
-   auto const shrink = isq.shrink(num, isq.base);
-   auto const growth = isq.growth(num, T(1));
-   auto const scaled = num * growth.scale / shrink.scale;
-   assert(scaled <= isq.base);
-   assert(scaled >= T(1));
- 
-   auto sum = T(0);
-   auto delta = T(2);
-   while (constexpr_abs(delta) >= lim::epsilon()) {
-     auto expterm = constexpr_exp(sum);
-     delta = T(2) * (scaled - expterm) / (scaled + expterm);
-     sum += delta;
-   }
-   auto const ln2 = numbers::ln2_v<T>;
-   return sum - growth.power * ln2 + shrink.power * ln2;
- }
- 
- /// constexpr_pow
- ///
- /// Calculates an approximation of the value of base raised to the exponent exp.
- ///
- /// The implementation uses iterated squaring and multiplication for the integer
- /// part of the exponent and uses the identity x^y = exp(y * log(x)) for the
- /// fractional part of the exponent.
- ///
- /// Notes:
- /// * Forbids base of +0 or -0 with finite non-positive exponent: in part since
- ///   the plausible infinite result would be sensitive to the sign of the zero;
- ///   and in part since std::pow would be required or permitted to raise error
- ///   div-by-zero.
- /// * Forbids finite negative base with finite non-integer exponent: in part
- ///   since std::pow would be required to raise error invalid.
- ///
- /// mimic: std::pow (C++26)
- template <
-     typename T,
-     typename E,
-     std::enable_if_t<
-         std::is_integral<E>::value && !std::is_same<E, bool>::value,
-         int> = 0>
- constexpr T constexpr_pow(T const base, E const exp) {
-   return detail::constexpr_ipow(base, exp);
- }
- template <
-     typename T,
-     std::enable_if_t<std::is_floating_point<T>::value, int> = 0>
- constexpr T constexpr_pow(T const base, T const exp) {
-   using lim = std::numeric_limits<T>;
- 
-   // edge cases
-   if (exp == T(0)) {
-     return T(1);
-   }
-   if (constexpr_isnan(base)) {
-     return base;
-   }
-   if (exp == lim::infinity() || exp == -lim::infinity()) {
-     auto const abase = constexpr_abs(base);
-     if (abase < T(1)) {
-       return exp == lim::infinity() ? T(0) : lim::infinity();
-     }
-     if (T(1) < abase) {
-       return exp == lim::infinity() ? lim::infinity() : T(0);
-     }
-     return T(1);
-   }
-   if (base == T(1)) {
-     return base;
-   }
-   if (constexpr_isnan(exp)) {
-     return exp;
-   }
-   assert(base != T(0) || exp > T(0)); // error div-by-zero
-   if (base == lim::infinity()) {
-     return exp < T(0) ? T(0) : lim::infinity();
-   }
-   if (base == -lim::infinity()) {
-     auto const oddi = //
-         exp == constexpr_trunc(exp) &&
-         exp != constexpr_trunc(exp / T(2)) * T(2);
-     return (oddi ? -T(1) : T(1)) * (exp < T(0) ? T(0) : lim::infinity());
-   }
-   if (base == T(0)) {
-     auto const oddi = //
-         exp == constexpr_trunc(exp) &&
-         exp != constexpr_trunc(exp / T(2)) * T(2);
-     return oddi ? base : T(0);
-   }
-   if (exp < T(0)) {
-     return T(1) / constexpr_pow(base, -exp);
-   }
- 
-   // as an identity: x^y = exp(y * log(x)); but calculation is imprecise ... so,
-   // for better precision, split the calculation into its integral-power and its
-   // fractional-power components
-   // as a cost, the complexity of constexpr_ipow here is logarithmic in y, i.e.,
-   // linear in the logarithm of y, which can be prohibitive
-   auto const exp_trunc = constexpr_trunc(exp);
-   assert(T(0) < base || exp == exp_trunc); // error invalid
-   auto const exp_fract = exp - exp_trunc;
-   auto const anyi = exp_fract == T(0);
-   return constexpr_mult(
-       detail::constexpr_ipow(base, exp_trunc),
-       anyi ? T(1) : constexpr_exp(exp_fract * constexpr_log(base)));
- }
- 
- /// constexpr_find_last_set
- ///
- /// Return the 1-based index of the most significant bit which is set.
- /// For x > 0, constexpr_find_last_set(x) == 1 + floor(log2(x)).
- template <typename T>
- constexpr std::size_t constexpr_find_last_set(T const t) {
-   using U = std::make_unsigned_t<T>;
-   return t == T(0) ? 0 : 1 + constexpr_log2(static_cast<U>(t));
- }
- 
- namespace detail {
- template <typename U>
- constexpr std::size_t constexpr_find_first_set_(
-     std::size_t s, std::size_t a, U const u) {
-   return s == 0 ? a
-                 : constexpr_find_first_set_(
-                       s / 2, a + s * bool((u >> a) % (U(1) << s) == U(0)), u);
- }
- } // namespace detail
- 
- /// constexpr_find_first_set
- ///
- /// Return the 1-based index of the least significant bit which is set.
- /// For x > 0, the exponent in the largest power of two which does not divide x.
- template <typename T>
- constexpr std::size_t constexpr_find_first_set(T t) {
-   using U = std::make_unsigned_t<T>;
-   using size = std::integral_constant<std::size_t, sizeof(T) * 4>;
-   return t == T(0)
-       ? 0
-       : 1 + detail::constexpr_find_first_set_(size{}, 0, static_cast<U>(t));
- }
- 
- template <typename T>
- constexpr T constexpr_add_overflow_clamped(T a, T b) {
-   using L = std::numeric_limits<T>;
-   using M = std::intmax_t;
-   static_assert(
-       !std::is_integral<T>::value || sizeof(T) <= sizeof(M),
-       "Integral type too large!");
-   if (!folly::is_constant_evaluated_or(true)) {
-     if constexpr (std::is_integral_v<T>) {
-       T ret{};
-       if (FOLLY_UNLIKELY(!checked_add(&ret, a, b))) {
-         if constexpr (std::is_signed_v<T>) {
-           // Could be either overflow or underflow for signed types.
-           // Can only be underflow if both inputs are negative.
-           if (a < 0 && b < 0) {
-             return L::min();
-           }
-         }
-         return L::max();
-       }
-       return ret;
-     }
-   }
-   // clang-format off
-   return
-     // don't do anything special for non-integral types.
-     !std::is_integral<T>::value ? a + b :
-     // for narrow integral types, just convert to intmax_t.
-     sizeof(T) < sizeof(M)
-       ? T(constexpr_clamp(
-           static_cast<M>(a) + static_cast<M>(b),
-           static_cast<M>(L::min()),
-           static_cast<M>(L::max()))) :
-     // when a >= 0, cannot add more than `MAX - a` onto a.
-     !(a < 0) ? a + constexpr_min(b, T(L::max() - a)) :
-     // a < 0 && b >= 0, `a + b` will always be in valid range of type T.
-     !(b < 0) ? a + b :
-     // a < 0 && b < 0, keep the result >= MIN.
-               a + constexpr_max(b, T(L::min() - a));
-   // clang-format on
- }
- 
- template <typename T>
- constexpr T constexpr_sub_overflow_clamped(T a, T b) {
-   using L = std::numeric_limits<T>;
-   using M = std::intmax_t;
-   static_assert(
-       !std::is_integral<T>::value || sizeof(T) <= sizeof(M),
-       "Integral type too large!");
-   // clang-format off
-   return
-     // don't do anything special for non-integral types.
-     !std::is_integral<T>::value ? a - b :
-     // for unsigned type, keep result >= 0.
-     std::is_unsigned<T>::value ? (a < b ? 0 : a - b) :
-     // for narrow signed integral types, just convert to intmax_t.
-     sizeof(T) < sizeof(M)
-       ? T(constexpr_clamp(
-           static_cast<M>(a) - static_cast<M>(b),
-           static_cast<M>(L::min()),
-           static_cast<M>(L::max()))) :
-     // (a >= 0 && b >= 0) || (a < 0 && b < 0), `a - b` will always be valid.
-     (a < 0) == (b < 0) ? a - b :
-     // MIN < b, so `-b` should be in valid range (-MAX <= -b <= MAX),
-     // convert subtraction to addition.
-     L::min() < b ? constexpr_add_overflow_clamped(a, T(-b)) :
-     // -b = -MIN = (MAX + 1) and a <= -1, result is in valid range.
-     a < 0 ? a - b :
-     // -b = -MIN = (MAX + 1) and a >= 0, result > MAX.
-             L::max();
-   // clang-format on
- }
- 
- // clamp_cast<> provides sane numeric conversions from float point numbers to
- // integral numbers, and between different types of integral numbers. It helps
- // to avoid unexpected bugs introduced by bad conversion, and undefined behavior
- // like overflow when casting float point numbers to integral numbers.
- //
- // When doing clamp_cast<Dst>(value), if `value` is in valid range of Dst,
- // it will give correct result in Dst, equal to `value`.
- //
- // If `value` is outside the representable range of Dst, it will be clamped to
- // MAX or MIN in Dst, instead of being undefined behavior.
- //
- // Float NaNs are converted to 0 in integral type.
- //
- // Here's some comparison with static_cast<>:
- // (with FB-internal gcc-5-glibc-2.23 toolchain)
- //
- // static_cast<int32_t>(NaN) = 6
- // clamp_cast<int32_t>(NaN) = 0
- //
- // static_cast<int32_t>(9999999999.0f) = -348639895
- // clamp_cast<int32_t>(9999999999.0f) = 2147483647
- //
- // static_cast<int32_t>(2147483647.0f) = -348639895
- // clamp_cast<int32_t>(2147483647.0f) = 2147483647
- //
- // static_cast<uint32_t>(4294967295.0f) = 0
- // clamp_cast<uint32_t>(4294967295.0f) = 4294967295
- //
- // static_cast<uint32_t>(-1) = 4294967295
- // clamp_cast<uint32_t>(-1) = 0
- //
- // static_cast<int16_t>(32768u) = -32768
- // clamp_cast<int16_t>(32768u) = 32767
- 
- template <typename Dst, typename Src>
- constexpr typename std::enable_if<std::is_integral<Src>::value, Dst>::type
- constexpr_clamp_cast(Src src) {
-   static_assert(
-       std::is_integral<Dst>::value && sizeof(Dst) <= sizeof(int64_t),
-       "constexpr_clamp_cast can only cast into integral type (up to 64bit)");
- 
-   using L = std::numeric_limits<Dst>;
-   // clang-format off
-   return
-     // Check if Src and Dst have same signedness.
-     std::is_signed<Src>::value == std::is_signed<Dst>::value
-     ? (
-       // Src and Dst have same signedness. If sizeof(Src) <= sizeof(Dst),
-       // we can safely convert Src to Dst without any loss of accuracy.
-       sizeof(Src) <= sizeof(Dst) ? Dst(src) :
-       // If Src is larger in size, we need to clamp it to valid range in Dst.
-       Dst(constexpr_clamp(src, Src(L::min()), Src(L::max()))))
-     // Src and Dst have different signedness.
-     // Check if it's signed -> unsigend cast.
-     : std::is_signed<Src>::value && std::is_unsigned<Dst>::value
-     ? (
-       // If src < 0, the result should be 0.
-       src < 0 ? Dst(0) :
-       // Otherwise, src >= 0. If src can fit into Dst, we can safely cast it
-       // without loss of accuracy.
-       sizeof(Src) <= sizeof(Dst) ? Dst(src) :
-       // If Src is larger in size than Dst, we need to ensure the result is
-       // at most Dst MAX.
-       Dst(constexpr_min(src, Src(L::max()))))
-     // It's unsigned -> signed cast.
-     : (
-       // Since Src is unsigned, and Dst is signed, Src can fit into Dst only
-       // when sizeof(Src) < sizeof(Dst).
-       sizeof(Src) < sizeof(Dst) ? Dst(src) :
-       // If Src does not fit into Dst, we need to ensure the result is at most
-       // Dst MAX.
-       Dst(constexpr_min(src, Src(L::max()))));
-   // clang-format on
- }
- 
- namespace detail {
- // Upper/lower bound values that could be accurately represented in both
- // integral and float point types.
- constexpr double kClampCastLowerBoundDoubleToInt64F = -9223372036854774784.0;
- constexpr double kClampCastUpperBoundDoubleToInt64F = 9223372036854774784.0;
- constexpr double kClampCastUpperBoundDoubleToUInt64F = 18446744073709549568.0;
- 
- constexpr float kClampCastLowerBoundFloatToInt32F = -2147483520.0f;
- constexpr float kClampCastUpperBoundFloatToInt32F = 2147483520.0f;
- constexpr float kClampCastUpperBoundFloatToUInt32F = 4294967040.0f;
- 
- // This works the same as constexpr_clamp, but the comparison are done in Src
- // to prevent any implicit promotions.
- template <typename D, typename S>
- constexpr D constexpr_clamp_cast_helper(S src, S sl, S su, D dl, D du) {
-   return src < sl ? dl : (src > su ? du : D(src));
- }
- } // namespace detail
- 
- template <typename Dst, typename Src>
- constexpr typename std::enable_if<std::is_floating_point<Src>::value, Dst>::type
- constexpr_clamp_cast(Src src) {
-   static_assert(
-       std::is_integral<Dst>::value && sizeof(Dst) <= sizeof(int64_t),
-       "constexpr_clamp_cast can only cast into integral type (up to 64bit)");
- 
-   using L = std::numeric_limits<Dst>;
-   // clang-format off
-   return
-     // Special case: cast NaN into 0.
-     constexpr_isnan(src) ? Dst(0) :
-     // using `sizeof(Src) > sizeof(Dst)` as a heuristic that Dst can be
-     // represented in Src without loss of accuracy.
-     // see: https://en.wikipedia.org/wiki/Floating-point_arithmetic
-     sizeof(Src) > sizeof(Dst) ?
-       detail::constexpr_clamp_cast_helper(
-           src, Src(L::min()), Src(L::max()), L::min(), L::max()) :
-     // sizeof(Src) < sizeof(Dst) only happens when doing cast of
-     // 32bit float -> u/int64_t.
-     // Losslessly promote float into double, change into double -> u/int64_t.
-     sizeof(Src) < sizeof(Dst) ? (
-       src >= 0.0
-       ? constexpr_clamp_cast<Dst>(
-             constexpr_clamp_cast<std::uint64_t>(double(src)))
-       : constexpr_clamp_cast<Dst>(
-             constexpr_clamp_cast<std::int64_t>(double(src)))) :
-     // The following are for sizeof(Src) == sizeof(Dst).
-     std::is_same<Src, double>::value && std::is_same<Dst, int64_t>::value ?
-       detail::constexpr_clamp_cast_helper(
-           double(src),
-           detail::kClampCastLowerBoundDoubleToInt64F,
-           detail::kClampCastUpperBoundDoubleToInt64F,
-           L::min(),
-           L::max()) :
-     std::is_same<Src, double>::value && std::is_same<Dst, uint64_t>::value ?
-       detail::constexpr_clamp_cast_helper(
-           double(src),
-           0.0,
-           detail::kClampCastUpperBoundDoubleToUInt64F,
-           L::min(),
-           L::max()) :
-     std::is_same<Src, float>::value && std::is_same<Dst, int32_t>::value ?
-       detail::constexpr_clamp_cast_helper(
-           float(src),
-           detail::kClampCastLowerBoundFloatToInt32F,
-           detail::kClampCastUpperBoundFloatToInt32F,
-           L::min(),
-           L::max()) :
-       detail::constexpr_clamp_cast_helper(
-           float(src),
-           0.0f,
-           detail::kClampCastUpperBoundFloatToUInt32F,
-           L::min(),
-           L::max());
-   // clang-format on
- }
- 
- } // namespace folly
+T list[] = {ts..., a}; // 0-length arrays are illegal
+// [Windows #12703 - Fix folly CodeQL issues]
+for (size_t i = 0; i < sizeof...(Ts); ++i) {
+  a = list[i] < a ? a : list[i];
+}
+return a;
+}
+
+// When a and b are equivalent objects, we return a to
+// make sorting stable.
+template <typename T, typename... Ts>
+constexpr T constexpr_min(T a, Ts... ts) {
+T list[] = {ts..., a}; // 0-length arrays are illegal
+// [Windows #12703 - Fix folly CodeQL issues]
+for (size_t i = 0; i < sizeof...(Ts); ++i) {
+  a = list[i] < a ? list[i] : a;
+}
+return a;
+}
+
+template <typename T, typename Less>
+constexpr T const& constexpr_clamp(
+    T const& v, T const& lo, T const& hi, Less less) {
+  T const& a = less(v, lo) ? lo : v;
+  T const& b = less(hi, a) ? hi : a;
+  return b;
+}
+template <typename T>
+constexpr T const& constexpr_clamp(T const& v, T const& lo, T const& hi) {
+  return constexpr_clamp(v, lo, hi, std::less<T>{});
+}
+
+template <typename T>
+constexpr bool constexpr_isnan(T const t) {
+  return t != t; // NOLINT
+}
+
+namespace detail {
+
+template <typename T, typename = void>
+struct constexpr_abs_helper {};
+
+template <typename T>
+struct constexpr_abs_helper<
+    T,
+    typename std::enable_if<std::is_floating_point<T>::value>::type> {
+  static constexpr T go(T t) { return t < static_cast<T>(0) ? -t : t; }
+};
+
+template <typename T>
+struct constexpr_abs_helper<
+    T,
+    typename std::enable_if<
+        std::is_integral<T>::value && !std::is_same<T, bool>::value &&
+        std::is_unsigned<T>::value>::type> {
+  static constexpr T go(T t) { return t; }
+};
+
+template <typename T>
+struct constexpr_abs_helper<
+    T,
+    typename std::enable_if<
+        std::is_integral<T>::value && !std::is_same<T, bool>::value &&
+        std::is_signed<T>::value>::type> {
+  static constexpr typename std::make_unsigned<T>::type go(T t) {
+    return typename std::make_unsigned<T>::type(t < static_cast<T>(0) ? -t : t);
+  }
+};
+
+} // namespace detail
+
+template <typename T>
+constexpr auto constexpr_abs(T t)
+    -> decltype(detail::constexpr_abs_helper<T>::go(t)) {
+  return detail::constexpr_abs_helper<T>::go(t);
+}
+
+namespace detail {
+
+template <typename T>
+constexpr T constexpr_log2_(T a, T e) {
+  return e == T(1) ? a : constexpr_log2_(a + T(1), e / T(2));
+}
+
+template <typename T>
+constexpr T constexpr_log2_ceil_(T l2, T t) {
+  return l2 + T(T(1) << l2 < t ? 1 : 0);
+}
+
+} // namespace detail
+
+template <typename T>
+constexpr T constexpr_log2(T t) {
+  return detail::constexpr_log2_(T(0), t);
+}
+
+template <typename T>
+constexpr T constexpr_log2_ceil(T t) {
+  return detail::constexpr_log2_ceil_(constexpr_log2(t), t);
+}
+
+/// constexpr_trunc
+///
+/// mimic: std::trunc (C++23)
+template <
+    typename T,
+    std::enable_if_t<std::is_floating_point<T>::value, int> = 0>
+constexpr T constexpr_trunc(T const t) {
+  using lim = std::numeric_limits<T>;
+  using int_type = std::uintmax_t;
+  using int_lim = std::numeric_limits<int_type>;
+  static_assert(lim::radix == 2, "non-binary radix");
+  static_assert(lim::digits <= int_lim::digits, "overwide mantissa");
+  constexpr auto bound = static_cast<T>(std::uintmax_t(1) << (lim::digits - 1));
+  auto const neg = !constexpr_isnan(t) && t < T(0);
+  auto const s = neg ? -t : t;
+  if (constexpr_isnan(t) || t == T(0) || !(s < bound)) {
+    return t;
+  }
+  if (s < T(1)) {
+    return neg ? -T(0) : T(0);
+  }
+  auto const r = static_cast<T>(static_cast<int_type>(s));
+  return neg ? -r : r;
+}
+
+template <typename T, std::enable_if_t<std::is_integral<T>::value, int> = 0>
+constexpr T constexpr_trunc(T const t) {
+  return t;
+}
+
+/// constexpr_round
+///
+/// mimic: std::round (C++23)
+template <typename T>
+constexpr T constexpr_round(T const t) {
+  constexpr auto half = T(1) / T(2);
+  auto const same = constexpr_isnan(t) || t == T(0);
+  return same ? t : constexpr_trunc(t < T(0) ? t - half : t + half);
+}
+
+/// constexpr_floor
+///
+/// mimic: std::floor (C++23)
+template <typename T>
+constexpr T constexpr_floor(T const t) {
+  auto const s = constexpr_trunc(t);
+  return t < s ? s - T(1) : s;
+}
+
+/// constexpr_ceil
+///
+/// mimic: std::ceil (C++23)
+template <typename T>
+constexpr T constexpr_ceil(T const t) {
+  auto const s = constexpr_trunc(t);
+  return s < t ? s + T(1) : s;
+}
+
+/// constexpr_ceil
+///
+/// The least integer at least t that round divides.
+template <typename T>
+constexpr T constexpr_ceil(T t, T round) {
+  return round == T(0)
+      ? t
+      : ((t + (t <= T(0) ? T(0) : round - T(1))) / round) * round;
+}
+
+/// constexpr_mult
+///
+/// Multiply two values, allowing for constexpr floating-pooint overflow to
+/// infinity.
+template <typename T>
+constexpr T constexpr_mult(T const a, T const b) {
+  using lim = std::numeric_limits<T>;
+  if (constexpr_isnan(a) || constexpr_isnan(b)) {
+    return constexpr_isnan(a) ? a : b;
+  }
+  if (std::is_floating_point<T>::value) {
+    constexpr auto inf = lim::infinity();
+    auto const ax = constexpr_abs(a);
+    auto const bx = constexpr_abs(b);
+    if ((ax == T(0) && bx == inf) || (bx == T(0) && ax == inf)) {
+      return lim::quiet_NaN();
+    }
+    // floating-point multiplication overflow, ie where multiplication of two
+    // finite values overflows to infinity of either sign, is not constexpr per
+    // gcc
+    // floating-point division overflow, ie where division of two finite values
+    // overflows to infinity of either sign, is not constexpr per gcc
+    // floating-point division by zero is not constexpr per any compiler, but we
+    // use it in the checks for the other two conditions
+    if (ax != inf && bx != inf && T(1) < bx && lim::max() / bx < ax) {
+      auto const a_neg = static_cast<bool>(a < T(0));
+      auto const b_neg = static_cast<bool>(b < T(0));
+      auto const sign = a_neg == b_neg ? T(1) : T(-1);
+      return sign * inf;
+    }
+  }
+  return a * b;
+}
+
+namespace detail {
+
+template <
+    typename T,
+    typename E,
+    std::enable_if_t<std::is_signed<E>::value, int> = 1>
+constexpr T constexpr_ipow(T const base, E const exp) {
+  if (std::is_floating_point<T>::value) {
+    if (exp < E(0)) {
+      return T(1) / constexpr_ipow(base, -exp);
+    }
+    if (exp == E(0)) {
+      return T(1);
+    }
+    if (constexpr_isnan(base)) {
+      return base;
+    }
+  }
+  assert(!(exp < E(0)) && "negative exponent with integral base");
+  if (exp == E(0)) {
+    return T(1);
+  }
+  if (exp == E(1)) {
+    return base;
+  }
+  auto const hexp = constexpr_trunc(exp / E(2));
+  auto const div = constexpr_ipow(base, hexp);
+  auto const rem = hexp * E(2) == exp ? T(1) : base;
+  return constexpr_mult(constexpr_mult(div, div), rem);
+}
+
+template <
+    typename T,
+    typename E,
+    std::enable_if_t<std::is_unsigned<E>::value, int> = 1>
+constexpr T constexpr_ipow(T const base, E const exp) {
+  if (std::is_floating_point<T>::value) {
+    if (exp == E(0)) {
+      return T(1);
+    }
+    if (constexpr_isnan(base)) {
+      return base;
+    }
+  }
+  if (exp == E(0)) {
+    return T(1);
+  }
+  if (exp == E(1)) {
+    return base;
+  }
+  auto const hexp = constexpr_trunc(exp / E(2));
+  auto const div = constexpr_ipow(base, hexp);
+  auto const rem = hexp * E(2) == exp ? T(1) : base;
+  return constexpr_mult(constexpr_mult(div, div), rem);
+}
+
+} // namespace detail
+
+/// constexpr_exp
+///
+/// Calculates an approximation of the mathematical function exp(num). Usable in
+/// constant evaluations. Like std::exp, which becomes constexpr in C++26.
+///
+/// The integer overload uses iterated squaring and multiplication. The
+/// floating-point overlaod naively evaluates the taylor series of exp(num)
+/// until approximate convergence.
+///
+/// mimic: std::exp (C++23, C++26)
+template <
+    typename T,
+    typename N,
+    std::enable_if_t<
+        std::is_floating_point<T>::value && std::is_integral<N>::value &&
+            !std::is_same<N, bool>::value,
+        int> = 0>
+constexpr T constexpr_exp(N const power) {
+  auto const npower = constexpr_abs(power);
+  auto const result = detail::constexpr_ipow(numbers::e_v<T>, npower);
+  return power < N(0) ? T(1) / result : result;
+}
+template <
+    typename N,
+    std::enable_if_t<
+        std::is_integral<N>::value && !std::is_same<N, bool>::value,
+        int> = 0>
+constexpr double constexpr_exp(N const power) {
+  return constexpr_exp<double>(power);
+}
+template <
+    typename T,
+    std::enable_if_t<std::is_floating_point<T>::value, int> = 0>
+constexpr T constexpr_exp(T const power) {
+  using lim = std::numeric_limits<T>;
+
+  // edge cases
+  if (constexpr_isnan(power)) {
+    return power;
+  }
+  if (power == -lim::infinity()) {
+    return +T(0);
+  }
+  if (power == +lim::infinity()) {
+    return power;
+  }
+
+  // convergence works better with positive powers since signs do not alternate
+  auto const abspower = constexpr_abs(power);
+  // convergence must short-circuit when terms grow to floating-point infinity
+  auto const bound = T(1) < abspower ? lim::max() / abspower : lim::infinity();
+
+  // term #index = power * coeff
+  auto index = size_t(0);
+  auto term = T(1);
+  // result = sum of terms
+  auto result = T(1);
+  // sum the terms until ~convergence
+  while (!(constexpr_abs(term) < lim::epsilon())) {
+    if (bound < term) {
+      return power < T(0) ? T(0) : lim::infinity();
+    }
+    index += 1;
+    term = term * abspower / index;
+    result += term;
+  }
+  return power < T(0) ? T(1) / result : result;
+}
+
+/// constexpr_log
+///
+/// Calculates an approximation of the natural logarithm ln(num).
+///
+/// The implementation uses a quickly-converging, high-precision iterative
+/// technique as described in:
+///   https://en.wikipedia.org/wiki/Natural_logarithm#High_precision
+///
+/// The technique works best with numbers that are close enough to 1, so the
+/// implementation uses a quick shrink/growth technique as described in:
+///   https://en.wikipedia.org/wiki/Natural_logarithm#Efficient_computation
+template <
+    typename T,
+    std::enable_if_t<std::is_floating_point<T>::value, int> = 0>
+constexpr T constexpr_log(T const num) {
+  using lim = std::numeric_limits<T>;
+  constexpr auto& isq = constexpr_iterated_squares_desc_2_v<T>;
+
+  // edge cases
+  if (constexpr_isnan(num)) {
+    return num;
+  }
+  if (num < T(0)) {
+    return lim::quiet_NaN();
+  }
+  if (num == T(0)) {
+    return -lim::infinity();
+  }
+  if (num == lim::infinity()) {
+    return num;
+  }
+
+  // compression
+  auto const shrink = isq.shrink(num, isq.base);
+  auto const growth = isq.growth(num, T(1));
+  auto const scaled = num * growth.scale / shrink.scale;
+  assert(scaled <= isq.base);
+  assert(scaled >= T(1));
+
+  auto sum = T(0);
+  auto delta = T(2);
+  while (constexpr_abs(delta) >= lim::epsilon()) {
+    auto expterm = constexpr_exp(sum);
+    delta = T(2) * (scaled - expterm) / (scaled + expterm);
+    sum += delta;
+  }
+  auto const ln2 = numbers::ln2_v<T>;
+  return sum - growth.power * ln2 + shrink.power * ln2;
+}
+
+/// constexpr_pow
+///
+/// Calculates an approximation of the value of base raised to the exponent exp.
+///
+/// The implementation uses iterated squaring and multiplication for the integer
+/// part of the exponent and uses the identity x^y = exp(y * log(x)) for the
+/// fractional part of the exponent.
+///
+/// Notes:
+/// * Forbids base of +0 or -0 with finite non-positive exponent: in part since
+///   the plausible infinite result would be sensitive to the sign of the zero;
+///   and in part since std::pow would be required or permitted to raise error
+///   div-by-zero.
+/// * Forbids finite negative base with finite non-integer exponent: in part
+///   since std::pow would be required to raise error invalid.
+///
+/// mimic: std::pow (C++26)
+template <
+    typename T,
+    typename E,
+    std::enable_if_t<
+        std::is_integral<E>::value && !std::is_same<E, bool>::value,
+        int> = 0>
+constexpr T constexpr_pow(T const base, E const exp) {
+  return detail::constexpr_ipow(base, exp);
+}
+template <
+    typename T,
+    std::enable_if_t<std::is_floating_point<T>::value, int> = 0>
+constexpr T constexpr_pow(T const base, T const exp) {
+  using lim = std::numeric_limits<T>;
+
+  // edge cases
+  if (exp == T(0)) {
+    return T(1);
+  }
+  if (constexpr_isnan(base)) {
+    return base;
+  }
+  if (exp == lim::infinity() || exp == -lim::infinity()) {
+    auto const abase = constexpr_abs(base);
+    if (abase < T(1)) {
+      return exp == lim::infinity() ? T(0) : lim::infinity();
+    }
+    if (T(1) < abase) {
+      return exp == lim::infinity() ? lim::infinity() : T(0);
+    }
+    return T(1);
+  }
+  if (base == T(1)) {
+    return base;
+  }
+  if (constexpr_isnan(exp)) {
+    return exp;
+  }
+  assert(base != T(0) || exp > T(0)); // error div-by-zero
+  if (base == lim::infinity()) {
+    return exp < T(0) ? T(0) : lim::infinity();
+  }
+  if (base == -lim::infinity()) {
+    auto const oddi = //
+        exp == constexpr_trunc(exp) &&
+        exp != constexpr_trunc(exp / T(2)) * T(2);
+    return (oddi ? -T(1) : T(1)) * (exp < T(0) ? T(0) : lim::infinity());
+  }
+  if (base == T(0)) {
+    auto const oddi = //
+        exp == constexpr_trunc(exp) &&
+        exp != constexpr_trunc(exp / T(2)) * T(2);
+    return oddi ? base : T(0);
+  }
+  if (exp < T(0)) {
+    return T(1) / constexpr_pow(base, -exp);
+  }
+
+  // as an identity: x^y = exp(y * log(x)); but calculation is imprecise ... so,
+  // for better precision, split the calculation into its integral-power and its
+  // fractional-power components
+  // as a cost, the complexity of constexpr_ipow here is logarithmic in y, i.e.,
+  // linear in the logarithm of y, which can be prohibitive
+  auto const exp_trunc = constexpr_trunc(exp);
+  assert(T(0) < base || exp == exp_trunc); // error invalid
+  auto const exp_fract = exp - exp_trunc;
+  auto const anyi = exp_fract == T(0);
+  return constexpr_mult(
+      detail::constexpr_ipow(base, exp_trunc),
+      anyi ? T(1) : constexpr_exp(exp_fract * constexpr_log(base)));
+}
+
+/// constexpr_find_last_set
+///
+/// Return the 1-based index of the most significant bit which is set.
+/// For x > 0, constexpr_find_last_set(x) == 1 + floor(log2(x)).
+template <typename T>
+constexpr std::size_t constexpr_find_last_set(T const t) {
+  using U = std::make_unsigned_t<T>;
+  return t == T(0) ? 0 : 1 + constexpr_log2(static_cast<U>(t));
+}
+
+namespace detail {
+template <typename U>
+constexpr std::size_t constexpr_find_first_set_(
+    std::size_t s, std::size_t a, U const u) {
+  return s == 0 ? a
+                : constexpr_find_first_set_(
+                      s / 2, a + s * bool((u >> a) % (U(1) << s) == U(0)), u);
+}
+} // namespace detail
+
+/// constexpr_find_first_set
+///
+/// Return the 1-based index of the least significant bit which is set.
+/// For x > 0, the exponent in the largest power of two which does not divide x.
+template <typename T>
+constexpr std::size_t constexpr_find_first_set(T t) {
+  using U = std::make_unsigned_t<T>;
+  using size = std::integral_constant<std::size_t, sizeof(T) * 4>;
+  return t == T(0)
+      ? 0
+      : 1 + detail::constexpr_find_first_set_(size{}, 0, static_cast<U>(t));
+}
+
+template <typename T>
+constexpr T constexpr_add_overflow_clamped(T a, T b) {
+  using L = std::numeric_limits<T>;
+  using M = std::intmax_t;
+  static_assert(
+      !std::is_integral<T>::value || sizeof(T) <= sizeof(M),
+      "Integral type too large!");
+  if (!folly::is_constant_evaluated_or(true)) {
+    if constexpr (std::is_integral_v<T>) {
+      T ret{};
+      if (FOLLY_UNLIKELY(!checked_add(&ret, a, b))) {
+        if constexpr (std::is_signed_v<T>) {
+          // Could be either overflow or underflow for signed types.
+          // Can only be underflow if both inputs are negative.
+          if (a < 0 && b < 0) {
+            return L::min();
+          }
+        }
+        return L::max();
+      }
+      return ret;
+    }
+  }
+  // clang-format off
+  return
+    // don't do anything special for non-integral types.
+    !std::is_integral<T>::value ? a + b :
+    // for narrow integral types, just convert to intmax_t.
+    sizeof(T) < sizeof(M)
+      ? T(constexpr_clamp(
+          static_cast<M>(a) + static_cast<M>(b),
+          static_cast<M>(L::min()),
+          static_cast<M>(L::max()))) :
+    // when a >= 0, cannot add more than `MAX - a` onto a.
+    !(a < 0) ? a + constexpr_min(b, T(L::max() - a)) :
+    // a < 0 && b >= 0, `a + b` will always be in valid range of type T.
+    !(b < 0) ? a + b :
+    // a < 0 && b < 0, keep the result >= MIN.
+              a + constexpr_max(b, T(L::min() - a));
+  // clang-format on
+}
+
+template <typename T>
+constexpr T constexpr_sub_overflow_clamped(T a, T b) {
+  using L = std::numeric_limits<T>;
+  using M = std::intmax_t;
+  static_assert(
+      !std::is_integral<T>::value || sizeof(T) <= sizeof(M),
+      "Integral type too large!");
+  // clang-format off
+  return
+    // don't do anything special for non-integral types.
+    !std::is_integral<T>::value ? a - b :
+    // for unsigned type, keep result >= 0.
+    std::is_unsigned<T>::value ? (a < b ? 0 : a - b) :
+    // for narrow signed integral types, just convert to intmax_t.
+    sizeof(T) < sizeof(M)
+      ? T(constexpr_clamp(
+          static_cast<M>(a) - static_cast<M>(b),
+          static_cast<M>(L::min()),
+          static_cast<M>(L::max()))) :
+    // (a >= 0 && b >= 0) || (a < 0 && b < 0), `a - b` will always be valid.
+    (a < 0) == (b < 0) ? a - b :
+    // MIN < b, so `-b` should be in valid range (-MAX <= -b <= MAX),
+    // convert subtraction to addition.
+    L::min() < b ? constexpr_add_overflow_clamped(a, T(-b)) :
+    // -b = -MIN = (MAX + 1) and a <= -1, result is in valid range.
+    a < 0 ? a - b :
+    // -b = -MIN = (MAX + 1) and a >= 0, result > MAX.
+            L::max();
+  // clang-format on
+}
+
+// clamp_cast<> provides sane numeric conversions from float point numbers to
+// integral numbers, and between different types of integral numbers. It helps
+// to avoid unexpected bugs introduced by bad conversion, and undefined behavior
+// like overflow when casting float point numbers to integral numbers.
+//
+// When doing clamp_cast<Dst>(value), if `value` is in valid range of Dst,
+// it will give correct result in Dst, equal to `value`.
+//
+// If `value` is outside the representable range of Dst, it will be clamped to
+// MAX or MIN in Dst, instead of being undefined behavior.
+//
+// Float NaNs are converted to 0 in integral type.
+//
+// Here's some comparison with static_cast<>:
+// (with FB-internal gcc-5-glibc-2.23 toolchain)
+//
+// static_cast<int32_t>(NaN) = 6
+// clamp_cast<int32_t>(NaN) = 0
+//
+// static_cast<int32_t>(9999999999.0f) = -348639895
+// clamp_cast<int32_t>(9999999999.0f) = 2147483647
+//
+// static_cast<int32_t>(2147483647.0f) = -348639895
+// clamp_cast<int32_t>(2147483647.0f) = 2147483647
+//
+// static_cast<uint32_t>(4294967295.0f) = 0
+// clamp_cast<uint32_t>(4294967295.0f) = 4294967295
+//
+// static_cast<uint32_t>(-1) = 4294967295
+// clamp_cast<uint32_t>(-1) = 0
+//
+// static_cast<int16_t>(32768u) = -32768
+// clamp_cast<int16_t>(32768u) = 32767
+
+template <typename Dst, typename Src>
+constexpr typename std::enable_if<std::is_integral<Src>::value, Dst>::type
+constexpr_clamp_cast(Src src) {
+  static_assert(
+      std::is_integral<Dst>::value && sizeof(Dst) <= sizeof(int64_t),
+      "constexpr_clamp_cast can only cast into integral type (up to 64bit)");
+
+  using L = std::numeric_limits<Dst>;
+  // clang-format off
+  return
+    // Check if Src and Dst have same signedness.
+    std::is_signed<Src>::value == std::is_signed<Dst>::value
+    ? (
+      // Src and Dst have same signedness. If sizeof(Src) <= sizeof(Dst),
+      // we can safely convert Src to Dst without any loss of accuracy.
+      sizeof(Src) <= sizeof(Dst) ? Dst(src) :
+      // If Src is larger in size, we need to clamp it to valid range in Dst.
+      Dst(constexpr_clamp(src, Src(L::min()), Src(L::max()))))
+    // Src and Dst have different signedness.
+    // Check if it's signed -> unsigend cast.
+    : std::is_signed<Src>::value && std::is_unsigned<Dst>::value
+    ? (
+      // If src < 0, the result should be 0.
+      src < 0 ? Dst(0) :
+      // Otherwise, src >= 0. If src can fit into Dst, we can safely cast it
+      // without loss of accuracy.
+      sizeof(Src) <= sizeof(Dst) ? Dst(src) :
+      // If Src is larger in size than Dst, we need to ensure the result is
+      // at most Dst MAX.
+      Dst(constexpr_min(src, Src(L::max()))))
+    // It's unsigned -> signed cast.
+    : (
+      // Since Src is unsigned, and Dst is signed, Src can fit into Dst only
+      // when sizeof(Src) < sizeof(Dst).
+      sizeof(Src) < sizeof(Dst) ? Dst(src) :
+      // If Src does not fit into Dst, we need to ensure the result is at most
+      // Dst MAX.
+      Dst(constexpr_min(src, Src(L::max()))));
+  // clang-format on
+}
+
+namespace detail {
+// Upper/lower bound values that could be accurately represented in both
+// integral and float point types.
+constexpr double kClampCastLowerBoundDoubleToInt64F = -9223372036854774784.0;
+constexpr double kClampCastUpperBoundDoubleToInt64F = 9223372036854774784.0;
+constexpr double kClampCastUpperBoundDoubleToUInt64F = 18446744073709549568.0;
+
+constexpr float kClampCastLowerBoundFloatToInt32F = -2147483520.0f;
+constexpr float kClampCastUpperBoundFloatToInt32F = 2147483520.0f;
+constexpr float kClampCastUpperBoundFloatToUInt32F = 4294967040.0f;
+
+// This works the same as constexpr_clamp, but the comparison are done in Src
+// to prevent any implicit promotions.
+template <typename D, typename S>
+constexpr D constexpr_clamp_cast_helper(S src, S sl, S su, D dl, D du) {
+  return src < sl ? dl : (src > su ? du : D(src));
+}
+} // namespace detail
+
+template <typename Dst, typename Src>
+constexpr typename std::enable_if<std::is_floating_point<Src>::value, Dst>::type
+constexpr_clamp_cast(Src src) {
+  static_assert(
+      std::is_integral<Dst>::value && sizeof(Dst) <= sizeof(int64_t),
+      "constexpr_clamp_cast can only cast into integral type (up to 64bit)");
+
+  using L = std::numeric_limits<Dst>;
+  // clang-format off
+  return
+    // Special case: cast NaN into 0.
+    constexpr_isnan(src) ? Dst(0) :
+    // using `sizeof(Src) > sizeof(Dst)` as a heuristic that Dst can be
+    // represented in Src without loss of accuracy.
+    // see: https://en.wikipedia.org/wiki/Floating-point_arithmetic
+    sizeof(Src) > sizeof(Dst) ?
+      detail::constexpr_clamp_cast_helper(
+          src, Src(L::min()), Src(L::max()), L::min(), L::max()) :
+    // sizeof(Src) < sizeof(Dst) only happens when doing cast of
+    // 32bit float -> u/int64_t.
+    // Losslessly promote float into double, change into double -> u/int64_t.
+    sizeof(Src) < sizeof(Dst) ? (
+      src >= 0.0
+      ? constexpr_clamp_cast<Dst>(
+            constexpr_clamp_cast<std::uint64_t>(double(src)))
+      : constexpr_clamp_cast<Dst>(
+            constexpr_clamp_cast<std::int64_t>(double(src)))) :
+    // The following are for sizeof(Src) == sizeof(Dst).
+    std::is_same<Src, double>::value && std::is_same<Dst, int64_t>::value ?
+      detail::constexpr_clamp_cast_helper(
+          double(src),
+          detail::kClampCastLowerBoundDoubleToInt64F,
+          detail::kClampCastUpperBoundDoubleToInt64F,
+          L::min(),
+          L::max()) :
+    std::is_same<Src, double>::value && std::is_same<Dst, uint64_t>::value ?
+      detail::constexpr_clamp_cast_helper(
+          double(src),
+          0.0,
+          detail::kClampCastUpperBoundDoubleToUInt64F,
+          L::min(),
+          L::max()) :
+    std::is_same<Src, float>::value && std::is_same<Dst, int32_t>::value ?
+      detail::constexpr_clamp_cast_helper(
+          float(src),
+          detail::kClampCastLowerBoundFloatToInt32F,
+          detail::kClampCastUpperBoundFloatToInt32F,
+          L::min(),
+          L::max()) :
+      detail::constexpr_clamp_cast_helper(
+          float(src),
+          0.0f,
+          detail::kClampCastUpperBoundFloatToUInt32F,
+          L::min(),
+          L::max());
+  // clang-format on
+}
+
+} // namespace folly
diff --git a/vnext/Folly/TEMP_UntilFollyUpdate/Conv.cpp b/vnext/Folly/TEMP_UntilFollyUpdate/Conv.cpp
index da5a205056c..d5f4b2cb50b 100644
--- a/vnext/Folly/TEMP_UntilFollyUpdate/Conv.cpp
+++ b/vnext/Folly/TEMP_UntilFollyUpdate/Conv.cpp
@@ -1,1205 +1,1205 @@
 /*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * 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 <folly/Conv.h>
-
- #include <array>
- #include <istream>
- 
- #include <folly/lang/SafeAssert.h>
- 
- #include <fast_float/fast_float.h> // @manual=fbsource//third-party/fast_float:fast_float
- 
- namespace folly {
- namespace detail {
- 
- namespace {
- 
- /**
-  * Finds the first non-digit in a string. The number of digits
-  * searched depends on the precision of the Tgt integral. Assumes the
-  * string starts with NO whitespace and NO sign.
-  *
-  * The semantics of the routine is:
-  *   for (;; ++b) {
-  *     if (b >= e || !isdigit(*b)) return b;
-  *   }
-  *
-  *  Complete unrolling marks bottom-line (i.e. entire conversion)
-  *  improvements of 20%.
-  */
- inline const char* findFirstNonDigit(const char* b, const char* e) {
-   for (; b < e; ++b) {
-     auto const c = static_cast<unsigned>(*b) - '0';
-     if (c >= 10) {
-       break;
-     }
-   }
-   return b;
- }
- 
- // Maximum value of number when represented as a string
- template <class T>
- struct MaxString {
-   static const char* const value;
- };
- 
- template <>
- const char* const MaxString<uint8_t>::value = "255";
- template <>
- const char* const MaxString<uint16_t>::value = "65535";
- template <>
- const char* const MaxString<uint32_t>::value = "4294967295";
- #if __SIZEOF_LONG__ == 4
- template <>
- const char* const MaxString<unsigned long>::value = "4294967295";
- #else
- template <>
- const char* const MaxString<unsigned long>::value = "18446744073709551615";
- #endif
- static_assert(
-     sizeof(unsigned long) >= 4,
-     "Wrong value for MaxString<unsigned long>::value,"
-     " please update.");
- template <>
- const char* const MaxString<unsigned long long>::value = "18446744073709551615";
- static_assert(
-     sizeof(unsigned long long) >= 8,
-     "Wrong value for MaxString<unsigned long long>::value"
-     ", please update.");
- 
- #if FOLLY_HAVE_INT128_T
- template <>
- const char* const MaxString<__uint128_t>::value =
-     "340282366920938463463374607431768211455";
- #endif
- 
- /*
-  * Lookup tables that converts from a decimal character value to an integral
-  * binary value, shifted by a decimal "shift" multiplier.
-  * For all character values in the range '0'..'9', the table at those
-  * index locations returns the actual decimal value shifted by the multiplier.
-  * For all other values, the lookup table returns an invalid OOR value.
-  */
- // Out-of-range flag value, larger than the largest value that can fit in
- // four decimal bytes (9999), but four of these added up together should
- // still not overflow uint16_t.
- constexpr int32_t OOR = 10000;
- 
- alignas(16) constexpr uint16_t shift1[] = {
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 0-9
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  10
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  20
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  30
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, 0,   1, //  40
-     2,   3,   4,   5,   6,   7,   8,   9,   OOR, OOR,
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  60
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  70
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  80
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  90
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 100
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 110
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 120
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 130
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 140
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 150
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 160
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 170
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 180
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 190
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 200
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 210
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 220
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 230
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 240
-     OOR, OOR, OOR, OOR, OOR, OOR // 250
- };
- 
- alignas(16) constexpr uint16_t shift10[] = {
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 0-9
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  10
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  20
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  30
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, 0,   10, //  40
-     20,  30,  40,  50,  60,  70,  80,  90,  OOR, OOR,
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  60
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  70
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  80
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  90
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 100
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 110
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 120
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 130
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 140
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 150
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 160
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 170
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 180
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 190
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 200
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 210
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 220
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 230
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 240
-     OOR, OOR, OOR, OOR, OOR, OOR // 250
- };
- 
- alignas(16) constexpr uint16_t shift100[] = {
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 0-9
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  10
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  20
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  30
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, 0,   100, //  40
-     200, 300, 400, 500, 600, 700, 800, 900, OOR, OOR,
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  60
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  70
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  80
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  90
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 100
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 110
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 120
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 130
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 140
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 150
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 160
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 170
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 180
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 190
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 200
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 210
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 220
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 230
-     OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 240
-     OOR, OOR, OOR, OOR, OOR, OOR // 250
- };
- 
- alignas(16) constexpr uint16_t shift1000[] = {
-     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 0-9
-     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, //  10
-     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, //  20
-     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, //  30
-     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  0,   1000, //  40
-     2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, OOR, OOR,
-     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, //  60
-     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, //  70
-     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, //  80
-     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, //  90
-     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 100
-     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 110
-     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 120
-     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 130
-     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 140
-     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 150
-     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 160
-     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 170
-     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 180
-     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 190
-     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 200
-     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 210
-     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 220
-     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 230
-     OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 240
-     OOR,  OOR,  OOR,  OOR,  OOR,  OOR // 250
- };
- 
- struct ErrorString {
-   const char* string;
-   bool quote;
- };
- 
- // Keep this in sync with ConversionCode in Conv.h
- constexpr const std::array<
-     ErrorString,
-     static_cast<std::size_t>(ConversionCode::NUM_ERROR_CODES)>
-     kErrorStrings{{
-         {"Success", true},
-         {"Empty input string", true},
-         {"No digits found in input string", true},
-         {"Integer overflow when parsing bool (must be 0 or 1)", true},
-         {"Invalid value for bool", true},
-         {"Non-digit character found", true},
-         {"Invalid leading character", true},
-         {"Overflow during conversion", true},
-         {"Negative overflow during conversion", true},
-         {"Unable to convert string to floating point value", true},
-         {"Non-whitespace character found after end of conversion", true},
-         {"Overflow during arithmetic conversion", false},
-         {"Negative overflow during arithmetic conversion", false},
-         {"Loss of precision during arithmetic conversion", false},
-     }};
- 
- // Check if ASCII is really ASCII
- using IsAscii =
-     std::bool_constant<'A' == 65 && 'Z' == 90 && 'a' == 97 && 'z' == 122>;
- 
- // The code in this file that uses tolower() really only cares about
- // 7-bit ASCII characters, so we can take a nice shortcut here.
- inline char tolower_ascii(char in) {
-   return IsAscii::value ? in | 0x20 : char(std::tolower(in));
- }
- 
- inline bool bool_str_cmp(const char** b, size_t len, const char* value) {
-   // Can't use strncasecmp, since we want to ensure that the full value matches
-   const char* p = *b;
-   const char* e = *b + len;
-   const char* v = value;
-   while (*v != '\0') {
-     if (p == e || tolower_ascii(*p) != *v) { // value is already lowercase
-       return false;
-     }
-     ++p;
-     ++v;
-   }
- 
-   *b = p;
-   return true;
- }
- 
- } // namespace
- 
- Expected<bool, ConversionCode> str_to_bool(StringPiece* src) noexcept {
-   auto b = src->begin(), e = src->end();
-   for (;; ++b) {
-     if (b >= e) {
-       return makeUnexpected(ConversionCode::EMPTY_INPUT_STRING);
-     }
-     if ((*b < '\t' || *b > '\r') && *b != ' ') {
-       break;
-     }
-   }
- 
-   bool result;
-   auto len = size_t(e - b);
-   switch (*b) {
-     case '0':
-     case '1': {
-       result = false;
-       for (; b < e && isdigit(*b); ++b) {
-         if (result || (*b != '0' && *b != '1')) {
-           return makeUnexpected(ConversionCode::BOOL_OVERFLOW);
-         }
-         result = (*b == '1');
-       }
-       break;
-     }
-     case 'y':
-     case 'Y':
-       result = true;
-       if (!bool_str_cmp(&b, len, "yes")) {
-         ++b; // accept the single 'y' character
-       }
-       break;
-     case 'n':
-     case 'N':
-       result = false;
-       if (!bool_str_cmp(&b, len, "no")) {
-         ++b;
-       }
-       break;
-     case 't':
-     case 'T':
-       result = true;
-       if (!bool_str_cmp(&b, len, "true")) {
-         ++b;
-       }
-       break;
-     case 'f':
-     case 'F':
-       result = false;
-       if (!bool_str_cmp(&b, len, "false")) {
-         ++b;
-       }
-       break;
-     case 'o':
-     case 'O':
-       if (bool_str_cmp(&b, len, "on")) {
-         result = true;
-       } else if (bool_str_cmp(&b, len, "off")) {
-         result = false;
-       } else {
-         return makeUnexpected(ConversionCode::BOOL_INVALID_VALUE);
-       }
-       break;
-     default:
-       return makeUnexpected(ConversionCode::BOOL_INVALID_VALUE);
-   }
- 
-   src->assign(b, e);
- 
-   return result;
- }
- 
- /// Uses `double_conversion` library to convert from string to a floating
- /// point.
- template <class Tgt>
- Expected<Tgt, ConversionCode> str_to_floating_double_conversion(
-     StringPiece* src) noexcept {
-   using namespace double_conversion;
-   static StringToDoubleConverter conv(
-       StringToDoubleConverter::ALLOW_TRAILING_JUNK |
-           StringToDoubleConverter::ALLOW_LEADING_SPACES,
-       0.0,
-       // return this for junk input string
-       std::numeric_limits<Tgt>::quiet_NaN(),
-       nullptr,
-       nullptr);
- 
-   if (src->empty()) {
-     return makeUnexpected(ConversionCode::EMPTY_INPUT_STRING);
-   }
- 
-   int length; // processed char count
-   auto result = std::is_same<Tgt, float>::value
-       ? conv.StringToFloat(src->data(), static_cast<int>(src->size()), &length)
-       : static_cast<Tgt>(conv.StringToDouble(
-             src->data(), static_cast<int>(src->size()), &length));
- 
-   if (!std::isnan(result)) {
-     // If we get here with length = 0, the input string is empty.
-     // If we get here with result = 0.0, it's either because the string
-     // contained only whitespace, or because we had an actual zero value
-     // (with potential trailing junk). If it was only whitespace, we
-     // want to raise an error; length will point past the last character
-     // that was processed, so we need to check if that character was
-     // whitespace or not.
-     if (length == 0 ||
-         (result == 0.0 && std::isspace((*src)[size_t(length) - 1]))) {
-       return makeUnexpected(ConversionCode::EMPTY_INPUT_STRING);
-     }
-     if (length >= 2) {
-       const char* suffix = src->data() + length - 1;
-       // double_conversion doesn't update length correctly when there is an
-       // incomplete exponent specifier. Converting "12e-f-g" shouldn't consume
-       // any more than "12", but it will consume "12e-".
- 
-       // "123-" should only parse "123"
-       if (*suffix == '-' || *suffix == '+') {
-         --suffix;
-         --length;
-       }
-       // "12e-f-g" or "12euro" should only parse "12"
-       if (*suffix == 'e' || *suffix == 'E') {
-         --length;
-       }
-     }
-     src->advance(size_t(length));
-     return Tgt(result);
-   }
- 
-   auto* e = src->end();
-   auto* b = std::find_if_not(src->begin(), e, [](char c) {
-     return (c >= '\t' && c <= '\r') || c == ' ';
-   });
-   if (b == e) {
-     return makeUnexpected(ConversionCode::EMPTY_INPUT_STRING);
-   }
-   auto size = size_t(e - b);
- 
-   bool negative = false;
-   if (*b == '-') {
-     negative = true;
-     ++b;
-     --size;
-     if (size == 0) {
-       return makeUnexpected(ConversionCode::STRING_TO_FLOAT_ERROR);
-     }
-   }
-   assert(size > 0);
- 
-   result = 0.0;
- 
-   switch (tolower_ascii(*b)) {
-     case 'i':
-       if (size >= 3 && tolower_ascii(b[1]) == 'n' &&
-           tolower_ascii(b[2]) == 'f') {
-         if (size >= 8 && tolower_ascii(b[3]) == 'i' &&
-             tolower_ascii(b[4]) == 'n' && tolower_ascii(b[5]) == 'i' &&
-             tolower_ascii(b[6]) == 't' && tolower_ascii(b[7]) == 'y') {
-           b += 8;
-         } else {
-           b += 3;
-         }
-         result = std::numeric_limits<Tgt>::infinity();
-       }
-       break;
- 
-     case 'n':
-       if (size >= 3 && tolower_ascii(b[1]) == 'a' &&
-           tolower_ascii(b[2]) == 'n') {
-         b += 3;
-         result = std::numeric_limits<Tgt>::quiet_NaN();
-       }
-       break;
- 
-     default:
-       break;
-   }
- 
-   if (result == 0.0) {
-     // All bets are off
-     return makeUnexpected(ConversionCode::STRING_TO_FLOAT_ERROR);
-   }
- 
-   if (negative) {
-     result = -result;
-   }
- 
-   src->assign(b, e);
- 
-   return Tgt(result);
- }
- 
- /// Uses `fast_float::from_chars` to convert from string to an integer.
- template <class Tgt>
- Expected<Tgt, ConversionCode> str_to_floating_fast_float_from_chars(
-     StringPiece* src) noexcept {
-   if (src->empty()) {
-     return makeUnexpected(ConversionCode::EMPTY_INPUT_STRING);
-   }
- 
-   // move through leading whitespace characters
-   auto* e = src->end();
-   auto* b = std::find_if_not(src->begin(), e, [](char c) {
-     return (c >= '\t' && c <= '\r') || c == ' ';
-   });
-   if (b == e) {
-     return makeUnexpected(ConversionCode::EMPTY_INPUT_STRING);
-   }
- 
-   Tgt result;
-   auto [ptr, ec] = fast_float::from_chars(b, e, result);
-   bool isOutOfRange{ec == std::errc::result_out_of_range};
-   bool isOk{ec == std::errc()};
-   if (!isOk && !isOutOfRange) {
-     return makeUnexpected(ConversionCode::STRING_TO_FLOAT_ERROR);
-   }
- 
-   auto numMatchedChars = ptr - src->data();
-   src->advance(numMatchedChars);
- 
-   if (isOutOfRange) {
-     if (*b == '-') {
-       return -std::numeric_limits<Tgt>::infinity();
-     } else {
-       return std::numeric_limits<Tgt>::infinity();
-     }
-   }
- 
-   return result;
- }
- 
- template Expected<float, ConversionCode>
- str_to_floating_fast_float_from_chars<float>(StringPiece* src) noexcept;
- template Expected<double, ConversionCode>
- str_to_floating_fast_float_from_chars<double>(StringPiece* src) noexcept;
- 
- /**
-  * StringPiece to double, with progress information. Alters the
-  * StringPiece parameter to munch the already-parsed characters.
-  */
- template <class Tgt>
- Expected<Tgt, ConversionCode> str_to_floating(StringPiece* src) noexcept {
- #if defined(FOLLY_CONV_ATOD_MODE) && FOLLY_CONV_ATOD_MODE == 1
-   return detail::str_to_floating_fast_float_from_chars<Tgt>(src);
- #else
-   return detail::str_to_floating_double_conversion<Tgt>(src);
- #endif
- }
- 
- template Expected<float, ConversionCode> str_to_floating<float>(
-     StringPiece* src) noexcept;
- template Expected<double, ConversionCode> str_to_floating<double>(
-     StringPiece* src) noexcept;
- 
- namespace {
- 
- /**
-  * This class takes care of additional processing needed for signed values,
-  * like leading sign character and overflow checks.
-  */
- template <typename T, bool IsSigned = is_signed_v<T>>
- class SignedValueHandler;
- 
- template <typename T>
- class SignedValueHandler<T, true> {
-  public:
-   ConversionCode init(const char*& b) {
-     negative_ = false;
-     if (!std::isdigit(*b)) {
-       if (*b == '-') {
-         negative_ = true;
-       } else if (FOLLY_UNLIKELY(*b != '+')) {
-         return ConversionCode::INVALID_LEADING_CHAR;
-       }
-       ++b;
-     }
-     return ConversionCode::SUCCESS;
-   }
- 
-   ConversionCode overflow() {
-     return negative_ ? ConversionCode::NEGATIVE_OVERFLOW
-                      : ConversionCode::POSITIVE_OVERFLOW;
-   }
- 
-   template <typename U>
-   Expected<T, ConversionCode> finalize(U value) {
-     T rv;
-     if (negative_) {
-       FOLLY_PUSH_WARNING
-       FOLLY_MSVC_DISABLE_WARNING(4146)
- 
-       // unary minus operator applied to unsigned type, result still unsigned
-       rv = T(-value);
- 
-       FOLLY_POP_WARNING
- 
-       if (FOLLY_UNLIKELY(rv > 0)) {
-         return makeUnexpected(ConversionCode::NEGATIVE_OVERFLOW);
-       }
-     } else {
-       rv = T(value);
-       if (FOLLY_UNLIKELY(rv < 0)) {
-         return makeUnexpected(ConversionCode::POSITIVE_OVERFLOW);
-       }
-     }
-     return rv;
-   }
- 
-  private:
-   bool negative_;
- };
- 
- // For unsigned types, we don't need any extra processing
- template <typename T>
- class SignedValueHandler<T, false> {
-  public:
-   ConversionCode init(const char*&) { return ConversionCode::SUCCESS; }
- 
-   ConversionCode overflow() { return ConversionCode::POSITIVE_OVERFLOW; }
- 
-   Expected<T, ConversionCode> finalize(T value) { return value; }
- };
- 
- } // namespace
- 
- /**
-  * String represented as a pair of pointers to char to signed/unsigned
-  * integrals. Assumes NO whitespace before or after, and also that the
-  * string is composed entirely of digits (and an optional sign only for
-  * signed types). String may be empty, in which case digits_to returns
-  * an appropriate error.
-  */
- template <class Tgt>
- inline Expected<Tgt, ConversionCode> digits_to(
-     const char* b, const char* const e) noexcept {
-   using UT = make_unsigned_t<Tgt>;
-   assert(b <= e);
- 
-   SignedValueHandler<Tgt> sgn;
- 
-   auto err = sgn.init(b);
-   if (FOLLY_UNLIKELY(err != ConversionCode::SUCCESS)) {
-     return makeUnexpected(err);
-   }
- 
-   auto size = size_t(e - b);
- 
-   /* Although the string is entirely made of digits, we still need to
-    * check for overflow.
-    */
-   if (size > std::numeric_limits<UT>::digits10) {
-     // Leading zeros?
-     if (b < e && *b == '0') {
-       for (++b;; ++b) {
-         if (b == e) {
-           return Tgt(0); // just zeros, e.g. "0000"
-         }
-         if (*b != '0') {
-           size = size_t(e - b);
-           break;
-         }
-       }
-     }
-     if (size > std::numeric_limits<UT>::digits10 &&
-         (size != std::numeric_limits<UT>::digits10 + 1 ||
-          strncmp(b, MaxString<UT>::value, size) > 0)) {
-       return makeUnexpected(sgn.overflow());
-     }
-   }
- 
-   // Here we know that the number won't overflow when
-   // converted. Proceed without checks.
- 
-   UT result = 0;
- 
-   for (; e - b >= 4; b += 4) {
-     result *= UT(10000);
-     const int32_t r0 = shift1000[static_cast<size_t>(b[0])];
-     const int32_t r1 = shift100[static_cast<size_t>(b[1])];
-     const int32_t r2 = shift10[static_cast<size_t>(b[2])];
-     const int32_t r3 = shift1[static_cast<size_t>(b[3])];
-     const auto sum = r0 + r1 + r2 + r3;
-     if (sum >= OOR) {
-       goto outOfRange;
-     }
-     result += UT(sum);
-   }
- 
-   switch (e - b) {
-     case 3: {
-       const int32_t r0 = shift100[static_cast<size_t>(b[0])];
-       const int32_t r1 = shift10[static_cast<size_t>(b[1])];
-       const int32_t r2 = shift1[static_cast<size_t>(b[2])];
-       const auto sum = r0 + r1 + r2;
-       if (sum >= OOR) {
-         goto outOfRange;
-       }
-       result = UT(1000 * result + sum);
-       break;
-     }
-     case 2: {
-       const int32_t r0 = shift10[static_cast<size_t>(b[0])];
-       const int32_t r1 = shift1[static_cast<size_t>(b[1])];
-       const auto sum = r0 + r1;
-       if (sum >= OOR) {
-         goto outOfRange;
-       }
-       result = UT(100 * result + sum);
-       break;
-     }
-     case 1: {
-       const int32_t sum = shift1[static_cast<size_t>(b[0])];
-       if (sum >= OOR) {
-         goto outOfRange;
-       }
-       result = UT(10 * result + sum);
-       break;
-     }
-     default:
-       assert(b == e);
-       if (size == 0) {
-         return makeUnexpected(ConversionCode::NO_DIGITS);
-       }
-       break;
-   }
- 
-   return sgn.finalize(result);
- 
- outOfRange:
-   return makeUnexpected(ConversionCode::NON_DIGIT_CHAR);
- }
- 
- template Expected<char, ConversionCode> digits_to<char>(
-     const char*, const char*) noexcept;
- template Expected<signed char, ConversionCode> digits_to<signed char>(
-     const char*, const char*) noexcept;
- template Expected<unsigned char, ConversionCode> digits_to<unsigned char>(
-     const char*, const char*) noexcept;
- 
- template Expected<short, ConversionCode> digits_to<short>(
-     const char*, const char*) noexcept;
- template Expected<unsigned short, ConversionCode> digits_to<unsigned short>(
-     const char*, const char*) noexcept;
- 
- template Expected<int, ConversionCode> digits_to<int>(
-     const char*, const char*) noexcept;
- template Expected<unsigned int, ConversionCode> digits_to<unsigned int>(
-     const char*, const char*) noexcept;
- 
- template Expected<long, ConversionCode> digits_to<long>(
-     const char*, const char*) noexcept;
- template Expected<unsigned long, ConversionCode> digits_to<unsigned long>(
-     const char*, const char*) noexcept;
- 
- template Expected<long long, ConversionCode> digits_to<long long>(
-     const char*, const char*) noexcept;
- template Expected<unsigned long long, ConversionCode>
- digits_to<unsigned long long>(const char*, const char*) noexcept;
- 
- #if FOLLY_HAVE_INT128_T
- template Expected<__int128, ConversionCode> digits_to<__int128>(
-     const char*, const char*) noexcept;
- template Expected<unsigned __int128, ConversionCode>
- digits_to<unsigned __int128>(const char*, const char*) noexcept;
- #endif
- 
- /**
-  * StringPiece to integrals, with progress information. Alters the
-  * StringPiece parameter to munch the already-parsed characters.
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* 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 <folly/Conv.h>
+
+#include <array>
+#include <istream>
+
+#include <folly/lang/SafeAssert.h>
+
+#include <fast_float/fast_float.h> // @manual=fbsource//third-party/fast_float:fast_float
+
+namespace folly {
+namespace detail {
+
+namespace {
+
+/**
+* Finds the first non-digit in a string. The number of digits
+* searched depends on the precision of the Tgt integral. Assumes the
+* string starts with NO whitespace and NO sign.
+*
+* The semantics of the routine is:
+*   for (;; ++b) {
+*     if (b >= e || !isdigit(*b)) return b;
+*   }
+*
+*  Complete unrolling marks bottom-line (i.e. entire conversion)
+*  improvements of 20%.
+*/
+inline const char* findFirstNonDigit(const char* b, const char* e) {
+  for (; b < e; ++b) {
+    auto const c = static_cast<unsigned>(*b) - '0';
+    if (c >= 10) {
+      break;
+    }
+  }
+  return b;
+}
+
+// Maximum value of number when represented as a string
+template <class T>
+struct MaxString {
+  static const char* const value;
+};
+
+template <>
+const char* const MaxString<uint8_t>::value = "255";
+template <>
+const char* const MaxString<uint16_t>::value = "65535";
+template <>
+const char* const MaxString<uint32_t>::value = "4294967295";
+#if __SIZEOF_LONG__ == 4
+template <>
+const char* const MaxString<unsigned long>::value = "4294967295";
+#else
+template <>
+const char* const MaxString<unsigned long>::value = "18446744073709551615";
+#endif
+static_assert(
+    sizeof(unsigned long) >= 4,
+    "Wrong value for MaxString<unsigned long>::value,"
+    " please update.");
+template <>
+const char* const MaxString<unsigned long long>::value = "18446744073709551615";
+static_assert(
+    sizeof(unsigned long long) >= 8,
+    "Wrong value for MaxString<unsigned long long>::value"
+    ", please update.");
+
+#if FOLLY_HAVE_INT128_T
+template <>
+const char* const MaxString<__uint128_t>::value =
+    "340282366920938463463374607431768211455";
+#endif
+
+/*
+* Lookup tables that converts from a decimal character value to an integral
+* binary value, shifted by a decimal "shift" multiplier.
+* For all character values in the range '0'..'9', the table at those
+* index locations returns the actual decimal value shifted by the multiplier.
+* For all other values, the lookup table returns an invalid OOR value.
+*/
+// Out-of-range flag value, larger than the largest value that can fit in
+// four decimal bytes (9999), but four of these added up together should
+// still not overflow uint16_t.
+constexpr int32_t OOR = 10000;
+
+alignas(16) constexpr uint16_t shift1[] = {
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 0-9
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  10
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  20
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  30
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, 0,   1, //  40
+    2,   3,   4,   5,   6,   7,   8,   9,   OOR, OOR,
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  60
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  70
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  80
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  90
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 100
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 110
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 120
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 130
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 140
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 150
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 160
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 170
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 180
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 190
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 200
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 210
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 220
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 230
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 240
+    OOR, OOR, OOR, OOR, OOR, OOR // 250
+};
+
+alignas(16) constexpr uint16_t shift10[] = {
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 0-9
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  10
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  20
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  30
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, 0,   10, //  40
+    20,  30,  40,  50,  60,  70,  80,  90,  OOR, OOR,
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  60
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  70
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  80
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  90
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 100
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 110
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 120
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 130
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 140
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 150
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 160
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 170
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 180
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 190
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 200
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 210
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 220
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 230
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 240
+    OOR, OOR, OOR, OOR, OOR, OOR // 250
+};
+
+alignas(16) constexpr uint16_t shift100[] = {
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 0-9
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  10
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  20
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  30
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, 0,   100, //  40
+    200, 300, 400, 500, 600, 700, 800, 900, OOR, OOR,
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  60
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  70
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  80
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, //  90
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 100
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 110
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 120
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 130
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 140
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 150
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 160
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 170
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 180
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 190
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 200
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 210
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 220
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 230
+    OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, OOR, // 240
+    OOR, OOR, OOR, OOR, OOR, OOR // 250
+};
+
+alignas(16) constexpr uint16_t shift1000[] = {
+    OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 0-9
+    OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, //  10
+    OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, //  20
+    OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, //  30
+    OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  0,   1000, //  40
+    2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, OOR, OOR,
+    OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, //  60
+    OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, //  70
+    OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, //  80
+    OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, //  90
+    OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 100
+    OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 110
+    OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 120
+    OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 130
+    OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 140
+    OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 150
+    OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 160
+    OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 170
+    OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 180
+    OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 190
+    OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 200
+    OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 210
+    OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 220
+    OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 230
+    OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR,  OOR, OOR, // 240
+    OOR,  OOR,  OOR,  OOR,  OOR,  OOR // 250
+};
+
+struct ErrorString {
+  const char* string;
+  bool quote;
+};
+
+// Keep this in sync with ConversionCode in Conv.h
+constexpr const std::array<
+    ErrorString,
+    static_cast<std::size_t>(ConversionCode::NUM_ERROR_CODES)>
+    kErrorStrings{{
+        {"Success", true},
+        {"Empty input string", true},
+        {"No digits found in input string", true},
+        {"Integer overflow when parsing bool (must be 0 or 1)", true},
+        {"Invalid value for bool", true},
+        {"Non-digit character found", true},
+        {"Invalid leading character", true},
+        {"Overflow during conversion", true},
+        {"Negative overflow during conversion", true},
+        {"Unable to convert string to floating point value", true},
+        {"Non-whitespace character found after end of conversion", true},
+        {"Overflow during arithmetic conversion", false},
+        {"Negative overflow during arithmetic conversion", false},
+        {"Loss of precision during arithmetic conversion", false},
+    }};
+
+// Check if ASCII is really ASCII
+using IsAscii =
+    std::bool_constant<'A' == 65 && 'Z' == 90 && 'a' == 97 && 'z' == 122>;
+
+// The code in this file that uses tolower() really only cares about
+// 7-bit ASCII characters, so we can take a nice shortcut here.
+inline char tolower_ascii(char in) {
+  return IsAscii::value ? in | 0x20 : char(std::tolower(in));
+}
+
+inline bool bool_str_cmp(const char** b, size_t len, const char* value) {
+  // Can't use strncasecmp, since we want to ensure that the full value matches
+  const char* p = *b;
+  const char* e = *b + len;
+  const char* v = value;
+  while (*v != '\0') {
+    if (p == e || tolower_ascii(*p) != *v) { // value is already lowercase
+      return false;
+    }
+    ++p;
+    ++v;
+  }
+
+  *b = p;
+  return true;
+}
+
+} // namespace
+
+Expected<bool, ConversionCode> str_to_bool(StringPiece* src) noexcept {
+  auto b = src->begin(), e = src->end();
+  for (;; ++b) {
+    if (b >= e) {
+      return makeUnexpected(ConversionCode::EMPTY_INPUT_STRING);
+    }
+    if ((*b < '\t' || *b > '\r') && *b != ' ') {
+      break;
+    }
+  }
+
+  bool result;
+  auto len = size_t(e - b);
+  switch (*b) {
+    case '0':
+    case '1': {
+      result = false;
+      for (; b < e && isdigit(*b); ++b) {
+        if (result || (*b != '0' && *b != '1')) {
+          return makeUnexpected(ConversionCode::BOOL_OVERFLOW);
+        }
+        result = (*b == '1');
+      }
+      break;
+    }
+    case 'y':
+    case 'Y':
+      result = true;
+      if (!bool_str_cmp(&b, len, "yes")) {
+        ++b; // accept the single 'y' character
+      }
+      break;
+    case 'n':
+    case 'N':
+      result = false;
+      if (!bool_str_cmp(&b, len, "no")) {
+        ++b;
+      }
+      break;
+    case 't':
+    case 'T':
+      result = true;
+      if (!bool_str_cmp(&b, len, "true")) {
+        ++b;
+      }
+      break;
+    case 'f':
+    case 'F':
+      result = false;
+      if (!bool_str_cmp(&b, len, "false")) {
+        ++b;
+      }
+      break;
+    case 'o':
+    case 'O':
+      if (bool_str_cmp(&b, len, "on")) {
+        result = true;
+      } else if (bool_str_cmp(&b, len, "off")) {
+        result = false;
+      } else {
+        return makeUnexpected(ConversionCode::BOOL_INVALID_VALUE);
+      }
+      break;
+    default:
+      return makeUnexpected(ConversionCode::BOOL_INVALID_VALUE);
+  }
+
+  src->assign(b, e);
+
+  return result;
+}
+
+/// Uses `double_conversion` library to convert from string to a floating
+/// point.
+template <class Tgt>
+Expected<Tgt, ConversionCode> str_to_floating_double_conversion(
+    StringPiece* src) noexcept {
+  using namespace double_conversion;
+  static StringToDoubleConverter conv(
+      StringToDoubleConverter::ALLOW_TRAILING_JUNK |
+          StringToDoubleConverter::ALLOW_LEADING_SPACES,
+      0.0,
+      // return this for junk input string
+      std::numeric_limits<Tgt>::quiet_NaN(),
+      nullptr,
+      nullptr);
+
+  if (src->empty()) {
+    return makeUnexpected(ConversionCode::EMPTY_INPUT_STRING);
+  }
+
+  int length; // processed char count
+  auto result = std::is_same<Tgt, float>::value
+      ? conv.StringToFloat(src->data(), static_cast<int>(src->size()), &length)
+      : static_cast<Tgt>(conv.StringToDouble(
+            src->data(), static_cast<int>(src->size()), &length));
+
+  if (!std::isnan(result)) {
+    // If we get here with length = 0, the input string is empty.
+    // If we get here with result = 0.0, it's either because the string
+    // contained only whitespace, or because we had an actual zero value
+    // (with potential trailing junk). If it was only whitespace, we
+    // want to raise an error; length will point past the last character
+    // that was processed, so we need to check if that character was
+    // whitespace or not.
+    if (length == 0 ||
+        (result == 0.0 && std::isspace((*src)[size_t(length) - 1]))) {
+      return makeUnexpected(ConversionCode::EMPTY_INPUT_STRING);
+    }
+    if (length >= 2) {
+      const char* suffix = src->data() + length - 1;
+      // double_conversion doesn't update length correctly when there is an
+      // incomplete exponent specifier. Converting "12e-f-g" shouldn't consume
+      // any more than "12", but it will consume "12e-".
+
+      // "123-" should only parse "123"
+      if (*suffix == '-' || *suffix == '+') {
+        --suffix;
+        --length;
+      }
+      // "12e-f-g" or "12euro" should only parse "12"
+      if (*suffix == 'e' || *suffix == 'E') {
+        --length;
+      }
+    }
+    src->advance(size_t(length));
+    return Tgt(result);
+  }
+
+  auto* e = src->end();
+  auto* b = std::find_if_not(src->begin(), e, [](char c) {
+    return (c >= '\t' && c <= '\r') || c == ' ';
+  });
+  if (b == e) {
+    return makeUnexpected(ConversionCode::EMPTY_INPUT_STRING);
+  }
+  auto size = size_t(e - b);
+
+  bool negative = false;
+  if (*b == '-') {
+    negative = true;
+    ++b;
+    --size;
+    if (size == 0) {
+      return makeUnexpected(ConversionCode::STRING_TO_FLOAT_ERROR);
+    }
+  }
+  assert(size > 0);
+
+  result = 0.0;
+
+  switch (tolower_ascii(*b)) {
+    case 'i':
+      if (size >= 3 && tolower_ascii(b[1]) == 'n' &&
+          tolower_ascii(b[2]) == 'f') {
+        if (size >= 8 && tolower_ascii(b[3]) == 'i' &&
+            tolower_ascii(b[4]) == 'n' && tolower_ascii(b[5]) == 'i' &&
+            tolower_ascii(b[6]) == 't' && tolower_ascii(b[7]) == 'y') {
+          b += 8;
+        } else {
+          b += 3;
+        }
+        result = std::numeric_limits<Tgt>::infinity();
+      }
+      break;
+
+    case 'n':
+      if (size >= 3 && tolower_ascii(b[1]) == 'a' &&
+          tolower_ascii(b[2]) == 'n') {
+        b += 3;
+        result = std::numeric_limits<Tgt>::quiet_NaN();
+      }
+      break;
+
+    default:
+      break;
+  }
+
+  if (result == 0.0) {
+    // All bets are off
+    return makeUnexpected(ConversionCode::STRING_TO_FLOAT_ERROR);
+  }
+
+  if (negative) {
+    result = -result;
+  }
+
+  src->assign(b, e);
+
+  return Tgt(result);
+}
+
+/// Uses `fast_float::from_chars` to convert from string to an integer.
+template <class Tgt>
+Expected<Tgt, ConversionCode> str_to_floating_fast_float_from_chars(
+    StringPiece* src) noexcept {
+  if (src->empty()) {
+    return makeUnexpected(ConversionCode::EMPTY_INPUT_STRING);
+  }
+
+  // move through leading whitespace characters
+  auto* e = src->end();
+  auto* b = std::find_if_not(src->begin(), e, [](char c) {
+    return (c >= '\t' && c <= '\r') || c == ' ';
+  });
+  if (b == e) {
+    return makeUnexpected(ConversionCode::EMPTY_INPUT_STRING);
+  }
+
+  Tgt result;
+  auto [ptr, ec] = fast_float::from_chars(b, e, result);
+  bool isOutOfRange{ec == std::errc::result_out_of_range};
+  bool isOk{ec == std::errc()};
+  if (!isOk && !isOutOfRange) {
+    return makeUnexpected(ConversionCode::STRING_TO_FLOAT_ERROR);
+  }
+
+  auto numMatchedChars = ptr - src->data();
+  src->advance(numMatchedChars);
+
+  if (isOutOfRange) {
+    if (*b == '-') {
+      return -std::numeric_limits<Tgt>::infinity();
+    } else {
+      return std::numeric_limits<Tgt>::infinity();
+    }
+  }
+
+  return result;
+}
+
+template Expected<float, ConversionCode>
+str_to_floating_fast_float_from_chars<float>(StringPiece* src) noexcept;
+template Expected<double, ConversionCode>
+str_to_floating_fast_float_from_chars<double>(StringPiece* src) noexcept;
+
+/**
+* StringPiece to double, with progress information. Alters the
+* StringPiece parameter to munch the already-parsed characters.
+*/
+template <class Tgt>
+Expected<Tgt, ConversionCode> str_to_floating(StringPiece* src) noexcept {
+#if defined(FOLLY_CONV_ATOD_MODE) && FOLLY_CONV_ATOD_MODE == 1
+  return detail::str_to_floating_fast_float_from_chars<Tgt>(src);
+#else
+  return detail::str_to_floating_double_conversion<Tgt>(src);
+#endif
+}
+
+template Expected<float, ConversionCode> str_to_floating<float>(
+    StringPiece* src) noexcept;
+template Expected<double, ConversionCode> str_to_floating<double>(
+    StringPiece* src) noexcept;
+
+namespace {
+
+/**
+* This class takes care of additional processing needed for signed values,
+* like leading sign character and overflow checks.
+*/
+template <typename T, bool IsSigned = is_signed_v<T>>
+class SignedValueHandler;
+
+template <typename T>
+class SignedValueHandler<T, true> {
+public:
+  ConversionCode init(const char*& b) {
+    negative_ = false;
+    if (!std::isdigit(*b)) {
+      if (*b == '-') {
+        negative_ = true;
+      } else if (FOLLY_UNLIKELY(*b != '+')) {
+        return ConversionCode::INVALID_LEADING_CHAR;
+      }
+      ++b;
+    }
+    return ConversionCode::SUCCESS;
+  }
+
+  ConversionCode overflow() {
+    return negative_ ? ConversionCode::NEGATIVE_OVERFLOW
+                    : ConversionCode::POSITIVE_OVERFLOW;
+  }
+
+  template <typename U>
+  Expected<T, ConversionCode> finalize(U value) {
+    T rv;
+    if (negative_) {
+      FOLLY_PUSH_WARNING
+      FOLLY_MSVC_DISABLE_WARNING(4146)
+
+      // unary minus operator applied to unsigned type, result still unsigned
+      rv = T(-value);
+
+      FOLLY_POP_WARNING
+
+      if (FOLLY_UNLIKELY(rv > 0)) {
+        return makeUnexpected(ConversionCode::NEGATIVE_OVERFLOW);
+      }
+    } else {
+      rv = T(value);
+      if (FOLLY_UNLIKELY(rv < 0)) {
+        return makeUnexpected(ConversionCode::POSITIVE_OVERFLOW);
+      }
+    }
+    return rv;
+  }
+
+private:
+  bool negative_;
+};
+
+// For unsigned types, we don't need any extra processing
+template <typename T>
+class SignedValueHandler<T, false> {
+public:
+  ConversionCode init(const char*&) { return ConversionCode::SUCCESS; }
+
+  ConversionCode overflow() { return ConversionCode::POSITIVE_OVERFLOW; }
+
+  Expected<T, ConversionCode> finalize(T value) { return value; }
+};
+
+} // namespace
+
+/**
+* String represented as a pair of pointers to char to signed/unsigned
+* integrals. Assumes NO whitespace before or after, and also that the
+* string is composed entirely of digits (and an optional sign only for
+* signed types). String may be empty, in which case digits_to returns
+* an appropriate error.
+*/
+template <class Tgt>
+inline Expected<Tgt, ConversionCode> digits_to(
+    const char* b, const char* const e) noexcept {
+  using UT = make_unsigned_t<Tgt>;
+  assert(b <= e);
+
+  SignedValueHandler<Tgt> sgn;
+
+  auto err = sgn.init(b);
+  if (FOLLY_UNLIKELY(err != ConversionCode::SUCCESS)) {
+    return makeUnexpected(err);
+  }
+
+  auto size = size_t(e - b);
+
+  /* Although the string is entirely made of digits, we still need to
+  * check for overflow.
   */
- template <class Tgt>
- Expected<Tgt, ConversionCode> str_to_integral(StringPiece* src) noexcept {
-   using UT = make_unsigned_t<Tgt>;
- 
-   auto b = src->data(), past = src->data() + src->size();
- 
-   for (;; ++b) {
-     if (FOLLY_UNLIKELY(b >= past)) {
-       return makeUnexpected(ConversionCode::EMPTY_INPUT_STRING);
-     }
-     if ((*b < '\t' || *b > '\r') && *b != ' ') {
-       break;
-     }
-   }
- 
-   SignedValueHandler<Tgt> sgn;
-   auto err = sgn.init(b);
- 
-   if (FOLLY_UNLIKELY(err != ConversionCode::SUCCESS)) {
-     return makeUnexpected(err);
-   }
-   if (is_signed_v<Tgt> && FOLLY_UNLIKELY(b >= past)) {
-     return makeUnexpected(ConversionCode::NO_DIGITS);
-   }
-   if (FOLLY_UNLIKELY(!isdigit(*b))) {
-     return makeUnexpected(ConversionCode::NON_DIGIT_CHAR);
-   }
- 
-   auto m = findFirstNonDigit(b + 1, past);
- 
-   auto tmp = digits_to<UT>(b, m);
- 
-   if (FOLLY_UNLIKELY(!tmp.hasValue())) {
-     return makeUnexpected(
-         tmp.error() == ConversionCode::POSITIVE_OVERFLOW ? sgn.overflow()
-                                                          : tmp.error());
-   }
- 
-   auto res = sgn.finalize(tmp.value());
- 
-   if (res.hasValue()) {
-     src->advance(size_t(m - src->data()));
-   }
- 
-   return res;
- }
- 
- template Expected<char, ConversionCode> str_to_integral<char>(
-     StringPiece* src) noexcept;
- template Expected<signed char, ConversionCode> str_to_integral<signed char>(
-     StringPiece* src) noexcept;
- template Expected<unsigned char, ConversionCode> str_to_integral<unsigned char>(
-     StringPiece* src) noexcept;
- 
- template Expected<short, ConversionCode> str_to_integral<short>(
-     StringPiece* src) noexcept;
- template Expected<unsigned short, ConversionCode>
- str_to_integral<unsigned short>(StringPiece* src) noexcept;
- 
- template Expected<int, ConversionCode> str_to_integral<int>(
-     StringPiece* src) noexcept;
- template Expected<unsigned int, ConversionCode> str_to_integral<unsigned int>(
-     StringPiece* src) noexcept;
- 
- template Expected<long, ConversionCode> str_to_integral<long>(
-     StringPiece* src) noexcept;
- template Expected<unsigned long, ConversionCode> str_to_integral<unsigned long>(
-     StringPiece* src) noexcept;
- 
- template Expected<long long, ConversionCode> str_to_integral<long long>(
-     StringPiece* src) noexcept;
- template Expected<unsigned long long, ConversionCode>
- str_to_integral<unsigned long long>(StringPiece* src) noexcept;
- 
- #if FOLLY_HAVE_INT128_T
- template Expected<__int128, ConversionCode> str_to_integral<__int128>(
-     StringPiece* src) noexcept;
- template Expected<unsigned __int128, ConversionCode>
- str_to_integral<unsigned __int128>(StringPiece* src) noexcept;
- #endif
- 
- #if defined(FOLLY_CONV_AVALIABILITY_TO_CHARS_FLOATING_POINT) && \
-     FOLLY_CONV_AVALIABILITY_TO_CHARS_FLOATING_POINT == 1
- DtoaFlagsSet::DtoaFlagsSet(DtoaFlags flags) : flags_(flags) {}
- 
- bool DtoaFlagsSet::isSet(DtoaFlags flag) const {
-   return (flags_ & flag) == flag;
- }
- 
- bool DtoaFlagsSet::emitPositiveExponentSign() const {
-   return isSet(DtoaFlags::EMIT_POSITIVE_EXPONENT_SIGN);
- }
- 
- bool DtoaFlagsSet::emitTrailingDecimalPoint() const {
-   return isSet(DtoaFlags::EMIT_TRAILING_DECIMAL_POINT);
- }
- 
- bool DtoaFlagsSet::emitTrailingZeroAfterPoint() const {
-   return isSet(DtoaFlags::EMIT_TRAILING_ZERO_AFTER_POINT);
- }
- 
- bool DtoaFlagsSet::uniqueZero() const {
-   return isSet(DtoaFlags::UNIQUE_ZERO);
- }
- 
- bool DtoaFlagsSet::noTrailingZero() const {
-   return isSet(DtoaFlags::NO_TRAILING_ZERO);
- }
- 
- int ParsedDecimal::numPrecisionFigures() const {
-   int numInts = 0;
- 
-   bool intIsZero = true;
-   int numLeadingIntZeros = 0;
-   bool isLeadingIntZero = true;
-   for (char* p = integerBegin; p && p != integerEnd; p++) {
-     if (*p == '0') {
-       if (isLeadingIntZero) {
-         numLeadingIntZeros += 1;
-       } else {
-         numInts += 1;
-       }
-     } else if (std::isdigit(*p)) {
-       intIsZero = false;
-       isLeadingIntZero = false;
-       numInts += 1;
-     } else {
-       folly::throw_exception<std::runtime_error>("non-numeric int");
-     }
-   }
- 
-   bool fractionalIsZero = true;
-   int numFractional = 0;
-   int numLeadingFractionalZeros = 0;
-   bool isLeadingFractionalZero = true;
-   for (char* p = fractionalBegin; p && p != fractionalEnd; p++) {
-     if (*p == '0') {
-       if (isLeadingFractionalZero) {
-         numLeadingFractionalZeros += 1;
-       } else {
-         numFractional += 1;
-       }
-     } else if (std::isdigit(*p)) {
-       fractionalIsZero = false;
-       isLeadingFractionalZero = false;
-       numFractional += 1;
-     } else {
-       folly::throw_exception<std::runtime_error>("non-numeric frac");
-     }
-   }
- 
-   if (intIsZero && fractionalIsZero) {
-     return numLeadingIntZeros + numLeadingFractionalZeros;
-   } else if (intIsZero) {
-     return numLeadingFractionalZeros + numFractional;
-   } else if (fractionalIsZero) {
-     return numInts + numLeadingFractionalZeros + numFractional;
-   } else {
-     return numInts + numLeadingFractionalZeros + numFractional;
-   }
- }
- 
- std::optional<detail::ParsedDecimal::FractionalSuffix>
- ParsedDecimal::fractionalSuffix() const {
-   if (exponentSymbol) {
-     if (exponentEnd) {
-       return std::make_pair(exponentSymbol, exponentEnd);
-     } else if (exponentSign) {
-       return std::make_pair(exponentSymbol, exponentSign);
-     } else {
-       return std::make_pair(exponentSymbol, exponentSymbol + 1);
-     }
-   } else if (exponentSign) {
-     if (exponentEnd) {
-       return std::make_pair(exponentSign, exponentEnd);
-     } else {
-       return std::make_pair(exponentSign, exponentSign + 1);
-     }
-   } else if (exponentBegin) {
-     if (exponentEnd) {
-       return std::make_pair(exponentEnd, exponentEnd);
-     } else {
-       return std::make_pair(exponentBegin, exponentSign + 1);
-     }
-   } else {
-     return std::nullopt;
-   }
- }
- 
- void ParsedDecimal::shiftFractionalSuffixPtrs(size_t amount) {
-   if (exponentSymbol) {
-     exponentSymbol += amount;
-   }
-   if (exponentSign) {
-     exponentSign += amount;
-   }
-   if (exponentBegin) {
-     exponentBegin += amount;
-   }
-   if (exponentEnd) {
-     exponentEnd += amount;
-   }
- }
- 
- namespace {
- 
- struct Stream : std::istream {
-   struct CharBuf : std::streambuf {
-     CharBuf(char* begin, char* end) { setg(begin, begin, end); }
- 
-     char* pos() const { return gptr(); }
-   };
-   CharBuf& buf_;
- 
-   explicit Stream(CharBuf& buf) : std::istream(&buf), buf_(buf) {}
- 
-   char* pos() { return buf_.pos(); }
- 
-   void advance() { get(); }
- };
- 
- } // namespace
- 
- ParsedDecimal::ParsedDecimal(char* begin, char* end) {
-   if (!begin || !end || begin >= end) {
-     folly::throw_exception<std::invalid_argument>("invalid args");
-   }
- 
-   Stream::CharBuf buf(begin, end);
-   Stream stream(buf);
-   if (stream.peek() == '-') {
-     negativeSign = stream.pos();
-     stream.advance();
-   }
- 
-   if (char c = static_cast<unsigned char>(stream.peek()); std::isdigit(c)) { // [Windows - fix conversion from 'int' to 'char']
-     integerBegin = stream.pos();
- 
-     while (!stream.eof() && std::isdigit(stream.peek())) {
-       stream.advance();
-     }
- 
-     integerEnd = stream.pos();
-   }
- 
-   if (stream.eof()) {
-     if (!integerBegin) {
-       folly::throw_exception<std::invalid_argument>("no int part");
-     }
- 
-     return;
-   }
- 
-   if (stream.peek() == '.') {
-     decimalPoint = stream.pos();
-     stream.advance();
-   }
- 
-   if (stream.eof()) {
-     if (!integerBegin) {
-       folly::throw_exception<std::invalid_argument>("no int part");
-     }
-     return;
-   }
- 
-   if (char c = static_cast<unsigned char>(stream.peek()); std::isdigit(c)) { // [Windows - fix conversion from 'int' to 'char']
-     fractionalBegin = stream.pos();
- 
-     while (!stream.eof() && std::isdigit(stream.peek())) {
-       stream.advance();
-     }
- 
-     fractionalEnd = stream.pos();
-   }
- 
-   if (!integerBegin && !fractionalBegin) {
-     // there was no integer or fractional part.
-     folly::throw_exception<std::invalid_argument>("no int or frac part");
-   }
- 
-   if (stream.eof()) {
-     return;
-   }
- 
-   if (stream.peek() == 'e') {
-     exponentSymbol = stream.pos();
-     stream.advance();
- 
-     if (stream.eof()) {
-       return;
-     }
- 
-     if (char c = static_cast<unsigned char>(stream.peek()); c == '-' || c == '+') { // [Windows - fix conversion from 'int' to 'char']
-       exponentSign = stream.pos();
-       stream.advance();
-     }
- 
-     if (char c = static_cast<unsigned char>(stream.peek()); std::isdigit(c)) { // [Windows - fix conversion from 'int' to 'char']
-       exponentBegin = stream.pos();
-       while (!stream.eof() && std::isdigit(stream.peek())) {
-         stream.advance();
-       }
- 
-       exponentEnd = stream.pos();
-     }
-   }
- 
-   while (!stream.eof()) {
-     int c = stream.get();
-     if (c != '\0' && !std::isspace(c)) {
-       folly::throw_exception<std::invalid_argument>("unexpected chars");
-     }
-   }
- }
- 
- std::pair<char*, char*> formatAsDoubleConversion(
-     bool valueIsZero,
-     DtoaMode mode,
-     unsigned int numDigits,
-     DtoaFlags flags,
-     char* resultBegin,
-     char* resultEnd,
-     char* bufferEnd) {
-   detail::ParsedDecimal parsedDecimal(resultBegin, resultEnd);
-   detail::DtoaFlagsSet flagsSet{flags};
-   if (parsedDecimal.negativeSign && flagsSet.uniqueZero() && valueIsZero) {
-     // skip the negative sign (-) if it's a zero and UNIQUE_ZERO is set
-     resultBegin += 1;
-   }
- 
-   unsigned int numTrailingZerosToAdd = 0;
-   if (!flagsSet.noTrailingZero() && mode == DtoaMode::PRECISION) {
-     // std::to_chars outputs no trailing zeros, so if it's not set, add
-     // trailing zeros
-     unsigned int numPrecisionFigures = parsedDecimal.numPrecisionFigures();
-     if (numDigits > numPrecisionFigures) {
-       numTrailingZerosToAdd = numDigits - numPrecisionFigures;
-     }
-   }
- 
-   bool insertDecimalPoint = false;
-   char* insertionPoint;
-   if (parsedDecimal.fractionalEnd) {
-     insertionPoint = parsedDecimal.fractionalEnd;
-   } else if (parsedDecimal.decimalPoint) {
-     insertionPoint = parsedDecimal.decimalPoint + 1;
-   } else {
-     insertionPoint = parsedDecimal.integerEnd;
-     if (flagsSet.emitTrailingDecimalPoint() || numTrailingZerosToAdd > 0) {
-       insertDecimalPoint = true;
-     }
- 
-     if (flagsSet.emitTrailingZeroAfterPoint()) {
-       numTrailingZerosToAdd += 1;
-     }
-   }
- 
-   unsigned int numCharsToInsert =
-       numTrailingZerosToAdd + (insertDecimalPoint ? 1 : 0);
- 
-   if (numCharsToInsert > 0) {
-     if (resultEnd + numCharsToInsert > bufferEnd) {
-       folly::throw_exception<std::invalid_argument>("buffer too small");
-     }
- 
-     std::optional<detail::ParsedDecimal::FractionalSuffix> fractionalsuffix =
-         parsedDecimal.fractionalSuffix();
-     if (fractionalsuffix.has_value()) {
-       auto [fractionalSuffixBegin, fractionalSuffixEnd] = *fractionalsuffix;
-       std::memmove(
-           insertionPoint + numCharsToInsert,
-           fractionalSuffixBegin,
-           fractionalSuffixEnd - fractionalSuffixBegin);
-       parsedDecimal.shiftFractionalSuffixPtrs(numCharsToInsert);
-     }
- 
-     resultEnd += numCharsToInsert;
-   }
- 
-   if (insertDecimalPoint) {
-     *insertionPoint++ = '.';
-   }
- 
-   while (numTrailingZerosToAdd) {
-     *insertionPoint++ = '0';
-     numTrailingZerosToAdd -= 1;
-   }
- 
-   if (parsedDecimal.exponentSymbol) {
-     // std::tochars outputs a lowercase e and it needs to be uppercase.
-     *parsedDecimal.exponentSymbol = 'E';
-   }
- 
-   size_t charsToRemove = 0;
-   char* removalBegin = nullptr;
-   if (!flagsSet.emitPositiveExponentSign() && parsedDecimal.exponentSign &&
-       *parsedDecimal.exponentSign == '+') {
-     // std::to_chars outputs a + sign, remove it if the flag wasn't set.
-     // e.g., 1.23e+45 -> 1.23e45
-     removalBegin = parsedDecimal.exponentSign;
-     charsToRemove += 1;
-   }
- 
-   if (char* p = parsedDecimal.exponentBegin; p && *p == '0') {
-     // std::to_chars outputs a leading zero, remove it to match
-     // double_conversion formating. e.g., 1.23e+04 -> 1.23e4
-     if (!removalBegin) {
-       removalBegin = p;
-     }
- 
-     while (p != parsedDecimal.exponentEnd && *p == '0') {
-       charsToRemove += 1;
-       p += 1;
-     }
- 
-     if (p == parsedDecimal.exponentEnd) {
-       // they all were 0 digits. keep a single 0.
-       charsToRemove -= 1;
-       p -= 1;
-       if (p == removalBegin) {
-         // there was only one 0, keep it.
-         removalBegin = nullptr;
-       }
-     }
-   }
- 
-   if (charsToRemove && removalBegin) {
-     size_t len = resultEnd - (removalBegin + charsToRemove);
-     std::memmove(removalBegin, removalBegin + charsToRemove, len);
-     resultEnd -= charsToRemove;
-   }
- 
-   return std::pair{resultBegin, resultEnd};
- }
- #endif // FOLLY_CONV_AVALIABILITY_TO_CHARS_FLOATING_POINT
- } // namespace detail
- 
- ConversionError makeConversionError(ConversionCode code, StringPiece input) {
-   using namespace detail;
-   static_assert(
-       std::is_unsigned<std::underlying_type<ConversionCode>::type>::value,
-       "ConversionCode should be unsigned");
-   auto index = static_cast<std::size_t>(code);
-   FOLLY_SAFE_CHECK(index < kErrorStrings.size(), "code=", uint64_t(index));
-   const ErrorString& err = kErrorStrings[index];
-   if (code == ConversionCode::EMPTY_INPUT_STRING && input.empty()) {
-     return {err.string, code};
-   }
-   std::string tmp(err.string);
-   tmp.append(": ");
-   if (err.quote) {
-     tmp.append(1, '"');
-   }
-   if (!input.empty()) {
-     tmp.append(input.data(), input.size());
-   }
-   if (err.quote) {
-     tmp.append(1, '"');
-   }
-   return {tmp, code};
- }
- 
- } // namespace folly
\ No newline at end of file
+  if (size > std::numeric_limits<UT>::digits10) {
+    // Leading zeros?
+    if (b < e && *b == '0') {
+      for (++b;; ++b) {
+        if (b == e) {
+          return Tgt(0); // just zeros, e.g. "0000"
+        }
+        if (*b != '0') {
+          size = size_t(e - b);
+          break;
+        }
+      }
+    }
+    if (size > std::numeric_limits<UT>::digits10 &&
+        (size != std::numeric_limits<UT>::digits10 + 1 ||
+        strncmp(b, MaxString<UT>::value, size) > 0)) {
+      return makeUnexpected(sgn.overflow());
+    }
+  }
+
+  // Here we know that the number won't overflow when
+  // converted. Proceed without checks.
+
+  UT result = 0;
+
+  for (; e - b >= 4; b += 4) {
+    result *= UT(10000);
+    const int32_t r0 = shift1000[static_cast<size_t>(b[0])];
+    const int32_t r1 = shift100[static_cast<size_t>(b[1])];
+    const int32_t r2 = shift10[static_cast<size_t>(b[2])];
+    const int32_t r3 = shift1[static_cast<size_t>(b[3])];
+    const auto sum = r0 + r1 + r2 + r3;
+    if (sum >= OOR) {
+      goto outOfRange;
+    }
+    result += UT(sum);
+  }
+
+  switch (e - b) {
+    case 3: {
+      const int32_t r0 = shift100[static_cast<size_t>(b[0])];
+      const int32_t r1 = shift10[static_cast<size_t>(b[1])];
+      const int32_t r2 = shift1[static_cast<size_t>(b[2])];
+      const auto sum = r0 + r1 + r2;
+      if (sum >= OOR) {
+        goto outOfRange;
+      }
+      result = UT(1000 * result + sum);
+      break;
+    }
+    case 2: {
+      const int32_t r0 = shift10[static_cast<size_t>(b[0])];
+      const int32_t r1 = shift1[static_cast<size_t>(b[1])];
+      const auto sum = r0 + r1;
+      if (sum >= OOR) {
+        goto outOfRange;
+      }
+      result = UT(100 * result + sum);
+      break;
+    }
+    case 1: {
+      const int32_t sum = shift1[static_cast<size_t>(b[0])];
+      if (sum >= OOR) {
+        goto outOfRange;
+      }
+      result = UT(10 * result + sum);
+      break;
+    }
+    default:
+      assert(b == e);
+      if (size == 0) {
+        return makeUnexpected(ConversionCode::NO_DIGITS);
+      }
+      break;
+  }
+
+  return sgn.finalize(result);
+
+outOfRange:
+  return makeUnexpected(ConversionCode::NON_DIGIT_CHAR);
+}
+
+template Expected<char, ConversionCode> digits_to<char>(
+    const char*, const char*) noexcept;
+template Expected<signed char, ConversionCode> digits_to<signed char>(
+    const char*, const char*) noexcept;
+template Expected<unsigned char, ConversionCode> digits_to<unsigned char>(
+    const char*, const char*) noexcept;
+
+template Expected<short, ConversionCode> digits_to<short>(
+    const char*, const char*) noexcept;
+template Expected<unsigned short, ConversionCode> digits_to<unsigned short>(
+    const char*, const char*) noexcept;
+
+template Expected<int, ConversionCode> digits_to<int>(
+    const char*, const char*) noexcept;
+template Expected<unsigned int, ConversionCode> digits_to<unsigned int>(
+    const char*, const char*) noexcept;
+
+template Expected<long, ConversionCode> digits_to<long>(
+    const char*, const char*) noexcept;
+template Expected<unsigned long, ConversionCode> digits_to<unsigned long>(
+    const char*, const char*) noexcept;
+
+template Expected<long long, ConversionCode> digits_to<long long>(
+    const char*, const char*) noexcept;
+template Expected<unsigned long long, ConversionCode>
+digits_to<unsigned long long>(const char*, const char*) noexcept;
+
+#if FOLLY_HAVE_INT128_T
+template Expected<__int128, ConversionCode> digits_to<__int128>(
+    const char*, const char*) noexcept;
+template Expected<unsigned __int128, ConversionCode>
+digits_to<unsigned __int128>(const char*, const char*) noexcept;
+#endif
+
+/**
+* StringPiece to integrals, with progress information. Alters the
+* StringPiece parameter to munch the already-parsed characters.
+*/
+template <class Tgt>
+Expected<Tgt, ConversionCode> str_to_integral(StringPiece* src) noexcept {
+  using UT = make_unsigned_t<Tgt>;
+
+  auto b = src->data(), past = src->data() + src->size();
+
+  for (;; ++b) {
+    if (FOLLY_UNLIKELY(b >= past)) {
+      return makeUnexpected(ConversionCode::EMPTY_INPUT_STRING);
+    }
+    if ((*b < '\t' || *b > '\r') && *b != ' ') {
+      break;
+    }
+  }
+
+  SignedValueHandler<Tgt> sgn;
+  auto err = sgn.init(b);
+
+  if (FOLLY_UNLIKELY(err != ConversionCode::SUCCESS)) {
+    return makeUnexpected(err);
+  }
+  if (is_signed_v<Tgt> && FOLLY_UNLIKELY(b >= past)) {
+    return makeUnexpected(ConversionCode::NO_DIGITS);
+  }
+  if (FOLLY_UNLIKELY(!isdigit(*b))) {
+    return makeUnexpected(ConversionCode::NON_DIGIT_CHAR);
+  }
+
+  auto m = findFirstNonDigit(b + 1, past);
+
+  auto tmp = digits_to<UT>(b, m);
+
+  if (FOLLY_UNLIKELY(!tmp.hasValue())) {
+    return makeUnexpected(
+        tmp.error() == ConversionCode::POSITIVE_OVERFLOW ? sgn.overflow()
+                                                        : tmp.error());
+  }
+
+  auto res = sgn.finalize(tmp.value());
+
+  if (res.hasValue()) {
+    src->advance(size_t(m - src->data()));
+  }
+
+  return res;
+}
+
+template Expected<char, ConversionCode> str_to_integral<char>(
+    StringPiece* src) noexcept;
+template Expected<signed char, ConversionCode> str_to_integral<signed char>(
+    StringPiece* src) noexcept;
+template Expected<unsigned char, ConversionCode> str_to_integral<unsigned char>(
+    StringPiece* src) noexcept;
+
+template Expected<short, ConversionCode> str_to_integral<short>(
+    StringPiece* src) noexcept;
+template Expected<unsigned short, ConversionCode>
+str_to_integral<unsigned short>(StringPiece* src) noexcept;
+
+template Expected<int, ConversionCode> str_to_integral<int>(
+    StringPiece* src) noexcept;
+template Expected<unsigned int, ConversionCode> str_to_integral<unsigned int>(
+    StringPiece* src) noexcept;
+
+template Expected<long, ConversionCode> str_to_integral<long>(
+    StringPiece* src) noexcept;
+template Expected<unsigned long, ConversionCode> str_to_integral<unsigned long>(
+    StringPiece* src) noexcept;
+
+template Expected<long long, ConversionCode> str_to_integral<long long>(
+    StringPiece* src) noexcept;
+template Expected<unsigned long long, ConversionCode>
+str_to_integral<unsigned long long>(StringPiece* src) noexcept;
+
+#if FOLLY_HAVE_INT128_T
+template Expected<__int128, ConversionCode> str_to_integral<__int128>(
+    StringPiece* src) noexcept;
+template Expected<unsigned __int128, ConversionCode>
+str_to_integral<unsigned __int128>(StringPiece* src) noexcept;
+#endif
+
+#if defined(FOLLY_CONV_AVALIABILITY_TO_CHARS_FLOATING_POINT) && \
+    FOLLY_CONV_AVALIABILITY_TO_CHARS_FLOATING_POINT == 1
+DtoaFlagsSet::DtoaFlagsSet(DtoaFlags flags) : flags_(flags) {}
+
+bool DtoaFlagsSet::isSet(DtoaFlags flag) const {
+  return (flags_ & flag) == flag;
+}
+
+bool DtoaFlagsSet::emitPositiveExponentSign() const {
+  return isSet(DtoaFlags::EMIT_POSITIVE_EXPONENT_SIGN);
+}
+
+bool DtoaFlagsSet::emitTrailingDecimalPoint() const {
+  return isSet(DtoaFlags::EMIT_TRAILING_DECIMAL_POINT);
+}
+
+bool DtoaFlagsSet::emitTrailingZeroAfterPoint() const {
+  return isSet(DtoaFlags::EMIT_TRAILING_ZERO_AFTER_POINT);
+}
+
+bool DtoaFlagsSet::uniqueZero() const {
+  return isSet(DtoaFlags::UNIQUE_ZERO);
+}
+
+bool DtoaFlagsSet::noTrailingZero() const {
+  return isSet(DtoaFlags::NO_TRAILING_ZERO);
+}
+
+int ParsedDecimal::numPrecisionFigures() const {
+  int numInts = 0;
+
+  bool intIsZero = true;
+  int numLeadingIntZeros = 0;
+  bool isLeadingIntZero = true;
+  for (char* p = integerBegin; p && p != integerEnd; p++) {
+    if (*p == '0') {
+      if (isLeadingIntZero) {
+        numLeadingIntZeros += 1;
+      } else {
+        numInts += 1;
+      }
+    } else if (std::isdigit(*p)) {
+      intIsZero = false;
+      isLeadingIntZero = false;
+      numInts += 1;
+    } else {
+      folly::throw_exception<std::runtime_error>("non-numeric int");
+    }
+  }
+
+  bool fractionalIsZero = true;
+  int numFractional = 0;
+  int numLeadingFractionalZeros = 0;
+  bool isLeadingFractionalZero = true;
+  for (char* p = fractionalBegin; p && p != fractionalEnd; p++) {
+    if (*p == '0') {
+      if (isLeadingFractionalZero) {
+        numLeadingFractionalZeros += 1;
+      } else {
+        numFractional += 1;
+      }
+    } else if (std::isdigit(*p)) {
+      fractionalIsZero = false;
+      isLeadingFractionalZero = false;
+      numFractional += 1;
+    } else {
+      folly::throw_exception<std::runtime_error>("non-numeric frac");
+    }
+  }
+
+  if (intIsZero && fractionalIsZero) {
+    return numLeadingIntZeros + numLeadingFractionalZeros;
+  } else if (intIsZero) {
+    return numLeadingFractionalZeros + numFractional;
+  } else if (fractionalIsZero) {
+    return numInts + numLeadingFractionalZeros + numFractional;
+  } else {
+    return numInts + numLeadingFractionalZeros + numFractional;
+  }
+}
+
+std::optional<detail::ParsedDecimal::FractionalSuffix>
+ParsedDecimal::fractionalSuffix() const {
+  if (exponentSymbol) {
+    if (exponentEnd) {
+      return std::make_pair(exponentSymbol, exponentEnd);
+    } else if (exponentSign) {
+      return std::make_pair(exponentSymbol, exponentSign);
+    } else {
+      return std::make_pair(exponentSymbol, exponentSymbol + 1);
+    }
+  } else if (exponentSign) {
+    if (exponentEnd) {
+      return std::make_pair(exponentSign, exponentEnd);
+    } else {
+      return std::make_pair(exponentSign, exponentSign + 1);
+    }
+  } else if (exponentBegin) {
+    if (exponentEnd) {
+      return std::make_pair(exponentEnd, exponentEnd);
+    } else {
+      return std::make_pair(exponentBegin, exponentSign + 1);
+    }
+  } else {
+    return std::nullopt;
+  }
+}
+
+void ParsedDecimal::shiftFractionalSuffixPtrs(size_t amount) {
+  if (exponentSymbol) {
+    exponentSymbol += amount;
+  }
+  if (exponentSign) {
+    exponentSign += amount;
+  }
+  if (exponentBegin) {
+    exponentBegin += amount;
+  }
+  if (exponentEnd) {
+    exponentEnd += amount;
+  }
+}
+
+namespace {
+
+struct Stream : std::istream {
+  struct CharBuf : std::streambuf {
+    CharBuf(char* begin, char* end) { setg(begin, begin, end); }
+
+    char* pos() const { return gptr(); }
+  };
+  CharBuf& buf_;
+
+  explicit Stream(CharBuf& buf) : std::istream(&buf), buf_(buf) {}
+
+  char* pos() { return buf_.pos(); }
+
+  void advance() { get(); }
+};
+
+} // namespace
+
+ParsedDecimal::ParsedDecimal(char* begin, char* end) {
+  if (!begin || !end || begin >= end) {
+    folly::throw_exception<std::invalid_argument>("invalid args");
+  }
+
+  Stream::CharBuf buf(begin, end);
+  Stream stream(buf);
+  if (stream.peek() == '-') {
+    negativeSign = stream.pos();
+    stream.advance();
+  }
+
+  if (char c = static_cast<unsigned char>(stream.peek()); std::isdigit(c)) { // [Windows - fix conversion from 'int' to 'char']
+    integerBegin = stream.pos();
+
+    while (!stream.eof() && std::isdigit(stream.peek())) {
+      stream.advance();
+    }
+
+    integerEnd = stream.pos();
+  }
+
+  if (stream.eof()) {
+    if (!integerBegin) {
+      folly::throw_exception<std::invalid_argument>("no int part");
+    }
+
+    return;
+  }
+
+  if (stream.peek() == '.') {
+    decimalPoint = stream.pos();
+    stream.advance();
+  }
+
+  if (stream.eof()) {
+    if (!integerBegin) {
+      folly::throw_exception<std::invalid_argument>("no int part");
+    }
+    return;
+  }
+
+  if (char c = static_cast<unsigned char>(stream.peek()); std::isdigit(c)) { // [Windows - fix conversion from 'int' to 'char']
+    fractionalBegin = stream.pos();
+
+    while (!stream.eof() && std::isdigit(stream.peek())) {
+      stream.advance();
+    }
+
+    fractionalEnd = stream.pos();
+  }
+
+  if (!integerBegin && !fractionalBegin) {
+    // there was no integer or fractional part.
+    folly::throw_exception<std::invalid_argument>("no int or frac part");
+  }
+
+  if (stream.eof()) {
+    return;
+  }
+
+  if (stream.peek() == 'e') {
+    exponentSymbol = stream.pos();
+    stream.advance();
+
+    if (stream.eof()) {
+      return;
+    }
+
+    if (char c = static_cast<unsigned char>(stream.peek()); c == '-' || c == '+') { // [Windows - fix conversion from 'int' to 'char']
+      exponentSign = stream.pos();
+      stream.advance();
+    }
+
+    if (char c = static_cast<unsigned char>(stream.peek()); std::isdigit(c)) { // [Windows - fix conversion from 'int' to 'char']
+      exponentBegin = stream.pos();
+      while (!stream.eof() && std::isdigit(stream.peek())) {
+        stream.advance();
+      }
+
+      exponentEnd = stream.pos();
+    }
+  }
+
+  while (!stream.eof()) {
+    int c = stream.get();
+    if (c != '\0' && !std::isspace(c)) {
+      folly::throw_exception<std::invalid_argument>("unexpected chars");
+    }
+  }
+}
+
+std::pair<char*, char*> formatAsDoubleConversion(
+    bool valueIsZero,
+    DtoaMode mode,
+    unsigned int numDigits,
+    DtoaFlags flags,
+    char* resultBegin,
+    char* resultEnd,
+    char* bufferEnd) {
+  detail::ParsedDecimal parsedDecimal(resultBegin, resultEnd);
+  detail::DtoaFlagsSet flagsSet{flags};
+  if (parsedDecimal.negativeSign && flagsSet.uniqueZero() && valueIsZero) {
+    // skip the negative sign (-) if it's a zero and UNIQUE_ZERO is set
+    resultBegin += 1;
+  }
+
+  unsigned int numTrailingZerosToAdd = 0;
+  if (!flagsSet.noTrailingZero() && mode == DtoaMode::PRECISION) {
+    // std::to_chars outputs no trailing zeros, so if it's not set, add
+    // trailing zeros
+    unsigned int numPrecisionFigures = parsedDecimal.numPrecisionFigures();
+    if (numDigits > numPrecisionFigures) {
+      numTrailingZerosToAdd = numDigits - numPrecisionFigures;
+    }
+  }
+
+  bool insertDecimalPoint = false;
+  char* insertionPoint;
+  if (parsedDecimal.fractionalEnd) {
+    insertionPoint = parsedDecimal.fractionalEnd;
+  } else if (parsedDecimal.decimalPoint) {
+    insertionPoint = parsedDecimal.decimalPoint + 1;
+  } else {
+    insertionPoint = parsedDecimal.integerEnd;
+    if (flagsSet.emitTrailingDecimalPoint() || numTrailingZerosToAdd > 0) {
+      insertDecimalPoint = true;
+    }
+
+    if (flagsSet.emitTrailingZeroAfterPoint()) {
+      numTrailingZerosToAdd += 1;
+    }
+  }
+
+  unsigned int numCharsToInsert =
+      numTrailingZerosToAdd + (insertDecimalPoint ? 1 : 0);
+
+  if (numCharsToInsert > 0) {
+    if (resultEnd + numCharsToInsert > bufferEnd) {
+      folly::throw_exception<std::invalid_argument>("buffer too small");
+    }
+
+    std::optional<detail::ParsedDecimal::FractionalSuffix> fractionalsuffix =
+        parsedDecimal.fractionalSuffix();
+    if (fractionalsuffix.has_value()) {
+      auto [fractionalSuffixBegin, fractionalSuffixEnd] = *fractionalsuffix;
+      std::memmove(
+          insertionPoint + numCharsToInsert,
+          fractionalSuffixBegin,
+          fractionalSuffixEnd - fractionalSuffixBegin);
+      parsedDecimal.shiftFractionalSuffixPtrs(numCharsToInsert);
+    }
+
+    resultEnd += numCharsToInsert;
+  }
+
+  if (insertDecimalPoint) {
+    *insertionPoint++ = '.';
+  }
+
+  while (numTrailingZerosToAdd) {
+    *insertionPoint++ = '0';
+    numTrailingZerosToAdd -= 1;
+  }
+
+  if (parsedDecimal.exponentSymbol) {
+    // std::tochars outputs a lowercase e and it needs to be uppercase.
+    *parsedDecimal.exponentSymbol = 'E';
+  }
+
+  size_t charsToRemove = 0;
+  char* removalBegin = nullptr;
+  if (!flagsSet.emitPositiveExponentSign() && parsedDecimal.exponentSign &&
+      *parsedDecimal.exponentSign == '+') {
+    // std::to_chars outputs a + sign, remove it if the flag wasn't set.
+    // e.g., 1.23e+45 -> 1.23e45
+    removalBegin = parsedDecimal.exponentSign;
+    charsToRemove += 1;
+  }
+
+  if (char* p = parsedDecimal.exponentBegin; p && *p == '0') {
+    // std::to_chars outputs a leading zero, remove it to match
+    // double_conversion formating. e.g., 1.23e+04 -> 1.23e4
+    if (!removalBegin) {
+      removalBegin = p;
+    }
+
+    while (p != parsedDecimal.exponentEnd && *p == '0') {
+      charsToRemove += 1;
+      p += 1;
+    }
+
+    if (p == parsedDecimal.exponentEnd) {
+      // they all were 0 digits. keep a single 0.
+      charsToRemove -= 1;
+      p -= 1;
+      if (p == removalBegin) {
+        // there was only one 0, keep it.
+        removalBegin = nullptr;
+      }
+    }
+  }
+
+  if (charsToRemove && removalBegin) {
+    size_t len = resultEnd - (removalBegin + charsToRemove);
+    std::memmove(removalBegin, removalBegin + charsToRemove, len);
+    resultEnd -= charsToRemove;
+  }
+
+  return std::pair{resultBegin, resultEnd};
+}
+#endif // FOLLY_CONV_AVALIABILITY_TO_CHARS_FLOATING_POINT
+} // namespace detail
+
+ConversionError makeConversionError(ConversionCode code, StringPiece input) {
+  using namespace detail;
+  static_assert(
+      std::is_unsigned<std::underlying_type<ConversionCode>::type>::value,
+      "ConversionCode should be unsigned");
+  auto index = static_cast<std::size_t>(code);
+  FOLLY_SAFE_CHECK(index < kErrorStrings.size(), "code=", uint64_t(index));
+  const ErrorString& err = kErrorStrings[index];
+  if (code == ConversionCode::EMPTY_INPUT_STRING && input.empty()) {
+    return {err.string, code};
+  }
+  std::string tmp(err.string);
+  tmp.append(": ");
+  if (err.quote) {
+    tmp.append(1, '"');
+  }
+  if (!input.empty()) {
+    tmp.append(input.data(), input.size());
+  }
+  if (err.quote) {
+    tmp.append(1, '"');
+  }
+  return {tmp, code};
+}
+
+} // namespace folly
\ No newline at end of file
diff --git a/vnext/Folly/TEMP_UntilFollyUpdate/chrono/Hardware.h b/vnext/Folly/TEMP_UntilFollyUpdate/chrono/Hardware.h
index 87473f1a737..ff93f2d6c5f 100644
--- a/vnext/Folly/TEMP_UntilFollyUpdate/chrono/Hardware.h
+++ b/vnext/Folly/TEMP_UntilFollyUpdate/chrono/Hardware.h
@@ -1,31 +1,31 @@
 /*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * 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.
- */
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* 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.
+*/
 
- #pragma once
+#pragma once
 
- #include <folly/Portability.h>
- 
- #include <chrono>
- #include <cstdint>
- 
- //  Description of and implementation of sequences for precise measurement:
- //    https://github.com/abseil/abseil-cpp/blob/20240116.2/absl/random/internal/nanobenchmark.cc#L164-L277
- 
- #if defined(_MSC_VER) && !defined(__clang__) && \
- (defined(_M_IX86) || defined(_M_X64)) && !defined(_M_ARM64EC) // [Windows]
+#include <folly/Portability.h>
+
+#include <chrono>
+#include <cstdint>
+
+//  Description of and implementation of sequences for precise measurement:
+//    https://github.com/abseil/abseil-cpp/blob/20240116.2/absl/random/internal/nanobenchmark.cc#L164-L277
+
+#if defined(_MSC_VER) && !defined(__clang__) && \
+(defined(_M_IX86) || defined(_M_X64)) && !defined(_M_ARM64EC) // [Windows]
 extern "C" std::uint64_t __rdtsc();
 extern "C" std::uint64_t __rdtscp(unsigned int*);
 extern "C" void _ReadWriteBarrier();
@@ -35,121 +35,121 @@ extern "C" void _mm_lfence();
 #pragma intrinsic(_ReadWriteBarrier)
 #pragma intrinsic(_mm_lfence)
 #endif
- 
- namespace folly {
- 
- inline std::uint64_t hardware_timestamp() {
- #if defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64))
-   return __rdtsc();
- #elif defined(__GNUC__) && (defined(__i386__) || FOLLY_X64)
-   return __builtin_ia32_rdtsc();
- #elif FOLLY_AARCH64 && !FOLLY_MOBILE
-   uint64_t cval;
-   asm volatile("mrs %0, cntvct_el0" : "=r"(cval));
-   return cval;
- #else
-   // use steady_clock::now() as an approximation for the timestamp counter on
-   // non-x86 systems
-   return std::chrono::steady_clock::now().time_since_epoch().count();
- #endif
- }
- 
- /// hardware_timestamp_measurement_start
- /// hardware_timestamp_measurement_stop
- ///
- /// Suitable for beginning precise measurement of a region of code.
- ///
- /// Prevents the compiler from reordering instructions across the call. This is
- /// in contrast with hardware_timestamp(), which may not prevent the compiler
- /// from reordering instructions across the call.
- ///
- /// Prevents the processor from pipelining the call with loads. This is in
- /// contrast with hardware_timestamp(), which allows the processor to pipeline
- /// the call with surrounding loads.
- ///
- /// Does not prevent instruction pipelines from continuing execution across the
- /// call. For example, does not prevent a store issued before the call from
- /// continuing execution (becoming globally visible) across the call. This means
- /// that this form may not be suitable for certain measurement use-cases which
- /// would require such prevention. However, this would be suitable for typical
- /// measurement use-cases which do not specifically need to measure background
- /// work such as store execution.
- std::uint64_t hardware_timestamp_measurement_start() noexcept;
- std::uint64_t hardware_timestamp_measurement_stop() noexcept;
- 
- inline std::uint64_t hardware_timestamp_measurement_start() noexcept {
- #if defined(_MSC_VER) && !defined(__clang__) && \
-     (defined(_M_IX86) || defined(_M_X64))
-   // msvc does not have embedded assembly
-   _ReadWriteBarrier();
-   _mm_lfence();
-   _ReadWriteBarrier();
-   auto const ret = __rdtsc();
-   _ReadWriteBarrier();
-   _mm_lfence();
-   _ReadWriteBarrier();
-   return ret;
- #elif defined(__GNUC__) && FOLLY_X64
-   uint64_t ret = 0;
- #if !defined(__clang_major__) || __clang_major__ >= 11
-   asm volatile inline(
- #else
-   asm volatile(
- #endif
-       "lfence\n"
-       "rdtsc\n" // loads 64-bit tsc into edx:eax
-       "shl $32, %%rdx\n" // prep rdx for combine into rax
-       "or %%rdx, %[ret]\n" // combine rdx into rax
-       "lfence\n"
-       : [ret] "=a"(ret) // bind ret to rax for output
-       : // no inputs
-       : "rdx", // rdtsc loads into edx:eax
-         "cc", // shl clobbers condition-code
-         "memory" // memory clobber asks gcc/clang not to reorder
-   );
-   return ret;
- #else
-   // use steady_clock::now() as an approximation for the timestamp counter on
-   // non-x64 systems
-   return std::chrono::steady_clock::now().time_since_epoch().count();
- #endif
- }
- 
- inline std::uint64_t hardware_timestamp_measurement_stop() noexcept {
- #if defined(_MSC_VER) && !defined(__clang__) && \
-     (defined(_M_IX86) || defined(_M_X64))
-   // msvc does not have embedded assembly
-   _ReadWriteBarrier();
-   unsigned int aux;
-   auto const ret = __rdtscp(&aux);
-   _ReadWriteBarrier();
-   _mm_lfence();
-   _ReadWriteBarrier();
-   return ret;
- #elif defined(__GNUC__) && FOLLY_X64
-   uint64_t ret = 0;
- #if !defined(__clang_major__) || __clang_major__ >= 11
-   asm volatile inline(
- #else
-   asm volatile(
- #endif
-       "rdtscp\n" // loads 64-bit tsc into edx:eax, clobbers ecx
-       "shl $32, %%rdx\n" // prep rdx for combine into rax
-       "or %%rdx, %[ret]\n" // combine rdx into rax
-       "lfence\n"
-       : [ret] "=a"(ret) // bind ret to rax for output
-       : // no inputs
-       : "rdx", // rdtscp loads into edx:eax
-         "rcx", // rdtscp clobbers rcx
-         "cc", // shl clobbers condition-code
-         "memory" // memory clobber asks gcc/clang not to reorder
-   );
-   return ret;
- #else
-   // use steady_clock::now() as an approximation for the timestamp counter on
-   // non-x64 systems
-   return std::chrono::steady_clock::now().time_since_epoch().count();
- #endif
- }
- 
- } // namespace folly
\ No newline at end of file
+
+namespace folly {
+
+inline std::uint64_t hardware_timestamp() {
+#if defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64))
+  return __rdtsc();
+#elif defined(__GNUC__) && (defined(__i386__) || FOLLY_X64)
+  return __builtin_ia32_rdtsc();
+#elif FOLLY_AARCH64 && !FOLLY_MOBILE
+  uint64_t cval;
+  asm volatile("mrs %0, cntvct_el0" : "=r"(cval));
+  return cval;
+#else
+  // use steady_clock::now() as an approximation for the timestamp counter on
+  // non-x86 systems
+  return std::chrono::steady_clock::now().time_since_epoch().count();
+#endif
+}
+
+/// hardware_timestamp_measurement_start
+/// hardware_timestamp_measurement_stop
+///
+/// Suitable for beginning precise measurement of a region of code.
+///
+/// Prevents the compiler from reordering instructions across the call. This is
+/// in contrast with hardware_timestamp(), which may not prevent the compiler
+/// from reordering instructions across the call.
+///
+/// Prevents the processor from pipelining the call with loads. This is in
+/// contrast with hardware_timestamp(), which allows the processor to pipeline
+/// the call with surrounding loads.
+///
+/// Does not prevent instruction pipelines from continuing execution across the
+/// call. For example, does not prevent a store issued before the call from
+/// continuing execution (becoming globally visible) across the call. This means
+/// that this form may not be suitable for certain measurement use-cases which
+/// would require such prevention. However, this would be suitable for typical
+/// measurement use-cases which do not specifically need to measure background
+/// work such as store execution.
+std::uint64_t hardware_timestamp_measurement_start() noexcept;
+std::uint64_t hardware_timestamp_measurement_stop() noexcept;
+
+inline std::uint64_t hardware_timestamp_measurement_start() noexcept {
+#if defined(_MSC_VER) && !defined(__clang__) && \
+    (defined(_M_IX86) || defined(_M_X64))
+  // msvc does not have embedded assembly
+  _ReadWriteBarrier();
+  _mm_lfence();
+  _ReadWriteBarrier();
+  auto const ret = __rdtsc();
+  _ReadWriteBarrier();
+  _mm_lfence();
+  _ReadWriteBarrier();
+  return ret;
+#elif defined(__GNUC__) && FOLLY_X64
+  uint64_t ret = 0;
+#if !defined(__clang_major__) || __clang_major__ >= 11
+  asm volatile inline(
+#else
+  asm volatile(
+#endif
+      "lfence\n"
+      "rdtsc\n" // loads 64-bit tsc into edx:eax
+      "shl $32, %%rdx\n" // prep rdx for combine into rax
+      "or %%rdx, %[ret]\n" // combine rdx into rax
+      "lfence\n"
+      : [ret] "=a"(ret) // bind ret to rax for output
+      : // no inputs
+      : "rdx", // rdtsc loads into edx:eax
+        "cc", // shl clobbers condition-code
+        "memory" // memory clobber asks gcc/clang not to reorder
+  );
+  return ret;
+#else
+  // use steady_clock::now() as an approximation for the timestamp counter on
+  // non-x64 systems
+  return std::chrono::steady_clock::now().time_since_epoch().count();
+#endif
+}
+
+inline std::uint64_t hardware_timestamp_measurement_stop() noexcept {
+#if defined(_MSC_VER) && !defined(__clang__) && \
+    (defined(_M_IX86) || defined(_M_X64))
+  // msvc does not have embedded assembly
+  _ReadWriteBarrier();
+  unsigned int aux;
+  auto const ret = __rdtscp(&aux);
+  _ReadWriteBarrier();
+  _mm_lfence();
+  _ReadWriteBarrier();
+  return ret;
+#elif defined(__GNUC__) && FOLLY_X64
+  uint64_t ret = 0;
+#if !defined(__clang_major__) || __clang_major__ >= 11
+  asm volatile inline(
+#else
+  asm volatile(
+#endif
+      "rdtscp\n" // loads 64-bit tsc into edx:eax, clobbers ecx
+      "shl $32, %%rdx\n" // prep rdx for combine into rax
+      "or %%rdx, %[ret]\n" // combine rdx into rax
+      "lfence\n"
+      : [ret] "=a"(ret) // bind ret to rax for output
+      : // no inputs
+      : "rdx", // rdtscp loads into edx:eax
+        "rcx", // rdtscp clobbers rcx
+        "cc", // shl clobbers condition-code
+        "memory" // memory clobber asks gcc/clang not to reorder
+  );
+  return ret;
+#else
+  // use steady_clock::now() as an approximation for the timestamp counter on
+  // non-x64 systems
+  return std::chrono::steady_clock::now().time_since_epoch().count();
+#endif
+}
+
+} // namespace folly
\ No newline at end of file
diff --git a/vnext/Folly/TEMP_UntilFollyUpdate/concurrency/CacheLocality.cpp b/vnext/Folly/TEMP_UntilFollyUpdate/concurrency/CacheLocality.cpp
index 633230f406e..ff917ea7db0 100644
--- a/vnext/Folly/TEMP_UntilFollyUpdate/concurrency/CacheLocality.cpp
+++ b/vnext/Folly/TEMP_UntilFollyUpdate/concurrency/CacheLocality.cpp
@@ -1,633 +1,633 @@
 /*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * 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 <folly/concurrency/CacheLocality.h>
-
- #ifndef _MSC_VER
- #define _GNU_SOURCE 1 // for RTLD_NOLOAD
- #include <dlfcn.h>
- #endif
- #include <fstream>
- #include <mutex>
- #include <numeric>
- #include <optional>
- 
- #include <fmt/core.h>
- #include <glog/logging.h>
- #include <folly/Indestructible.h>
- #include <folly/Memory.h>
- #include <folly/ScopeGuard.h>
- #include <folly/detail/StaticSingletonManager.h>
- #include <folly/hash/Hash.h>
- #include <folly/lang/Exception.h>
- #include <folly/portability/Unistd.h>
- #include <folly/system/ThreadId.h>
- 
- namespace folly {
- 
- ///////////// CacheLocality
- 
- /// Returns the CacheLocality information best for this machine
- static CacheLocality getSystemLocalityInfo() {
-   if (kIsLinux) {
-     // First try to parse /proc/cpuinfo.
-     // If that fails, then try to parse /sys/devices/.
-     // The latter is slower but more accurate.
-     try {
-       return CacheLocality::readFromProcCpuinfo();
-     } catch (...) {
-       // /proc/cpuinfo might be non-standard
-       // lets try with sysfs /sys/devices/cpu
-     }
- 
-     try {
-       return CacheLocality::readFromSysfs();
-     } catch (...) {
-       // keep trying
-     }
-   }
- 
-   long numCpus = sysconf(_SC_NPROCESSORS_CONF);
-   if (numCpus <= 0) {
-     // This shouldn't happen, but if it does we should try to keep
-     // going.  We are probably not going to be able to parse /sys on
-     // this box either (although we will try), which means we are going
-     // to fall back to the SequentialThreadId splitter.  On my 16 core
-     // (x hyperthreading) dev box 16 stripes is enough to get pretty good
-     // contention avoidance with SequentialThreadId, and there is little
-     // improvement from going from 32 to 64.  This default gives us some
-     // wiggle room
-     numCpus = 32;
-   }
-   return CacheLocality::uniform(size_t(numCpus));
- }
- 
- template <>
- const CacheLocality& CacheLocality::system<std::atomic>() {
-   static std::atomic<const CacheLocality*> cache;
-   auto value = cache.load(std::memory_order_acquire);
-   if (value != nullptr) {
-     return *value;
-   }
-   auto next = new CacheLocality(getSystemLocalityInfo());
-   if (cache.compare_exchange_strong(value, next, std::memory_order_acq_rel)) {
-     return *next;
-   }
-   delete next;
-   return *value;
- }
- 
- CacheLocality::CacheLocality(std::vector<std::vector<size_t>> equivClasses) {
-   numCpus = equivClasses.size();
- 
-   for (size_t cpu = 0; cpu < numCpus; ++cpu) {
-     for (size_t level = 0; level < equivClasses[cpu].size(); ++level) {
-       if (equivClasses[cpu][level] == cpu) {
-         // we only want to count the equiv classes once, so we do it when we
-         // are processing their representative.
-         while (numCachesByLevel.size() <= level) {
-           numCachesByLevel.push_back(0);
-         }
-         numCachesByLevel[level]++;
-       }
-     }
-   }
- 
-   std::vector<size_t> cpus(numCpus);
-   std::iota(cpus.begin(), cpus.end(), 0);
- 
-   std::sort(cpus.begin(), cpus.end(), [&](size_t lhs, size_t rhs) -> bool {
-     auto& lhsEquiv = equivClasses[lhs];
-     auto& rhsEquiv = equivClasses[rhs];
- 
-     // If different cpus have different numbers of caches group first by number
-     // of caches to guarantee strict weak ordering, even though the resulting
-     // order may be sub-optimal.
-     if (lhsEquiv.size() != rhsEquiv.size()) {
-       return lhsEquiv.size() < rhsEquiv.size();
-     }
- 
-     // Order by equiv class of cache with highest index, direction doesn't
-     // matter.
-     for (size_t i = lhsEquiv.size(); i > 0; --i) {
-       auto idx = i - 1;
-       if (lhsEquiv[idx] != rhsEquiv[idx]) {
-         return lhsEquiv[idx] < rhsEquiv[idx];
-       }
-     }
- 
-     // Break ties deterministically by cpu.
-     return lhs < rhs;
-   });
- 
-   // The cpus are now sorted by locality, with neighboring entries closer
-   // to each other than entries that are far away.  For striping we want
-   // the inverse map, since we are starting with the cpu.
-   localityIndexByCpu.resize(numCpus);
-   for (size_t i = 0; i < cpus.size(); ++i) {
-     localityIndexByCpu[cpus[i]] = i;
-   }
- 
-   equivClassesByCpu = std::move(equivClasses);
- }
- 
- // Each level of cache has sharing sets, which are the set of cpus that share a
- // common cache at that level.  These are available in a hex bitset form
- // (/sys/devices/system/cpu/cpu0/cache/index0/shared_cpu_map, for example).
- // They are also available in human-readable form in the shared_cpu_list file in
- // the same directory.  The list is a comma-separated list of numbers and
- // ranges, where the ranges are pairs of decimal numbers separated by a '-'.
- //
- // To sort the cpus for optimum locality we don't really need to parse the
- // sharing sets, we just need a unique representative from the equivalence
- // class.  The smallest value works fine, and happens to be the first decimal
- // number in the file.  We load all of the equivalence class information from
- // all of the cpu*/index* directories, order the cpus first by increasing
- // last-level cache equivalence class, then by the smaller caches.  Finally, we
- // break ties with the cpu number itself.
- 
- /// Returns the first decimal number in the line, or throws an exception if the
- /// line does not start with a number terminated by ',', '-', '\n', or EOS.
- static size_t parseLeadingNumber(const std::string& line) {
-   auto raw = line.c_str();
-   char* end;
-   unsigned long val = strtoul(raw, &end, 10);
-   if (end == raw || (*end != ',' && *end != '-' && *end != '\n' && *end != 0)) {
-     throw std::runtime_error(fmt::format("error parsing list '{}'", line));
-   }
-   return val;
- }
- 
- CacheLocality CacheLocality::readFromSysfsTree(
-     const std::function<std::string(std::string const&)>& mapping) {
-   // the list of cache equivalence classes, where equivalence classes
-   // are named by the smallest cpu in the class
-   std::vector<std::vector<size_t>> equivClassesByCpu;
- 
-   for (size_t cpu = 0;; ++cpu) {
-     std::vector<size_t> levels;
-     for (size_t index = 0;; ++index) {
-       auto dir = fmt::format(
-           "/sys/devices/system/cpu/cpu{}/cache/index{}/", cpu, index);
-       auto cacheType = mapping(dir + "type");
-       auto equivStr = mapping(dir + "shared_cpu_list");
-       if (cacheType.empty() || equivStr.empty()) {
-         // no more caches
-         break;
-       }
-       if (cacheType[0] == 'I') {
-         // cacheType in { "Data", "Instruction", "Unified" }. skip icache
-         continue;
-       }
-       auto equiv = parseLeadingNumber(equivStr);
-       levels.push_back(equiv);
-     }
- 
-     if (levels.empty()) {
-       // no levels at all for this cpu, we must be done
-       break;
-     }
-     equivClassesByCpu.emplace_back(std::move(levels));
-   }
- 
-   if (equivClassesByCpu.empty()) {
-     throw std::runtime_error("unable to load cache sharing info");
-   }
- 
-   return CacheLocality{std::move(equivClassesByCpu)};
- }
- 
- CacheLocality CacheLocality::readFromSysfs() {
-   return readFromSysfsTree([](std::string const& name) {
-     std::ifstream xi(name.c_str());
-     std::string rv;
-     std::getline(xi, rv);
-     return rv;
-   });
- }
- 
- namespace {
- 
- static bool procCpuinfoLineRelevant(std::string const& line) {
-   return line.size() > 4 && (line[0] == 'p' || line[0] == 'c');
- }
- 
- std::vector<std::tuple<size_t, size_t, size_t>> parseProcCpuinfoLines(
-     std::vector<std::string> const& lines) {
-   std::vector<std::tuple<size_t, size_t, size_t>> cpus;
-   size_t physicalId = 0;
-   size_t coreId = 0;
-   size_t maxCpu = 0;
-   size_t numberOfPhysicalIds = 0;
-   size_t numberOfCoreIds = 0;
-   for (auto iter = lines.rbegin(); iter != lines.rend(); ++iter) {
-     auto& line = *iter;
-     if (!procCpuinfoLineRelevant(line)) {
-       continue;
-     }
- 
-     auto sepIndex = line.find(':');
-     if (sepIndex == std::string::npos || sepIndex + 2 > line.size()) {
-       continue;
-     }
-     auto arg = line.substr(sepIndex + 2);
- 
-     // "physical id" is socket, which is the most important locality
-     // context.  "core id" is a real core, so two "processor" entries with
-     // the same physical id and core id are hyperthreads of each other.
-     // "processor" is the top line of each record, so when we hit it in
-     // the reverse order then we can emit a record.
-     if (line.find("physical id") == 0) {
-       physicalId = parseLeadingNumber(arg);
-       ++numberOfPhysicalIds;
-     } else if (line.find("core id") == 0) {
-       coreId = parseLeadingNumber(arg);
-       ++numberOfCoreIds;
-     } else if (line.find("processor") == 0) {
-       auto cpu = parseLeadingNumber(arg);
-       maxCpu = std::max(cpu, maxCpu);
-       cpus.emplace_back(physicalId, coreId, cpu);
-     }
-   }
- 
-   if (cpus.empty()) {
-     throw std::runtime_error("no CPUs parsed from /proc/cpuinfo");
-   }
-   if (maxCpu != cpus.size() - 1) {
-     throw std::runtime_error(
-         "offline CPUs not supported for /proc/cpuinfo cache locality source");
-   }
-   if (numberOfPhysicalIds == 0) {
-     throw std::runtime_error("no physical ids found");
-   }
-   if (numberOfCoreIds == 0) {
-     throw std::runtime_error("no core ids found");
-   }
- 
-   return cpus;
- }
- 
- } // namespace
- 
- CacheLocality CacheLocality::readFromProcCpuinfoLines(
-     std::vector<std::string> const& lines) {
-   // (physicalId, coreId, cpu)
-   std::vector<std::tuple<size_t, size_t, size_t>> cpus =
-       parseProcCpuinfoLines(lines);
-   // Sort to make equivalence classes contiguous.
-   std::sort(cpus.begin(), cpus.end());
- 
-   // We can't tell the real cache hierarchy from /proc/cpuinfo, but it works
-   // well enough to assume there are 3 levels, L1 and L2 per-core and L3 per
-   // socket.
-   std::vector<std::vector<size_t>> equivClassesByCpu(cpus.size());
-   size_t l1Equiv = 0;
-   size_t l3Equiv = 0;
-   for (size_t i = 0; i < cpus.size(); ++i) {
-     auto [physicalId, coreId, cpu] = cpus[i];
-     // The representative for each L1 and L3 equivalence class is the first cpu
-     // in the class.
-     if (i == 0 || physicalId != std::get<0>(cpus[i - 1]) ||
-         coreId != std::get<1>(cpus[i - 1])) {
-       l1Equiv = cpu;
-     }
-     if (i == 0 || physicalId != std::get<0>(cpus[i - 1])) {
-       l3Equiv = cpu;
-     }
-     equivClassesByCpu[cpu] = {l1Equiv, l1Equiv, l3Equiv};
-   }
- 
-   return CacheLocality{std::move(equivClassesByCpu)};
- }
- 
- CacheLocality CacheLocality::readFromProcCpuinfo() {
-   std::vector<std::string> lines;
-   {
-     std::ifstream xi("/proc/cpuinfo");
-     if (xi.fail()) {
-       throw std::runtime_error("unable to open /proc/cpuinfo");
-     }
-     char buf[8192];
-     while (xi.good() && lines.size() < 20000) {
-       xi.getline(buf, sizeof(buf));
-       std::string str(buf);
-       if (procCpuinfoLineRelevant(str)) {
-         lines.emplace_back(std::move(str));
-       }
-     }
-   }
-   return readFromProcCpuinfoLines(lines);
- }
- 
- CacheLocality CacheLocality::uniform(size_t numCpus) {
-   // One cache shared by all cpus.
-   std::vector<std::vector<size_t>> equivClassesByCpu(numCpus, {0});
-   return CacheLocality{std::move(equivClassesByCpu)};
- }
- 
- ////////////// Getcpu
- 
- Getcpu::Func Getcpu::resolveVdsoFunc() {
- #if !defined(FOLLY_HAVE_LINUX_VDSO) || defined(FOLLY_SANITIZE_MEMORY)
-   return nullptr;
- #else
-   void* h = dlopen("linux-vdso.so.1", RTLD_LAZY | RTLD_LOCAL | RTLD_NOLOAD);
-   if (h == nullptr) {
-     return nullptr;
-   }
- 
-   auto func = Getcpu::Func(dlsym(h, "__vdso_getcpu"));
-   if (func == nullptr) {
-     // technically a null result could either be a failure or a successful
-     // lookup of a symbol with the null value, but the second can't actually
-     // happen for this symbol.  No point holding the handle forever if
-     // we don't need the code
-     dlclose(h);
-   }
- 
-   return func;
- #endif
- }
- 
- /////////////// SequentialThreadId
- unsigned SequentialThreadId::get() {
-   static std::atomic<unsigned> global{0};
-   static thread_local unsigned local{0};
-   return FOLLY_LIKELY(local) ? local : (local = ++global);
- }
- 
- /////////////// HashingThreadId
- unsigned HashingThreadId::get() {
-   return hash::twang_32from64(getCurrentThreadID());
- }
- 
- namespace detail {
- 
- int AccessSpreaderBase::degenerateGetcpu(unsigned* cpu, unsigned* node, void*) {
-   if (cpu != nullptr) {
-     *cpu = 0;
-   }
-   if (node != nullptr) {
-     *node = 0;
-   }
-   return 0;
- }
- 
- struct AccessSpreaderStaticInit {
-   static AccessSpreaderStaticInit instance;
-   AccessSpreaderStaticInit() { (void)AccessSpreader<>::current(~size_t(0)); }
- };
- AccessSpreaderStaticInit AccessSpreaderStaticInit::instance;
- 
- bool AccessSpreaderBase::initialize(
-     GlobalState& state,
-     Getcpu::Func (&pickGetcpuFunc)(),
-     const CacheLocality& (&system)()) {
-   (void)AccessSpreaderStaticInit::instance; // ODR-use it so it is not dropped
-   constexpr auto relaxed = std::memory_order_relaxed;
-   auto& cacheLocality = system();
-   auto n = cacheLocality.numCpus;
-   for (size_t width = 0; width <= kMaxCpus; ++width) {
-     auto& row = state.table[width];
-     auto numStripes = std::max(size_t{1}, width);
-     for (size_t cpu = 0; cpu < kMaxCpus && cpu < n; ++cpu) {
-       auto index = cacheLocality.localityIndexByCpu[cpu];
-       assert(index < n);
-       // as index goes from 0..n, post-transform value goes from
-       // 0..numStripes
-       make_atomic_ref(row[cpu]).store(
-           static_cast<CompactStripe>((index * numStripes) / n), relaxed);
-       assert(make_atomic_ref(row[cpu]).load(relaxed) < numStripes);
-     }
-     size_t filled = n;
-     while (filled < kMaxCpus) {
-       size_t len = std::min(filled, kMaxCpus - filled);
-       for (size_t i = 0; i < len; ++i) {
-         make_atomic_ref(row[filled + i])
-             .store(make_atomic_ref(row[i]).load(relaxed), relaxed);
-       }
-       filled += len;
-     }
-     for (size_t cpu = n; cpu < kMaxCpus; ++cpu) {
-       assert(
-           make_atomic_ref(row[cpu]).load(relaxed) ==
-           make_atomic_ref(row[cpu - n]).load(relaxed));
-     }
-   }
-   state.getcpu.exchange(pickGetcpuFunc(), std::memory_order_acq_rel);
-   return true;
- }
- 
- } // namespace detail
- 
- namespace {
- 
- /**
-  * A simple freelist allocator.  Allocates things of size sz, from slabs of size
-  * kAllocSize.  Takes a lock on each allocation/deallocation.
-  */
- class SimpleAllocator {
-  public:
-   // To support array aggregate initialization without an implicit constructor.
-   struct Ctor {};
- 
-   SimpleAllocator(Ctor, size_t sz) : sz_(sz) {}
-   ~SimpleAllocator() {
-     std::lock_guard<std::mutex> g(m_);
-     for (auto& block : blocks_) {
-       folly::aligned_free(block);
-     }
-   }
- 
-   void* allocate() {
-     std::lock_guard<std::mutex> g(m_);
-     // Freelist allocation.
-     if (freelist_) {
-       auto mem = freelist_;
-       freelist_ = *static_cast<void**>(freelist_);
-       return mem;
-     }
- 
-     if (mem_) {
-       // Bump-ptr allocation.
-       if (intptr_t(mem_) % kMallocAlign == 0) {
-         // Avoid allocating pointers that may look like malloc
-         // pointers.
-         mem_ += std::min(sz_, max_align_v);
-       }
-       if (mem_ + sz_ <= end_) {
-         auto mem = mem_;
-         mem_ += sz_;
- 
-         assert(intptr_t(mem) % kMallocAlign != 0);
-         return mem;
-       }
-     }
- 
-     return allocateHard();
-   }
- 
-   static void deallocate(void* ptr) {
-     assert(intptr_t(ptr) % kMallocAlign != 0);
-     // Find the allocator instance.
-     auto addr =
-         reinterpret_cast<void*>(intptr_t(ptr) & ~intptr_t(kAllocSize - 1));
-     auto allocator = *static_cast<SimpleAllocator**>(addr);
- 
-     std::lock_guard<std::mutex> g(allocator->m_);
-     *static_cast<void**>(ptr) = allocator->freelist_;
-     if constexpr (kIsSanitizeAddress) {
-       // If running under ASAN, scrub the memory on deallocation, so we don't
-       // leave pointers that could hide leaks at shutdown, since the backing
-       // slabs may not be deallocated if the instance is a leaky singleton.
-       auto* base = static_cast<char*>(ptr);
-       std::fill(
-           base + sizeof(void*), base + allocator->sz_, static_cast<char>(0));
-     }
-     allocator->freelist_ = ptr;
-   }
- 
-   constexpr static size_t kMallocAlign = 128;
-   static_assert(
-       kMallocAlign % hardware_destructive_interference_size == 0,
-       "Large allocations should be cacheline-aligned");
- 
-  private:
-   constexpr static size_t kAllocSize = 4096;
- 
-   void* allocateHard() {
-     // Allocate a new slab.
-     mem_ = static_cast<uint8_t*>(folly::aligned_malloc(kAllocSize, kAllocSize));
-     if (!mem_) {
-       throw_exception<std::bad_alloc>();
-     }
-     end_ = mem_ + kAllocSize;
-     blocks_.push_back(mem_);
- 
-     // Install a pointer to ourselves as the allocator.
-     *reinterpret_cast<SimpleAllocator**>(mem_) = this;
-     static_assert(
-         max_align_v >= sizeof(SimpleAllocator*), "alignment too small");
-     mem_ += std::min(sz_, max_align_v);
- 
-     // New allocation.
-     auto mem = mem_;
-     mem_ += sz_;
-     assert(intptr_t(mem) % kMallocAlign != 0);
-     return mem;
-   }
- 
-   std::mutex m_;
-   uint8_t* mem_{nullptr};
-   uint8_t* end_{nullptr};
-   void* freelist_{nullptr};
-   size_t sz_;
-   std::vector<void*> blocks_;
- };
- 
- class Allocator {
-  public:
-   void* allocate(size_t size) {
-     if (auto cl = sizeClass(size)) {
-       return allocators_[*cl].allocate();
-     }
- 
-     // Fall back to malloc, returning a kMallocAlign-aligned allocation so it
-     // can be distinguished from SimpleAllocator allocations.
-     size = size + (SimpleAllocator::kMallocAlign - 1);
-     size &= ~size_t(SimpleAllocator::kMallocAlign - 1);
-     void* mem = aligned_malloc(size, SimpleAllocator::kMallocAlign);
-     if (!mem) {
-       throw_exception<std::bad_alloc>();
-     }
-     return mem;
-   }
- 
-   static void deallocate(void* ptr) {
-     if (!ptr) {
-       return;
-     }
- 
-     // See if it came from SimpleAllocator or malloc.
-     if (intptr_t(ptr) % SimpleAllocator::kMallocAlign != 0) {
-       SimpleAllocator::deallocate(ptr);
-     } else {
-       aligned_free(ptr);
-     }
-   }
- 
-  private:
-   std::optional<uint8_t> sizeClass(size_t size) {
-     if (size <= 8) {
-       return static_cast<uint8_t>(0); // [Windows]
-     } else if (size <= 16) {
-       return static_cast<uint8_t>(1); // [Windows]
-     } else if (size <= 32) {
-       return static_cast<uint8_t>(2); // [Windows]
-     } else if (size <= 64) {
-       return static_cast<uint8_t>(3); // [Windows]
-     } else {
-       return std::nullopt;
-     }
-   }
- 
-   std::array<SimpleAllocator, 4> allocators_{
-       {{SimpleAllocator::Ctor{}, 8},
-        {SimpleAllocator::Ctor{}, 16},
-        {SimpleAllocator::Ctor{}, 32},
-        {SimpleAllocator::Ctor{}, 64}}};
- };
- 
- } // namespace
- 
- void* coreMalloc(size_t size, size_t numStripes, size_t stripe) {
-   static folly::Indestructible<Allocator>
-       allocators[AccessSpreader<>::maxLocalityIndexValue()];
-   auto index = AccessSpreader<>::localityIndexForStripe(numStripes, stripe);
-   return allocators[index]->allocate(size);
- }
- 
- void coreFree(void* ptr) {
-   Allocator::deallocate(ptr);
- }
- 
- namespace {
- thread_local CoreAllocatorGuard* gCoreAllocatorGuard = nullptr;
- }
- 
- CoreAllocatorGuard::CoreAllocatorGuard(size_t numStripes, size_t stripe)
-     : numStripes_(numStripes), stripe_(stripe) {
-   CHECK(gCoreAllocatorGuard == nullptr)
-       << "CoreAllocator::Guard cannot be used recursively";
-   gCoreAllocatorGuard = this;
- }
- 
- CoreAllocatorGuard::~CoreAllocatorGuard() {
-   gCoreAllocatorGuard = nullptr;
- }
- 
- namespace detail {
- 
- void* coreMallocFromGuard(size_t size) {
-   CHECK(gCoreAllocatorGuard != nullptr)
-       << "CoreAllocator::allocator called without an active Guard";
-   return coreMalloc(
-       size, gCoreAllocatorGuard->numStripes_, gCoreAllocatorGuard->stripe_);
- }
- 
- } // namespace detail
- 
- } // namespace folly
\ No newline at end of file
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* 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 <folly/concurrency/CacheLocality.h>
+
+#ifndef _MSC_VER
+#define _GNU_SOURCE 1 // for RTLD_NOLOAD
+#include <dlfcn.h>
+#endif
+#include <fstream>
+#include <mutex>
+#include <numeric>
+#include <optional>
+
+#include <fmt/core.h>
+#include <glog/logging.h>
+#include <folly/Indestructible.h>
+#include <folly/Memory.h>
+#include <folly/ScopeGuard.h>
+#include <folly/detail/StaticSingletonManager.h>
+#include <folly/hash/Hash.h>
+#include <folly/lang/Exception.h>
+#include <folly/portability/Unistd.h>
+#include <folly/system/ThreadId.h>
+
+namespace folly {
+
+///////////// CacheLocality
+
+/// Returns the CacheLocality information best for this machine
+static CacheLocality getSystemLocalityInfo() {
+  if (kIsLinux) {
+    // First try to parse /proc/cpuinfo.
+    // If that fails, then try to parse /sys/devices/.
+    // The latter is slower but more accurate.
+    try {
+      return CacheLocality::readFromProcCpuinfo();
+    } catch (...) {
+      // /proc/cpuinfo might be non-standard
+      // lets try with sysfs /sys/devices/cpu
+    }
+
+    try {
+      return CacheLocality::readFromSysfs();
+    } catch (...) {
+      // keep trying
+    }
+  }
+
+  long numCpus = sysconf(_SC_NPROCESSORS_CONF);
+  if (numCpus <= 0) {
+    // This shouldn't happen, but if it does we should try to keep
+    // going.  We are probably not going to be able to parse /sys on
+    // this box either (although we will try), which means we are going
+    // to fall back to the SequentialThreadId splitter.  On my 16 core
+    // (x hyperthreading) dev box 16 stripes is enough to get pretty good
+    // contention avoidance with SequentialThreadId, and there is little
+    // improvement from going from 32 to 64.  This default gives us some
+    // wiggle room
+    numCpus = 32;
+  }
+  return CacheLocality::uniform(size_t(numCpus));
+}
+
+template <>
+const CacheLocality& CacheLocality::system<std::atomic>() {
+  static std::atomic<const CacheLocality*> cache;
+  auto value = cache.load(std::memory_order_acquire);
+  if (value != nullptr) {
+    return *value;
+  }
+  auto next = new CacheLocality(getSystemLocalityInfo());
+  if (cache.compare_exchange_strong(value, next, std::memory_order_acq_rel)) {
+    return *next;
+  }
+  delete next;
+  return *value;
+}
+
+CacheLocality::CacheLocality(std::vector<std::vector<size_t>> equivClasses) {
+  numCpus = equivClasses.size();
+
+  for (size_t cpu = 0; cpu < numCpus; ++cpu) {
+    for (size_t level = 0; level < equivClasses[cpu].size(); ++level) {
+      if (equivClasses[cpu][level] == cpu) {
+        // we only want to count the equiv classes once, so we do it when we
+        // are processing their representative.
+        while (numCachesByLevel.size() <= level) {
+          numCachesByLevel.push_back(0);
+        }
+        numCachesByLevel[level]++;
+      }
+    }
+  }
+
+  std::vector<size_t> cpus(numCpus);
+  std::iota(cpus.begin(), cpus.end(), 0);
+
+  std::sort(cpus.begin(), cpus.end(), [&](size_t lhs, size_t rhs) -> bool {
+    auto& lhsEquiv = equivClasses[lhs];
+    auto& rhsEquiv = equivClasses[rhs];
+
+    // If different cpus have different numbers of caches group first by number
+    // of caches to guarantee strict weak ordering, even though the resulting
+    // order may be sub-optimal.
+    if (lhsEquiv.size() != rhsEquiv.size()) {
+      return lhsEquiv.size() < rhsEquiv.size();
+    }
+
+    // Order by equiv class of cache with highest index, direction doesn't
+    // matter.
+    for (size_t i = lhsEquiv.size(); i > 0; --i) {
+      auto idx = i - 1;
+      if (lhsEquiv[idx] != rhsEquiv[idx]) {
+        return lhsEquiv[idx] < rhsEquiv[idx];
+      }
+    }
+
+    // Break ties deterministically by cpu.
+    return lhs < rhs;
+  });
+
+  // The cpus are now sorted by locality, with neighboring entries closer
+  // to each other than entries that are far away.  For striping we want
+  // the inverse map, since we are starting with the cpu.
+  localityIndexByCpu.resize(numCpus);
+  for (size_t i = 0; i < cpus.size(); ++i) {
+    localityIndexByCpu[cpus[i]] = i;
+  }
+
+  equivClassesByCpu = std::move(equivClasses);
+}
+
+// Each level of cache has sharing sets, which are the set of cpus that share a
+// common cache at that level.  These are available in a hex bitset form
+// (/sys/devices/system/cpu/cpu0/cache/index0/shared_cpu_map, for example).
+// They are also available in human-readable form in the shared_cpu_list file in
+// the same directory.  The list is a comma-separated list of numbers and
+// ranges, where the ranges are pairs of decimal numbers separated by a '-'.
+//
+// To sort the cpus for optimum locality we don't really need to parse the
+// sharing sets, we just need a unique representative from the equivalence
+// class.  The smallest value works fine, and happens to be the first decimal
+// number in the file.  We load all of the equivalence class information from
+// all of the cpu*/index* directories, order the cpus first by increasing
+// last-level cache equivalence class, then by the smaller caches.  Finally, we
+// break ties with the cpu number itself.
+
+/// Returns the first decimal number in the line, or throws an exception if the
+/// line does not start with a number terminated by ',', '-', '\n', or EOS.
+static size_t parseLeadingNumber(const std::string& line) {
+  auto raw = line.c_str();
+  char* end;
+  unsigned long val = strtoul(raw, &end, 10);
+  if (end == raw || (*end != ',' && *end != '-' && *end != '\n' && *end != 0)) {
+    throw std::runtime_error(fmt::format("error parsing list '{}'", line));
+  }
+  return val;
+}
+
+CacheLocality CacheLocality::readFromSysfsTree(
+    const std::function<std::string(std::string const&)>& mapping) {
+  // the list of cache equivalence classes, where equivalence classes
+  // are named by the smallest cpu in the class
+  std::vector<std::vector<size_t>> equivClassesByCpu;
+
+  for (size_t cpu = 0;; ++cpu) {
+    std::vector<size_t> levels;
+    for (size_t index = 0;; ++index) {
+      auto dir = fmt::format(
+          "/sys/devices/system/cpu/cpu{}/cache/index{}/", cpu, index);
+      auto cacheType = mapping(dir + "type");
+      auto equivStr = mapping(dir + "shared_cpu_list");
+      if (cacheType.empty() || equivStr.empty()) {
+        // no more caches
+        break;
+      }
+      if (cacheType[0] == 'I') {
+        // cacheType in { "Data", "Instruction", "Unified" }. skip icache
+        continue;
+      }
+      auto equiv = parseLeadingNumber(equivStr);
+      levels.push_back(equiv);
+    }
+
+    if (levels.empty()) {
+      // no levels at all for this cpu, we must be done
+      break;
+    }
+    equivClassesByCpu.emplace_back(std::move(levels));
+  }
+
+  if (equivClassesByCpu.empty()) {
+    throw std::runtime_error("unable to load cache sharing info");
+  }
+
+  return CacheLocality{std::move(equivClassesByCpu)};
+}
+
+CacheLocality CacheLocality::readFromSysfs() {
+  return readFromSysfsTree([](std::string const& name) {
+    std::ifstream xi(name.c_str());
+    std::string rv;
+    std::getline(xi, rv);
+    return rv;
+  });
+}
+
+namespace {
+
+static bool procCpuinfoLineRelevant(std::string const& line) {
+  return line.size() > 4 && (line[0] == 'p' || line[0] == 'c');
+}
+
+std::vector<std::tuple<size_t, size_t, size_t>> parseProcCpuinfoLines(
+    std::vector<std::string> const& lines) {
+  std::vector<std::tuple<size_t, size_t, size_t>> cpus;
+  size_t physicalId = 0;
+  size_t coreId = 0;
+  size_t maxCpu = 0;
+  size_t numberOfPhysicalIds = 0;
+  size_t numberOfCoreIds = 0;
+  for (auto iter = lines.rbegin(); iter != lines.rend(); ++iter) {
+    auto& line = *iter;
+    if (!procCpuinfoLineRelevant(line)) {
+      continue;
+    }
+
+    auto sepIndex = line.find(':');
+    if (sepIndex == std::string::npos || sepIndex + 2 > line.size()) {
+      continue;
+    }
+    auto arg = line.substr(sepIndex + 2);
+
+    // "physical id" is socket, which is the most important locality
+    // context.  "core id" is a real core, so two "processor" entries with
+    // the same physical id and core id are hyperthreads of each other.
+    // "processor" is the top line of each record, so when we hit it in
+    // the reverse order then we can emit a record.
+    if (line.find("physical id") == 0) {
+      physicalId = parseLeadingNumber(arg);
+      ++numberOfPhysicalIds;
+    } else if (line.find("core id") == 0) {
+      coreId = parseLeadingNumber(arg);
+      ++numberOfCoreIds;
+    } else if (line.find("processor") == 0) {
+      auto cpu = parseLeadingNumber(arg);
+      maxCpu = std::max(cpu, maxCpu);
+      cpus.emplace_back(physicalId, coreId, cpu);
+    }
+  }
+
+  if (cpus.empty()) {
+    throw std::runtime_error("no CPUs parsed from /proc/cpuinfo");
+  }
+  if (maxCpu != cpus.size() - 1) {
+    throw std::runtime_error(
+        "offline CPUs not supported for /proc/cpuinfo cache locality source");
+  }
+  if (numberOfPhysicalIds == 0) {
+    throw std::runtime_error("no physical ids found");
+  }
+  if (numberOfCoreIds == 0) {
+    throw std::runtime_error("no core ids found");
+  }
+
+  return cpus;
+}
+
+} // namespace
+
+CacheLocality CacheLocality::readFromProcCpuinfoLines(
+    std::vector<std::string> const& lines) {
+  // (physicalId, coreId, cpu)
+  std::vector<std::tuple<size_t, size_t, size_t>> cpus =
+      parseProcCpuinfoLines(lines);
+  // Sort to make equivalence classes contiguous.
+  std::sort(cpus.begin(), cpus.end());
+
+  // We can't tell the real cache hierarchy from /proc/cpuinfo, but it works
+  // well enough to assume there are 3 levels, L1 and L2 per-core and L3 per
+  // socket.
+  std::vector<std::vector<size_t>> equivClassesByCpu(cpus.size());
+  size_t l1Equiv = 0;
+  size_t l3Equiv = 0;
+  for (size_t i = 0; i < cpus.size(); ++i) {
+    auto [physicalId, coreId, cpu] = cpus[i];
+    // The representative for each L1 and L3 equivalence class is the first cpu
+    // in the class.
+    if (i == 0 || physicalId != std::get<0>(cpus[i - 1]) ||
+        coreId != std::get<1>(cpus[i - 1])) {
+      l1Equiv = cpu;
+    }
+    if (i == 0 || physicalId != std::get<0>(cpus[i - 1])) {
+      l3Equiv = cpu;
+    }
+    equivClassesByCpu[cpu] = {l1Equiv, l1Equiv, l3Equiv};
+  }
+
+  return CacheLocality{std::move(equivClassesByCpu)};
+}
+
+CacheLocality CacheLocality::readFromProcCpuinfo() {
+  std::vector<std::string> lines;
+  {
+    std::ifstream xi("/proc/cpuinfo");
+    if (xi.fail()) {
+      throw std::runtime_error("unable to open /proc/cpuinfo");
+    }
+    char buf[8192];
+    while (xi.good() && lines.size() < 20000) {
+      xi.getline(buf, sizeof(buf));
+      std::string str(buf);
+      if (procCpuinfoLineRelevant(str)) {
+        lines.emplace_back(std::move(str));
+      }
+    }
+  }
+  return readFromProcCpuinfoLines(lines);
+}
+
+CacheLocality CacheLocality::uniform(size_t numCpus) {
+  // One cache shared by all cpus.
+  std::vector<std::vector<size_t>> equivClassesByCpu(numCpus, {0});
+  return CacheLocality{std::move(equivClassesByCpu)};
+}
+
+////////////// Getcpu
+
+Getcpu::Func Getcpu::resolveVdsoFunc() {
+#if !defined(FOLLY_HAVE_LINUX_VDSO) || defined(FOLLY_SANITIZE_MEMORY)
+  return nullptr;
+#else
+  void* h = dlopen("linux-vdso.so.1", RTLD_LAZY | RTLD_LOCAL | RTLD_NOLOAD);
+  if (h == nullptr) {
+    return nullptr;
+  }
+
+  auto func = Getcpu::Func(dlsym(h, "__vdso_getcpu"));
+  if (func == nullptr) {
+    // technically a null result could either be a failure or a successful
+    // lookup of a symbol with the null value, but the second can't actually
+    // happen for this symbol.  No point holding the handle forever if
+    // we don't need the code
+    dlclose(h);
+  }
+
+  return func;
+#endif
+}
+
+/////////////// SequentialThreadId
+unsigned SequentialThreadId::get() {
+  static std::atomic<unsigned> global{0};
+  static thread_local unsigned local{0};
+  return FOLLY_LIKELY(local) ? local : (local = ++global);
+}
+
+/////////////// HashingThreadId
+unsigned HashingThreadId::get() {
+  return hash::twang_32from64(getCurrentThreadID());
+}
+
+namespace detail {
+
+int AccessSpreaderBase::degenerateGetcpu(unsigned* cpu, unsigned* node, void*) {
+  if (cpu != nullptr) {
+    *cpu = 0;
+  }
+  if (node != nullptr) {
+    *node = 0;
+  }
+  return 0;
+}
+
+struct AccessSpreaderStaticInit {
+  static AccessSpreaderStaticInit instance;
+  AccessSpreaderStaticInit() { (void)AccessSpreader<>::current(~size_t(0)); }
+};
+AccessSpreaderStaticInit AccessSpreaderStaticInit::instance;
+
+bool AccessSpreaderBase::initialize(
+    GlobalState& state,
+    Getcpu::Func (&pickGetcpuFunc)(),
+    const CacheLocality& (&system)()) {
+  (void)AccessSpreaderStaticInit::instance; // ODR-use it so it is not dropped
+  constexpr auto relaxed = std::memory_order_relaxed;
+  auto& cacheLocality = system();
+  auto n = cacheLocality.numCpus;
+  for (size_t width = 0; width <= kMaxCpus; ++width) {
+    auto& row = state.table[width];
+    auto numStripes = std::max(size_t{1}, width);
+    for (size_t cpu = 0; cpu < kMaxCpus && cpu < n; ++cpu) {
+      auto index = cacheLocality.localityIndexByCpu[cpu];
+      assert(index < n);
+      // as index goes from 0..n, post-transform value goes from
+      // 0..numStripes
+      make_atomic_ref(row[cpu]).store(
+          static_cast<CompactStripe>((index * numStripes) / n), relaxed);
+      assert(make_atomic_ref(row[cpu]).load(relaxed) < numStripes);
+    }
+    size_t filled = n;
+    while (filled < kMaxCpus) {
+      size_t len = std::min(filled, kMaxCpus - filled);
+      for (size_t i = 0; i < len; ++i) {
+        make_atomic_ref(row[filled + i])
+            .store(make_atomic_ref(row[i]).load(relaxed), relaxed);
+      }
+      filled += len;
+    }
+    for (size_t cpu = n; cpu < kMaxCpus; ++cpu) {
+      assert(
+          make_atomic_ref(row[cpu]).load(relaxed) ==
+          make_atomic_ref(row[cpu - n]).load(relaxed));
+    }
+  }
+  state.getcpu.exchange(pickGetcpuFunc(), std::memory_order_acq_rel);
+  return true;
+}
+
+} // namespace detail
+
+namespace {
+
+/**
+* A simple freelist allocator.  Allocates things of size sz, from slabs of size
+* kAllocSize.  Takes a lock on each allocation/deallocation.
+*/
+class SimpleAllocator {
+public:
+  // To support array aggregate initialization without an implicit constructor.
+  struct Ctor {};
+
+  SimpleAllocator(Ctor, size_t sz) : sz_(sz) {}
+  ~SimpleAllocator() {
+    std::lock_guard<std::mutex> g(m_);
+    for (auto& block : blocks_) {
+      folly::aligned_free(block);
+    }
+  }
+
+  void* allocate() {
+    std::lock_guard<std::mutex> g(m_);
+    // Freelist allocation.
+    if (freelist_) {
+      auto mem = freelist_;
+      freelist_ = *static_cast<void**>(freelist_);
+      return mem;
+    }
+
+    if (mem_) {
+      // Bump-ptr allocation.
+      if (intptr_t(mem_) % kMallocAlign == 0) {
+        // Avoid allocating pointers that may look like malloc
+        // pointers.
+        mem_ += std::min(sz_, max_align_v);
+      }
+      if (mem_ + sz_ <= end_) {
+        auto mem = mem_;
+        mem_ += sz_;
+
+        assert(intptr_t(mem) % kMallocAlign != 0);
+        return mem;
+      }
+    }
+
+    return allocateHard();
+  }
+
+  static void deallocate(void* ptr) {
+    assert(intptr_t(ptr) % kMallocAlign != 0);
+    // Find the allocator instance.
+    auto addr =
+        reinterpret_cast<void*>(intptr_t(ptr) & ~intptr_t(kAllocSize - 1));
+    auto allocator = *static_cast<SimpleAllocator**>(addr);
+
+    std::lock_guard<std::mutex> g(allocator->m_);
+    *static_cast<void**>(ptr) = allocator->freelist_;
+    if constexpr (kIsSanitizeAddress) {
+      // If running under ASAN, scrub the memory on deallocation, so we don't
+      // leave pointers that could hide leaks at shutdown, since the backing
+      // slabs may not be deallocated if the instance is a leaky singleton.
+      auto* base = static_cast<char*>(ptr);
+      std::fill(
+          base + sizeof(void*), base + allocator->sz_, static_cast<char>(0));
+    }
+    allocator->freelist_ = ptr;
+  }
+
+  constexpr static size_t kMallocAlign = 128;
+  static_assert(
+      kMallocAlign % hardware_destructive_interference_size == 0,
+      "Large allocations should be cacheline-aligned");
+
+private:
+  constexpr static size_t kAllocSize = 4096;
+
+  void* allocateHard() {
+    // Allocate a new slab.
+    mem_ = static_cast<uint8_t*>(folly::aligned_malloc(kAllocSize, kAllocSize));
+    if (!mem_) {
+      throw_exception<std::bad_alloc>();
+    }
+    end_ = mem_ + kAllocSize;
+    blocks_.push_back(mem_);
+
+    // Install a pointer to ourselves as the allocator.
+    *reinterpret_cast<SimpleAllocator**>(mem_) = this;
+    static_assert(
+        max_align_v >= sizeof(SimpleAllocator*), "alignment too small");
+    mem_ += std::min(sz_, max_align_v);
+
+    // New allocation.
+    auto mem = mem_;
+    mem_ += sz_;
+    assert(intptr_t(mem) % kMallocAlign != 0);
+    return mem;
+  }
+
+  std::mutex m_;
+  uint8_t* mem_{nullptr};
+  uint8_t* end_{nullptr};
+  void* freelist_{nullptr};
+  size_t sz_;
+  std::vector<void*> blocks_;
+};
+
+class Allocator {
+public:
+  void* allocate(size_t size) {
+    if (auto cl = sizeClass(size)) {
+      return allocators_[*cl].allocate();
+    }
+
+    // Fall back to malloc, returning a kMallocAlign-aligned allocation so it
+    // can be distinguished from SimpleAllocator allocations.
+    size = size + (SimpleAllocator::kMallocAlign - 1);
+    size &= ~size_t(SimpleAllocator::kMallocAlign - 1);
+    void* mem = aligned_malloc(size, SimpleAllocator::kMallocAlign);
+    if (!mem) {
+      throw_exception<std::bad_alloc>();
+    }
+    return mem;
+  }
+
+  static void deallocate(void* ptr) {
+    if (!ptr) {
+      return;
+    }
+
+    // See if it came from SimpleAllocator or malloc.
+    if (intptr_t(ptr) % SimpleAllocator::kMallocAlign != 0) {
+      SimpleAllocator::deallocate(ptr);
+    } else {
+      aligned_free(ptr);
+    }
+  }
+
+private:
+  std::optional<uint8_t> sizeClass(size_t size) {
+    if (size <= 8) {
+      return static_cast<uint8_t>(0); // [Windows]
+    } else if (size <= 16) {
+      return static_cast<uint8_t>(1); // [Windows]
+    } else if (size <= 32) {
+      return static_cast<uint8_t>(2); // [Windows]
+    } else if (size <= 64) {
+      return static_cast<uint8_t>(3); // [Windows]
+    } else {
+      return std::nullopt;
+    }
+  }
+
+  std::array<SimpleAllocator, 4> allocators_{
+      {{SimpleAllocator::Ctor{}, 8},
+      {SimpleAllocator::Ctor{}, 16},
+      {SimpleAllocator::Ctor{}, 32},
+      {SimpleAllocator::Ctor{}, 64}}};
+};
+
+} // namespace
+
+void* coreMalloc(size_t size, size_t numStripes, size_t stripe) {
+  static folly::Indestructible<Allocator>
+      allocators[AccessSpreader<>::maxLocalityIndexValue()];
+  auto index = AccessSpreader<>::localityIndexForStripe(numStripes, stripe);
+  return allocators[index]->allocate(size);
+}
+
+void coreFree(void* ptr) {
+  Allocator::deallocate(ptr);
+}
+
+namespace {
+thread_local CoreAllocatorGuard* gCoreAllocatorGuard = nullptr;
+}
+
+CoreAllocatorGuard::CoreAllocatorGuard(size_t numStripes, size_t stripe)
+    : numStripes_(numStripes), stripe_(stripe) {
+  CHECK(gCoreAllocatorGuard == nullptr)
+      << "CoreAllocator::Guard cannot be used recursively";
+  gCoreAllocatorGuard = this;
+}
+
+CoreAllocatorGuard::~CoreAllocatorGuard() {
+  gCoreAllocatorGuard = nullptr;
+}
+
+namespace detail {
+
+void* coreMallocFromGuard(size_t size) {
+  CHECK(gCoreAllocatorGuard != nullptr)
+      << "CoreAllocator::allocator called without an active Guard";
+  return coreMalloc(
+      size, gCoreAllocatorGuard->numStripes_, gCoreAllocatorGuard->stripe_);
+}
+
+} // namespace detail
+
+} // namespace folly
\ No newline at end of file
diff --git a/vnext/Folly/TEMP_UntilFollyUpdate/json.cpp b/vnext/Folly/TEMP_UntilFollyUpdate/json.cpp
deleted file mode 100644
index 1f094b51bbd..00000000000
--- a/vnext/Folly/TEMP_UntilFollyUpdate/json.cpp
+++ /dev/null
@@ -1,1117 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * 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 <folly/json/json.h>
-
- #include <algorithm>
- #include <functional>
- #include <iterator>
- #include <sstream>
- #include <type_traits>
- 
- #include <boost/algorithm/string.hpp>
- #include <glog/logging.h>
- 
- #include <folly/Conv.h>
- #include <folly/Portability.h>
- #include <folly/Range.h>
- #include <folly/Unicode.h>
- #include <folly/Utility.h>
- #include <folly/lang/Bits.h>
- #include <folly/portability/Constexpr.h>
- 
- namespace folly {
- 
- //////////////////////////////////////////////////////////////////////
- 
- namespace json {
- 
- namespace {
- 
- parse_error make_parse_error(
-     unsigned int line,
-     std::string const& context,
-     std::string const& expected) {
-   return parse_error(to<std::string>(
-       "json parse error on line ",
-       line,
-       !context.empty() ? to<std::string>(" near `", context, '\'') : "",
-       ": ",
-       expected));
- }
- 
- struct Printer {
-   // Context class is allows to restore the path to element that we are about to
-   // print so that if error happens we can throw meaningful exception.
-   class Context {
-    public:
-     Context(const Context* parent_context, const dynamic& key)
-         : parent_context_(parent_context), key_(key), is_key_(false) {}
-     Context(const Context* parent_context, const dynamic& key, bool is_key)
-         : parent_context_(parent_context), key_(key), is_key_(is_key) {}
- 
-     // Return location description of a context as a chain of keys
-     // ex., '"outherKey"->"innerKey"'.
-     std::string locationDescription() const {
-       std::vector<std::string> keys;
-       const Context* ptr = parent_context_;
-       while (ptr) {
-         keys.push_back(ptr->getName());
-         ptr = ptr->parent_context_;
-       }
-       keys.push_back(getName());
-       std::ostringstream stream;
-       std::reverse_copy(
-           keys.begin(),
-           keys.end() - 1,
-           std::ostream_iterator<std::string>(stream, "->"));
- 
-       // Add current key.
-       stream << keys.back();
-       return stream.str();
-     }
-     std::string getName() const {
-       return Printer::toStringOr(key_, "<unprintable>");
-     }
-     std::string typeDescription() const { return is_key_ ? "key" : "value"; }
- 
-    private:
-     const Context* const parent_context_;
-     const dynamic& key_;
-     bool is_key_;
-   };
- 
-   explicit Printer(
-       std::string& out, unsigned* indentLevel, serialization_opts const* opts)
-       : out_(out), indentLevel_(indentLevel), opts_(*opts) {}
- 
-   void operator()(dynamic const& v, const Context& context) const {
-     (*this)(v, &context);
-   }
-   void operator()(dynamic const& v, const Context* context) const {
-     switch (v.type()) {
-       case dynamic::DOUBLE: {
-         if (!opts_.allow_nan_inf) {
-           if (std::isnan(v.asDouble())) {
-             throw json::print_error(
-                 "folly::toJson: JSON object value was a NaN when serializing " +
-                 contextDescription(context));
-           }
-           if (std::isinf(v.asDouble())) {
-             throw json::print_error(
-                 "folly::toJson: JSON object value was an INF when serializing " +
-                 contextDescription(context));
-           }
-         }
-         toAppend(
-             v.asDouble(),
-             &out_,
-             opts_.dtoa_mode,
-             opts_.double_num_digits,
-             opts_.dtoa_flags);
-         break;
-       }
-       case dynamic::INT64: {
-         auto intval = v.asInt();
-         if (opts_.javascript_safe) {
-           // Use folly::to to check that this integer can be represented
-           // as a double without loss of precision.
-           intval = int64_t(to<double>(intval));
-         }
-         toAppend(intval, &out_);
-         break;
-       }
-       case dynamic::BOOL:
-         out_ += v.asBool() ? "true" : "false";
-         break;
-       case dynamic::NULLT:
-         out_ += "null";
-         break;
-       case dynamic::STRING:
-         escapeString(v.stringPiece(), out_, opts_);
-         break;
-       case dynamic::OBJECT:
-         printObject(v, context);
-         break;
-       case dynamic::ARRAY:
-         printArray(v, context);
-         break;
-       default:
-         CHECK(0) << "Bad type " << v.type();
-     }
-   }
- 
-  private:
-   void printKV(
-       dynamic const& o,
-       const std::pair<const dynamic, dynamic>& p,
-       const Context* context) const {
-     if (opts_.convert_int_keys && p.first.isInt()) {
-       auto strKey = p.first.asString();
-       if (o.count(strKey)) {
-         throw json::print_error(folly::to<std::string>(
-             "folly::toJson: Source object has integer and string keys "
-             "representing the same value: ",
-             p.first.asInt()));
-       }
-       (*this)(p.first.asString(), Context(context, p.first, true));
-     } else if (!opts_.allow_non_string_keys && !p.first.isString()) {
-       throw json::print_error(
-           "folly::toJson: JSON object key " +
-           toStringOr(p.first, "<unprintable key>") + " was not a string " +
-           (opts_.convert_int_keys ? "or integer " : "") +
-           "when serializing key at " +
-           Context(context, p.first, true).locationDescription());
-     } else {
-       (*this)(p.first, Context(context, p.first, true)); // Key
-     }
-     mapColon();
-     (*this)(p.second, Context(context, p.first, false)); // Value
-   }
- 
-   template <typename Iterator>
-   void printKVPairs(
-       dynamic const& o,
-       Iterator begin,
-       Iterator end,
-       const Context* context) const {
-     printKV(o, *begin, context);
-     for (++begin; begin != end; ++begin) {
-       out_ += ',';
-       newline();
-       printKV(o, *begin, context);
-     }
-   }
- 
-   void printObject(dynamic const& o, const Context* context) const {
-     if (o.empty()) {
-       out_ += "{}";
-       return;
-     }
- 
-     out_ += '{';
-     indent();
-     newline();
-     if (opts_.sort_keys || opts_.sort_keys_by) {
-       using ref = std::reference_wrapper<decltype(o.items())::value_type const>;
-       auto sort_keys_by = [&](auto begin, auto end, const auto& comp) {
-         std::sort(begin, end, [&](ref a, ref b) {
-           // Only compare keys.  No ordering among identical keys.
-           return comp(a.get().first, b.get().first);
-         });
-       };
-       std::vector<ref> refs(o.items().begin(), o.items().end());
-       if (opts_.sort_keys_by) {
-         sort_keys_by(refs.begin(), refs.end(), opts_.sort_keys_by);
-       } else {
-         sort_keys_by(refs.begin(), refs.end(), std::less<>());
-       }
-       printKVPairs(o, refs.cbegin(), refs.cend(), context);
-     } else {
-       printKVPairs(o, o.items().begin(), o.items().end(), context);
-     }
-     outdent();
-     newline();
-     out_ += '}';
-   }
- 
-   static std::string toStringOr(dynamic const& v, const char* placeholder) {
-     try {
-       std::string result;
-       unsigned indentLevel = 0;
-       serialization_opts opts;
-       opts.allow_nan_inf = true;
-       opts.allow_non_string_keys = true;
-       Printer printer(result, &indentLevel, &opts);
-       printer(v, nullptr);
-       return result;
-     } catch (...) {
-       return placeholder;
-     }
-   }
- 
-   static std::string contextDescription(const Context* context) {
-     if (!context) {
-       return "<undefined location>";
-     }
-     return context->typeDescription() + " at " + context->locationDescription();
-   }
- 
-   void printArray(dynamic const& a, const Context* context) const {
-     if (a.empty()) {
-       out_ += "[]";
-       return;
-     }
- 
-     out_ += '[';
-     indent();
-     newline();
-     (*this)(a[0], Context(context, dynamic(0)));
-     for (auto it = std::next(a.begin()); it != a.end(); ++it) {
-       out_ += ',';
-       newline();
-       (*this)(*it, Context(context, dynamic(std::distance(a.begin(), it))));
-     }
-     outdent();
-     newline();
-     out_ += ']';
-   }
- 
-  private:
-   void outdent() const {
-     if (indentLevel_) {
-       --*indentLevel_;
-     }
-   }
- 
-   void indent() const {
-     if (indentLevel_) {
-       ++*indentLevel_;
-     }
-   }
- 
-   void newline() const {
-     if (indentLevel_) {
-       auto indent = *indentLevel_ * opts_.pretty_formatting_indent_width;
-       out_ += to<std::string>('\n', std::string(indent, ' '));
-     }
-   }
- 
-   void mapColon() const { out_ += indentLevel_ ? ": " : ":"; }
- 
-  private:
-   std::string& out_;
-   unsigned* const indentLevel_;
-   serialization_opts const& opts_;
- };
- 
- //////////////////////////////////////////////////////////////////////
- 
- // Wraps our input buffer with some helper functions.
- struct Input {
-   explicit Input(StringPiece range, json::serialization_opts const* opts)
-       : range_(range), opts_(*opts), lineNum_(0) {
-     storeCurrent();
-   }
- 
-   Input(Input const&) = delete;
-   Input& operator=(Input const&) = delete;
- 
-   char const* begin() const { return range_.begin(); }
- 
-   unsigned getLineNum() const { return lineNum_; }
- 
-   // Parse ahead for as long as the supplied predicate is satisfied,
-   // returning a range of what was skipped.
-   template <class Predicate>
-   StringPiece skipWhile(const Predicate& p) {
-     std::size_t skipped = 0;
-     for (; skipped < range_.size(); ++skipped) {
-       if (!p(range_[skipped])) {
-         break;
-       }
-       if (range_[skipped] == '\n') {
-         ++lineNum_;
-       }
-     }
-     auto ret = range_.subpiece(0, skipped);
-     range_.advance(skipped);
-     storeCurrent();
-     return ret;
-   }
- 
-   StringPiece skipDigits() {
-     return skipWhile([](char c) { return c >= '0' && c <= '9'; });
-   }
- 
-   StringPiece skipMinusAndDigits() {
-     bool firstChar = true;
-     return skipWhile([&firstChar](char c) {
-       bool result = (c >= '0' && c <= '9') || (firstChar && c == '-');
-       firstChar = false;
-       return result;
-     });
-   }
- 
-   void skipWhitespace() {
-     unsigned index = 0;
-     while (true) {
-       while (index < range_.size() && range_[index] == ' ') {
-         index++;
-       }
-       if (index < range_.size()) {
-         if (range_[index] == '\n') {
-           index++;
-           ++lineNum_;
-           continue;
-         }
-         if (range_[index] == '\t' || range_[index] == '\r') {
-           index++;
-           continue;
-         }
-       }
-       break;
-     }
-     range_.advance(index);
-     storeCurrent();
-   }
- 
-   void expect(char c) {
-     if (**this != c) {
-       throw json::make_parse_error(
-           lineNum_, context(), to<std::string>("expected '", c, '\''));
-     }
-     ++*this;
-   }
- 
-   std::size_t size() const { return range_.size(); }
- 
-   int operator*() const { return current_; }
- 
-   void operator++() {
-     range_.pop_front();
-     storeCurrent();
-   }
- 
-   template <class T>
-   T extract() {
-     try {
-       return to<T>(&range_);
-     } catch (std::exception const& e) {
-       error(e.what());
-     }
-   }
- 
-   bool consume(StringPiece str) {
-     if (boost::starts_with(range_, str)) {
-       range_.advance(str.size());
-       storeCurrent();
-       return true;
-     }
-     return false;
-   }
- 
-   std::string context() const {
-     return range_.subpiece(0, 16 /* arbitrary */).toString();
-   }
- 
-   [[noreturn]] void error(char const* what) const {
-     throw json::make_parse_error(lineNum_, context(), what);
-   }
-   template <typename R>
-   R error(char const* what) const {
-     error(what);
-   }
- 
-   json::serialization_opts const& getOpts() { return opts_; }
- 
-   void incrementRecursionLevel() {
-     if (currentRecursionLevel_ > opts_.recursion_limit) {
-       error("recursion limit exceeded");
-     }
-     currentRecursionLevel_++;
-   }
- 
-   void decrementRecursionLevel() { currentRecursionLevel_--; }
- 
-  private:
-   void storeCurrent() { current_ = range_.empty() ? EOF : range_.front(); }
- 
-  private:
-   StringPiece range_;
-   json::serialization_opts const& opts_;
-   unsigned lineNum_;
-   int current_;
-   unsigned int currentRecursionLevel_{0};
- };
- 
- class RecursionGuard {
-  public:
-   explicit RecursionGuard(Input& in) : in_(in) {
-     in_.incrementRecursionLevel();
-   }
- 
-   ~RecursionGuard() { in_.decrementRecursionLevel(); }
- 
-  private:
-   Input& in_;
- };
- 
- dynamic parseValue(Input& in, json::metadata_map* map);
- std::string parseString(Input& in);
- dynamic parseNumber(Input& in);
- 
- void parseObjectKeyValue(
-     Input& in,
-     dynamic& ret,
-     dynamic&& key,
-     json::metadata_map* map,
-     bool distinct) {
-   auto keyLineNumber = in.getLineNum();
-   in.skipWhitespace();
-   in.expect(':');
-   in.skipWhitespace();
-   auto valueLineNumber = in.getLineNum();
-   auto value = parseValue(in, map);
-   auto [it, inserted] = ret.try_emplace(std::move(key), std::move(value));
-   if (!inserted) {
-     if (distinct) {
-       in.error("duplicate key inserted");
-     }
-     it->second = std::move(value);
-   }
-   if (map) {
-     map->emplace(
-         &it->second,
-         json::parse_metadata{{{keyLineNumber}}, {{valueLineNumber}}});
-   }
- }
- 
- dynamic parseObject(Input& in, json::metadata_map* map) {
-   DCHECK_EQ(*in, '{');
-   ++in;
- 
-   dynamic ret = dynamic::object;
- 
-   in.skipWhitespace();
-   if (*in == '}') {
-     ++in;
-     return ret;
-   }
- 
-   const auto& opts = in.getOpts();
-   const bool distinct = opts.validate_keys || opts.convert_int_keys;
-   for (;;) {
-     if (opts.allow_trailing_comma && *in == '}') {
-       break;
-     }
-     dynamic key = parseValue(in, map);
-     if (opts.convert_int_keys && key.isInt()) {
-       key = key.asString();
-     } else if (!opts.allow_non_string_keys && !key.isString()) {
-       in.error(
-           opts.convert_int_keys ? "expected string or integer for object key"
-                                 : "expected string for object key");
-     }
-     parseObjectKeyValue(in, ret, std::move(key), map, distinct);
- 
-     in.skipWhitespace();
-     if (*in != ',') {
-       break;
-     }
-     ++in;
-     in.skipWhitespace();
-   }
-   in.expect('}');
- 
-   return ret;
- }
- 
- dynamic parseArray(Input& in, json::metadata_map* map) {
-   DCHECK_EQ(*in, '[');
-   ++in;
- 
-   dynamic ret = dynamic::array;
- 
-   in.skipWhitespace();
-   if (*in == ']') {
-     ++in;
-     return ret;
-   }
- 
-   std::vector<uint32_t> lineNumbers;
-   for (;;) {
-     if (in.getOpts().allow_trailing_comma && *in == ']') {
-       break;
-     }
-     ret.push_back(parseValue(in, map));
-     if (map) {
-       lineNumbers.push_back(in.getLineNum());
-     }
-     in.skipWhitespace();
-     if (*in != ',') {
-       break;
-     }
-     ++in;
-     in.skipWhitespace();
-   }
-   if (map) {
-     for (size_t i = 0, e = ret.size(); i < e; i++) {
-       map->emplace(&ret[i], json::parse_metadata{{{0}}, {{lineNumbers[i]}}});
-     }
-   }
-   in.expect(']');
- 
-   return ret;
- }
- 
- dynamic parseNumber(Input& in) {
-   bool const negative = (*in == '-');
-   if (negative && in.consume("-Infinity")) {
-     if (in.getOpts().parse_numbers_as_strings) {
-       return "-Infinity";
-     } else {
-       return -std::numeric_limits<double>::infinity();
-     }
-   }
- 
-   auto integral = in.skipMinusAndDigits();
-   if (negative && integral.size() < 2) {
-     in.error("expected digits after `-'");
-   }
- 
-   auto const wasE = *in == 'e' || *in == 'E';
- 
-   if (*in != '.' && !wasE && in.getOpts().parse_numbers_as_strings) {
-     return integral;
-   }
- 
-   constexpr const char* maxIntStr = "9223372036854775807";
-   constexpr const char* minIntStr = "-9223372036854775808";
-   constexpr auto maxIntLen = constexpr_strlen(maxIntStr);
-   constexpr auto minIntLen = constexpr_strlen(minIntStr);
-   auto extremaLen = negative ? minIntLen : maxIntLen;
-   auto extremaStr = negative ? minIntStr : maxIntStr;
-   if (*in != '.' && !wasE) {
-     if (FOLLY_LIKELY(
-             !in.getOpts().double_fallback || integral.size() < extremaLen) ||
-         (integral.size() == extremaLen && integral <= extremaStr)) {
-       auto val = to<int64_t>(integral);
-       in.skipWhitespace();
-       return val;
-     } else {
-       auto val = to<double>(integral);
-       in.skipWhitespace();
-       return val;
-     }
-   }
- 
-   auto end = !wasE ? (++in, in.skipDigits().end()) : in.begin();
-   if (*in == 'e' || *in == 'E') {
-     ++in;
-     if (*in == '+' || *in == '-') {
-       ++in;
-     }
-     auto expPart = in.skipDigits();
-     end = expPart.end();
-   }
-   auto fullNum = range(integral.begin(), end);
-   if (in.getOpts().parse_numbers_as_strings) {
-     return fullNum;
-   }
-   auto val = to<double>(fullNum);
-   return val;
- }
- 
- void decodeUnicodeEscape(Input& in, std::string& out) {
-   auto hexVal = [&](int c) -> uint16_t {
-     // clang-format off
-     return uint16_t(
-         c >= '0' && c <= '9' ? c - '0' :
-         c >= 'a' && c <= 'f' ? c - 'a' + 10 :
-         c >= 'A' && c <= 'F' ? c - 'A' + 10 :
-         in.error<uint16_t>("invalid hex digit"));
-     // clang-format on
-   };
- 
-   auto readHex = [&]() -> uint16_t {
-     if (in.size() < 4) {
-       in.error("expected 4 hex digits");
-     }
- 
-     auto ret = uint16_t(hexVal(*in) * 4096);
-     ++in;
-     ret += hexVal(*in) * 256;
-     ++in;
-     ret += hexVal(*in) * 16;
-     ++in;
-     ret += hexVal(*in);
-     ++in;
-     return ret;
-   };
- 
-   //  If the value encoded is in the surrogate pair range, we need to make
-   //  sure there is another escape that we can use also.
-   //
-   //  See the explanation in folly/Unicode.h.
-   uint16_t prefix = readHex();
-   char32_t codePoint = prefix;
-   if (utf16_code_unit_is_high_surrogate(prefix)) {
-     if (!in.consume("\\u")) {
-       in.error(
-           "expected another unicode escape for second half of "
-           "surrogate pair");
-     }
-     uint16_t suffix = readHex();
-     if (!utf16_code_unit_is_low_surrogate(suffix)) {
-       in.error("second character in surrogate pair is invalid");
-     }
-     codePoint = unicode_code_point_from_utf16_surrogate_pair(prefix, suffix);
-   } else if (!utf16_code_unit_is_bmp(prefix)) {
-     in.error("invalid unicode code point (in range [0xdc00,0xdfff])");
-   }
- 
-   appendCodePointToUtf8(codePoint, out);
- }
- 
- std::string parseString(Input& in) {
-   DCHECK_EQ(*in, '\"');
-   ++in;
- 
-   std::string ret;
-   for (;;) {
-     auto range = in.skipWhile([](char c) { return c != '\"' && c != '\\'; });
-     ret.append(range.begin(), range.end());
- 
-     if (*in == '\"') {
-       ++in;
-       break;
-     }
-     if (*in == '\\') {
-       ++in;
-       switch (*in) {
-           // clang-format off
-         case '\"':    ret.push_back('\"'); ++in; break;
-         case '\\':    ret.push_back('\\'); ++in; break;
-         case '/':     ret.push_back('/');  ++in; break;
-         case 'b':     ret.push_back('\b'); ++in; break;
-         case 'f':     ret.push_back('\f'); ++in; break;
-         case 'n':     ret.push_back('\n'); ++in; break;
-         case 'r':     ret.push_back('\r'); ++in; break;
-         case 't':     ret.push_back('\t'); ++in; break;
-         case 'u':     ++in; decodeUnicodeEscape(in, ret); break;
-         // clang-format on
-         default:
-           in.error(
-               to<std::string>("unknown escape ", *in, " in string").c_str());
-       }
-       continue;
-     }
-     if (*in == EOF) {
-       in.error("unterminated string");
-     }
-     if (!*in) {
-       /*
-        * Apparently we're actually supposed to ban all control
-        * characters from strings.  This seems unnecessarily
-        * restrictive, so we're only banning zero bytes.  (Since the
-        * string is presumed to be UTF-8 encoded it's fine to just
-        * check this way.)
-        */
-       in.error("null byte in string");
-     }
- 
-     ret.push_back(char(*in));
-     ++in;
-   }
- 
-   return ret;
- }
- 
- dynamic parseValue(Input& in, json::metadata_map* map) {
-   RecursionGuard guard(in);
- 
-   in.skipWhitespace();
-   // clang-format off
-   return
-       *in == '[' ? parseArray(in, map) :
-       *in == '{' ? parseObject(in, map) :
-       *in == '\"' ? parseString(in) :
-       (*in == '-' || (*in >= '0' && *in <= '9')) ? parseNumber(in) :
-       in.consume("true") ? true :
-       in.consume("false") ? false :
-       in.consume("null") ? nullptr :
-       in.consume("Infinity") ?
-       (in.getOpts().parse_numbers_as_strings ? (dynamic)"Infinity" :
-         (dynamic)std::numeric_limits<double>::infinity()) :
-       in.consume("NaN") ?
-         (in.getOpts().parse_numbers_as_strings ? (dynamic)"NaN" :
-           (dynamic)std::numeric_limits<double>::quiet_NaN()) :
-       in.error<dynamic>("expected json value");
-   // clang-format on
- }
- 
- } // namespace
- 
- //////////////////////////////////////////////////////////////////////
- 
- std::array<uint64_t, 2> buildExtraAsciiToEscapeBitmap(StringPiece chars) {
-   std::array<uint64_t, 2> escapes{{0, 0}};
-   for (auto b : ByteRange(chars)) {
-     if (b >= 0x20 && b < 0x80) {
-       escapes[b / 64] |= uint64_t(1) << (b % 64);
-     }
-   }
-   return escapes;
- }
- 
- std::string serialize(dynamic const& dyn, serialization_opts const& opts) {
-   std::string ret;
-   unsigned indentLevel = 0;
-   Printer p(ret, opts.pretty_formatting ? &indentLevel : nullptr, &opts);
-   p(dyn, nullptr);
-   return ret;
- }
- 
- // Fast path to determine the longest prefix that can be left
- // unescaped in a string of sizeof(T) bytes packed in an integer of
- // type T.
- template <bool EnableExtraAsciiEscapes, class T>
- size_t firstEscapableInWord(T s, const serialization_opts& opts) {
-   static_assert(std::is_unsigned<T>::value, "Unsigned integer required");
-   static constexpr T kOnes = ~T() / 255; // 0x...0101
-   static constexpr T kMsbs = kOnes * 0x80; // 0x...8080
- 
-   // Sets the MSB of bytes < b. Precondition: b < 128.
-   auto isLess = [](T w, uint8_t b) {
-     // A byte is < b iff subtracting b underflows, so we check that
-     // the MSB wasn't set before and it's set after the subtraction.
-     return (w - kOnes * b) & ~w & kMsbs;
-   };
- 
-   auto isChar = [&](uint8_t c) {
-     // A byte is == c iff it is 0 if xor'd with c.
-     return isLess(s ^ (kOnes * c), 1);
-   };
- 
-   // The following masks have the MSB set for each byte of the word
-   // that satisfies the corresponding condition.
-   auto isHigh = s & kMsbs; // >= 128
-   auto isLow = isLess(s, 0x20); // <= 0x1f
-   auto needsEscape = isHigh | isLow | isChar('\\') | isChar('"');
- 
-   if /* constexpr */ (EnableExtraAsciiEscapes) {
-     // Deal with optional bitmap for unicode escapes. Escapes can optionally be
-     // set for ascii characters 32 - 127, so the inner loop may run up to 96
-     // times. However, for the case where 0 or a handful of bits are set,
-     // looping will be minimal through use of findFirstSet.
-     for (size_t i = 0, e = opts.extra_ascii_to_escape_bitmap.size(); i < e;
-          ++i) {
-       const auto offset = i * 64;
-       // Clear first 32 characters if this is the first index, since those are
-       // always escaped.
-       auto bitmap = opts.extra_ascii_to_escape_bitmap[i] &
-           (i == 0 ? uint64_t(-1) << 32 : ~0ULL);
-       while (bitmap) {
-         auto bit = folly::findFirstSet(bitmap);
-         needsEscape |= isChar(static_cast<uint8_t>(offset + bit - 1));
-         bitmap &= bitmap - 1;
-       }
-     }
-   }
- 
-   if (!needsEscape) {
-     return sizeof(T);
-   }
- 
-   if (folly::kIsLittleEndian) {
-     return folly::findFirstSet(needsEscape) / 8 - 1;
-   } else {
-     return sizeof(T) - folly::findLastSet(needsEscape) / 8;
-   }
- }
- 
- // Escape a string so that it is legal to print it in JSON text.
- template <bool EnableExtraAsciiEscapes>
- void escapeStringImpl(
-     StringPiece input, std::string& out, const serialization_opts& opts) {
-   auto hexDigit = [](uint8_t c) -> char {
-     return c < 10 ? c + '0' : c - 10 + 'a';
-   };
- 
-   out.push_back('\"');
- 
-   auto* p = reinterpret_cast<const unsigned char*>(input.begin());
-   auto* q = reinterpret_cast<const unsigned char*>(input.begin());
-   auto* e = reinterpret_cast<const unsigned char*>(input.end());
- 
-   while (p < e) {
-     // Find the longest prefix that does not need escaping, and copy
-     // it literally into the output string.
-     auto firstEsc = p;
-     while (firstEsc < e) {
-       auto avail = to_unsigned(e - firstEsc);
-       uint64_t word = 0;
-       if (avail >= 8) {
-         word = folly::loadUnaligned<uint64_t>(firstEsc);
-       } else {
-         word = folly::partialLoadUnaligned<uint64_t>(firstEsc, avail);
-       }
-       auto prefix = firstEscapableInWord<EnableExtraAsciiEscapes>(word, opts);
-       DCHECK_LE(prefix, avail);
-      // [Windows Sometimes prefix is completely wrong (corrupt?), only in Release, causing a later AV (see issue #14394).
-      // Prefix should always be <= avail, capping it here as a workaround, hoping the assert above eventually catches this in Debug.
-      prefix = std::min(prefix, (size_t)avail);
-      // Windows]
-       firstEsc += prefix;
-       if (prefix < 8) {
-         break;
-       }
-     }
-     if (firstEsc > p) {
-       out.append(reinterpret_cast<const char*>(p), firstEsc - p);
-       p = firstEsc;
-       // We can't be in the middle of a multibyte sequence, so we can reset q.
-       q = p;
-       if (p == e) {
-         break;
-       }
-     }
- 
-     // Handle the next byte that may need escaping.
- 
-     // Since non-ascii encoding inherently does utf8 validation
-     // we explicitly validate utf8 only if non-ascii encoding is disabled.
-     if ((opts.validate_utf8 || opts.skip_invalid_utf8) &&
-         !opts.encode_non_ascii) {
-       // To achieve better spatial and temporal coherence
-       // we do utf8 validation progressively along with the
-       // string-escaping instead of two separate passes.
- 
-       // As the encoding progresses, q will stay at or ahead of p.
-       CHECK_GE(q, p);
- 
-       // As p catches up with q, move q forward.
-       if (q == p) {
-         // calling utf8_decode has the side effect of
-         // checking that utf8 encodings are valid
-         char32_t v = utf8ToCodePoint(q, e, opts.skip_invalid_utf8);
-         if (opts.skip_invalid_utf8 && v == U'\ufffd') {
-           out.append(reinterpret_cast<const char*>(u8"\ufffd"));
-           p = q;
-           continue;
-         }
-       }
-     }
- 
-     auto encodeUnicode = opts.encode_non_ascii && (*p & 0x80);
-     if /* constexpr */ (EnableExtraAsciiEscapes) {
-       encodeUnicode = encodeUnicode ||
-           (*p >= 0x20 && *p < 0x80 &&
-            (opts.extra_ascii_to_escape_bitmap[*p / 64] &
-             (uint64_t(1) << (*p % 64))));
-     }
- 
-     if (encodeUnicode) {
-       // note that this if condition captures utf8 chars
-       // with value > 127, so size > 1 byte (or they are whitelisted for
-       // Unicode encoding).
-       // NOTE: char32_t / char16_t are both unsigned.
-       char32_t cp = utf8ToCodePoint(p, e, opts.skip_invalid_utf8);
-       auto writeHex = [&](char16_t v) {
-         char buf[] = "\\u\0\0\0\0";
-         buf[2] = hexDigit((v >> 12) & 0x0f);
-         buf[3] = hexDigit((v >> 8) & 0x0f);
-         buf[4] = hexDigit((v >> 4) & 0x0f);
-         buf[5] = hexDigit(v & 0x0f);
-         out.append(buf, 6);
-       };
-       // From the ECMA-404 The JSON Data Interchange Syntax 2nd Edition Dec 2017
-       if (cp < 0x10000u) {
-         // If the code point is in the Basic Multilingual Plane (U+0000 through
-         // U+FFFF), then it may be represented as a six-character sequence:
-         // a reverse solidus, followed by the lowercase letter u, followed by
-         // four hexadecimal digits that encode the code point.
-         writeHex(static_cast<char16_t>(cp));
-       } else {
-         // To escape a code point that is not in the Basic Multilingual Plane,
-         // the character may be represented as a twelve-character sequence,
-         // encoding the UTF-16 surrogate pair corresponding to the code point.
-         writeHex(static_cast<char16_t>(
-             0xd800u + (((cp - 0x10000u) >> 10) & 0x3ffu)));
-         writeHex(static_cast<char16_t>(0xdc00u + ((cp - 0x10000u) & 0x3ffu)));
-       }
-     } else if (*p == '\\' || *p == '\"') {
-       char buf[] = "\\\0";
-       buf[1] = char(*p++);
-       out.append(buf, 2);
-     } else if (*p <= 0x1f) {
-       switch (*p) {
-           // clang-format off
-         case '\b': out.append("\\b"); p++; break;
-         case '\f': out.append("\\f"); p++; break;
-         case '\n': out.append("\\n"); p++; break;
-         case '\r': out.append("\\r"); p++; break;
-         case '\t': out.append("\\t"); p++; break;
-         // clang-format on
-         default:
-           // Note that this if condition captures non readable chars
-           // with value < 32, so size = 1 byte (e.g control chars).
-           char buf[] = "\\u00\0\0";
-           buf[4] = hexDigit(uint8_t((*p & 0xf0) >> 4));
-           buf[5] = hexDigit(uint8_t(*p & 0xf));
-           out.append(buf, 6);
-           p++;
-       }
-     } else {
-       out.push_back(char(*p++));
-     }
-   }
- 
-   out.push_back('\"');
- }
- 
- void escapeString(
-     StringPiece input, std::string& out, const serialization_opts& opts) {
-   if (FOLLY_UNLIKELY(
-           opts.extra_ascii_to_escape_bitmap[0] ||
-           opts.extra_ascii_to_escape_bitmap[1])) {
-     escapeStringImpl<true>(input, out, opts);
-   } else {
-     escapeStringImpl<false>(input, out, opts);
-   }
- }
- 
- std::string stripComments(StringPiece jsonC) {
-   std::string result;
-   enum class State {
-     None,
-     InString,
-     InlineComment,
-     LineComment
-   } state = State::None;
- 
-   for (size_t i = 0; i < jsonC.size(); ++i) {
-     auto s = jsonC.subpiece(i);
-     switch (state) {
-       case State::None:
-         if (s.startsWith("/*")) {
-           state = State::InlineComment;
-           ++i;
-           continue;
-         } else if (s.startsWith("//")) {
-           state = State::LineComment;
-           ++i;
-           continue;
-         } else if (s[0] == '\"') {
-           state = State::InString;
-         }
-         result.push_back(s[0]);
-         break;
-       case State::InString:
-         if (s[0] == '\\') {
-           if (FOLLY_UNLIKELY(s.size() == 1)) {
-             throw std::logic_error("Invalid JSONC: string is not terminated");
-           }
-           result.push_back(s[0]);
-           result.push_back(s[1]);
-           ++i;
-           continue;
-         } else if (s[0] == '\"') {
-           state = State::None;
-         }
-         result.push_back(s[0]);
-         break;
-       case State::InlineComment:
-         if (s.startsWith('\n')) {
-           // preserve the line break to preserve the line count
-           result.push_back(s[0]);
-         } else if (s.startsWith("*/")) {
-           state = State::None;
-           ++i;
-         }
-         break;
-       case State::LineComment:
-         if (s[0] == '\n') {
-           // preserve the line break to preserve the line count
-           result.push_back(s[0]);
-           state = State::None;
-         }
-         break;
-       default:
-         throw std::logic_error("Unknown comment state");
-     }
-   }
-   return result;
- }
- 
- } // namespace json
- 
- //////////////////////////////////////////////////////////////////////
- 
- dynamic parseJsonWithMetadata(StringPiece range, json::metadata_map* map) {
-   return parseJsonWithMetadata(range, json::serialization_opts(), map);
- }
- 
- dynamic parseJsonWithMetadata(
-     StringPiece range,
-     json::serialization_opts const& opts,
-     json::metadata_map* map) {
-   json::Input in(range, &opts);
- 
-   uint32_t n = in.getLineNum();
-   auto ret = parseValue(in, map);
-   if (map) {
-     map->emplace(&ret, json::parse_metadata{{{0}}, {{n}}});
-   }
- 
-   in.skipWhitespace();
-   if (in.size() && *in != '\0') {
-     in.error("parsing didn't consume all input");
-   }
-   return ret;
- }
- 
- dynamic parseJson(StringPiece range) {
-   return parseJson(range, json::serialization_opts());
- }
- 
- dynamic parseJson(StringPiece range, json::serialization_opts const& opts) {
-   json::Input in(range, &opts);
- 
-   auto ret = parseValue(in, nullptr);
-   in.skipWhitespace();
-   if (in.size() && *in != '\0') {
-     in.error("parsing didn't consume all input");
-   }
-   return ret;
- }
- 
- std::string toJson(dynamic const& dyn) {
-   return json::serialize(dyn, json::serialization_opts());
- }
- 
- std::string toPrettyJson(dynamic const& dyn) {
-   json::serialization_opts opts;
-   opts.pretty_formatting = true;
-   opts.sort_keys = true;
-   return json::serialize(dyn, opts);
- }
- 
- //////////////////////////////////////////////////////////////////////
- // dynamic::print_as_pseudo_json() is implemented here for header
- // ordering reasons (most of the dynamic implementation is in
- // dynamic-inl.h, which we don't want to include json.h).
- 
- void dynamic::print_as_pseudo_json(std::ostream& out) const {
-   json::serialization_opts opts;
-   opts.allow_non_string_keys = true;
-   opts.allow_nan_inf = true;
-   out << json::serialize(*this, opts);
- }
- 
- void PrintTo(const dynamic& dyn, std::ostream* os) {
-   json::serialization_opts opts;
-   opts.allow_nan_inf = true;
-   opts.allow_non_string_keys = true;
-   opts.pretty_formatting = true;
-   opts.sort_keys = true;
-   *os << json::serialize(dyn, opts);
- }
- 
- //////////////////////////////////////////////////////////////////////
- 
- } // namespace folly
\ No newline at end of file
diff --git a/vnext/Folly/TEMP_UntilFollyUpdate/json/dynamic-inl.h b/vnext/Folly/TEMP_UntilFollyUpdate/json/dynamic-inl.h
index a90471ff4dd..da83d32fc86 100644
--- a/vnext/Folly/TEMP_UntilFollyUpdate/json/dynamic-inl.h
+++ b/vnext/Folly/TEMP_UntilFollyUpdate/json/dynamic-inl.h
@@ -1,1438 +1,1438 @@
 /*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * 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.
- */
-
- #pragma once
-
- #include <functional>
- 
- #include <folly/CPortability.h>
- #include <folly/Conv.h>
- #include <folly/Format.h>
- #include <folly/Likely.h>
- #include <folly/Portability.h>
- #include <folly/detail/Iterators.h>
- #include <folly/lang/Exception.h>
- 
- namespace folly {
- namespace detail {
- 
- struct DynamicHasher {
-   using is_transparent = void;
-   using folly_is_avalanching = std::true_type;
- 
-   size_t operator()(dynamic const& d) const { return d.hash(); }
- 
-   template <typename T>
-   std::enable_if_t<std::is_convertible<T, StringPiece>::value, size_t>
-   operator()(T const& val) const {
-     // keep consistent with dynamic::hash() for strings
-     return Hash()(static_cast<StringPiece>(val));
-   }
- };
- 
- struct DynamicKeyEqual {
-   using is_transparent = void;
- 
-   bool operator()(const dynamic& lhs, const dynamic& rhs) const {
-     return std::equal_to<dynamic>()(lhs, rhs);
-   }
- 
-   // Dynamic objects contains a map<dynamic, dynamic>. At least one of the
-   // operands should be a dynamic. Hence, an operator() where both operands are
-   // convertible to StringPiece is unnecessary.
-   template <typename A, typename B>
-   std::enable_if_t<
-       std::is_convertible<A, StringPiece>::value &&
-           std::is_convertible<B, StringPiece>::value,
-       bool>
-   operator()(A const& lhs, B const& rhs) const = delete;
- 
-   template <typename A>
-   std::enable_if_t<std::is_convertible<A, StringPiece>::value, bool> operator()(
-       A const& lhs, dynamic const& rhs) const {
-     return FOLLY_LIKELY(rhs.type() == dynamic::Type::STRING) &&
-         std::equal_to<StringPiece>()(lhs, rhs.stringPiece());
-   }
- 
-   template <typename B>
-   std::enable_if_t<std::is_convertible<B, StringPiece>::value, bool> operator()(
-       dynamic const& lhs, B const& rhs) const {
-     return FOLLY_LIKELY(lhs.type() == dynamic::Type::STRING) &&
-         std::equal_to<StringPiece>()(lhs.stringPiece(), rhs);
-   }
- };
- } // namespace detail
- } // namespace folly
- 
- //////////////////////////////////////////////////////////////////////
- 
- /* clang-format off */
- // This is a higher-order preprocessor macro to aid going from runtime
- // types to the compile time type system.
- 
- #define FB_DYNAMIC_APPLY(type, apply)                                             \
-   do {                                                                            \
-     FOLLY_PUSH_WARNING FOLLY_CLANG_DISABLE_WARNING("-Wcovered-switch-default")    \
-     switch ((type)) {                                                             \
-       case NULLT:                                                                 \
-         apply(std::nullptr_t);                                                    \
-         break;                                                                    \
-       case ARRAY:                                                                 \
-         apply(Array);                                                             \
-         break;                                                                    \
-       case BOOL:                                                                  \
-         apply(bool);                                                              \
-         break;                                                                    \
-       case DOUBLE:                                                                \
-         apply(double);                                                            \
-         break;                                                                    \
-       case INT64:                                                                 \
-         apply(int64_t);                                                           \
-         break;                                                                    \
-       case OBJECT:                                                                \
-         apply(ObjectImpl);                                                        \
-         break;                                                                    \
-       case STRING:                                                                \
-         apply(std::string);                                                       \
-         break;                                                                    \
-       default:                                                                    \
-         abort();                                                                  \
-     }                                                                             \
-     FOLLY_POP_WARNING                                                             \
-   } while (0)
- /* clang-format on */
- //////////////////////////////////////////////////////////////////////
- 
- namespace folly {
- 
- struct FOLLY_EXPORT TypeError : std::runtime_error {
-   explicit TypeError(const std::string& expected, dynamic::Type actual);
-   explicit TypeError(
-       const std::string& expected,
-       dynamic::Type actual1,
-       dynamic::Type actual2);
- };
- 
- //////////////////////////////////////////////////////////////////////
- 
- namespace detail {
- 
- // This helper is used in destroy() to be able to run destructors on
- // types like "int64_t" without a compiler error.
- struct Destroy {
-   template <class T>
-   static void destroy(T* t) {
-     t->~T();
-   }
- };
- 
- /*
-  * Helper for implementing numeric conversions in operators on
-  * numbers.  Just promotes to double when one of the arguments is
-  * double, or throws if either is not a numeric type.
-  */
- template <template <class> class Op>
- dynamic numericOp(dynamic const& a, dynamic const& b) {
-   if (!a.isNumber() || !b.isNumber()) {
-     throw_exception<TypeError>("numeric", a.type(), b.type());
-   }
-   if (a.isDouble() || b.isDouble()) {
-     return Op<double>()(a.asDouble(), b.asDouble());
-   }
-   return Op<int64_t>()(a.asInt(), b.asInt());
- }
- 
- } // namespace detail
- 
- //////////////////////////////////////////////////////////////////////
- 
- /*
-  * We're doing this instead of a simple member typedef to avoid the
-  * undefined behavior of parameterizing F14NodeMap<> with an
-  * incomplete type.
-  *
-  * Note: Later we may add separate order tracking here (a multi-index
-  * type of thing.)
-  */
- struct dynamic::ObjectImpl : F14NodeMap<
-                                  dynamic,
-                                  dynamic,
-                                  detail::DynamicHasher,
-                                  detail::DynamicKeyEqual> {};
- 
- //////////////////////////////////////////////////////////////////////
- 
- // Helper object for creating objects conveniently.  See object and
- // the dynamic::dynamic(ObjectMaker&&) ctor.
- struct dynamic::ObjectMaker {
-   friend struct dynamic;
- 
-   explicit ObjectMaker() : val_(dynamic::object) {}
-   explicit ObjectMaker(dynamic key, dynamic val) : val_(dynamic::object) {
-     val_.insert(std::move(key), std::move(val));
-   }
- 
-   // Make sure no one tries to save one of these into an lvalue with
-   // auto or anything like that.
-   ObjectMaker(ObjectMaker&&) = default;
-   ObjectMaker(ObjectMaker const&) = delete;
-   ObjectMaker& operator=(ObjectMaker const&) = delete;
-   ObjectMaker& operator=(ObjectMaker&&) = delete;
- 
-   // This returns an rvalue-reference instead of an lvalue-reference
-   // to allow constructs like this to moved instead of copied:
-   //  dynamic a = dynamic::object("a", "b")("c", "d")
-   ObjectMaker&& operator()(dynamic key, dynamic val) {
-     val_.insert(std::move(key), std::move(val));
-     return std::move(*this);
-   }
- 
-  private:
-   dynamic val_;
- };
- 
- inline void dynamic::array(EmptyArrayTag) {}
- 
- template <class... Args>
- inline dynamic dynamic::array(Args&&... args) {
-   return dynamic(Array{std::forward<Args>(args)...});
- }
- 
- inline dynamic::ObjectMaker dynamic::object() {
-   return ObjectMaker();
- }
- inline dynamic::ObjectMaker dynamic::object(dynamic a, dynamic b) {
-   return ObjectMaker(std::move(a), std::move(b));
- }
- 
- //////////////////////////////////////////////////////////////////////
- 
- struct dynamic::item_iterator : detail::IteratorAdaptor<
-                                     dynamic::item_iterator,
-                                     dynamic::ObjectImpl::iterator,
-                                     std::pair<dynamic const, dynamic>,
-                                     std::forward_iterator_tag> {
-   using Super = detail::IteratorAdaptor<
-       dynamic::item_iterator,
-       dynamic::ObjectImpl::iterator,
-       std::pair<dynamic const, dynamic>,
-       std::forward_iterator_tag>;
-   item_iterator() = default;
-   /* implicit */ item_iterator(dynamic::ObjectImpl::iterator b) : Super(b) {}
- 
-   using object_type = dynamic::ObjectImpl;
- };
- 
- struct dynamic::value_iterator : detail::IteratorAdaptor<
-                                      dynamic::value_iterator,
-                                      dynamic::ObjectImpl::iterator,
-                                      dynamic,
-                                      std::forward_iterator_tag> {
-   using Super = detail::IteratorAdaptor<
-       dynamic::value_iterator,
-       dynamic::ObjectImpl::iterator,
-       dynamic,
-       std::forward_iterator_tag>;
-   value_iterator() = default;
-   /* implicit */ value_iterator(dynamic::ObjectImpl::iterator b) : Super(b) {}
- 
-   using object_type = dynamic::ObjectImpl;
- 
-   dynamic& dereference() const { return base()->second; }
- };
- 
- struct dynamic::const_item_iterator
-     : detail::IteratorAdaptor<
-           dynamic::const_item_iterator,
-           dynamic::ObjectImpl::const_iterator,
-           std::pair<dynamic const, dynamic> const,
-           std::forward_iterator_tag> {
-   using Super = detail::IteratorAdaptor<
-       dynamic::const_item_iterator,
-       dynamic::ObjectImpl::const_iterator,
-       std::pair<dynamic const, dynamic> const,
-       std::forward_iterator_tag>;
-   const_item_iterator() = default;
-   /* implicit */ const_item_iterator(dynamic::ObjectImpl::const_iterator b)
-       : Super(b) {}
-   /* implicit */ const_item_iterator(item_iterator i) : Super(i.base()) {}
- 
-   using object_type = dynamic::ObjectImpl const;
- };
- 
- struct dynamic::const_key_iterator : detail::IteratorAdaptor<
-                                          dynamic::const_key_iterator,
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* 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.
+*/
+
+#pragma once
+
+#include <functional>
+
+#include <folly/CPortability.h>
+#include <folly/Conv.h>
+#include <folly/Format.h>
+#include <folly/Likely.h>
+#include <folly/Portability.h>
+#include <folly/detail/Iterators.h>
+#include <folly/lang/Exception.h>
+
+namespace folly {
+namespace detail {
+
+struct DynamicHasher {
+  using is_transparent = void;
+  using folly_is_avalanching = std::true_type;
+
+  size_t operator()(dynamic const& d) const { return d.hash(); }
+
+  template <typename T>
+  std::enable_if_t<std::is_convertible<T, StringPiece>::value, size_t>
+  operator()(T const& val) const {
+    // keep consistent with dynamic::hash() for strings
+    return Hash()(static_cast<StringPiece>(val));
+  }
+};
+
+struct DynamicKeyEqual {
+  using is_transparent = void;
+
+  bool operator()(const dynamic& lhs, const dynamic& rhs) const {
+    return std::equal_to<dynamic>()(lhs, rhs);
+  }
+
+  // Dynamic objects contains a map<dynamic, dynamic>. At least one of the
+  // operands should be a dynamic. Hence, an operator() where both operands are
+  // convertible to StringPiece is unnecessary.
+  template <typename A, typename B>
+  std::enable_if_t<
+      std::is_convertible<A, StringPiece>::value &&
+          std::is_convertible<B, StringPiece>::value,
+      bool>
+  operator()(A const& lhs, B const& rhs) const = delete;
+
+  template <typename A>
+  std::enable_if_t<std::is_convertible<A, StringPiece>::value, bool> operator()(
+      A const& lhs, dynamic const& rhs) const {
+    return FOLLY_LIKELY(rhs.type() == dynamic::Type::STRING) &&
+        std::equal_to<StringPiece>()(lhs, rhs.stringPiece());
+  }
+
+  template <typename B>
+  std::enable_if_t<std::is_convertible<B, StringPiece>::value, bool> operator()(
+      dynamic const& lhs, B const& rhs) const {
+    return FOLLY_LIKELY(lhs.type() == dynamic::Type::STRING) &&
+        std::equal_to<StringPiece>()(lhs.stringPiece(), rhs);
+  }
+};
+} // namespace detail
+} // namespace folly
+
+//////////////////////////////////////////////////////////////////////
+
+/* clang-format off */
+// This is a higher-order preprocessor macro to aid going from runtime
+// types to the compile time type system.
+
+#define FB_DYNAMIC_APPLY(type, apply)                                             \
+  do {                                                                            \
+    FOLLY_PUSH_WARNING FOLLY_CLANG_DISABLE_WARNING("-Wcovered-switch-default")    \
+    switch ((type)) {                                                             \
+      case NULLT:                                                                 \
+        apply(std::nullptr_t);                                                    \
+        break;                                                                    \
+      case ARRAY:                                                                 \
+        apply(Array);                                                             \
+        break;                                                                    \
+      case BOOL:                                                                  \
+        apply(bool);                                                              \
+        break;                                                                    \
+      case DOUBLE:                                                                \
+        apply(double);                                                            \
+        break;                                                                    \
+      case INT64:                                                                 \
+        apply(int64_t);                                                           \
+        break;                                                                    \
+      case OBJECT:                                                                \
+        apply(ObjectImpl);                                                        \
+        break;                                                                    \
+      case STRING:                                                                \
+        apply(std::string);                                                       \
+        break;                                                                    \
+      default:                                                                    \
+        abort();                                                                  \
+    }                                                                             \
+    FOLLY_POP_WARNING                                                             \
+  } while (0)
+/* clang-format on */
+//////////////////////////////////////////////////////////////////////
+
+namespace folly {
+
+struct FOLLY_EXPORT TypeError : std::runtime_error {
+  explicit TypeError(const std::string& expected, dynamic::Type actual);
+  explicit TypeError(
+      const std::string& expected,
+      dynamic::Type actual1,
+      dynamic::Type actual2);
+};
+
+//////////////////////////////////////////////////////////////////////
+
+namespace detail {
+
+// This helper is used in destroy() to be able to run destructors on
+// types like "int64_t" without a compiler error.
+struct Destroy {
+  template <class T>
+  static void destroy(T* t) {
+    t->~T();
+  }
+};
+
+/*
+* Helper for implementing numeric conversions in operators on
+* numbers.  Just promotes to double when one of the arguments is
+* double, or throws if either is not a numeric type.
+*/
+template <template <class> class Op>
+dynamic numericOp(dynamic const& a, dynamic const& b) {
+  if (!a.isNumber() || !b.isNumber()) {
+    throw_exception<TypeError>("numeric", a.type(), b.type());
+  }
+  if (a.isDouble() || b.isDouble()) {
+    return Op<double>()(a.asDouble(), b.asDouble());
+  }
+  return Op<int64_t>()(a.asInt(), b.asInt());
+}
+
+} // namespace detail
+
+//////////////////////////////////////////////////////////////////////
+
+/*
+* We're doing this instead of a simple member typedef to avoid the
+* undefined behavior of parameterizing F14NodeMap<> with an
+* incomplete type.
+*
+* Note: Later we may add separate order tracking here (a multi-index
+* type of thing.)
+*/
+struct dynamic::ObjectImpl : F14NodeMap<
+                                dynamic,
+                                dynamic,
+                                detail::DynamicHasher,
+                                detail::DynamicKeyEqual> {};
+
+//////////////////////////////////////////////////////////////////////
+
+// Helper object for creating objects conveniently.  See object and
+// the dynamic::dynamic(ObjectMaker&&) ctor.
+struct dynamic::ObjectMaker {
+  friend struct dynamic;
+
+  explicit ObjectMaker() : val_(dynamic::object) {}
+  explicit ObjectMaker(dynamic key, dynamic val) : val_(dynamic::object) {
+    val_.insert(std::move(key), std::move(val));
+  }
+
+  // Make sure no one tries to save one of these into an lvalue with
+  // auto or anything like that.
+  ObjectMaker(ObjectMaker&&) = default;
+  ObjectMaker(ObjectMaker const&) = delete;
+  ObjectMaker& operator=(ObjectMaker const&) = delete;
+  ObjectMaker& operator=(ObjectMaker&&) = delete;
+
+  // This returns an rvalue-reference instead of an lvalue-reference
+  // to allow constructs like this to moved instead of copied:
+  //  dynamic a = dynamic::object("a", "b")("c", "d")
+  ObjectMaker&& operator()(dynamic key, dynamic val) {
+    val_.insert(std::move(key), std::move(val));
+    return std::move(*this);
+  }
+
+private:
+  dynamic val_;
+};
+
+inline void dynamic::array(EmptyArrayTag) {}
+
+template <class... Args>
+inline dynamic dynamic::array(Args&&... args) {
+  return dynamic(Array{std::forward<Args>(args)...});
+}
+
+inline dynamic::ObjectMaker dynamic::object() {
+  return ObjectMaker();
+}
+inline dynamic::ObjectMaker dynamic::object(dynamic a, dynamic b) {
+  return ObjectMaker(std::move(a), std::move(b));
+}
+
+//////////////////////////////////////////////////////////////////////
+
+struct dynamic::item_iterator : detail::IteratorAdaptor<
+                                    dynamic::item_iterator,
+                                    dynamic::ObjectImpl::iterator,
+                                    std::pair<dynamic const, dynamic>,
+                                    std::forward_iterator_tag> {
+  using Super = detail::IteratorAdaptor<
+      dynamic::item_iterator,
+      dynamic::ObjectImpl::iterator,
+      std::pair<dynamic const, dynamic>,
+      std::forward_iterator_tag>;
+  item_iterator() = default;
+  /* implicit */ item_iterator(dynamic::ObjectImpl::iterator b) : Super(b) {}
+
+  using object_type = dynamic::ObjectImpl;
+};
+
+struct dynamic::value_iterator : detail::IteratorAdaptor<
+                                    dynamic::value_iterator,
+                                    dynamic::ObjectImpl::iterator,
+                                    dynamic,
+                                    std::forward_iterator_tag> {
+  using Super = detail::IteratorAdaptor<
+      dynamic::value_iterator,
+      dynamic::ObjectImpl::iterator,
+      dynamic,
+      std::forward_iterator_tag>;
+  value_iterator() = default;
+  /* implicit */ value_iterator(dynamic::ObjectImpl::iterator b) : Super(b) {}
+
+  using object_type = dynamic::ObjectImpl;
+
+  dynamic& dereference() const { return base()->second; }
+};
+
+struct dynamic::const_item_iterator
+    : detail::IteratorAdaptor<
+          dynamic::const_item_iterator,
+          dynamic::ObjectImpl::const_iterator,
+          std::pair<dynamic const, dynamic> const,
+          std::forward_iterator_tag> {
+  using Super = detail::IteratorAdaptor<
+      dynamic::const_item_iterator,
+      dynamic::ObjectImpl::const_iterator,
+      std::pair<dynamic const, dynamic> const,
+      std::forward_iterator_tag>;
+  const_item_iterator() = default;
+  /* implicit */ const_item_iterator(dynamic::ObjectImpl::const_iterator b)
+      : Super(b) {}
+  /* implicit */ const_item_iterator(item_iterator i) : Super(i.base()) {}
+
+  using object_type = dynamic::ObjectImpl const;
+};
+
+struct dynamic::const_key_iterator : detail::IteratorAdaptor<
+                                        dynamic::const_key_iterator,
+                                        dynamic::ObjectImpl::const_iterator,
+                                        dynamic const,
+                                        std::forward_iterator_tag> {
+  using Super = detail::IteratorAdaptor<
+      dynamic::const_key_iterator,
+      dynamic::ObjectImpl::const_iterator,
+      dynamic const,
+      std::forward_iterator_tag>;
+  const_key_iterator() = default;
+  /* implicit */ const_key_iterator(dynamic::ObjectImpl::const_iterator b)
+      : Super(b) {}
+
+  using object_type = dynamic::ObjectImpl const;
+
+  dynamic const& dereference() const { return base()->first; }
+};
+
+struct dynamic::const_value_iterator : detail::IteratorAdaptor<
+                                          dynamic::const_value_iterator,
                                           dynamic::ObjectImpl::const_iterator,
                                           dynamic const,
                                           std::forward_iterator_tag> {
-   using Super = detail::IteratorAdaptor<
-       dynamic::const_key_iterator,
-       dynamic::ObjectImpl::const_iterator,
-       dynamic const,
-       std::forward_iterator_tag>;
-   const_key_iterator() = default;
-   /* implicit */ const_key_iterator(dynamic::ObjectImpl::const_iterator b)
-       : Super(b) {}
- 
-   using object_type = dynamic::ObjectImpl const;
- 
-   dynamic const& dereference() const { return base()->first; }
- };
- 
- struct dynamic::const_value_iterator : detail::IteratorAdaptor<
-                                            dynamic::const_value_iterator,
-                                            dynamic::ObjectImpl::const_iterator,
-                                            dynamic const,
-                                            std::forward_iterator_tag> {
-   using Super = detail::IteratorAdaptor<
-       dynamic::const_value_iterator,
-       dynamic::ObjectImpl::const_iterator,
-       dynamic const,
-       std::forward_iterator_tag>;
-   const_value_iterator() = default;
-   /* implicit */ const_value_iterator(dynamic::ObjectImpl::const_iterator b)
-       : Super(b) {}
-   /* implicit */ const_value_iterator(value_iterator i) : Super(i.base()) {}
-   /* implicit */ const_value_iterator(dynamic::ObjectImpl::iterator i)
-       : Super(i) {}
- 
-   using object_type = dynamic::ObjectImpl const;
- 
-   dynamic const& dereference() const { return base()->second; }
- };
- 
- //////////////////////////////////////////////////////////////////////
- 
- inline dynamic::dynamic() : dynamic(nullptr) {}
- 
- inline dynamic::dynamic(std::nullptr_t) : type_(NULLT) {}
- 
- inline dynamic::dynamic(void (*)(EmptyArrayTag)) : type_(ARRAY) {
-   new (&u_.array) Array();
- }
- 
- inline dynamic::dynamic(ObjectMaker (*)()) : type_(OBJECT) {
-   new (getAddress<ObjectImpl>()) ObjectImpl();
- }
- 
- inline dynamic::dynamic(char const* s) : type_(STRING) {
-   new (&u_.string) std::string(s);
- }
- 
- inline dynamic::dynamic(std::string s) : type_(STRING) {
-   new (&u_.string) std::string(std::move(s));
- }
- 
- template <typename Stringish, typename>
- inline dynamic::dynamic(Stringish&& s) : type_(STRING) {
-   new (&u_.string) std::string(s.data(), s.size());
- }
- 
- inline dynamic::dynamic(ObjectMaker&& maker) : type_(OBJECT) {
-   new (getAddress<ObjectImpl>())
-       ObjectImpl(std::move(*maker.val_.getAddress<ObjectImpl>()));
- }
- 
- inline dynamic::~dynamic() noexcept {
-   destroy();
- }
- 
- // Integral types except bool convert to int64_t, float types to double.
- template <class T>
- struct dynamic::NumericTypeHelper<
-     T,
-     typename std::enable_if<std::is_integral<T>::value>::type> {
-   static_assert(
-       !kIsObjC || sizeof(T) > sizeof(char),
-       "char-sized types are ambiguous in objc; cast to bool or wider type");
-   using type = int64_t;
- };
- template <>
- struct dynamic::NumericTypeHelper<bool> {
-   using type = bool;
- };
- template <>
- struct dynamic::NumericTypeHelper<float> {
-   using type = double;
- };
- template <>
- struct dynamic::NumericTypeHelper<double> {
-   using type = double;
- };
- 
- inline dynamic::dynamic(std::vector<bool>::reference b)
-     : dynamic(static_cast<bool>(b)) {}
- inline dynamic::dynamic(VectorBoolConstRefCtorType b)
-     : dynamic(static_cast<bool>(b)) {}
- 
- template <
-     class T,
-     class NumericType /* = typename NumericTypeHelper<T>::type */>
- dynamic::dynamic(T t) {
-   type_ = TypeInfo<NumericType>::type;
-   new (getAddress<NumericType>()) NumericType(NumericType(t));
- }
- 
- template <class Iterator>
- dynamic::dynamic(array_range_construct_t, Iterator first, Iterator last)
-     : type_(ARRAY) {
-   new (&u_.array) Array(first, last);
- }
- 
- template <
-     class T,
-     class NumericType /* = typename NumericTypeHelper<T>::type */>
- dynamic& dynamic::operator=(T t) {
-   const auto newType = TypeInfo<NumericType>::type;
-   if (type_ == newType) {
-     *getAddress<NumericType>() = t;
-   } else {
-     destroy();
-     new (getAddress<NumericType>()) NumericType(t);
-     type_ = newType;
-   }
-   return *this;
- }
- //////////////////////////////////////////////////////////////////////
- 
- inline dynamic::const_iterator dynamic::begin() const {
-   return get<Array>().begin();
- }
- inline dynamic::const_iterator dynamic::end() const {
-   return get<Array>().end();
- }
- 
- inline dynamic::iterator dynamic::begin() {
-   return get<Array>().begin();
- }
- inline dynamic::iterator dynamic::end() {
-   return get<Array>().end();
- }
- 
- template <class It>
- struct dynamic::IterableProxy {
-   typedef It iterator;
-   typedef typename It::value_type value_type;
-   typedef typename It::object_type object_type;
- 
-   /* implicit */ IterableProxy(object_type* o) : o_(o) {}
- 
-   It begin() const { return o_->begin(); }
- 
-   It end() const { return o_->end(); }
- 
-  private:
-   object_type* o_;
- };
- 
- inline dynamic::IterableProxy<dynamic::const_key_iterator> dynamic::keys()
-     const {
-   return &(get<ObjectImpl>());
- }
- 
- inline dynamic::IterableProxy<dynamic::const_value_iterator> dynamic::values()
-     const {
-   return &(get<ObjectImpl>());
- }
- 
- inline dynamic::IterableProxy<dynamic::const_item_iterator> dynamic::items()
-     const {
-   return &(get<ObjectImpl>());
- }
- 
- inline dynamic::IterableProxy<dynamic::value_iterator> dynamic::values() {
-   return &(get<ObjectImpl>());
- }
- 
- inline dynamic::IterableProxy<dynamic::item_iterator> dynamic::items() {
-   return &(get<ObjectImpl>());
- }
- 
- inline bool dynamic::isString() const {
-   return get_nothrow<std::string>() != nullptr;
- }
- inline bool dynamic::isObject() const {
-   return get_nothrow<ObjectImpl>() != nullptr;
- }
- inline bool dynamic::isBool() const {
-   return get_nothrow<bool>() != nullptr;
- }
- inline bool dynamic::isArray() const {
-   return get_nothrow<Array>() != nullptr;
- }
- inline bool dynamic::isDouble() const {
-   return get_nothrow<double>() != nullptr;
- }
- inline bool dynamic::isInt() const {
-   return get_nothrow<int64_t>() != nullptr;
- }
- inline bool dynamic::isNull() const {
-   return get_nothrow<std::nullptr_t>() != nullptr;
- }
- inline bool dynamic::isNumber() const {
-   return isInt() || isDouble();
- }
- 
- inline dynamic::Type dynamic::type() const {
-   return type_;
- }
- 
- inline std::string dynamic::asString() const {
-   return asImpl<std::string>();
- }
- inline double dynamic::asDouble() const {
-   return asImpl<double>();
- }
- inline int64_t dynamic::asInt() const {
-   return asImpl<int64_t>();
- }
- inline bool dynamic::asBool() const {
-   return asImpl<bool>();
- }
- 
- inline const std::string& dynamic::getString() const& {
-   return get<std::string>();
- }
- inline double dynamic::getDouble() const& {
-   return get<double>();
- }
- inline int64_t dynamic::getInt() const& {
-   return get<int64_t>();
- }
- inline bool dynamic::getBool() const& {
-   return get<bool>();
- }
- 
- inline std::string& dynamic::getString() & {
-   return get<std::string>();
- }
- inline double& dynamic::getDouble() & {
-   return get<double>();
- }
- inline int64_t& dynamic::getInt() & {
-   return get<int64_t>();
- }
- inline bool& dynamic::getBool() & {
-   return get<bool>();
- }
- 
- inline std::string&& dynamic::getString() && {
-   return std::move(get<std::string>());
- }
- inline double dynamic::getDouble() && {
-   return get<double>();
- }
- inline int64_t dynamic::getInt() && {
-   return get<int64_t>();
- }
- inline bool dynamic::getBool() && {
-   return get<bool>();
- }
- 
- inline const char* dynamic::c_str() const& {
-   return get<std::string>().c_str();
- }
- inline StringPiece dynamic::stringPiece() const {
-   return get<std::string>();
- }
- 
- template <class T>
- struct dynamic::CompareOp {
-   static bool comp(T const& a, T const& b) { return a < b; }
- };
- template <>
- struct dynamic::CompareOp<dynamic::ObjectImpl> {
-   static bool comp(ObjectImpl const&, ObjectImpl const&) {
-     // This code never executes; it is just here for the compiler.
-     return false;
-   }
- };
- template <>
- struct dynamic::CompareOp<std::nullptr_t> {
-   static bool comp(std::nullptr_t const&, std::nullptr_t const&) {
-     return false;
-   }
- };
- 
- inline dynamic& dynamic::operator+=(dynamic const& o) {
-   if (type() == STRING && o.type() == STRING) {
-     *getAddress<std::string>() += *o.getAddress<std::string>();
-     return *this;
-   }
-   *this = detail::numericOp<std::plus>(*this, o);
-   return *this;
- }
- 
- inline dynamic& dynamic::operator-=(dynamic const& o) {
-   *this = detail::numericOp<std::minus>(*this, o);
-   return *this;
- }
- 
- inline dynamic& dynamic::operator*=(dynamic const& o) {
-   *this = detail::numericOp<std::multiplies>(*this, o);
-   return *this;
- }
- 
- inline dynamic& dynamic::operator/=(dynamic const& o) {
-   *this = detail::numericOp<std::divides>(*this, o);
-   return *this;
- }
- 
- #define FB_DYNAMIC_INTEGER_OP(op)                            \
-   inline dynamic& dynamic::operator op(dynamic const& o) {   \
-     if (!isInt() || !o.isInt()) {                            \
-       throw_exception<TypeError>("int64", type(), o.type()); \
-     }                                                        \
-     *getAddress<int64_t>() op o.asInt();                     \
-     return *this;                                            \
-   }
- 
- FB_DYNAMIC_INTEGER_OP(%=)
- FB_DYNAMIC_INTEGER_OP(|=)
- FB_DYNAMIC_INTEGER_OP(&=)
- FB_DYNAMIC_INTEGER_OP(^=)
- 
- #undef FB_DYNAMIC_INTEGER_OP
- 
- inline dynamic& dynamic::operator++() {
-   ++get<int64_t>();
-   return *this;
- }
- 
- inline dynamic& dynamic::operator--() {
-   --get<int64_t>();
-   return *this;
- }
- 
- template <typename K>
- dynamic::IfIsNonStringDynamicConvertible<K, dynamic const&> dynamic::operator[](
-     K&& idx) const& {
-   return at(std::forward<K>(idx));
- }
- 
- template <typename K>
- dynamic::IfIsNonStringDynamicConvertible<K, dynamic&> dynamic::operator[](
-     K&& idx) & {
-   if (!isObject() && !isArray()) {
-     throw_exception<TypeError>("object/array", type());
-   }
-   if (isArray()) {
-     return at(std::forward<K>(idx));
-   }
-   auto& obj = get<ObjectImpl>();
-   auto ret = obj.emplace(std::forward<K>(idx), nullptr);
-   return ret.first->second;
- }
- 
- template <typename K>
- dynamic::IfIsNonStringDynamicConvertible<K, dynamic&&> dynamic::operator[](
-     K&& idx) && {
-   return std::move((*this)[std::forward<K>(idx)]);
- }
- 
- inline dynamic const& dynamic::operator[](StringPiece k) const& {
-   return at(k);
- }
- 
- inline dynamic&& dynamic::operator[](StringPiece k) && {
-   return std::move((*this)[k]);
- }
- 
- template <typename K>
- dynamic::IfIsNonStringDynamicConvertible<K, dynamic> dynamic::getDefault(
-     K&& k, const dynamic& v) const& {
-   auto& obj = get<ObjectImpl>();
-   auto it = obj.find(std::forward<K>(k));
-   return it == obj.end() ? v : it->second;
- }
- 
- template <typename K>
- dynamic::IfIsNonStringDynamicConvertible<K, dynamic> dynamic::getDefault(
-     K&& k, dynamic&& v) const& {
-   auto& obj = get<ObjectImpl>();
-   auto it = obj.find(std::forward<K>(k));
-   // Avoid clang bug with ternary
-   if (it == obj.end()) {
-     return std::move(v);
-   } else {
-     return it->second;
-   }
- }
- 
- template <typename K>
- dynamic::IfIsNonStringDynamicConvertible<K, dynamic> dynamic::getDefault(
-     K&& k, const dynamic& v) && {
-   auto& obj = get<ObjectImpl>();
-   auto it = obj.find(std::forward<K>(k));
-   // Avoid clang bug with ternary
-   if (it == obj.end()) {
-     return v;
-   } else {
-     return std::move(it->second);
-   }
- }
- 
- template <typename K>
- dynamic::IfIsNonStringDynamicConvertible<K, dynamic> dynamic::getDefault(
-     K&& k, dynamic&& v) && {
-   auto& obj = get<ObjectImpl>();
-   auto it = obj.find(std::forward<K>(k));
-   return std::move(it == obj.end() ? v : it->second);
- }
- 
- template <typename K, typename V>
- dynamic::IfIsNonStringDynamicConvertible<K, dynamic&> dynamic::setDefault(
-     K&& k, V&& v) {
-   auto& obj = get<ObjectImpl>();
-   return obj.emplace(std::forward<K>(k), std::forward<V>(v)).first->second;
- }
- 
- template <typename K>
- dynamic::IfIsNonStringDynamicConvertible<K, dynamic&> dynamic::setDefault(
-     K&& k, dynamic&& v) {
-   auto& obj = get<ObjectImpl>();
-   return obj.emplace(std::forward<K>(k), std::move(v)).first->second;
- }
- 
- template <typename K>
- dynamic::IfIsNonStringDynamicConvertible<K, dynamic&> dynamic::setDefault(
-     K&& k, const dynamic& v) {
-   auto& obj = get<ObjectImpl>();
-   return obj.emplace(std::forward<K>(k), v).first->second;
- }
- 
- template <typename V>
- dynamic& dynamic::setDefault(StringPiece k, V&& v) {
-   auto& obj = get<ObjectImpl>();
-   return obj.emplace(k, std::forward<V>(v)).first->second;
- }
- 
- inline dynamic& dynamic::setDefault(StringPiece k, dynamic&& v) {
-   auto& obj = get<ObjectImpl>();
-   return obj.emplace(k, std::move(v)).first->second;
- }
- 
- inline dynamic& dynamic::setDefault(StringPiece k, const dynamic& v) {
-   auto& obj = get<ObjectImpl>();
-   return obj.emplace(k, v).first->second;
- }
- 
- template <typename K>
- dynamic::IfIsNonStringDynamicConvertible<K, dynamic const*> dynamic::get_ptr(
-     K&& k) const& {
-   return get_ptrImpl(std::forward<K>(k));
- }
- 
- template <typename K>
- dynamic::IfIsNonStringDynamicConvertible<K, dynamic*> dynamic::get_ptr(
-     K&& idx) & {
-   return const_cast<dynamic*>(const_cast<dynamic const*>(this)->get_ptr(idx));
- }
- 
- inline dynamic* dynamic::get_ptr(StringPiece idx) & {
-   return const_cast<dynamic*>(const_cast<dynamic const*>(this)->get_ptr(idx));
- }
- 
- // clang-format off
- inline
- dynamic::resolved_json_pointer<dynamic>
- dynamic::try_get_ptr(json_pointer const& jsonPtr) & {
-   auto ret = const_cast<dynamic const*>(this)->try_get_ptr(jsonPtr);
-   if (ret.hasValue()) {
-     return json_pointer_resolved_value<dynamic>{
-         const_cast<dynamic*>(ret.value().parent),
-         const_cast<dynamic*>(ret.value().value),
-         ret.value().parent_key, ret.value().parent_index};
-   } else {
-     return makeUnexpected(
-         json_pointer_resolution_error<dynamic>{
-             ret.error().error_code,
-             ret.error().index,
-             const_cast<dynamic*>(ret.error().context)}
-         );
-   }
- }
- // clang-format on
- 
- inline dynamic* dynamic::get_ptr(json_pointer const& jsonPtr) & {
-   return const_cast<dynamic*>(
-       const_cast<dynamic const*>(this)->get_ptr(jsonPtr));
- }
- 
- template <typename K>
- dynamic::IfIsNonStringDynamicConvertible<K, dynamic const&> dynamic::at(
-     K&& k) const& {
-   return atImpl(std::forward<K>(k));
- }
- 
- template <typename K>
- dynamic::IfIsNonStringDynamicConvertible<K, dynamic&> dynamic::at(K&& idx) & {
-   return const_cast<dynamic&>(const_cast<dynamic const*>(this)->at(idx));
- }
- 
- template <typename K>
- dynamic::IfIsNonStringDynamicConvertible<K, dynamic&&> dynamic::at(K&& idx) && {
-   return std::move(at(idx));
- }
- 
- inline dynamic& dynamic::at(StringPiece idx) & {
-   return const_cast<dynamic&>(const_cast<dynamic const*>(this)->at(idx));
- }
- 
- inline dynamic&& dynamic::at(StringPiece idx) && {
-   return std::move(at(idx));
- }
- 
- inline bool dynamic::empty() const {
-   if (isNull()) {
-     return true;
-   }
-   return !size();
- }
- 
- template <typename K>
- dynamic::IfIsNonStringDynamicConvertible<K, dynamic::const_item_iterator>
- dynamic::find(K&& key) const {
-   return get<ObjectImpl>().find(std::forward<K>(key));
- }
- 
- template <typename K>
- dynamic::IfIsNonStringDynamicConvertible<K, dynamic::item_iterator>
- dynamic::find(K&& key) {
-   return get<ObjectImpl>().find(std::forward<K>(key));
- }
- 
- inline dynamic::const_item_iterator dynamic::find(StringPiece key) const {
-   return get<ObjectImpl>().find(key);
- }
- 
- inline dynamic::item_iterator dynamic::find(StringPiece key) {
-   return get<ObjectImpl>().find(key);
- }
- 
- template <typename K>
- dynamic::IfIsNonStringDynamicConvertible<K, std::size_t> dynamic::count(
-     K&& key) const {
-   return find(std::forward<K>(key)) != items().end() ? 1u : 0u;
- }
- 
- inline std::size_t dynamic::count(StringPiece key) const {
-   return find(key) != items().end() ? 1u : 0u;
- }
- 
- template <class K, class V>
- inline dynamic::IfNotIterator<K, void> dynamic::insert(K&& key, V&& val) {
-   auto& obj = get<ObjectImpl>();
-   obj[std::forward<K>(key)] = std::forward<V>(val);
- }
- 
- template <class... Args>
- inline std::pair<dynamic::item_iterator, bool> dynamic::emplace(
-     Args&&... args) {
-   auto& obj = get<ObjectImpl>();
-   return obj.emplace(std::forward<Args>(args)...);
- }
- 
- template <class K, class... Args>
- inline std::pair<dynamic::item_iterator, bool> dynamic::try_emplace(
-     K&& key, Args&&... args) {
-   auto& obj = get<ObjectImpl>();
-   return obj.try_emplace(std::forward<K>(key), std::forward<Args>(args)...);
- }
- 
- template <class T>
- inline dynamic::iterator dynamic::insert(const_iterator pos, T&& value) {
-   auto& arr = get<Array>();
-   return arr.insert(pos, std::forward<T>(value));
- }
- 
- template <class InputIt>
- inline dynamic::iterator dynamic::insert(
-     const_iterator pos, InputIt first, InputIt last) {
-   auto& arr = get<Array>();
-   return arr.insert(pos, first, last);
- }
- 
- inline void dynamic::update(const dynamic& mergeObj) {
-   if (!isObject() || !mergeObj.isObject()) {
-     throw_exception<TypeError>("object", type(), mergeObj.type());
-   }
- 
-   for (const auto& pair : mergeObj.items()) {
-     (*this)[pair.first] = pair.second;
-   }
- }
- 
- inline void dynamic::update_missing(const dynamic& mergeObj1) {
-   if (!isObject() || !mergeObj1.isObject()) {
-     throw_exception<TypeError>("object", type(), mergeObj1.type());
-   }
- 
-   // Only add if not already there
-   for (const auto& pair : mergeObj1.items()) {
-     if ((*this).find(pair.first) == (*this).items().end()) {
-       (*this)[pair.first] = pair.second;
-     }
-   }
- }
- 
- inline void dynamic::merge_patch(const dynamic& patch) {
-   auto& self = *this;
-   if (!patch.isObject()) {
-     self = patch;
-     return;
-   }
-   // if we are not an object, erase all contents, reset to object
-   if (!isObject()) {
-     self = object;
-   }
-   for (const auto& pair : patch.items()) {
-     if (pair.second.isNull()) {
-       // if name could be found in current object, remove it
-       auto it = self.find(pair.first);
-       if (it != self.items().end()) {
-         self.erase(it);
-       }
-     } else {
-       self[pair.first].merge_patch(pair.second);
-     }
-   }
- }
- 
- inline dynamic dynamic::merge(
-     const dynamic& mergeObj1, const dynamic& mergeObj2) {
-   // No checks on type needed here because they are done in update_missing
-   // Note that we do update_missing here instead of update() because
-   // it will prevent the extra writes that would occur with update()
-   auto ret = mergeObj2;
-   ret.update_missing(mergeObj1);
-   return ret;
- }
- 
- template <typename K>
- dynamic::IfIsNonStringDynamicConvertible<K, std::size_t> dynamic::erase(
-     K&& key) {
-   auto& obj = get<ObjectImpl>();
-   return obj.erase(std::forward<K>(key));
- }
- inline std::size_t dynamic::erase(StringPiece key) {
-   auto& obj = get<ObjectImpl>();
-   return obj.erase(key);
- }
- 
- inline dynamic::iterator dynamic::erase(const_iterator it) {
-   auto& arr = get<Array>();
-   // std::vector doesn't have an erase method that works on const iterators,
-   // even though the standard says it should, so this hack converts to a
-   // non-const iterator before calling erase.
-   return get<Array>().erase(arr.begin() + (it - arr.begin()));
- }
- 
- inline dynamic::const_key_iterator dynamic::erase(const_key_iterator it) {
-   return const_key_iterator(get<ObjectImpl>().erase(it.base()));
- }
- 
- inline dynamic::const_key_iterator dynamic::erase(
-     const_key_iterator first, const_key_iterator last) {
-   return const_key_iterator(get<ObjectImpl>().erase(first.base(), last.base()));
- }
- 
- inline dynamic::value_iterator dynamic::erase(const_value_iterator it) {
-   return value_iterator(get<ObjectImpl>().erase(it.base()));
- }
- 
- inline dynamic::value_iterator dynamic::erase(
-     const_value_iterator first, const_value_iterator last) {
-   return value_iterator(get<ObjectImpl>().erase(first.base(), last.base()));
- }
- 
- inline dynamic::item_iterator dynamic::erase(const_item_iterator it) {
-   return item_iterator(get<ObjectImpl>().erase(it.base()));
- }
- 
- inline dynamic::item_iterator dynamic::erase(
-     const_item_iterator first, const_item_iterator last) {
-   return item_iterator(get<ObjectImpl>().erase(first.base(), last.base()));
- }
- 
- inline void dynamic::resize(std::size_t sz, dynamic const& c) {
-   auto& arr = get<Array>();
-   arr.resize(sz, c);
- }
- 
- inline void dynamic::push_back(dynamic const& v) {
-   auto& arr = get<Array>();
-   arr.push_back(v);
- }
- 
- inline void dynamic::push_back(dynamic&& v) {
-   auto& arr = get<Array>();
-   arr.push_back(std::move(v));
- }
- 
- inline void dynamic::pop_back() {
-   auto& arr = get<Array>();
-   arr.pop_back();
- }
- 
- inline const dynamic& dynamic::back() const {
-   auto& arr = get<Array>();
-   return arr.back();
- }
- 
- //////////////////////////////////////////////////////////////////////
- 
- inline dynamic::dynamic(Array&& r) : type_(ARRAY) {
-   new (&u_.array) Array(std::move(r));
- }
- 
- #define FOLLY_DYNAMIC_DEC_TYPEINFO(T, val)     \
-   template <>                                  \
-   struct dynamic::TypeInfo<T> {                \
-     static const char* const name;             \
-     static constexpr dynamic::Type type = val; \
-   };                                           \
-   //
- 
- FOLLY_DYNAMIC_DEC_TYPEINFO(std::nullptr_t, dynamic::NULLT)
- FOLLY_DYNAMIC_DEC_TYPEINFO(bool, dynamic::BOOL)
- FOLLY_DYNAMIC_DEC_TYPEINFO(std::string, dynamic::STRING)
- FOLLY_DYNAMIC_DEC_TYPEINFO(dynamic::Array, dynamic::ARRAY)
- FOLLY_DYNAMIC_DEC_TYPEINFO(double, dynamic::DOUBLE)
- FOLLY_DYNAMIC_DEC_TYPEINFO(int64_t, dynamic::INT64)
- FOLLY_DYNAMIC_DEC_TYPEINFO(dynamic::ObjectImpl, dynamic::OBJECT)
- 
- #undef FOLLY_DYNAMIC_DEC_TYPEINFO
- 
- template <class T>
- T dynamic::asImpl() const {
-   FOLLY_PUSH_WARNING
-   FOLLY_CLANG_DISABLE_WARNING("-Wcovered-switch-default")
-   switch (type()) {
-     case INT64:
-       return to<T>(*get_nothrow<int64_t>());
-     case DOUBLE:
-       return to<T>(*get_nothrow<double>());
-     case BOOL:
-       return to<T>(*get_nothrow<bool>());
-     case STRING:
-       return to<T>(*get_nothrow<std::string>());
-     case NULLT:
-     case ARRAY:
-     case OBJECT:
-     default:
-       throw_exception<TypeError>("int/double/bool/string", type());
-   }
-   FOLLY_POP_WARNING
- }
- 
- // Return a T* to our type, or null if we're not that type.
- template <class T>
- T* dynamic::get_nothrow() & noexcept {
-   if (type_ != TypeInfo<T>::type) {
-     return nullptr;
-   }
-   return getAddress<T>();
- }
- 
- template <class T>
- T const* dynamic::get_nothrow() const& noexcept {
-   return const_cast<dynamic*>(this)->get_nothrow<T>();
- }
- 
- // Return T* for where we can put a T, without type checking.  (Memory
- // might be uninitialized, even.)
- template <class T>
- T* dynamic::getAddress() noexcept {
-   return GetAddrImpl<T>::get(u_);
- }
- 
- template <class T>
- T const* dynamic::getAddress() const noexcept {
-   return const_cast<dynamic*>(this)->getAddress<T>();
- }
- 
- template <class T>
- struct dynamic::GetAddrImpl {};
- template <>
- struct dynamic::GetAddrImpl<std::nullptr_t> {
-   static std::nullptr_t* get(Data& d) noexcept { return &d.nul; }
- };
- template <>
- struct dynamic::GetAddrImpl<dynamic::Array> {
-   static Array* get(Data& d) noexcept { return &d.array; }
- };
- template <>
- struct dynamic::GetAddrImpl<bool> {
-   static bool* get(Data& d) noexcept { return &d.boolean; }
- };
- template <>
- struct dynamic::GetAddrImpl<int64_t> {
-   static int64_t* get(Data& d) noexcept { return &d.integer; }
- };
- template <>
- struct dynamic::GetAddrImpl<double> {
-   static double* get(Data& d) noexcept { return &d.doubl; }
- };
- template <>
- struct dynamic::GetAddrImpl<std::string> {
-   static std::string* get(Data& d) noexcept { return &d.string; }
- };
- template <>
- struct dynamic::GetAddrImpl<dynamic::ObjectImpl> {
-   static_assert(
-       sizeof(ObjectImpl) <= sizeof(Data::objectBuffer),
-       "In your implementation, F14NodeMap<> apparently takes different"
-       " amount of space depending on its template parameters.  This is "
-       "weird.  Make objectBuffer bigger if you want to compile dynamic.");
- 
-   static ObjectImpl* get(Data& d) noexcept {
-     void* data = &d.objectBuffer;
-     return static_cast<ObjectImpl*>(data);
-   }
- };
- 
+  using Super = detail::IteratorAdaptor<
+      dynamic::const_value_iterator,
+      dynamic::ObjectImpl::const_iterator,
+      dynamic const,
+      std::forward_iterator_tag>;
+  const_value_iterator() = default;
+  /* implicit */ const_value_iterator(dynamic::ObjectImpl::const_iterator b)
+      : Super(b) {}
+  /* implicit */ const_value_iterator(value_iterator i) : Super(i.base()) {}
+  /* implicit */ const_value_iterator(dynamic::ObjectImpl::iterator i)
+      : Super(i) {}
+
+  using object_type = dynamic::ObjectImpl const;
+
+  dynamic const& dereference() const { return base()->second; }
+};
+
+//////////////////////////////////////////////////////////////////////
+
+inline dynamic::dynamic() : dynamic(nullptr) {}
+
+inline dynamic::dynamic(std::nullptr_t) : type_(NULLT) {}
+
+inline dynamic::dynamic(void (*)(EmptyArrayTag)) : type_(ARRAY) {
+  new (&u_.array) Array();
+}
+
+inline dynamic::dynamic(ObjectMaker (*)()) : type_(OBJECT) {
+  new (getAddress<ObjectImpl>()) ObjectImpl();
+}
+
+inline dynamic::dynamic(char const* s) : type_(STRING) {
+  new (&u_.string) std::string(s);
+}
+
+inline dynamic::dynamic(std::string s) : type_(STRING) {
+  new (&u_.string) std::string(std::move(s));
+}
+
+template <typename Stringish, typename>
+inline dynamic::dynamic(Stringish&& s) : type_(STRING) {
+  new (&u_.string) std::string(s.data(), s.size());
+}
+
+inline dynamic::dynamic(ObjectMaker&& maker) : type_(OBJECT) {
+  new (getAddress<ObjectImpl>())
+      ObjectImpl(std::move(*maker.val_.getAddress<ObjectImpl>()));
+}
+
+inline dynamic::~dynamic() noexcept {
+  destroy();
+}
+
+// Integral types except bool convert to int64_t, float types to double.
+template <class T>
+struct dynamic::NumericTypeHelper<
+    T,
+    typename std::enable_if<std::is_integral<T>::value>::type> {
+  static_assert(
+      !kIsObjC || sizeof(T) > sizeof(char),
+      "char-sized types are ambiguous in objc; cast to bool or wider type");
+  using type = int64_t;
+};
+template <>
+struct dynamic::NumericTypeHelper<bool> {
+  using type = bool;
+};
+template <>
+struct dynamic::NumericTypeHelper<float> {
+  using type = double;
+};
+template <>
+struct dynamic::NumericTypeHelper<double> {
+  using type = double;
+};
+
+inline dynamic::dynamic(std::vector<bool>::reference b)
+    : dynamic(static_cast<bool>(b)) {}
+inline dynamic::dynamic(VectorBoolConstRefCtorType b)
+    : dynamic(static_cast<bool>(b)) {}
+
+template <
+    class T,
+    class NumericType /* = typename NumericTypeHelper<T>::type */>
+dynamic::dynamic(T t) {
+  type_ = TypeInfo<NumericType>::type;
+  new (getAddress<NumericType>()) NumericType(NumericType(t));
+}
+
+template <class Iterator>
+dynamic::dynamic(array_range_construct_t, Iterator first, Iterator last)
+    : type_(ARRAY) {
+  new (&u_.array) Array(first, last);
+}
+
+template <
+    class T,
+    class NumericType /* = typename NumericTypeHelper<T>::type */>
+dynamic& dynamic::operator=(T t) {
+  const auto newType = TypeInfo<NumericType>::type;
+  if (type_ == newType) {
+    *getAddress<NumericType>() = t;
+  } else {
+    destroy();
+    new (getAddress<NumericType>()) NumericType(t);
+    type_ = newType;
+  }
+  return *this;
+}
+//////////////////////////////////////////////////////////////////////
+
+inline dynamic::const_iterator dynamic::begin() const {
+  return get<Array>().begin();
+}
+inline dynamic::const_iterator dynamic::end() const {
+  return get<Array>().end();
+}
+
+inline dynamic::iterator dynamic::begin() {
+  return get<Array>().begin();
+}
+inline dynamic::iterator dynamic::end() {
+  return get<Array>().end();
+}
+
+template <class It>
+struct dynamic::IterableProxy {
+  typedef It iterator;
+  typedef typename It::value_type value_type;
+  typedef typename It::object_type object_type;
+
+  /* implicit */ IterableProxy(object_type* o) : o_(o) {}
+
+  It begin() const { return o_->begin(); }
+
+  It end() const { return o_->end(); }
+
+private:
+  object_type* o_;
+};
+
+inline dynamic::IterableProxy<dynamic::const_key_iterator> dynamic::keys()
+    const {
+  return &(get<ObjectImpl>());
+}
+
+inline dynamic::IterableProxy<dynamic::const_value_iterator> dynamic::values()
+    const {
+  return &(get<ObjectImpl>());
+}
+
+inline dynamic::IterableProxy<dynamic::const_item_iterator> dynamic::items()
+    const {
+  return &(get<ObjectImpl>());
+}
+
+inline dynamic::IterableProxy<dynamic::value_iterator> dynamic::values() {
+  return &(get<ObjectImpl>());
+}
+
+inline dynamic::IterableProxy<dynamic::item_iterator> dynamic::items() {
+  return &(get<ObjectImpl>());
+}
+
+inline bool dynamic::isString() const {
+  return get_nothrow<std::string>() != nullptr;
+}
+inline bool dynamic::isObject() const {
+  return get_nothrow<ObjectImpl>() != nullptr;
+}
+inline bool dynamic::isBool() const {
+  return get_nothrow<bool>() != nullptr;
+}
+inline bool dynamic::isArray() const {
+  return get_nothrow<Array>() != nullptr;
+}
+inline bool dynamic::isDouble() const {
+  return get_nothrow<double>() != nullptr;
+}
+inline bool dynamic::isInt() const {
+  return get_nothrow<int64_t>() != nullptr;
+}
+inline bool dynamic::isNull() const {
+  return get_nothrow<std::nullptr_t>() != nullptr;
+}
+inline bool dynamic::isNumber() const {
+  return isInt() || isDouble();
+}
+
+inline dynamic::Type dynamic::type() const {
+  return type_;
+}
+
+inline std::string dynamic::asString() const {
+  return asImpl<std::string>();
+}
+inline double dynamic::asDouble() const {
+  return asImpl<double>();
+}
+inline int64_t dynamic::asInt() const {
+  return asImpl<int64_t>();
+}
+inline bool dynamic::asBool() const {
+  return asImpl<bool>();
+}
+
+inline const std::string& dynamic::getString() const& {
+  return get<std::string>();
+}
+inline double dynamic::getDouble() const& {
+  return get<double>();
+}
+inline int64_t dynamic::getInt() const& {
+  return get<int64_t>();
+}
+inline bool dynamic::getBool() const& {
+  return get<bool>();
+}
+
+inline std::string& dynamic::getString() & {
+  return get<std::string>();
+}
+inline double& dynamic::getDouble() & {
+  return get<double>();
+}
+inline int64_t& dynamic::getInt() & {
+  return get<int64_t>();
+}
+inline bool& dynamic::getBool() & {
+  return get<bool>();
+}
+
+inline std::string&& dynamic::getString() && {
+  return std::move(get<std::string>());
+}
+inline double dynamic::getDouble() && {
+  return get<double>();
+}
+inline int64_t dynamic::getInt() && {
+  return get<int64_t>();
+}
+inline bool dynamic::getBool() && {
+  return get<bool>();
+}
+
+inline const char* dynamic::c_str() const& {
+  return get<std::string>().c_str();
+}
+inline StringPiece dynamic::stringPiece() const {
+  return get<std::string>();
+}
+
+template <class T>
+struct dynamic::CompareOp {
+  static bool comp(T const& a, T const& b) { return a < b; }
+};
+template <>
+struct dynamic::CompareOp<dynamic::ObjectImpl> {
+  static bool comp(ObjectImpl const&, ObjectImpl const&) {
+    // This code never executes; it is just here for the compiler.
+    return false;
+  }
+};
+template <>
+struct dynamic::CompareOp<std::nullptr_t> {
+  static bool comp(std::nullptr_t const&, std::nullptr_t const&) {
+    return false;
+  }
+};
+
+inline dynamic& dynamic::operator+=(dynamic const& o) {
+  if (type() == STRING && o.type() == STRING) {
+    *getAddress<std::string>() += *o.getAddress<std::string>();
+    return *this;
+  }
+  *this = detail::numericOp<std::plus>(*this, o);
+  return *this;
+}
+
+inline dynamic& dynamic::operator-=(dynamic const& o) {
+  *this = detail::numericOp<std::minus>(*this, o);
+  return *this;
+}
+
+inline dynamic& dynamic::operator*=(dynamic const& o) {
+  *this = detail::numericOp<std::multiplies>(*this, o);
+  return *this;
+}
+
+inline dynamic& dynamic::operator/=(dynamic const& o) {
+  *this = detail::numericOp<std::divides>(*this, o);
+  return *this;
+}
+
+#define FB_DYNAMIC_INTEGER_OP(op)                            \
+  inline dynamic& dynamic::operator op(dynamic const& o) {   \
+    if (!isInt() || !o.isInt()) {                            \
+      throw_exception<TypeError>("int64", type(), o.type()); \
+    }                                                        \
+    *getAddress<int64_t>() op o.asInt();                     \
+    return *this;                                            \
+  }
+
+FB_DYNAMIC_INTEGER_OP(%=)
+FB_DYNAMIC_INTEGER_OP(|=)
+FB_DYNAMIC_INTEGER_OP(&=)
+FB_DYNAMIC_INTEGER_OP(^=)
+
+#undef FB_DYNAMIC_INTEGER_OP
+
+inline dynamic& dynamic::operator++() {
+  ++get<int64_t>();
+  return *this;
+}
+
+inline dynamic& dynamic::operator--() {
+  --get<int64_t>();
+  return *this;
+}
+
+template <typename K>
+dynamic::IfIsNonStringDynamicConvertible<K, dynamic const&> dynamic::operator[](
+    K&& idx) const& {
+  return at(std::forward<K>(idx));
+}
+
+template <typename K>
+dynamic::IfIsNonStringDynamicConvertible<K, dynamic&> dynamic::operator[](
+    K&& idx) & {
+  if (!isObject() && !isArray()) {
+    throw_exception<TypeError>("object/array", type());
+  }
+  if (isArray()) {
+    return at(std::forward<K>(idx));
+  }
+  auto& obj = get<ObjectImpl>();
+  auto ret = obj.emplace(std::forward<K>(idx), nullptr);
+  return ret.first->second;
+}
+
+template <typename K>
+dynamic::IfIsNonStringDynamicConvertible<K, dynamic&&> dynamic::operator[](
+    K&& idx) && {
+  return std::move((*this)[std::forward<K>(idx)]);
+}
+
+inline dynamic const& dynamic::operator[](StringPiece k) const& {
+  return at(k);
+}
+
+inline dynamic&& dynamic::operator[](StringPiece k) && {
+  return std::move((*this)[k]);
+}
+
+template <typename K>
+dynamic::IfIsNonStringDynamicConvertible<K, dynamic> dynamic::getDefault(
+    K&& k, const dynamic& v) const& {
+  auto& obj = get<ObjectImpl>();
+  auto it = obj.find(std::forward<K>(k));
+  return it == obj.end() ? v : it->second;
+}
+
+template <typename K>
+dynamic::IfIsNonStringDynamicConvertible<K, dynamic> dynamic::getDefault(
+    K&& k, dynamic&& v) const& {
+  auto& obj = get<ObjectImpl>();
+  auto it = obj.find(std::forward<K>(k));
+  // Avoid clang bug with ternary
+  if (it == obj.end()) {
+    return std::move(v);
+  } else {
+    return it->second;
+  }
+}
+
+template <typename K>
+dynamic::IfIsNonStringDynamicConvertible<K, dynamic> dynamic::getDefault(
+    K&& k, const dynamic& v) && {
+  auto& obj = get<ObjectImpl>();
+  auto it = obj.find(std::forward<K>(k));
+  // Avoid clang bug with ternary
+  if (it == obj.end()) {
+    return v;
+  } else {
+    return std::move(it->second);
+  }
+}
+
+template <typename K>
+dynamic::IfIsNonStringDynamicConvertible<K, dynamic> dynamic::getDefault(
+    K&& k, dynamic&& v) && {
+  auto& obj = get<ObjectImpl>();
+  auto it = obj.find(std::forward<K>(k));
+  return std::move(it == obj.end() ? v : it->second);
+}
+
+template <typename K, typename V>
+dynamic::IfIsNonStringDynamicConvertible<K, dynamic&> dynamic::setDefault(
+    K&& k, V&& v) {
+  auto& obj = get<ObjectImpl>();
+  return obj.emplace(std::forward<K>(k), std::forward<V>(v)).first->second;
+}
+
+template <typename K>
+dynamic::IfIsNonStringDynamicConvertible<K, dynamic&> dynamic::setDefault(
+    K&& k, dynamic&& v) {
+  auto& obj = get<ObjectImpl>();
+  return obj.emplace(std::forward<K>(k), std::move(v)).first->second;
+}
+
+template <typename K>
+dynamic::IfIsNonStringDynamicConvertible<K, dynamic&> dynamic::setDefault(
+    K&& k, const dynamic& v) {
+  auto& obj = get<ObjectImpl>();
+  return obj.emplace(std::forward<K>(k), v).first->second;
+}
+
+template <typename V>
+dynamic& dynamic::setDefault(StringPiece k, V&& v) {
+  auto& obj = get<ObjectImpl>();
+  return obj.emplace(k, std::forward<V>(v)).first->second;
+}
+
+inline dynamic& dynamic::setDefault(StringPiece k, dynamic&& v) {
+  auto& obj = get<ObjectImpl>();
+  return obj.emplace(k, std::move(v)).first->second;
+}
+
+inline dynamic& dynamic::setDefault(StringPiece k, const dynamic& v) {
+  auto& obj = get<ObjectImpl>();
+  return obj.emplace(k, v).first->second;
+}
+
+template <typename K>
+dynamic::IfIsNonStringDynamicConvertible<K, dynamic const*> dynamic::get_ptr(
+    K&& k) const& {
+  return get_ptrImpl(std::forward<K>(k));
+}
+
+template <typename K>
+dynamic::IfIsNonStringDynamicConvertible<K, dynamic*> dynamic::get_ptr(
+    K&& idx) & {
+  return const_cast<dynamic*>(const_cast<dynamic const*>(this)->get_ptr(idx));
+}
+
+inline dynamic* dynamic::get_ptr(StringPiece idx) & {
+  return const_cast<dynamic*>(const_cast<dynamic const*>(this)->get_ptr(idx));
+}
+
+// clang-format off
+inline
+dynamic::resolved_json_pointer<dynamic>
+dynamic::try_get_ptr(json_pointer const& jsonPtr) & {
+  auto ret = const_cast<dynamic const*>(this)->try_get_ptr(jsonPtr);
+  if (ret.hasValue()) {
+    return json_pointer_resolved_value<dynamic>{
+        const_cast<dynamic*>(ret.value().parent),
+        const_cast<dynamic*>(ret.value().value),
+        ret.value().parent_key, ret.value().parent_index};
+  } else {
+    return makeUnexpected(
+        json_pointer_resolution_error<dynamic>{
+            ret.error().error_code,
+            ret.error().index,
+            const_cast<dynamic*>(ret.error().context)}
+        );
+  }
+}
+// clang-format on
+
+inline dynamic* dynamic::get_ptr(json_pointer const& jsonPtr) & {
+  return const_cast<dynamic*>(
+      const_cast<dynamic const*>(this)->get_ptr(jsonPtr));
+}
+
+template <typename K>
+dynamic::IfIsNonStringDynamicConvertible<K, dynamic const&> dynamic::at(
+    K&& k) const& {
+  return atImpl(std::forward<K>(k));
+}
+
+template <typename K>
+dynamic::IfIsNonStringDynamicConvertible<K, dynamic&> dynamic::at(K&& idx) & {
+  return const_cast<dynamic&>(const_cast<dynamic const*>(this)->at(idx));
+}
+
+template <typename K>
+dynamic::IfIsNonStringDynamicConvertible<K, dynamic&&> dynamic::at(K&& idx) && {
+  return std::move(at(idx));
+}
+
+inline dynamic& dynamic::at(StringPiece idx) & {
+  return const_cast<dynamic&>(const_cast<dynamic const*>(this)->at(idx));
+}
+
+inline dynamic&& dynamic::at(StringPiece idx) && {
+  return std::move(at(idx));
+}
+
+inline bool dynamic::empty() const {
+  if (isNull()) {
+    return true;
+  }
+  return !size();
+}
+
+template <typename K>
+dynamic::IfIsNonStringDynamicConvertible<K, dynamic::const_item_iterator>
+dynamic::find(K&& key) const {
+  return get<ObjectImpl>().find(std::forward<K>(key));
+}
+
+template <typename K>
+dynamic::IfIsNonStringDynamicConvertible<K, dynamic::item_iterator>
+dynamic::find(K&& key) {
+  return get<ObjectImpl>().find(std::forward<K>(key));
+}
+
+inline dynamic::const_item_iterator dynamic::find(StringPiece key) const {
+  return get<ObjectImpl>().find(key);
+}
+
+inline dynamic::item_iterator dynamic::find(StringPiece key) {
+  return get<ObjectImpl>().find(key);
+}
+
+template <typename K>
+dynamic::IfIsNonStringDynamicConvertible<K, std::size_t> dynamic::count(
+    K&& key) const {
+  return find(std::forward<K>(key)) != items().end() ? 1u : 0u;
+}
+
+inline std::size_t dynamic::count(StringPiece key) const {
+  return find(key) != items().end() ? 1u : 0u;
+}
+
+template <class K, class V>
+inline dynamic::IfNotIterator<K, void> dynamic::insert(K&& key, V&& val) {
+  auto& obj = get<ObjectImpl>();
+  obj[std::forward<K>(key)] = std::forward<V>(val);
+}
+
+template <class... Args>
+inline std::pair<dynamic::item_iterator, bool> dynamic::emplace(
+    Args&&... args) {
+  auto& obj = get<ObjectImpl>();
+  return obj.emplace(std::forward<Args>(args)...);
+}
+
+template <class K, class... Args>
+inline std::pair<dynamic::item_iterator, bool> dynamic::try_emplace(
+    K&& key, Args&&... args) {
+  auto& obj = get<ObjectImpl>();
+  return obj.try_emplace(std::forward<K>(key), std::forward<Args>(args)...);
+}
+
+template <class T>
+inline dynamic::iterator dynamic::insert(const_iterator pos, T&& value) {
+  auto& arr = get<Array>();
+  return arr.insert(pos, std::forward<T>(value));
+}
+
+template <class InputIt>
+inline dynamic::iterator dynamic::insert(
+    const_iterator pos, InputIt first, InputIt last) {
+  auto& arr = get<Array>();
+  return arr.insert(pos, first, last);
+}
+
+inline void dynamic::update(const dynamic& mergeObj) {
+  if (!isObject() || !mergeObj.isObject()) {
+    throw_exception<TypeError>("object", type(), mergeObj.type());
+  }
+
+  for (const auto& pair : mergeObj.items()) {
+    (*this)[pair.first] = pair.second;
+  }
+}
+
+inline void dynamic::update_missing(const dynamic& mergeObj1) {
+  if (!isObject() || !mergeObj1.isObject()) {
+    throw_exception<TypeError>("object", type(), mergeObj1.type());
+  }
+
+  // Only add if not already there
+  for (const auto& pair : mergeObj1.items()) {
+    if ((*this).find(pair.first) == (*this).items().end()) {
+      (*this)[pair.first] = pair.second;
+    }
+  }
+}
+
+inline void dynamic::merge_patch(const dynamic& patch) {
+  auto& self = *this;
+  if (!patch.isObject()) {
+    self = patch;
+    return;
+  }
+  // if we are not an object, erase all contents, reset to object
+  if (!isObject()) {
+    self = object;
+  }
+  for (const auto& pair : patch.items()) {
+    if (pair.second.isNull()) {
+      // if name could be found in current object, remove it
+      auto it = self.find(pair.first);
+      if (it != self.items().end()) {
+        self.erase(it);
+      }
+    } else {
+      self[pair.first].merge_patch(pair.second);
+    }
+  }
+}
+
+inline dynamic dynamic::merge(
+    const dynamic& mergeObj1, const dynamic& mergeObj2) {
+  // No checks on type needed here because they are done in update_missing
+  // Note that we do update_missing here instead of update() because
+  // it will prevent the extra writes that would occur with update()
+  auto ret = mergeObj2;
+  ret.update_missing(mergeObj1);
+  return ret;
+}
+
+template <typename K>
+dynamic::IfIsNonStringDynamicConvertible<K, std::size_t> dynamic::erase(
+    K&& key) {
+  auto& obj = get<ObjectImpl>();
+  return obj.erase(std::forward<K>(key));
+}
+inline std::size_t dynamic::erase(StringPiece key) {
+  auto& obj = get<ObjectImpl>();
+  return obj.erase(key);
+}
+
+inline dynamic::iterator dynamic::erase(const_iterator it) {
+  auto& arr = get<Array>();
+  // std::vector doesn't have an erase method that works on const iterators,
+  // even though the standard says it should, so this hack converts to a
+  // non-const iterator before calling erase.
+  return get<Array>().erase(arr.begin() + (it - arr.begin()));
+}
+
+inline dynamic::const_key_iterator dynamic::erase(const_key_iterator it) {
+  return const_key_iterator(get<ObjectImpl>().erase(it.base()));
+}
+
+inline dynamic::const_key_iterator dynamic::erase(
+    const_key_iterator first, const_key_iterator last) {
+  return const_key_iterator(get<ObjectImpl>().erase(first.base(), last.base()));
+}
+
+inline dynamic::value_iterator dynamic::erase(const_value_iterator it) {
+  return value_iterator(get<ObjectImpl>().erase(it.base()));
+}
+
+inline dynamic::value_iterator dynamic::erase(
+    const_value_iterator first, const_value_iterator last) {
+  return value_iterator(get<ObjectImpl>().erase(first.base(), last.base()));
+}
+
+inline dynamic::item_iterator dynamic::erase(const_item_iterator it) {
+  return item_iterator(get<ObjectImpl>().erase(it.base()));
+}
+
+inline dynamic::item_iterator dynamic::erase(
+    const_item_iterator first, const_item_iterator last) {
+  return item_iterator(get<ObjectImpl>().erase(first.base(), last.base()));
+}
+
+inline void dynamic::resize(std::size_t sz, dynamic const& c) {
+  auto& arr = get<Array>();
+  arr.resize(sz, c);
+}
+
+inline void dynamic::push_back(dynamic const& v) {
+  auto& arr = get<Array>();
+  arr.push_back(v);
+}
+
+inline void dynamic::push_back(dynamic&& v) {
+  auto& arr = get<Array>();
+  arr.push_back(std::move(v));
+}
+
+inline void dynamic::pop_back() {
+  auto& arr = get<Array>();
+  arr.pop_back();
+}
+
+inline const dynamic& dynamic::back() const {
+  auto& arr = get<Array>();
+  return arr.back();
+}
+
+//////////////////////////////////////////////////////////////////////
+
+inline dynamic::dynamic(Array&& r) : type_(ARRAY) {
+  new (&u_.array) Array(std::move(r));
+}
+
+#define FOLLY_DYNAMIC_DEC_TYPEINFO(T, val)     \
+  template <>                                  \
+  struct dynamic::TypeInfo<T> {                \
+    static const char* const name;             \
+    static constexpr dynamic::Type type = val; \
+  };                                           \
+  //
+
+FOLLY_DYNAMIC_DEC_TYPEINFO(std::nullptr_t, dynamic::NULLT)
+FOLLY_DYNAMIC_DEC_TYPEINFO(bool, dynamic::BOOL)
+FOLLY_DYNAMIC_DEC_TYPEINFO(std::string, dynamic::STRING)
+FOLLY_DYNAMIC_DEC_TYPEINFO(dynamic::Array, dynamic::ARRAY)
+FOLLY_DYNAMIC_DEC_TYPEINFO(double, dynamic::DOUBLE)
+FOLLY_DYNAMIC_DEC_TYPEINFO(int64_t, dynamic::INT64)
+FOLLY_DYNAMIC_DEC_TYPEINFO(dynamic::ObjectImpl, dynamic::OBJECT)
+
+#undef FOLLY_DYNAMIC_DEC_TYPEINFO
+
+template <class T>
+T dynamic::asImpl() const {
+  FOLLY_PUSH_WARNING
+  FOLLY_CLANG_DISABLE_WARNING("-Wcovered-switch-default")
+  switch (type()) {
+    case INT64:
+      return to<T>(*get_nothrow<int64_t>());
+    case DOUBLE:
+      return to<T>(*get_nothrow<double>());
+    case BOOL:
+      return to<T>(*get_nothrow<bool>());
+    case STRING:
+      return to<T>(*get_nothrow<std::string>());
+    case NULLT:
+    case ARRAY:
+    case OBJECT:
+    default:
+      throw_exception<TypeError>("int/double/bool/string", type());
+  }
+  FOLLY_POP_WARNING
+}
+
+// Return a T* to our type, or null if we're not that type.
+template <class T>
+T* dynamic::get_nothrow() & noexcept {
+  if (type_ != TypeInfo<T>::type) {
+    return nullptr;
+  }
+  return getAddress<T>();
+}
+
+template <class T>
+T const* dynamic::get_nothrow() const& noexcept {
+  return const_cast<dynamic*>(this)->get_nothrow<T>();
+}
+
+// Return T* for where we can put a T, without type checking.  (Memory
+// might be uninitialized, even.)
+template <class T>
+T* dynamic::getAddress() noexcept {
+  return GetAddrImpl<T>::get(u_);
+}
+
+template <class T>
+T const* dynamic::getAddress() const noexcept {
+  return const_cast<dynamic*>(this)->getAddress<T>();
+}
+
+template <class T>
+struct dynamic::GetAddrImpl {};
+template <>
+struct dynamic::GetAddrImpl<std::nullptr_t> {
+  static std::nullptr_t* get(Data& d) noexcept { return &d.nul; }
+};
+template <>
+struct dynamic::GetAddrImpl<dynamic::Array> {
+  static Array* get(Data& d) noexcept { return &d.array; }
+};
+template <>
+struct dynamic::GetAddrImpl<bool> {
+  static bool* get(Data& d) noexcept { return &d.boolean; }
+};
+template <>
+struct dynamic::GetAddrImpl<int64_t> {
+  static int64_t* get(Data& d) noexcept { return &d.integer; }
+};
+template <>
+struct dynamic::GetAddrImpl<double> {
+  static double* get(Data& d) noexcept { return &d.doubl; }
+};
+template <>
+struct dynamic::GetAddrImpl<std::string> {
+  static std::string* get(Data& d) noexcept { return &d.string; }
+};
+template <>
+struct dynamic::GetAddrImpl<dynamic::ObjectImpl> {
+  static_assert(
+      sizeof(ObjectImpl) <= sizeof(Data::objectBuffer),
+      "In your implementation, F14NodeMap<> apparently takes different"
+      " amount of space depending on its template parameters.  This is "
+      "weird.  Make objectBuffer bigger if you want to compile dynamic.");
+
+  static ObjectImpl* get(Data& d) noexcept {
+    void* data = &d.objectBuffer;
+    return static_cast<ObjectImpl*>(data);
+  }
+};
+
 // [Win - Forked to avoid using exported data across the dll boundary.  Using exported data prevents the ability to
 // delay load the dll We can remove this, once react-native-win32 stops exporting folly (gets entirely onto the ABI
 // interface)
 template <class T>
 T &dynamic::get() {
-  if (auto *p = get_nothrow<T>()) {
-    return *p;
+if (auto *p = get_nothrow<T>()) {
+  return *p;
+}
+
+switch (type()) {
+  case dynamic::NULLT:
+    throw_exception<TypeError>("null", dynamic::NULLT);
+    break;
+  case dynamic::BOOL:
+    throw_exception<TypeError>("boolean", dynamic::BOOL);
+    break;
+  case dynamic::STRING:
+    throw_exception<TypeError>("string", dynamic::STRING);
+    break;
+  case dynamic::ARRAY:
+    throw_exception<TypeError>("array", dynamic::ARRAY);
+    break;
+  case dynamic::DOUBLE:
+    throw_exception<TypeError>("double", dynamic::DOUBLE);
+    break;
+  case dynamic::INT64:
+    throw_exception<TypeError>("int64", dynamic::INT64);
+    break;
+  case dynamic::OBJECT:
+    throw_exception<TypeError>("object", dynamic::OBJECT);
+    break;
+  default:
+    throw_exception<TypeError>("never", dynamic::OBJECT);
+    break;
+}
+}
+// Win]
+
+template <class T>
+T const& dynamic::get() const {
+  return const_cast<dynamic*>(this)->get<T>();
+}
+
+//////////////////////////////////////////////////////////////////////
+
+/*
+* Helper for implementing operator<<.  Throws if the type shouldn't
+* support it.
+*/
+template <class T>
+struct dynamic::PrintImpl {
+  static void print(dynamic const&, std::ostream& out, T const& t) { out << t; }
+};
+// Otherwise, null, being (void*)0, would print as 0.
+template <>
+struct dynamic::PrintImpl<std::nullptr_t> {
+  static void print(
+      dynamic const& /* d */, std::ostream& out, std::nullptr_t const&) {
+    out << "null";
+  }
+};
+template <>
+struct dynamic::PrintImpl<dynamic::ObjectImpl> {
+  static void print(
+      dynamic const& d, std::ostream& out, dynamic::ObjectImpl const&) {
+    d.print_as_pseudo_json(out);
   }
+};
+template <>
+struct dynamic::PrintImpl<dynamic::Array> {
+  static void print(
+      dynamic const& d, std::ostream& out, dynamic::Array const&) {
+    d.print_as_pseudo_json(out);
+  }
+};
 
-  switch (type()) {
-    case dynamic::NULLT:
-      throw_exception<TypeError>("null", dynamic::NULLT);
-      break;
-    case dynamic::BOOL:
-      throw_exception<TypeError>("boolean", dynamic::BOOL);
-      break;
-    case dynamic::STRING:
-      throw_exception<TypeError>("string", dynamic::STRING);
-      break;
-    case dynamic::ARRAY:
-      throw_exception<TypeError>("array", dynamic::ARRAY);
-      break;
-    case dynamic::DOUBLE:
-      throw_exception<TypeError>("double", dynamic::DOUBLE);
-      break;
-    case dynamic::INT64:
-      throw_exception<TypeError>("int64", dynamic::INT64);
-      break;
-    case dynamic::OBJECT:
-      throw_exception<TypeError>("object", dynamic::OBJECT);
-      break;
-    default:
-      throw_exception<TypeError>("never", dynamic::OBJECT);
-      break;
+inline void dynamic::print(std::ostream& out) const {
+#define FB_X(T) PrintImpl<T>::print(*this, out, *getAddress<T>())
+  FB_DYNAMIC_APPLY(type_, FB_X);
+#undef FB_X
+}
+
+inline std::ostream& operator<<(std::ostream& out, dynamic const& d) {
+  d.print(out);
+  return out;
+}
+
+//////////////////////////////////////////////////////////////////////
+
+inline const_dynamic_view::const_dynamic_view(dynamic const& d) noexcept
+    : d_(&d) {}
+
+inline const_dynamic_view::const_dynamic_view(dynamic const* d) noexcept
+    : d_(d) {}
+
+inline const_dynamic_view::operator bool() const noexcept {
+  return !empty();
+}
+
+inline bool const_dynamic_view::empty() const noexcept {
+  return d_ == nullptr;
+}
+
+inline void const_dynamic_view::reset() noexcept {
+  d_ = nullptr;
+}
+
+template <typename Key, typename... Keys>
+inline const_dynamic_view const_dynamic_view::descend(
+    Key const& key, Keys const&... keys) const noexcept {
+  return descend_(key, keys...);
+}
+
+template <typename Key1, typename Key2, typename... Keys>
+inline dynamic const* const_dynamic_view::descend_(
+    Key1 const& key1, Key2 const& key2, Keys const&... keys) const noexcept {
+  if (!d_) {
+    return nullptr;
   }
+  return const_dynamic_view{descend_unchecked_(key1)}.descend_(key2, keys...);
 }
-// Win]
- 
- template <class T>
- T const& dynamic::get() const {
-   return const_cast<dynamic*>(this)->get<T>();
- }
- 
- //////////////////////////////////////////////////////////////////////
- 
- /*
-  * Helper for implementing operator<<.  Throws if the type shouldn't
-  * support it.
-  */
- template <class T>
- struct dynamic::PrintImpl {
-   static void print(dynamic const&, std::ostream& out, T const& t) { out << t; }
- };
- // Otherwise, null, being (void*)0, would print as 0.
- template <>
- struct dynamic::PrintImpl<std::nullptr_t> {
-   static void print(
-       dynamic const& /* d */, std::ostream& out, std::nullptr_t const&) {
-     out << "null";
-   }
- };
- template <>
- struct dynamic::PrintImpl<dynamic::ObjectImpl> {
-   static void print(
-       dynamic const& d, std::ostream& out, dynamic::ObjectImpl const&) {
-     d.print_as_pseudo_json(out);
-   }
- };
- template <>
- struct dynamic::PrintImpl<dynamic::Array> {
-   static void print(
-       dynamic const& d, std::ostream& out, dynamic::Array const&) {
-     d.print_as_pseudo_json(out);
-   }
- };
- 
- inline void dynamic::print(std::ostream& out) const {
- #define FB_X(T) PrintImpl<T>::print(*this, out, *getAddress<T>())
-   FB_DYNAMIC_APPLY(type_, FB_X);
- #undef FB_X
- }
- 
- inline std::ostream& operator<<(std::ostream& out, dynamic const& d) {
-   d.print(out);
-   return out;
- }
- 
- //////////////////////////////////////////////////////////////////////
- 
- inline const_dynamic_view::const_dynamic_view(dynamic const& d) noexcept
-     : d_(&d) {}
- 
- inline const_dynamic_view::const_dynamic_view(dynamic const* d) noexcept
-     : d_(d) {}
- 
- inline const_dynamic_view::operator bool() const noexcept {
-   return !empty();
- }
- 
- inline bool const_dynamic_view::empty() const noexcept {
-   return d_ == nullptr;
- }
- 
- inline void const_dynamic_view::reset() noexcept {
-   d_ = nullptr;
- }
- 
- template <typename Key, typename... Keys>
- inline const_dynamic_view const_dynamic_view::descend(
-     Key const& key, Keys const&... keys) const noexcept {
-   return descend_(key, keys...);
- }
- 
- template <typename Key1, typename Key2, typename... Keys>
- inline dynamic const* const_dynamic_view::descend_(
-     Key1 const& key1, Key2 const& key2, Keys const&... keys) const noexcept {
-   if (!d_) {
-     return nullptr;
-   }
-   return const_dynamic_view{descend_unchecked_(key1)}.descend_(key2, keys...);
- }
- 
- template <typename Key>
- inline dynamic const* const_dynamic_view::descend_(
-     Key const& key) const noexcept {
-   if (!d_) {
-     return nullptr;
-   }
-   return descend_unchecked_(key);
- }
- 
- template <typename Key>
- inline dynamic::IfIsNonStringDynamicConvertible<Key, dynamic const*>
- const_dynamic_view::descend_unchecked_(Key const& key) const noexcept {
-   if (auto* parray = d_->get_nothrow<dynamic::Array>()) {
-     if /* constexpr */ (!std::is_integral<Key>::value) {
-       return nullptr;
-     }
-     if (key < 0 || folly::to_unsigned(key) >= parray->size()) {
-       return nullptr;
-     }
-     return &(*parray)[size_t(key)];
-   } else if (auto* pobject = d_->get_nothrow<dynamic::ObjectImpl>()) {
-     auto it = pobject->find(key);
-     if (it == pobject->end()) {
-       return nullptr;
-     }
-     return &it->second;
-   }
-   return nullptr;
- }
- 
- inline dynamic const* const_dynamic_view::descend_unchecked_(
-     folly::StringPiece key) const noexcept {
-   if (auto* pobject = d_->get_nothrow<dynamic::ObjectImpl>()) {
-     auto it = pobject->find(key);
-     if (it == pobject->end()) {
-       return nullptr;
-     }
-     return &it->second;
-   }
-   return nullptr;
- }
- 
- inline dynamic const_dynamic_view::value_or(dynamic&& val) const {
-   if (d_) {
-     return *d_;
-   }
-   return std::move(val);
- }
- 
- template <typename T, typename... Args>
- inline T const_dynamic_view::get_copy(Args&&... args) const {
-   if (auto* v = (d_ ? d_->get_nothrow<T>() : nullptr)) {
-     return *v;
-   }
-   return T(std::forward<Args>(args)...);
- }
- 
- inline std::string const_dynamic_view::string_or(char const* val) const {
-   return get_copy<std::string>(val);
- }
- 
- inline std::string const_dynamic_view::string_or(std::string val) const {
-   return get_copy<std::string>(std::move(val));
- }
- 
- // Specialized version for StringPiece, FixedString, and other types which are
- // not convertible to std::string, but can construct one from .data and .size
- // to std::string. Will not trigger a copy unless data and size require it.
- template <typename Stringish, typename>
- inline std::string const_dynamic_view::string_or(Stringish&& val) const {
-   return get_copy(val.data(), val.size());
- }
- 
- inline double const_dynamic_view::double_or(double val) const noexcept {
-   return get_copy<double>(val);
- }
- 
- inline int64_t const_dynamic_view::int_or(int64_t val) const noexcept {
-   return get_copy<int64_t>(val);
- }
- 
- inline bool const_dynamic_view::bool_or(bool val) const noexcept {
-   return get_copy<bool>(val);
- }
- 
- inline dynamic_view::dynamic_view(dynamic& d) noexcept
-     : const_dynamic_view(d) {}
- 
- template <typename Key, typename... Keys>
- inline dynamic_view dynamic_view::descend(
-     Key const& key, Keys const&... keys) const noexcept {
-   if (auto* child = const_dynamic_view::descend_(key, keys...)) {
-     return *const_cast<dynamic*>(child);
-   }
-   return {};
- }
- 
- inline dynamic dynamic_view::move_value_or(dynamic&& val) noexcept {
-   if (d_) {
-     return std::move(*const_cast<dynamic*>(d_));
-   }
-   return std::move(val);
- }
- 
- template <typename T, typename... Args>
- inline T dynamic_view::get_move(Args&&... args) {
-   if (auto* v = (d_ ? const_cast<dynamic*>(d_)->get_nothrow<T>() : nullptr)) {
-     return std::move(*v);
-   }
-   return T(std::forward<Args>(args)...);
- }
- 
- inline std::string dynamic_view::move_string_or(char const* val) {
-   return get_move<std::string>(val);
- }
- 
- inline std::string dynamic_view::move_string_or(std::string val) noexcept {
-   return get_move<std::string>(std::move(val));
- }
- 
- template <typename Stringish, typename>
- inline std::string dynamic_view::move_string_or(Stringish&& val) {
-   return get_move<std::string>(val.begin(), val.end());
- }
- 
- //////////////////////////////////////////////////////////////////////
- 
- // Specialization of FormatValue so dynamic objects can be formatted
- template <>
- class FormatValue<dynamic> {
-  public:
-   explicit FormatValue(const dynamic& val) : val_(val) {}
- 
-   template <class FormatCallback>
-   void format(FormatArg& arg, FormatCallback& cb) const {
-     switch (val_.type()) {
-       case dynamic::NULLT:
-         FormatValue<std::nullptr_t>(nullptr).format(arg, cb);
-         break;
-       case dynamic::BOOL:
-         FormatValue<bool>(val_.asBool()).format(arg, cb);
-         break;
-       case dynamic::INT64:
-         FormatValue<int64_t>(val_.asInt()).format(arg, cb);
-         break;
-       case dynamic::STRING:
-         FormatValue<std::string>(val_.asString()).format(arg, cb);
-         break;
-       case dynamic::DOUBLE:
-         FormatValue<double>(val_.asDouble()).format(arg, cb);
-         break;
-       case dynamic::ARRAY:
-         FormatValue(val_.at(arg.splitIntKey())).format(arg, cb);
-         break;
-       case dynamic::OBJECT:
-         FormatValue(val_.at(arg.splitKey().toString())).format(arg, cb);
-         break;
-     }
-   }
- 
-  private:
-   const dynamic& val_;
- };
- 
- template <class V>
- class FormatValue<detail::DefaultValueWrapper<dynamic, V>> {
-  public:
-   explicit FormatValue(const detail::DefaultValueWrapper<dynamic, V>& val)
-       : val_(val) {}
- 
-   template <class FormatCallback>
-   void format(FormatArg& arg, FormatCallback& cb) const {
-     auto& c = val_.container;
-     switch (c.type()) {
-       case dynamic::NULLT:
-       case dynamic::BOOL:
-       case dynamic::INT64:
-       case dynamic::STRING:
-       case dynamic::DOUBLE:
-         FormatValue<dynamic>(c).format(arg, cb);
-         break;
-       case dynamic::ARRAY: {
-         int key = arg.splitIntKey();
-         if (key >= 0 && size_t(key) < c.size()) {
-           FormatValue<dynamic>(c.at(key)).format(arg, cb);
-         } else {
-           FormatValue<V>(val_.defaultValue).format(arg, cb);
-         }
-         break;
-       }
-       case dynamic::OBJECT: {
-         auto pos = c.find(arg.splitKey());
-         if (pos != c.items().end()) {
-           FormatValue<dynamic>(pos->second).format(arg, cb);
-         } else {
-           FormatValue<V>(val_.defaultValue).format(arg, cb);
-         }
-         break;
-       }
-     }
-   }
- 
-  private:
-   const detail::DefaultValueWrapper<dynamic, V>& val_;
- };
- 
- } // namespace folly
- 
- #undef FB_DYNAMIC_APPLY
\ No newline at end of file
+
+template <typename Key>
+inline dynamic const* const_dynamic_view::descend_(
+    Key const& key) const noexcept {
+  if (!d_) {
+    return nullptr;
+  }
+  return descend_unchecked_(key);
+}
+
+template <typename Key>
+inline dynamic::IfIsNonStringDynamicConvertible<Key, dynamic const*>
+const_dynamic_view::descend_unchecked_(Key const& key) const noexcept {
+  if (auto* parray = d_->get_nothrow<dynamic::Array>()) {
+    if /* constexpr */ (!std::is_integral<Key>::value) {
+      return nullptr;
+    }
+    if (key < 0 || folly::to_unsigned(key) >= parray->size()) {
+      return nullptr;
+    }
+    return &(*parray)[size_t(key)];
+  } else if (auto* pobject = d_->get_nothrow<dynamic::ObjectImpl>()) {
+    auto it = pobject->find(key);
+    if (it == pobject->end()) {
+      return nullptr;
+    }
+    return &it->second;
+  }
+  return nullptr;
+}
+
+inline dynamic const* const_dynamic_view::descend_unchecked_(
+    folly::StringPiece key) const noexcept {
+  if (auto* pobject = d_->get_nothrow<dynamic::ObjectImpl>()) {
+    auto it = pobject->find(key);
+    if (it == pobject->end()) {
+      return nullptr;
+    }
+    return &it->second;
+  }
+  return nullptr;
+}
+
+inline dynamic const_dynamic_view::value_or(dynamic&& val) const {
+  if (d_) {
+    return *d_;
+  }
+  return std::move(val);
+}
+
+template <typename T, typename... Args>
+inline T const_dynamic_view::get_copy(Args&&... args) const {
+  if (auto* v = (d_ ? d_->get_nothrow<T>() : nullptr)) {
+    return *v;
+  }
+  return T(std::forward<Args>(args)...);
+}
+
+inline std::string const_dynamic_view::string_or(char const* val) const {
+  return get_copy<std::string>(val);
+}
+
+inline std::string const_dynamic_view::string_or(std::string val) const {
+  return get_copy<std::string>(std::move(val));
+}
+
+// Specialized version for StringPiece, FixedString, and other types which are
+// not convertible to std::string, but can construct one from .data and .size
+// to std::string. Will not trigger a copy unless data and size require it.
+template <typename Stringish, typename>
+inline std::string const_dynamic_view::string_or(Stringish&& val) const {
+  return get_copy(val.data(), val.size());
+}
+
+inline double const_dynamic_view::double_or(double val) const noexcept {
+  return get_copy<double>(val);
+}
+
+inline int64_t const_dynamic_view::int_or(int64_t val) const noexcept {
+  return get_copy<int64_t>(val);
+}
+
+inline bool const_dynamic_view::bool_or(bool val) const noexcept {
+  return get_copy<bool>(val);
+}
+
+inline dynamic_view::dynamic_view(dynamic& d) noexcept
+    : const_dynamic_view(d) {}
+
+template <typename Key, typename... Keys>
+inline dynamic_view dynamic_view::descend(
+    Key const& key, Keys const&... keys) const noexcept {
+  if (auto* child = const_dynamic_view::descend_(key, keys...)) {
+    return *const_cast<dynamic*>(child);
+  }
+  return {};
+}
+
+inline dynamic dynamic_view::move_value_or(dynamic&& val) noexcept {
+  if (d_) {
+    return std::move(*const_cast<dynamic*>(d_));
+  }
+  return std::move(val);
+}
+
+template <typename T, typename... Args>
+inline T dynamic_view::get_move(Args&&... args) {
+  if (auto* v = (d_ ? const_cast<dynamic*>(d_)->get_nothrow<T>() : nullptr)) {
+    return std::move(*v);
+  }
+  return T(std::forward<Args>(args)...);
+}
+
+inline std::string dynamic_view::move_string_or(char const* val) {
+  return get_move<std::string>(val);
+}
+
+inline std::string dynamic_view::move_string_or(std::string val) noexcept {
+  return get_move<std::string>(std::move(val));
+}
+
+template <typename Stringish, typename>
+inline std::string dynamic_view::move_string_or(Stringish&& val) {
+  return get_move<std::string>(val.begin(), val.end());
+}
+
+//////////////////////////////////////////////////////////////////////
+
+// Specialization of FormatValue so dynamic objects can be formatted
+template <>
+class FormatValue<dynamic> {
+public:
+  explicit FormatValue(const dynamic& val) : val_(val) {}
+
+  template <class FormatCallback>
+  void format(FormatArg& arg, FormatCallback& cb) const {
+    switch (val_.type()) {
+      case dynamic::NULLT:
+        FormatValue<std::nullptr_t>(nullptr).format(arg, cb);
+        break;
+      case dynamic::BOOL:
+        FormatValue<bool>(val_.asBool()).format(arg, cb);
+        break;
+      case dynamic::INT64:
+        FormatValue<int64_t>(val_.asInt()).format(arg, cb);
+        break;
+      case dynamic::STRING:
+        FormatValue<std::string>(val_.asString()).format(arg, cb);
+        break;
+      case dynamic::DOUBLE:
+        FormatValue<double>(val_.asDouble()).format(arg, cb);
+        break;
+      case dynamic::ARRAY:
+        FormatValue(val_.at(arg.splitIntKey())).format(arg, cb);
+        break;
+      case dynamic::OBJECT:
+        FormatValue(val_.at(arg.splitKey().toString())).format(arg, cb);
+        break;
+    }
+  }
+
+private:
+  const dynamic& val_;
+};
+
+template <class V>
+class FormatValue<detail::DefaultValueWrapper<dynamic, V>> {
+public:
+  explicit FormatValue(const detail::DefaultValueWrapper<dynamic, V>& val)
+      : val_(val) {}
+
+  template <class FormatCallback>
+  void format(FormatArg& arg, FormatCallback& cb) const {
+    auto& c = val_.container;
+    switch (c.type()) {
+      case dynamic::NULLT:
+      case dynamic::BOOL:
+      case dynamic::INT64:
+      case dynamic::STRING:
+      case dynamic::DOUBLE:
+        FormatValue<dynamic>(c).format(arg, cb);
+        break;
+      case dynamic::ARRAY: {
+        int key = arg.splitIntKey();
+        if (key >= 0 && size_t(key) < c.size()) {
+          FormatValue<dynamic>(c.at(key)).format(arg, cb);
+        } else {
+          FormatValue<V>(val_.defaultValue).format(arg, cb);
+        }
+        break;
+      }
+      case dynamic::OBJECT: {
+        auto pos = c.find(arg.splitKey());
+        if (pos != c.items().end()) {
+          FormatValue<dynamic>(pos->second).format(arg, cb);
+        } else {
+          FormatValue<V>(val_.defaultValue).format(arg, cb);
+        }
+        break;
+      }
+    }
+  }
+
+private:
+  const detail::DefaultValueWrapper<dynamic, V>& val_;
+};
+
+} // namespace folly
+
+#undef FB_DYNAMIC_APPLY
\ No newline at end of file
diff --git a/vnext/Folly/TEMP_UntilFollyUpdate/json/json.cpp b/vnext/Folly/TEMP_UntilFollyUpdate/json/json.cpp
new file mode 100644
index 00000000000..00193cbc786
--- /dev/null
+++ b/vnext/Folly/TEMP_UntilFollyUpdate/json/json.cpp
@@ -0,0 +1,1117 @@
+/*
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* 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 <folly/json/json.h>
+
+#include <algorithm>
+#include <functional>
+#include <iterator>
+#include <sstream>
+#include <type_traits>
+
+#include <boost/algorithm/string.hpp>
+#include <glog/logging.h>
+
+#include <folly/Conv.h>
+#include <folly/Portability.h>
+#include <folly/Range.h>
+#include <folly/Unicode.h>
+#include <folly/Utility.h>
+#include <folly/lang/Bits.h>
+#include <folly/portability/Constexpr.h>
+
+namespace folly {
+
+//////////////////////////////////////////////////////////////////////
+
+namespace json {
+
+namespace {
+
+parse_error make_parse_error(
+    unsigned int line,
+    std::string const& context,
+    std::string const& expected) {
+  return parse_error(to<std::string>(
+      "json parse error on line ",
+      line,
+      !context.empty() ? to<std::string>(" near `", context, '\'') : "",
+      ": ",
+      expected));
+}
+
+struct Printer {
+  // Context class is allows to restore the path to element that we are about to
+  // print so that if error happens we can throw meaningful exception.
+  class Context {
+  public:
+    Context(const Context* parent_context, const dynamic& key)
+        : parent_context_(parent_context), key_(key), is_key_(false) {}
+    Context(const Context* parent_context, const dynamic& key, bool is_key)
+        : parent_context_(parent_context), key_(key), is_key_(is_key) {}
+
+    // Return location description of a context as a chain of keys
+    // ex., '"outherKey"->"innerKey"'.
+    std::string locationDescription() const {
+      std::vector<std::string> keys;
+      const Context* ptr = parent_context_;
+      while (ptr) {
+        keys.push_back(ptr->getName());
+        ptr = ptr->parent_context_;
+      }
+      keys.push_back(getName());
+      std::ostringstream stream;
+      std::reverse_copy(
+          keys.begin(),
+          keys.end() - 1,
+          std::ostream_iterator<std::string>(stream, "->"));
+
+      // Add current key.
+      stream << keys.back();
+      return stream.str();
+    }
+    std::string getName() const {
+      return Printer::toStringOr(key_, "<unprintable>");
+    }
+    std::string typeDescription() const { return is_key_ ? "key" : "value"; }
+
+  private:
+    const Context* const parent_context_;
+    const dynamic& key_;
+    bool is_key_;
+  };
+
+  explicit Printer(
+      std::string& out, unsigned* indentLevel, serialization_opts const* opts)
+      : out_(out), indentLevel_(indentLevel), opts_(*opts) {}
+
+  void operator()(dynamic const& v, const Context& context) const {
+    (*this)(v, &context);
+  }
+  void operator()(dynamic const& v, const Context* context) const {
+    switch (v.type()) {
+      case dynamic::DOUBLE: {
+        if (!opts_.allow_nan_inf) {
+          if (std::isnan(v.asDouble())) {
+            throw json::print_error(
+                "folly::toJson: JSON object value was a NaN when serializing " +
+                contextDescription(context));
+          }
+          if (std::isinf(v.asDouble())) {
+            throw json::print_error(
+                "folly::toJson: JSON object value was an INF when serializing " +
+                contextDescription(context));
+          }
+        }
+        toAppend(
+            v.asDouble(),
+            &out_,
+            opts_.dtoa_mode,
+            opts_.double_num_digits,
+            opts_.dtoa_flags);
+        break;
+      }
+      case dynamic::INT64: {
+        auto intval = v.asInt();
+        if (opts_.javascript_safe) {
+          // Use folly::to to check that this integer can be represented
+          // as a double without loss of precision.
+          intval = int64_t(to<double>(intval));
+        }
+        toAppend(intval, &out_);
+        break;
+      }
+      case dynamic::BOOL:
+        out_ += v.asBool() ? "true" : "false";
+        break;
+      case dynamic::NULLT:
+        out_ += "null";
+        break;
+      case dynamic::STRING:
+        escapeString(v.stringPiece(), out_, opts_);
+        break;
+      case dynamic::OBJECT:
+        printObject(v, context);
+        break;
+      case dynamic::ARRAY:
+        printArray(v, context);
+        break;
+      default:
+        CHECK(0) << "Bad type " << v.type();
+    }
+  }
+
+private:
+  void printKV(
+      dynamic const& o,
+      const std::pair<const dynamic, dynamic>& p,
+      const Context* context) const {
+    if (opts_.convert_int_keys && p.first.isInt()) {
+      auto strKey = p.first.asString();
+      if (o.count(strKey)) {
+        throw json::print_error(folly::to<std::string>(
+            "folly::toJson: Source object has integer and string keys "
+            "representing the same value: ",
+            p.first.asInt()));
+      }
+      (*this)(p.first.asString(), Context(context, p.first, true));
+    } else if (!opts_.allow_non_string_keys && !p.first.isString()) {
+      throw json::print_error(
+          "folly::toJson: JSON object key " +
+          toStringOr(p.first, "<unprintable key>") + " was not a string " +
+          (opts_.convert_int_keys ? "or integer " : "") +
+          "when serializing key at " +
+          Context(context, p.first, true).locationDescription());
+    } else {
+      (*this)(p.first, Context(context, p.first, true)); // Key
+    }
+    mapColon();
+    (*this)(p.second, Context(context, p.first, false)); // Value
+  }
+
+  template <typename Iterator>
+  void printKVPairs(
+      dynamic const& o,
+      Iterator begin,
+      Iterator end,
+      const Context* context) const {
+    printKV(o, *begin, context);
+    for (++begin; begin != end; ++begin) {
+      out_ += ',';
+      newline();
+      printKV(o, *begin, context);
+    }
+  }
+
+  void printObject(dynamic const& o, const Context* context) const {
+    if (o.empty()) {
+      out_ += "{}";
+      return;
+    }
+
+    out_ += '{';
+    indent();
+    newline();
+    if (opts_.sort_keys || opts_.sort_keys_by) {
+      using ref = std::reference_wrapper<decltype(o.items())::value_type const>;
+      auto sort_keys_by = [&](auto begin, auto end, const auto& comp) {
+        std::sort(begin, end, [&](ref a, ref b) {
+          // Only compare keys.  No ordering among identical keys.
+          return comp(a.get().first, b.get().first);
+        });
+      };
+      std::vector<ref> refs(o.items().begin(), o.items().end());
+      if (opts_.sort_keys_by) {
+        sort_keys_by(refs.begin(), refs.end(), opts_.sort_keys_by);
+      } else {
+        sort_keys_by(refs.begin(), refs.end(), std::less<>());
+      }
+      printKVPairs(o, refs.cbegin(), refs.cend(), context);
+    } else {
+      printKVPairs(o, o.items().begin(), o.items().end(), context);
+    }
+    outdent();
+    newline();
+    out_ += '}';
+  }
+
+  static std::string toStringOr(dynamic const& v, const char* placeholder) {
+    try {
+      std::string result;
+      unsigned indentLevel = 0;
+      serialization_opts opts;
+      opts.allow_nan_inf = true;
+      opts.allow_non_string_keys = true;
+      Printer printer(result, &indentLevel, &opts);
+      printer(v, nullptr);
+      return result;
+    } catch (...) {
+      return placeholder;
+    }
+  }
+
+  static std::string contextDescription(const Context* context) {
+    if (!context) {
+      return "<undefined location>";
+    }
+    return context->typeDescription() + " at " + context->locationDescription();
+  }
+
+  void printArray(dynamic const& a, const Context* context) const {
+    if (a.empty()) {
+      out_ += "[]";
+      return;
+    }
+
+    out_ += '[';
+    indent();
+    newline();
+    (*this)(a[0], Context(context, dynamic(0)));
+    for (auto it = std::next(a.begin()); it != a.end(); ++it) {
+      out_ += ',';
+      newline();
+      (*this)(*it, Context(context, dynamic(std::distance(a.begin(), it))));
+    }
+    outdent();
+    newline();
+    out_ += ']';
+  }
+
+private:
+  void outdent() const {
+    if (indentLevel_) {
+      --*indentLevel_;
+    }
+  }
+
+  void indent() const {
+    if (indentLevel_) {
+      ++*indentLevel_;
+    }
+  }
+
+  void newline() const {
+    if (indentLevel_) {
+      auto indent = *indentLevel_ * opts_.pretty_formatting_indent_width;
+      out_ += to<std::string>('\n', std::string(indent, ' '));
+    }
+  }
+
+  void mapColon() const { out_ += indentLevel_ ? ": " : ":"; }
+
+private:
+  std::string& out_;
+  unsigned* const indentLevel_;
+  serialization_opts const& opts_;
+};
+
+//////////////////////////////////////////////////////////////////////
+
+// Wraps our input buffer with some helper functions.
+struct Input {
+  explicit Input(StringPiece range, json::serialization_opts const* opts)
+      : range_(range), opts_(*opts), lineNum_(0) {
+    storeCurrent();
+  }
+
+  Input(Input const&) = delete;
+  Input& operator=(Input const&) = delete;
+
+  char const* begin() const { return range_.begin(); }
+
+  unsigned getLineNum() const { return lineNum_; }
+
+  // Parse ahead for as long as the supplied predicate is satisfied,
+  // returning a range of what was skipped.
+  template <class Predicate>
+  StringPiece skipWhile(const Predicate& p) {
+    std::size_t skipped = 0;
+    for (; skipped < range_.size(); ++skipped) {
+      if (!p(range_[skipped])) {
+        break;
+      }
+      if (range_[skipped] == '\n') {
+        ++lineNum_;
+      }
+    }
+    auto ret = range_.subpiece(0, skipped);
+    range_.advance(skipped);
+    storeCurrent();
+    return ret;
+  }
+
+  StringPiece skipDigits() {
+    return skipWhile([](char c) { return c >= '0' && c <= '9'; });
+  }
+
+  StringPiece skipMinusAndDigits() {
+    bool firstChar = true;
+    return skipWhile([&firstChar](char c) {
+      bool result = (c >= '0' && c <= '9') || (firstChar && c == '-');
+      firstChar = false;
+      return result;
+    });
+  }
+
+  void skipWhitespace() {
+    unsigned index = 0;
+    while (true) {
+      while (index < range_.size() && range_[index] == ' ') {
+        index++;
+      }
+      if (index < range_.size()) {
+        if (range_[index] == '\n') {
+          index++;
+          ++lineNum_;
+          continue;
+        }
+        if (range_[index] == '\t' || range_[index] == '\r') {
+          index++;
+          continue;
+        }
+      }
+      break;
+    }
+    range_.advance(index);
+    storeCurrent();
+  }
+
+  void expect(char c) {
+    if (**this != c) {
+      throw json::make_parse_error(
+          lineNum_, context(), to<std::string>("expected '", c, '\''));
+    }
+    ++*this;
+  }
+
+  std::size_t size() const { return range_.size(); }
+
+  int operator*() const { return current_; }
+
+  void operator++() {
+    range_.pop_front();
+    storeCurrent();
+  }
+
+  template <class T>
+  T extract() {
+    try {
+      return to<T>(&range_);
+    } catch (std::exception const& e) {
+      error(e.what());
+    }
+  }
+
+  bool consume(StringPiece str) {
+    if (boost::starts_with(range_, str)) {
+      range_.advance(str.size());
+      storeCurrent();
+      return true;
+    }
+    return false;
+  }
+
+  std::string context() const {
+    return range_.subpiece(0, 16 /* arbitrary */).toString();
+  }
+
+  [[noreturn]] void error(char const* what) const {
+    throw json::make_parse_error(lineNum_, context(), what);
+  }
+  template <typename R>
+  R error(char const* what) const {
+    error(what);
+  }
+
+  json::serialization_opts const& getOpts() { return opts_; }
+
+  void incrementRecursionLevel() {
+    if (currentRecursionLevel_ > opts_.recursion_limit) {
+      error("recursion limit exceeded");
+    }
+    currentRecursionLevel_++;
+  }
+
+  void decrementRecursionLevel() { currentRecursionLevel_--; }
+
+private:
+  void storeCurrent() { current_ = range_.empty() ? EOF : range_.front(); }
+
+private:
+  StringPiece range_;
+  json::serialization_opts const& opts_;
+  unsigned lineNum_;
+  int current_;
+  unsigned int currentRecursionLevel_{0};
+};
+
+class RecursionGuard {
+public:
+  explicit RecursionGuard(Input& in) : in_(in) {
+    in_.incrementRecursionLevel();
+  }
+
+  ~RecursionGuard() { in_.decrementRecursionLevel(); }
+
+private:
+  Input& in_;
+};
+
+dynamic parseValue(Input& in, json::metadata_map* map);
+std::string parseString(Input& in);
+dynamic parseNumber(Input& in);
+
+void parseObjectKeyValue(
+    Input& in,
+    dynamic& ret,
+    dynamic&& key,
+    json::metadata_map* map,
+    bool distinct) {
+  auto keyLineNumber = in.getLineNum();
+  in.skipWhitespace();
+  in.expect(':');
+  in.skipWhitespace();
+  auto valueLineNumber = in.getLineNum();
+  auto value = parseValue(in, map);
+  auto [it, inserted] = ret.try_emplace(std::move(key), std::move(value));
+  if (!inserted) {
+    if (distinct) {
+      in.error("duplicate key inserted");
+    }
+    it->second = std::move(value);
+  }
+  if (map) {
+    map->emplace(
+        &it->second,
+        json::parse_metadata{{{keyLineNumber}}, {{valueLineNumber}}});
+  }
+}
+
+dynamic parseObject(Input& in, json::metadata_map* map) {
+  DCHECK_EQ(*in, '{');
+  ++in;
+
+  dynamic ret = dynamic::object;
+
+  in.skipWhitespace();
+  if (*in == '}') {
+    ++in;
+    return ret;
+  }
+
+  const auto& opts = in.getOpts();
+  const bool distinct = opts.validate_keys || opts.convert_int_keys;
+  for (;;) {
+    if (opts.allow_trailing_comma && *in == '}') {
+      break;
+    }
+    dynamic key = parseValue(in, map);
+    if (opts.convert_int_keys && key.isInt()) {
+      key = key.asString();
+    } else if (!opts.allow_non_string_keys && !key.isString()) {
+      in.error(
+          opts.convert_int_keys ? "expected string or integer for object key"
+                                : "expected string for object key");
+    }
+    parseObjectKeyValue(in, ret, std::move(key), map, distinct);
+
+    in.skipWhitespace();
+    if (*in != ',') {
+      break;
+    }
+    ++in;
+    in.skipWhitespace();
+  }
+  in.expect('}');
+
+  return ret;
+}
+
+dynamic parseArray(Input& in, json::metadata_map* map) {
+  DCHECK_EQ(*in, '[');
+  ++in;
+
+  dynamic ret = dynamic::array;
+
+  in.skipWhitespace();
+  if (*in == ']') {
+    ++in;
+    return ret;
+  }
+
+  std::vector<uint32_t> lineNumbers;
+  for (;;) {
+    if (in.getOpts().allow_trailing_comma && *in == ']') {
+      break;
+    }
+    ret.push_back(parseValue(in, map));
+    if (map) {
+      lineNumbers.push_back(in.getLineNum());
+    }
+    in.skipWhitespace();
+    if (*in != ',') {
+      break;
+    }
+    ++in;
+    in.skipWhitespace();
+  }
+  if (map) {
+    for (size_t i = 0, e = ret.size(); i < e; i++) {
+      map->emplace(&ret[i], json::parse_metadata{{{0}}, {{lineNumbers[i]}}});
+    }
+  }
+  in.expect(']');
+
+  return ret;
+}
+
+dynamic parseNumber(Input& in) {
+  bool const negative = (*in == '-');
+  if (negative && in.consume("-Infinity")) {
+    if (in.getOpts().parse_numbers_as_strings) {
+      return "-Infinity";
+    } else {
+      return -std::numeric_limits<double>::infinity();
+    }
+  }
+
+  auto integral = in.skipMinusAndDigits();
+  if (negative && integral.size() < 2) {
+    in.error("expected digits after `-'");
+  }
+
+  auto const wasE = *in == 'e' || *in == 'E';
+
+  if (*in != '.' && !wasE && in.getOpts().parse_numbers_as_strings) {
+    return integral;
+  }
+
+  constexpr const char* maxIntStr = "9223372036854775807";
+  constexpr const char* minIntStr = "-9223372036854775808";
+  constexpr auto maxIntLen = constexpr_strlen(maxIntStr);
+  constexpr auto minIntLen = constexpr_strlen(minIntStr);
+  auto extremaLen = negative ? minIntLen : maxIntLen;
+  auto extremaStr = negative ? minIntStr : maxIntStr;
+  if (*in != '.' && !wasE) {
+    if (FOLLY_LIKELY(
+            !in.getOpts().double_fallback || integral.size() < extremaLen) ||
+        (integral.size() == extremaLen && integral <= extremaStr)) {
+      auto val = to<int64_t>(integral);
+      in.skipWhitespace();
+      return val;
+    } else {
+      auto val = to<double>(integral);
+      in.skipWhitespace();
+      return val;
+    }
+  }
+
+  auto end = !wasE ? (++in, in.skipDigits().end()) : in.begin();
+  if (*in == 'e' || *in == 'E') {
+    ++in;
+    if (*in == '+' || *in == '-') {
+      ++in;
+    }
+    auto expPart = in.skipDigits();
+    end = expPart.end();
+  }
+  auto fullNum = range(integral.begin(), end);
+  if (in.getOpts().parse_numbers_as_strings) {
+    return fullNum;
+  }
+  auto val = to<double>(fullNum);
+  return val;
+}
+
+void decodeUnicodeEscape(Input& in, std::string& out) {
+  auto hexVal = [&](int c) -> uint16_t {
+    // clang-format off
+    return uint16_t(
+        c >= '0' && c <= '9' ? c - '0' :
+        c >= 'a' && c <= 'f' ? c - 'a' + 10 :
+        c >= 'A' && c <= 'F' ? c - 'A' + 10 :
+        in.error<uint16_t>("invalid hex digit"));
+    // clang-format on
+  };
+
+  auto readHex = [&]() -> uint16_t {
+    if (in.size() < 4) {
+      in.error("expected 4 hex digits");
+    }
+
+    auto ret = uint16_t(hexVal(*in) * 4096);
+    ++in;
+    ret += hexVal(*in) * 256;
+    ++in;
+    ret += hexVal(*in) * 16;
+    ++in;
+    ret += hexVal(*in);
+    ++in;
+    return ret;
+  };
+
+  //  If the value encoded is in the surrogate pair range, we need to make
+  //  sure there is another escape that we can use also.
+  //
+  //  See the explanation in folly/Unicode.h.
+  uint16_t prefix = readHex();
+  char32_t codePoint = prefix;
+  if (utf16_code_unit_is_high_surrogate(prefix)) {
+    if (!in.consume("\\u")) {
+      in.error(
+          "expected another unicode escape for second half of "
+          "surrogate pair");
+    }
+    uint16_t suffix = readHex();
+    if (!utf16_code_unit_is_low_surrogate(suffix)) {
+      in.error("second character in surrogate pair is invalid");
+    }
+    codePoint = unicode_code_point_from_utf16_surrogate_pair(prefix, suffix);
+  } else if (!utf16_code_unit_is_bmp(prefix)) {
+    in.error("invalid unicode code point (in range [0xdc00,0xdfff])");
+  }
+
+  appendCodePointToUtf8(codePoint, out);
+}
+
+std::string parseString(Input& in) {
+  DCHECK_EQ(*in, '\"');
+  ++in;
+
+  std::string ret;
+  for (;;) {
+    auto range = in.skipWhile([](char c) { return c != '\"' && c != '\\'; });
+    ret.append(range.begin(), range.end());
+
+    if (*in == '\"') {
+      ++in;
+      break;
+    }
+    if (*in == '\\') {
+      ++in;
+      switch (*in) {
+          // clang-format off
+        case '\"':    ret.push_back('\"'); ++in; break;
+        case '\\':    ret.push_back('\\'); ++in; break;
+        case '/':     ret.push_back('/');  ++in; break;
+        case 'b':     ret.push_back('\b'); ++in; break;
+        case 'f':     ret.push_back('\f'); ++in; break;
+        case 'n':     ret.push_back('\n'); ++in; break;
+        case 'r':     ret.push_back('\r'); ++in; break;
+        case 't':     ret.push_back('\t'); ++in; break;
+        case 'u':     ++in; decodeUnicodeEscape(in, ret); break;
+        // clang-format on
+        default:
+          in.error(
+              to<std::string>("unknown escape ", *in, " in string").c_str());
+      }
+      continue;
+    }
+    if (*in == EOF) {
+      in.error("unterminated string");
+    }
+    if (!*in) {
+      /*
+      * Apparently we're actually supposed to ban all control
+      * characters from strings.  This seems unnecessarily
+      * restrictive, so we're only banning zero bytes.  (Since the
+      * string is presumed to be UTF-8 encoded it's fine to just
+      * check this way.)
+      */
+      in.error("null byte in string");
+    }
+
+    ret.push_back(char(*in));
+    ++in;
+  }
+
+  return ret;
+}
+
+dynamic parseValue(Input& in, json::metadata_map* map) {
+  RecursionGuard guard(in);
+
+  in.skipWhitespace();
+  // clang-format off
+  return
+      *in == '[' ? parseArray(in, map) :
+      *in == '{' ? parseObject(in, map) :
+      *in == '\"' ? parseString(in) :
+      (*in == '-' || (*in >= '0' && *in <= '9')) ? parseNumber(in) :
+      in.consume("true") ? true :
+      in.consume("false") ? false :
+      in.consume("null") ? nullptr :
+      in.consume("Infinity") ?
+      (in.getOpts().parse_numbers_as_strings ? (dynamic)"Infinity" :
+        (dynamic)std::numeric_limits<double>::infinity()) :
+      in.consume("NaN") ?
+        (in.getOpts().parse_numbers_as_strings ? (dynamic)"NaN" :
+          (dynamic)std::numeric_limits<double>::quiet_NaN()) :
+      in.error<dynamic>("expected json value");
+  // clang-format on
+}
+
+} // namespace
+
+//////////////////////////////////////////////////////////////////////
+
+std::array<uint64_t, 2> buildExtraAsciiToEscapeBitmap(StringPiece chars) {
+  std::array<uint64_t, 2> escapes{{0, 0}};
+  for (auto b : ByteRange(chars)) {
+    if (b >= 0x20 && b < 0x80) {
+      escapes[b / 64] |= uint64_t(1) << (b % 64);
+    }
+  }
+  return escapes;
+}
+
+std::string serialize(dynamic const& dyn, serialization_opts const& opts) {
+  std::string ret;
+  unsigned indentLevel = 0;
+  Printer p(ret, opts.pretty_formatting ? &indentLevel : nullptr, &opts);
+  p(dyn, nullptr);
+  return ret;
+}
+
+// Fast path to determine the longest prefix that can be left
+// unescaped in a string of sizeof(T) bytes packed in an integer of
+// type T.
+template <bool EnableExtraAsciiEscapes, class T>
+size_t firstEscapableInWord(T s, const serialization_opts& opts) {
+  static_assert(std::is_unsigned<T>::value, "Unsigned integer required");
+  static constexpr T kOnes = ~T() / 255; // 0x...0101
+  static constexpr T kMsbs = kOnes * 0x80; // 0x...8080
+
+  // Sets the MSB of bytes < b. Precondition: b < 128.
+  auto isLess = [](T w, uint8_t b) {
+    // A byte is < b iff subtracting b underflows, so we check that
+    // the MSB wasn't set before and it's set after the subtraction.
+    return (w - kOnes * b) & ~w & kMsbs;
+  };
+
+  auto isChar = [&](uint8_t c) {
+    // A byte is == c iff it is 0 if xor'd with c.
+    return isLess(s ^ (kOnes * c), 1);
+  };
+
+  // The following masks have the MSB set for each byte of the word
+  // that satisfies the corresponding condition.
+  auto isHigh = s & kMsbs; // >= 128
+  auto isLow = isLess(s, 0x20); // <= 0x1f
+  auto needsEscape = isHigh | isLow | isChar('\\') | isChar('"');
+
+  if /* constexpr */ (EnableExtraAsciiEscapes) {
+    // Deal with optional bitmap for unicode escapes. Escapes can optionally be
+    // set for ascii characters 32 - 127, so the inner loop may run up to 96
+    // times. However, for the case where 0 or a handful of bits are set,
+    // looping will be minimal through use of findFirstSet.
+    for (size_t i = 0, e = opts.extra_ascii_to_escape_bitmap.size(); i < e;
+        ++i) {
+      const auto offset = i * 64;
+      // Clear first 32 characters if this is the first index, since those are
+      // always escaped.
+      auto bitmap = opts.extra_ascii_to_escape_bitmap[i] &
+          (i == 0 ? uint64_t(-1) << 32 : ~0ULL);
+      while (bitmap) {
+        auto bit = folly::findFirstSet(bitmap);
+        needsEscape |= isChar(static_cast<uint8_t>(offset + bit - 1));
+        bitmap &= bitmap - 1;
+      }
+    }
+  }
+
+  if (!needsEscape) {
+    return sizeof(T);
+  }
+
+  if (folly::kIsLittleEndian) {
+    return folly::findFirstSet(needsEscape) / 8 - 1;
+  } else {
+    return sizeof(T) - folly::findLastSet(needsEscape) / 8;
+  }
+}
+
+// Escape a string so that it is legal to print it in JSON text.
+template <bool EnableExtraAsciiEscapes>
+void escapeStringImpl(
+    StringPiece input, std::string& out, const serialization_opts& opts) {
+  auto hexDigit = [](uint8_t c) -> char {
+    return c < 10 ? c + '0' : c - 10 + 'a';
+  };
+
+  out.push_back('\"');
+
+  auto* p = reinterpret_cast<const unsigned char*>(input.begin());
+  auto* q = reinterpret_cast<const unsigned char*>(input.begin());
+  auto* e = reinterpret_cast<const unsigned char*>(input.end());
+
+  while (p < e) {
+    // Find the longest prefix that does not need escaping, and copy
+    // it literally into the output string.
+    auto firstEsc = p;
+    while (firstEsc < e) {
+      auto avail = to_unsigned(e - firstEsc);
+      uint64_t word = 0;
+      if (avail >= 8) {
+        word = folly::loadUnaligned<uint64_t>(firstEsc);
+      } else {
+        word = folly::partialLoadUnaligned<uint64_t>(firstEsc, avail);
+      }
+      auto prefix = firstEscapableInWord<EnableExtraAsciiEscapes>(word, opts);
+      DCHECK_LE(prefix, avail);
+    // [Windows Sometimes prefix is completely wrong (corrupt?), only in Release, causing a later AV (see issue #14394).
+    // Prefix should always be <= avail, capping it here as a workaround, hoping the assert above eventually catches this in Debug.
+    prefix = std::min(prefix, (size_t)avail);
+    // Windows]
+      firstEsc += prefix;
+      if (prefix < 8) {
+        break;
+      }
+    }
+    if (firstEsc > p) {
+      out.append(reinterpret_cast<const char*>(p), firstEsc - p);
+      p = firstEsc;
+      // We can't be in the middle of a multibyte sequence, so we can reset q.
+      q = p;
+      if (p == e) {
+        break;
+      }
+    }
+
+    // Handle the next byte that may need escaping.
+
+    // Since non-ascii encoding inherently does utf8 validation
+    // we explicitly validate utf8 only if non-ascii encoding is disabled.
+    if ((opts.validate_utf8 || opts.skip_invalid_utf8) &&
+        !opts.encode_non_ascii) {
+      // To achieve better spatial and temporal coherence
+      // we do utf8 validation progressively along with the
+      // string-escaping instead of two separate passes.
+
+      // As the encoding progresses, q will stay at or ahead of p.
+      CHECK_GE(q, p);
+
+      // As p catches up with q, move q forward.
+      if (q == p) {
+        // calling utf8_decode has the side effect of
+        // checking that utf8 encodings are valid
+        char32_t v = utf8ToCodePoint(q, e, opts.skip_invalid_utf8);
+        if (opts.skip_invalid_utf8 && v == U'\ufffd') {
+          out.append(reinterpret_cast<const char*>(u8"\ufffd"));
+          p = q;
+          continue;
+        }
+      }
+    }
+
+    auto encodeUnicode = opts.encode_non_ascii && (*p & 0x80);
+    if /* constexpr */ (EnableExtraAsciiEscapes) {
+      encodeUnicode = encodeUnicode ||
+          (*p >= 0x20 && *p < 0x80 &&
+          (opts.extra_ascii_to_escape_bitmap[*p / 64] &
+            (uint64_t(1) << (*p % 64))));
+    }
+
+    if (encodeUnicode) {
+      // note that this if condition captures utf8 chars
+      // with value > 127, so size > 1 byte (or they are whitelisted for
+      // Unicode encoding).
+      // NOTE: char32_t / char16_t are both unsigned.
+      char32_t cp = utf8ToCodePoint(p, e, opts.skip_invalid_utf8);
+      auto writeHex = [&](char16_t v) {
+        char buf[] = "\\u\0\0\0\0";
+        buf[2] = hexDigit((v >> 12) & 0x0f);
+        buf[3] = hexDigit((v >> 8) & 0x0f);
+        buf[4] = hexDigit((v >> 4) & 0x0f);
+        buf[5] = hexDigit(v & 0x0f);
+        out.append(buf, 6);
+      };
+      // From the ECMA-404 The JSON Data Interchange Syntax 2nd Edition Dec 2017
+      if (cp < 0x10000u) {
+        // If the code point is in the Basic Multilingual Plane (U+0000 through
+        // U+FFFF), then it may be represented as a six-character sequence:
+        // a reverse solidus, followed by the lowercase letter u, followed by
+        // four hexadecimal digits that encode the code point.
+        writeHex(static_cast<char16_t>(cp));
+      } else {
+        // To escape a code point that is not in the Basic Multilingual Plane,
+        // the character may be represented as a twelve-character sequence,
+        // encoding the UTF-16 surrogate pair corresponding to the code point.
+        writeHex(static_cast<char16_t>(
+            0xd800u + (((cp - 0x10000u) >> 10) & 0x3ffu)));
+        writeHex(static_cast<char16_t>(0xdc00u + ((cp - 0x10000u) & 0x3ffu)));
+      }
+    } else if (*p == '\\' || *p == '\"') {
+      char buf[] = "\\\0";
+      buf[1] = char(*p++);
+      out.append(buf, 2);
+    } else if (*p <= 0x1f) {
+      switch (*p) {
+          // clang-format off
+        case '\b': out.append("\\b"); p++; break;
+        case '\f': out.append("\\f"); p++; break;
+        case '\n': out.append("\\n"); p++; break;
+        case '\r': out.append("\\r"); p++; break;
+        case '\t': out.append("\\t"); p++; break;
+        // clang-format on
+        default:
+          // Note that this if condition captures non readable chars
+          // with value < 32, so size = 1 byte (e.g control chars).
+          char buf[] = "\\u00\0\0";
+          buf[4] = hexDigit(uint8_t((*p & 0xf0) >> 4));
+          buf[5] = hexDigit(uint8_t(*p & 0xf));
+          out.append(buf, 6);
+          p++;
+      }
+    } else {
+      out.push_back(char(*p++));
+    }
+  }
+
+  out.push_back('\"');
+}
+
+void escapeString(
+    StringPiece input, std::string& out, const serialization_opts& opts) {
+  if (FOLLY_UNLIKELY(
+          opts.extra_ascii_to_escape_bitmap[0] ||
+          opts.extra_ascii_to_escape_bitmap[1])) {
+    escapeStringImpl<true>(input, out, opts);
+  } else {
+    escapeStringImpl<false>(input, out, opts);
+  }
+}
+
+std::string stripComments(StringPiece jsonC) {
+  std::string result;
+  enum class State {
+    None,
+    InString,
+    InlineComment,
+    LineComment
+  } state = State::None;
+
+  for (size_t i = 0; i < jsonC.size(); ++i) {
+    auto s = jsonC.subpiece(i);
+    switch (state) {
+      case State::None:
+        if (s.startsWith("/*")) {
+          state = State::InlineComment;
+          ++i;
+          continue;
+        } else if (s.startsWith("//")) {
+          state = State::LineComment;
+          ++i;
+          continue;
+        } else if (s[0] == '\"') {
+          state = State::InString;
+        }
+        result.push_back(s[0]);
+        break;
+      case State::InString:
+        if (s[0] == '\\') {
+          if (FOLLY_UNLIKELY(s.size() == 1)) {
+            throw std::logic_error("Invalid JSONC: string is not terminated");
+          }
+          result.push_back(s[0]);
+          result.push_back(s[1]);
+          ++i;
+          continue;
+        } else if (s[0] == '\"') {
+          state = State::None;
+        }
+        result.push_back(s[0]);
+        break;
+      case State::InlineComment:
+        if (s.startsWith('\n')) {
+          // preserve the line break to preserve the line count
+          result.push_back(s[0]);
+        } else if (s.startsWith("*/")) {
+          state = State::None;
+          ++i;
+        }
+        break;
+      case State::LineComment:
+        if (s[0] == '\n') {
+          // preserve the line break to preserve the line count
+          result.push_back(s[0]);
+          state = State::None;
+        }
+        break;
+      default:
+        throw std::logic_error("Unknown comment state");
+    }
+  }
+  return result;
+}
+
+} // namespace json
+
+//////////////////////////////////////////////////////////////////////
+
+dynamic parseJsonWithMetadata(StringPiece range, json::metadata_map* map) {
+  return parseJsonWithMetadata(range, json::serialization_opts(), map);
+}
+
+dynamic parseJsonWithMetadata(
+    StringPiece range,
+    json::serialization_opts const& opts,
+    json::metadata_map* map) {
+  json::Input in(range, &opts);
+
+  uint32_t n = in.getLineNum();
+  auto ret = parseValue(in, map);
+  if (map) {
+    map->emplace(&ret, json::parse_metadata{{{0}}, {{n}}});
+  }
+
+  in.skipWhitespace();
+  if (in.size() && *in != '\0') {
+    in.error("parsing didn't consume all input");
+  }
+  return ret;
+}
+
+dynamic parseJson(StringPiece range) {
+  return parseJson(range, json::serialization_opts());
+}
+
+dynamic parseJson(StringPiece range, json::serialization_opts const& opts) {
+  json::Input in(range, &opts);
+
+  auto ret = parseValue(in, nullptr);
+  in.skipWhitespace();
+  if (in.size() && *in != '\0') {
+    in.error("parsing didn't consume all input");
+  }
+  return ret;
+}
+
+std::string toJson(dynamic const& dyn) {
+  return json::serialize(dyn, json::serialization_opts());
+}
+
+std::string toPrettyJson(dynamic const& dyn) {
+  json::serialization_opts opts;
+  opts.pretty_formatting = true;
+  opts.sort_keys = true;
+  return json::serialize(dyn, opts);
+}
+
+//////////////////////////////////////////////////////////////////////
+// dynamic::print_as_pseudo_json() is implemented here for header
+// ordering reasons (most of the dynamic implementation is in
+// dynamic-inl.h, which we don't want to include json.h).
+
+void dynamic::print_as_pseudo_json(std::ostream& out) const {
+  json::serialization_opts opts;
+  opts.allow_non_string_keys = true;
+  opts.allow_nan_inf = true;
+  out << json::serialize(*this, opts);
+}
+
+void PrintTo(const dynamic& dyn, std::ostream* os) {
+  json::serialization_opts opts;
+  opts.allow_nan_inf = true;
+  opts.allow_non_string_keys = true;
+  opts.pretty_formatting = true;
+  opts.sort_keys = true;
+  *os << json::serialize(dyn, opts);
+}
+
+//////////////////////////////////////////////////////////////////////
+
+} // namespace folly
\ No newline at end of file
diff --git a/vnext/Folly/TEMP_UntilFollyUpdate/lang/SafeAssert.h b/vnext/Folly/TEMP_UntilFollyUpdate/lang/SafeAssert.h
index b46e4faefbb..e0fa799ac04 100644
--- a/vnext/Folly/TEMP_UntilFollyUpdate/lang/SafeAssert.h
+++ b/vnext/Folly/TEMP_UntilFollyUpdate/lang/SafeAssert.h
@@ -1,188 +1,188 @@
 /*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * 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.
- */
-
- #pragma once
-
- #include <cstdint>
- #include <utility>
- 
- #include <folly/CppAttributes.h>
- #include <folly/Portability.h>
- #include <folly/Preprocessor.h>
- #include <folly/lang/CArray.h>
- 
- #define FOLLY_DETAIL_SAFE_CHECK_IMPL(d, p, u, expr, ...)                  \
-   do {                                                                    \
-     if ((!d || ::folly::kIsDebug || ::folly::kIsSanitize) &&              \
-         !static_cast<bool>(expr)) {                                       \
-       static constexpr auto __folly_detail_safe_assert_fun = __func__;    \
-       static constexpr ::folly::detail::safe_assert_arg                   \
-           __folly_detail_safe_assert_arg{                                 \
-               u ? nullptr : #expr,                                        \
-               __FILE__,                                                   \
-               FOLLY_PP_CONSTINIT_LINE_UNSIGNED,                           \
-               __folly_detail_safe_assert_fun,                             \
-               ::folly::detail::safe_assert_msg_types<                     \
-                   decltype(::folly::detail::safe_assert_msg_types_seq_of( \
-                       __VA_ARGS__))>::value.data};                        \
-       constexpr ::folly::detail::safe_assert_terminate_w<p>               \
-           __folly_detail_safe_assert_terminate_w{                         \
-               __folly_detail_safe_assert_arg};                            \
-       __folly_detail_safe_assert_terminate_w(__VA_ARGS__);                \
-     }                                                                     \
-   } while (false)
- 
- //  FOLLY_SAFE_CHECK
- //
- //  If expr evaluates to false after explicit conversion to bool, prints context
- //  information to stderr and aborts. Context information includes the remaining
- //  variadic arguments.
- //
- //  When the remaining variadic arguments are printed to stderr, there are two
- //  supported types after implicit conversions: char const* and uint64_t. This
- //  facility is intentionally not extensible to custom types.
- //
- //  multi-thread-safe
- //  async-signal-safe
- #define FOLLY_SAFE_CHECK(expr, ...) \
-   FOLLY_DETAIL_SAFE_CHECK_IMPL(0, 0, 0, expr, __VA_ARGS__)
- 
- //  FOLLY_SAFE_DCHECK
- //
- //  Equivalent to FOLLY_SAFE_CHECK when in debug or instrumented builds, where
- //  debug builds are signalled by NDEBUG being undefined and instrumented builds
- //  include sanitizer builds.
- //
- //  multi-thread-safe
- //  async-signal-safe
- #define FOLLY_SAFE_DCHECK(expr, ...) \
-   FOLLY_DETAIL_SAFE_CHECK_IMPL(1, 0, 0, expr, __VA_ARGS__)
- 
- //  FOLLY_SAFE_PCHECK
- //
- //  Equivalent to FOLLY_SAFE_CHECK but includes errno in the contextual
- //  information printed to stderr.
- //
- //  multi-thread-safe
- //  async-signal-safe
- #define FOLLY_SAFE_PCHECK(expr, ...) \
-   FOLLY_DETAIL_SAFE_CHECK_IMPL(0, 1, 0, expr, __VA_ARGS__)
- 
- //  FOLLY_SAFE_DPCHECK
- //
- //  Equivalent to FOLLY_SAFE_DCHECK but includes errno in the contextual
- //  information printed to stderr.
- //
- //  multi-thread-safe
- //  async-signal-safe
- #define FOLLY_SAFE_DPCHECK(expr, ...) \
-   FOLLY_DETAIL_SAFE_CHECK_IMPL(1, 1, 0, expr, __VA_ARGS__)
- 
- //  FOLLY_SAFE_FATAL
- //
- //  Equivalent to FOLLY_SAFE_CHECK(false, ...) but excludes any failing
- //  expression from the contextual information printed to stderr.
- //
- //  multi-thread-safe
- //  async-signal-safe
- #define FOLLY_SAFE_FATAL(...) \
-   FOLLY_DETAIL_SAFE_CHECK_IMPL(0, 0, 1, false, __VA_ARGS__)
- 
- //  FOLLY_SAFE_DFATAL
- //
- //  Equivalent to FOLLY_SAFE_DCHECK(false, ...) but excludes any failing
- //  expression from the contextual information printed to stderr.
- //
- //  multi-thread-safe
- //  async-signal-safe
- #define FOLLY_SAFE_DFATAL(...) \
-   FOLLY_DETAIL_SAFE_CHECK_IMPL(1, 0, 1, false, __VA_ARGS__)
- 
- namespace folly {
- namespace detail {
- 
- enum class safe_assert_msg_type : char { term, cstr, ui64 };
- 
- template <safe_assert_msg_type... A>
- struct safe_assert_msg_type_s {};
- 
- struct safe_assert_msg_types_one_fn {
-   template <safe_assert_msg_type A>
-   using c = std::integral_constant<safe_assert_msg_type, A>;
-   // only used in unevaluated contexts:
-   c<safe_assert_msg_type::cstr> operator()(char const*) const;
-   c<safe_assert_msg_type::ui64> operator()(uint64_t) const;
- };
- inline constexpr safe_assert_msg_types_one_fn
-     safe_assert_msg_types_one{}; // a function object to prevent extensions
- 
- template <typename... A>
- safe_assert_msg_type_s<decltype(safe_assert_msg_types_one((A)A{}))::value...>
- safe_assert_msg_types_seq_of(A...); // only used in unevaluated contexts
- 
- template <typename>
- struct safe_assert_msg_types;
- template <safe_assert_msg_type... A>
- struct safe_assert_msg_types<safe_assert_msg_type_s<A...>> {
-   using value_type = c_array<safe_assert_msg_type, sizeof...(A) + 1>;
-   static constexpr value_type value = {{A..., safe_assert_msg_type::term}};
- };
- 
- struct safe_assert_arg {
-   char const* expr;
-   char const* file;
-   unsigned int line;
-   char const* function;
-   safe_assert_msg_type const* msg_types;
- };
- 
- struct safe_assert_msg_cast_one_fn {
-   FOLLY_ERASE auto operator()(char const* const a) const { return a; }
-   FOLLY_ERASE auto operator()(uint64_t const a) const { return a; }
- };
- inline constexpr safe_assert_msg_cast_one_fn
-     safe_assert_msg_cast_one{}; // a function object to prevent extensions
- 
- template <bool P>
- [[noreturn, FOLLY_ATTR_GNU_COLD]] FOLLY_NOINLINE void safe_assert_terminate(
-     safe_assert_arg const* arg, ...) noexcept; // the true backing function
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* 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.
+*/
+
+#pragma once
+
+#include <cstdint>
+#include <utility>
+
+#include <folly/CppAttributes.h>
+#include <folly/Portability.h>
+#include <folly/Preprocessor.h>
+#include <folly/lang/CArray.h>
+
+#define FOLLY_DETAIL_SAFE_CHECK_IMPL(d, p, u, expr, ...)                  \
+  do {                                                                    \
+    if ((!d || ::folly::kIsDebug || ::folly::kIsSanitize) &&              \
+        !static_cast<bool>(expr)) {                                       \
+      static constexpr auto __folly_detail_safe_assert_fun = __func__;    \
+      static constexpr ::folly::detail::safe_assert_arg                   \
+          __folly_detail_safe_assert_arg{                                 \
+              u ? nullptr : #expr,                                        \
+              __FILE__,                                                   \
+              FOLLY_PP_CONSTINIT_LINE_UNSIGNED,                           \
+              __folly_detail_safe_assert_fun,                             \
+              ::folly::detail::safe_assert_msg_types<                     \
+                  decltype(::folly::detail::safe_assert_msg_types_seq_of( \
+                      __VA_ARGS__))>::value.data};                        \
+      constexpr ::folly::detail::safe_assert_terminate_w<p>               \
+          __folly_detail_safe_assert_terminate_w{                         \
+              __folly_detail_safe_assert_arg};                            \
+      __folly_detail_safe_assert_terminate_w(__VA_ARGS__);                \
+    }                                                                     \
+  } while (false)
+
+//  FOLLY_SAFE_CHECK
+//
+//  If expr evaluates to false after explicit conversion to bool, prints context
+//  information to stderr and aborts. Context information includes the remaining
+//  variadic arguments.
+//
+//  When the remaining variadic arguments are printed to stderr, there are two
+//  supported types after implicit conversions: char const* and uint64_t. This
+//  facility is intentionally not extensible to custom types.
+//
+//  multi-thread-safe
+//  async-signal-safe
+#define FOLLY_SAFE_CHECK(expr, ...) \
+  FOLLY_DETAIL_SAFE_CHECK_IMPL(0, 0, 0, expr, __VA_ARGS__)
+
+//  FOLLY_SAFE_DCHECK
+//
+//  Equivalent to FOLLY_SAFE_CHECK when in debug or instrumented builds, where
+//  debug builds are signalled by NDEBUG being undefined and instrumented builds
+//  include sanitizer builds.
+//
+//  multi-thread-safe
+//  async-signal-safe
+#define FOLLY_SAFE_DCHECK(expr, ...) \
+  FOLLY_DETAIL_SAFE_CHECK_IMPL(1, 0, 0, expr, __VA_ARGS__)
+
+//  FOLLY_SAFE_PCHECK
+//
+//  Equivalent to FOLLY_SAFE_CHECK but includes errno in the contextual
+//  information printed to stderr.
+//
+//  multi-thread-safe
+//  async-signal-safe
+#define FOLLY_SAFE_PCHECK(expr, ...) \
+  FOLLY_DETAIL_SAFE_CHECK_IMPL(0, 1, 0, expr, __VA_ARGS__)
+
+//  FOLLY_SAFE_DPCHECK
+//
+//  Equivalent to FOLLY_SAFE_DCHECK but includes errno in the contextual
+//  information printed to stderr.
+//
+//  multi-thread-safe
+//  async-signal-safe
+#define FOLLY_SAFE_DPCHECK(expr, ...) \
+  FOLLY_DETAIL_SAFE_CHECK_IMPL(1, 1, 0, expr, __VA_ARGS__)
+
+//  FOLLY_SAFE_FATAL
+//
+//  Equivalent to FOLLY_SAFE_CHECK(false, ...) but excludes any failing
+//  expression from the contextual information printed to stderr.
+//
+//  multi-thread-safe
+//  async-signal-safe
+#define FOLLY_SAFE_FATAL(...) \
+  FOLLY_DETAIL_SAFE_CHECK_IMPL(0, 0, 1, false, __VA_ARGS__)
+
+//  FOLLY_SAFE_DFATAL
+//
+//  Equivalent to FOLLY_SAFE_DCHECK(false, ...) but excludes any failing
+//  expression from the contextual information printed to stderr.
+//
+//  multi-thread-safe
+//  async-signal-safe
+#define FOLLY_SAFE_DFATAL(...) \
+  FOLLY_DETAIL_SAFE_CHECK_IMPL(1, 0, 1, false, __VA_ARGS__)
+
+namespace folly {
+namespace detail {
+
+enum class safe_assert_msg_type : char { term, cstr, ui64 };
+
+template <safe_assert_msg_type... A>
+struct safe_assert_msg_type_s {};
+
+struct safe_assert_msg_types_one_fn {
+  template <safe_assert_msg_type A>
+  using c = std::integral_constant<safe_assert_msg_type, A>;
+  // only used in unevaluated contexts:
+  c<safe_assert_msg_type::cstr> operator()(char const*) const;
+  c<safe_assert_msg_type::ui64> operator()(uint64_t) const;
+};
+inline constexpr safe_assert_msg_types_one_fn
+    safe_assert_msg_types_one{}; // a function object to prevent extensions
+
+template <typename... A>
+safe_assert_msg_type_s<decltype(safe_assert_msg_types_one((A)A{}))::value...>
+safe_assert_msg_types_seq_of(A...); // only used in unevaluated contexts
+
+template <typename>
+struct safe_assert_msg_types;
+template <safe_assert_msg_type... A>
+struct safe_assert_msg_types<safe_assert_msg_type_s<A...>> {
+  using value_type = c_array<safe_assert_msg_type, sizeof...(A) + 1>;
+  static constexpr value_type value = {{A..., safe_assert_msg_type::term}};
+};
+
+struct safe_assert_arg {
+  char const* expr;
+  char const* file;
+  unsigned int line;
+  char const* function;
+  safe_assert_msg_type const* msg_types;
+};
+
+struct safe_assert_msg_cast_one_fn {
+  FOLLY_ERASE auto operator()(char const* const a) const { return a; }
+  FOLLY_ERASE auto operator()(uint64_t const a) const { return a; }
+};
+inline constexpr safe_assert_msg_cast_one_fn
+    safe_assert_msg_cast_one{}; // a function object to prevent extensions
+
+template <bool P>
+[[noreturn, FOLLY_ATTR_GNU_COLD]] FOLLY_NOINLINE void safe_assert_terminate(
+    safe_assert_arg const* arg, ...) noexcept; // the true backing function
 
 // [Win - Fixes Error C2908 explicit specialization; 'void folly::detail::safe_assert_terminate<false>(const folly::detail::safe_assert_arg *,...) noexcept' has already been instantiated
 template <>
 [[noreturn, FOLLY_ATTR_GNU_COLD]] FOLLY_NOINLINE void safe_assert_terminate<0>(
-    safe_assert_arg const* arg, ...) noexcept;
+  safe_assert_arg const* arg, ...) noexcept;
 
 template <>
 [[noreturn, FOLLY_ATTR_GNU_COLD]] FOLLY_NOINLINE void safe_assert_terminate<1>(
-    safe_assert_arg const* arg, ...) noexcept;
+  safe_assert_arg const* arg, ...) noexcept;
 // Win]
 
- template <bool P>
- struct safe_assert_terminate_w {
-   safe_assert_arg const& arg;
- 
-   FOLLY_ERASE constexpr safe_assert_terminate_w(
-       safe_assert_arg const& arg_) noexcept
-       : arg{arg_} {}
- 
-   template <typename... A>
-   [[noreturn]] FOLLY_ERASE void operator()(A... a) const noexcept {
-     safe_assert_terminate<P>(&arg, safe_assert_msg_cast_one(a)...);
-   }
- };
- 
- } // namespace detail
- } // namespace folly
+template <bool P>
+struct safe_assert_terminate_w {
+  safe_assert_arg const& arg;
+
+  FOLLY_ERASE constexpr safe_assert_terminate_w(
+      safe_assert_arg const& arg_) noexcept
+      : arg{arg_} {}
+
+  template <typename... A>
+  [[noreturn]] FOLLY_ERASE void operator()(A... a) const noexcept {
+    safe_assert_terminate<P>(&arg, safe_assert_msg_cast_one(a)...);
+  }
+};
+
+} // namespace detail
+} // namespace folly
diff --git a/vnext/Folly/TEMP_UntilFollyUpdate/lang/ToAscii.h b/vnext/Folly/TEMP_UntilFollyUpdate/lang/ToAscii.h
index f4545362bef..87858453650 100644
--- a/vnext/Folly/TEMP_UntilFollyUpdate/lang/ToAscii.h
+++ b/vnext/Folly/TEMP_UntilFollyUpdate/lang/ToAscii.h
@@ -1,18 +1,18 @@
 /*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * 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.
- */
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* 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.
+*/
 
 #pragma once
 
@@ -39,14 +39,14 @@ namespace folly {
 //  the constructibility/destructibility and the interface of this one.
 template <bool Upper>
 struct to_ascii_alphabet {
-  //  operator()
-  //
-  //  Translates a single digit to 0-9,a-z or 0-9,A-Z.
-  //
-  //  async-signal-safe
-  constexpr char operator()(uint8_t b) const {
-    return b < 10 ? '0' + b : (Upper ? 'A' : 'a') + (b - 10);
-  }
+//  operator()
+//
+//  Translates a single digit to 0-9,a-z or 0-9,A-Z.
+//
+//  async-signal-safe
+constexpr char operator()(uint8_t b) const {
+  return b < 10 ? '0' + b : (Upper ? 'A' : 'a') + (b - 10);
+}
 };
 using to_ascii_alphabet_lower = to_ascii_alphabet<false>;
 using to_ascii_alphabet_upper = to_ascii_alphabet<true>;
@@ -63,7 +63,7 @@ using to_ascii_alphabet_upper = to_ascii_alphabet<true>;
 /*
 template <uint64_t Base, typename Int>
 inline  constexpr size_t to_ascii_size_max =
-    detail::to_ascii_powers<Base, Int>::size;
+  detail::to_ascii_powers<Base, Int>::size;
 */
 //  to_ascii_size_max_decimal
 //
@@ -104,7 +104,7 @@ FOLLY_ALWAYS_INLINE size_t to_ascii_with_route(char (&out)[N], uint64_t v);
 //  async-signal-safe
 template <uint64_t Base>
 size_t to_ascii_size(uint64_t v) {
-  return detail::to_ascii_size_route<Base>(v);
+return detail::to_ascii_size_route<Base>(v);
 }
 
 //  to_ascii_size_decimal
@@ -113,7 +113,7 @@ size_t to_ascii_size(uint64_t v) {
 //
 //  async-signal-safe
 inline size_t to_ascii_size_decimal(uint64_t v) {
-  return to_ascii_size<10>(v);
+return to_ascii_size<10>(v);
 }
 
 //  to_ascii_with
@@ -131,11 +131,11 @@ inline size_t to_ascii_size_decimal(uint64_t v) {
 //  async-signal-safe
 template <uint64_t Base, typename Alphabet>
 size_t to_ascii_with(char* outb, char const* oute, uint64_t v) {
-  return detail::to_ascii_with_route<Base, Alphabet>(outb, oute, v);
+return detail::to_ascii_with_route<Base, Alphabet>(outb, oute, v);
 }
 template <uint64_t Base, typename Alphabet, size_t N>
 size_t to_ascii_with(char (&out)[N], uint64_t v) {
-  return detail::to_ascii_with_route<Base, Alphabet>(out, v);
+return detail::to_ascii_with_route<Base, Alphabet>(out, v);
 }
 
 //  to_ascii_lower
@@ -145,11 +145,11 @@ size_t to_ascii_with(char (&out)[N], uint64_t v) {
 //  async-signal-safe
 template <uint64_t Base>
 size_t to_ascii_lower(char* outb, char const* oute, uint64_t v) {
-  return to_ascii_with<Base, to_ascii_alphabet_lower>(outb, oute, v);
+return to_ascii_with<Base, to_ascii_alphabet_lower>(outb, oute, v);
 }
 template <uint64_t Base, size_t N>
 size_t to_ascii_lower(char (&out)[N], uint64_t v) {
-  return to_ascii_with<Base, to_ascii_alphabet_lower>(out, v);
+return to_ascii_with<Base, to_ascii_alphabet_lower>(out, v);
 }
 
 //  to_ascii_upper
@@ -159,11 +159,11 @@ size_t to_ascii_lower(char (&out)[N], uint64_t v) {
 //  async-signal-safe
 template <uint64_t Base>
 size_t to_ascii_upper(char* outb, char const* oute, uint64_t v) {
-  return to_ascii_with<Base, to_ascii_alphabet_upper>(outb, oute, v);
+return to_ascii_with<Base, to_ascii_alphabet_upper>(outb, oute, v);
 }
 template <uint64_t Base, size_t N>
 size_t to_ascii_upper(char (&out)[N], uint64_t v) {
-  return to_ascii_with<Base, to_ascii_alphabet_upper>(out, v);
+return to_ascii_with<Base, to_ascii_alphabet_upper>(out, v);
 }
 
 //  to_ascii_decimal
@@ -172,11 +172,11 @@ size_t to_ascii_upper(char (&out)[N], uint64_t v) {
 //
 //  async-signal-safe
 inline size_t to_ascii_decimal(char* outb, char const* oute, uint64_t v) {
-  return to_ascii_lower<10>(outb, oute, v);
+return to_ascii_lower<10>(outb, oute, v);
 }
 template <size_t N>
 inline size_t to_ascii_decimal(char (&out)[N], uint64_t v) {
-  return to_ascii_lower<10>(out, v);
+return to_ascii_lower<10>(out, v);
 }
 
 } // namespace folly
\ No newline at end of file

From 89a0f4475d71c8ca0f121296fb5fc3a62a891bd5 Mon Sep 17 00:00:00 2001
From: Tatiana Kapos <tatianakapos@microsoft.com>
Date: Mon, 21 Apr 2025 17:34:57 -0700
Subject: [PATCH 12/13] fix

---
 .../TEMP_UntilFollyUpdate/ConstexprMath.h     |  56 +++---
 vnext/Folly/TEMP_UntilFollyUpdate/Conv.cpp    |  52 +++---
 .../concurrency/CacheLocality.cpp             |  28 +--
 .../TEMP_UntilFollyUpdate/json/dynamic-inl.h  | 160 +++++++++---------
 .../Folly/TEMP_UntilFollyUpdate/json/json.cpp |  72 ++++----
 .../TEMP_UntilFollyUpdate/lang/SafeAssert.h   |  28 +--
 .../TEMP_UntilFollyUpdate/lang/ToAscii.h      |  64 +++----
 .../packages.lock.json                        |  73 +++++++-
 8 files changed, 300 insertions(+), 233 deletions(-)

diff --git a/vnext/Folly/TEMP_UntilFollyUpdate/ConstexprMath.h b/vnext/Folly/TEMP_UntilFollyUpdate/ConstexprMath.h
index 428849f451f..eddc4fe39bd 100644
--- a/vnext/Folly/TEMP_UntilFollyUpdate/ConstexprMath.h
+++ b/vnext/Folly/TEMP_UntilFollyUpdate/ConstexprMath.h
@@ -1,18 +1,18 @@
 /*
-* Copyright (c) Meta Platforms, Inc. and affiliates.
-*
-* 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.
-*/
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * 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.
+ */
 
 #pragma once
 
@@ -139,14 +139,14 @@ struct constexpr_iterated_squares_desc {
   base_type base;
   item_type scaling[size];
 
-private:
+ private:
   using lim = std::numeric_limits<base_type>;
 
   static_assert(
       lim::max_exponent < std::numeric_limits<size_type>::max(),
       "size_type too small for base_type");
 
-public:
+ public:
   explicit constexpr constexpr_iterated_squares_desc(base_type r) noexcept
       : base{r}, scaling{} {
     assert(size <= detail::constexpr_iterated_squares_desc_size_(base));
@@ -248,24 +248,24 @@ constexpr auto& constexpr_iterated_squares_desc_2_v =
 // See http://stepanovpapers.com/notes.pdf for details.
 template <typename T, typename... Ts>
 constexpr T constexpr_max(T a, Ts... ts) {
-T list[] = {ts..., a}; // 0-length arrays are illegal
-// [Windows #12703 - Fix folly CodeQL issues]
-for (size_t i = 0; i < sizeof...(Ts); ++i) {
-  a = list[i] < a ? a : list[i];
-}
-return a;
+  T list[] = {ts..., a}; // 0-length arrays are illegal
+  // [Windows #12703 - Fix folly CodeQL issues]
+  for (size_t i = 0; i < sizeof...(Ts); ++i) {
+    a = list[i] < a ? a : list[i];
+  }
+  return a;
 }
 
 // When a and b are equivalent objects, we return a to
 // make sorting stable.
 template <typename T, typename... Ts>
 constexpr T constexpr_min(T a, Ts... ts) {
-T list[] = {ts..., a}; // 0-length arrays are illegal
-// [Windows #12703 - Fix folly CodeQL issues]
-for (size_t i = 0; i < sizeof...(Ts); ++i) {
-  a = list[i] < a ? list[i] : a;
-}
-return a;
+  T list[] = {ts..., a}; // 0-length arrays are illegal
+  // [Windows #12703 - Fix folly CodeQL issues]
+  for (size_t i = 0; i < sizeof...(Ts); ++i) {
+    a = list[i] < a ? list[i] : a;
+  }
+  return a;
 }
 
 template <typename T, typename Less>
diff --git a/vnext/Folly/TEMP_UntilFollyUpdate/Conv.cpp b/vnext/Folly/TEMP_UntilFollyUpdate/Conv.cpp
index d5f4b2cb50b..44b2851409c 100644
--- a/vnext/Folly/TEMP_UntilFollyUpdate/Conv.cpp
+++ b/vnext/Folly/TEMP_UntilFollyUpdate/Conv.cpp
@@ -1,18 +1,18 @@
 /*
-* Copyright (c) Meta Platforms, Inc. and affiliates.
-*
-* 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.
-*/
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * 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 <folly/Conv.h>
 
@@ -29,18 +29,18 @@ namespace detail {
 namespace {
 
 /**
-* Finds the first non-digit in a string. The number of digits
-* searched depends on the precision of the Tgt integral. Assumes the
-* string starts with NO whitespace and NO sign.
-*
-* The semantics of the routine is:
-*   for (;; ++b) {
-*     if (b >= e || !isdigit(*b)) return b;
-*   }
-*
-*  Complete unrolling marks bottom-line (i.e. entire conversion)
-*  improvements of 20%.
-*/
+ * Finds the first non-digit in a string. The number of digits
+ * searched depends on the precision of the Tgt integral. Assumes the
+ * string starts with NO whitespace and NO sign.
+ *
+ * The semantics of the routine is:
+ *   for (;; ++b) {
+ *     if (b >= e || !isdigit(*b)) return b;
+ *   }
+ *
+ *  Complete unrolling marks bottom-line (i.e. entire conversion)
+ *  improvements of 20%.
+ */
 inline const char* findFirstNonDigit(const char* b, const char* e) {
   for (; b < e; ++b) {
     auto const c = static_cast<unsigned>(*b) - '0';
diff --git a/vnext/Folly/TEMP_UntilFollyUpdate/concurrency/CacheLocality.cpp b/vnext/Folly/TEMP_UntilFollyUpdate/concurrency/CacheLocality.cpp
index ff917ea7db0..ab91cbab19e 100644
--- a/vnext/Folly/TEMP_UntilFollyUpdate/concurrency/CacheLocality.cpp
+++ b/vnext/Folly/TEMP_UntilFollyUpdate/concurrency/CacheLocality.cpp
@@ -1,18 +1,18 @@
 /*
-* Copyright (c) Meta Platforms, Inc. and affiliates.
-*
-* 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.
-*/
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * 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 <folly/concurrency/CacheLocality.h>
 
diff --git a/vnext/Folly/TEMP_UntilFollyUpdate/json/dynamic-inl.h b/vnext/Folly/TEMP_UntilFollyUpdate/json/dynamic-inl.h
index da83d32fc86..ee000cdd7de 100644
--- a/vnext/Folly/TEMP_UntilFollyUpdate/json/dynamic-inl.h
+++ b/vnext/Folly/TEMP_UntilFollyUpdate/json/dynamic-inl.h
@@ -1,18 +1,18 @@
 /*
-* Copyright (c) Meta Platforms, Inc. and affiliates.
-*
-* 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.
-*/
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * 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.
+ */
 
 #pragma once
 
@@ -140,10 +140,10 @@ struct Destroy {
 };
 
 /*
-* Helper for implementing numeric conversions in operators on
-* numbers.  Just promotes to double when one of the arguments is
-* double, or throws if either is not a numeric type.
-*/
+ * Helper for implementing numeric conversions in operators on
+ * numbers.  Just promotes to double when one of the arguments is
+ * double, or throws if either is not a numeric type.
+ */
 template <template <class> class Op>
 dynamic numericOp(dynamic const& a, dynamic const& b) {
   if (!a.isNumber() || !b.isNumber()) {
@@ -160,18 +160,18 @@ dynamic numericOp(dynamic const& a, dynamic const& b) {
 //////////////////////////////////////////////////////////////////////
 
 /*
-* We're doing this instead of a simple member typedef to avoid the
-* undefined behavior of parameterizing F14NodeMap<> with an
-* incomplete type.
-*
-* Note: Later we may add separate order tracking here (a multi-index
-* type of thing.)
-*/
+ * We're doing this instead of a simple member typedef to avoid the
+ * undefined behavior of parameterizing F14NodeMap<> with an
+ * incomplete type.
+ *
+ * Note: Later we may add separate order tracking here (a multi-index
+ * type of thing.)
+ */
 struct dynamic::ObjectImpl : F14NodeMap<
-                                dynamic,
-                                dynamic,
-                                detail::DynamicHasher,
-                                detail::DynamicKeyEqual> {};
+                                 dynamic,
+                                 dynamic,
+                                 detail::DynamicHasher,
+                                 detail::DynamicKeyEqual> {};
 
 //////////////////////////////////////////////////////////////////////
 
@@ -200,7 +200,7 @@ struct dynamic::ObjectMaker {
     return std::move(*this);
   }
 
-private:
+ private:
   dynamic val_;
 };
 
@@ -237,10 +237,10 @@ struct dynamic::item_iterator : detail::IteratorAdaptor<
 };
 
 struct dynamic::value_iterator : detail::IteratorAdaptor<
-                                    dynamic::value_iterator,
-                                    dynamic::ObjectImpl::iterator,
-                                    dynamic,
-                                    std::forward_iterator_tag> {
+                                     dynamic::value_iterator,
+                                     dynamic::ObjectImpl::iterator,
+                                     dynamic,
+                                     std::forward_iterator_tag> {
   using Super = detail::IteratorAdaptor<
       dynamic::value_iterator,
       dynamic::ObjectImpl::iterator,
@@ -274,10 +274,10 @@ struct dynamic::const_item_iterator
 };
 
 struct dynamic::const_key_iterator : detail::IteratorAdaptor<
-                                        dynamic::const_key_iterator,
-                                        dynamic::ObjectImpl::const_iterator,
-                                        dynamic const,
-                                        std::forward_iterator_tag> {
+                                         dynamic::const_key_iterator,
+                                         dynamic::ObjectImpl::const_iterator,
+                                         dynamic const,
+                                         std::forward_iterator_tag> {
   using Super = detail::IteratorAdaptor<
       dynamic::const_key_iterator,
       dynamic::ObjectImpl::const_iterator,
@@ -293,10 +293,10 @@ struct dynamic::const_key_iterator : detail::IteratorAdaptor<
 };
 
 struct dynamic::const_value_iterator : detail::IteratorAdaptor<
-                                          dynamic::const_value_iterator,
-                                          dynamic::ObjectImpl::const_iterator,
-                                          dynamic const,
-                                          std::forward_iterator_tag> {
+                                           dynamic::const_value_iterator,
+                                           dynamic::ObjectImpl::const_iterator,
+                                           dynamic const,
+                                           std::forward_iterator_tag> {
   using Super = detail::IteratorAdaptor<
       dynamic::const_value_iterator,
       dynamic::ObjectImpl::const_iterator,
@@ -434,7 +434,7 @@ struct dynamic::IterableProxy {
 
   It end() const { return o_->end(); }
 
-private:
+ private:
   object_type* o_;
 };
 
@@ -1110,36 +1110,36 @@ struct dynamic::GetAddrImpl<dynamic::ObjectImpl> {
 // interface)
 template <class T>
 T &dynamic::get() {
-if (auto *p = get_nothrow<T>()) {
-  return *p;
-}
-
-switch (type()) {
-  case dynamic::NULLT:
-    throw_exception<TypeError>("null", dynamic::NULLT);
-    break;
-  case dynamic::BOOL:
-    throw_exception<TypeError>("boolean", dynamic::BOOL);
-    break;
-  case dynamic::STRING:
-    throw_exception<TypeError>("string", dynamic::STRING);
-    break;
-  case dynamic::ARRAY:
-    throw_exception<TypeError>("array", dynamic::ARRAY);
-    break;
-  case dynamic::DOUBLE:
-    throw_exception<TypeError>("double", dynamic::DOUBLE);
-    break;
-  case dynamic::INT64:
-    throw_exception<TypeError>("int64", dynamic::INT64);
-    break;
-  case dynamic::OBJECT:
-    throw_exception<TypeError>("object", dynamic::OBJECT);
-    break;
-  default:
-    throw_exception<TypeError>("never", dynamic::OBJECT);
-    break;
-}
+  if (auto *p = get_nothrow<T>()) {
+    return *p;
+  }
+
+  switch (type()) {
+    case dynamic::NULLT:
+      throw_exception<TypeError>("null", dynamic::NULLT);
+      break;
+    case dynamic::BOOL:
+      throw_exception<TypeError>("boolean", dynamic::BOOL);
+      break;
+    case dynamic::STRING:
+      throw_exception<TypeError>("string", dynamic::STRING);
+      break;
+    case dynamic::ARRAY:
+      throw_exception<TypeError>("array", dynamic::ARRAY);
+      break;
+    case dynamic::DOUBLE:
+      throw_exception<TypeError>("double", dynamic::DOUBLE);
+      break;
+    case dynamic::INT64:
+      throw_exception<TypeError>("int64", dynamic::INT64);
+      break;
+    case dynamic::OBJECT:
+      throw_exception<TypeError>("object", dynamic::OBJECT);
+      break;
+    default:
+      throw_exception<TypeError>("never", dynamic::OBJECT);
+      break;
+  }
 }
 // Win]
 
@@ -1151,9 +1151,9 @@ T const& dynamic::get() const {
 //////////////////////////////////////////////////////////////////////
 
 /*
-* Helper for implementing operator<<.  Throws if the type shouldn't
-* support it.
-*/
+ * Helper for implementing operator<<.  Throws if the type shouldn't
+ * support it.
+ */
 template <class T>
 struct dynamic::PrintImpl {
   static void print(dynamic const&, std::ostream& out, T const& t) { out << t; }
@@ -1357,7 +1357,7 @@ inline std::string dynamic_view::move_string_or(Stringish&& val) {
 // Specialization of FormatValue so dynamic objects can be formatted
 template <>
 class FormatValue<dynamic> {
-public:
+ public:
   explicit FormatValue(const dynamic& val) : val_(val) {}
 
   template <class FormatCallback>
@@ -1387,13 +1387,13 @@ class FormatValue<dynamic> {
     }
   }
 
-private:
+ private:
   const dynamic& val_;
 };
 
 template <class V>
 class FormatValue<detail::DefaultValueWrapper<dynamic, V>> {
-public:
+ public:
   explicit FormatValue(const detail::DefaultValueWrapper<dynamic, V>& val)
       : val_(val) {}
 
@@ -1429,7 +1429,7 @@ class FormatValue<detail::DefaultValueWrapper<dynamic, V>> {
     }
   }
 
-private:
+ private:
   const detail::DefaultValueWrapper<dynamic, V>& val_;
 };
 
diff --git a/vnext/Folly/TEMP_UntilFollyUpdate/json/json.cpp b/vnext/Folly/TEMP_UntilFollyUpdate/json/json.cpp
index 00193cbc786..2f8c7944e14 100644
--- a/vnext/Folly/TEMP_UntilFollyUpdate/json/json.cpp
+++ b/vnext/Folly/TEMP_UntilFollyUpdate/json/json.cpp
@@ -1,18 +1,18 @@
 /*
-* Copyright (c) Meta Platforms, Inc. and affiliates.
-*
-* 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.
-*/
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * 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 <folly/json/json.h>
 
@@ -57,7 +57,7 @@ struct Printer {
   // Context class is allows to restore the path to element that we are about to
   // print so that if error happens we can throw meaningful exception.
   class Context {
-  public:
+   public:
     Context(const Context* parent_context, const dynamic& key)
         : parent_context_(parent_context), key_(key), is_key_(false) {}
     Context(const Context* parent_context, const dynamic& key, bool is_key)
@@ -88,7 +88,7 @@ struct Printer {
     }
     std::string typeDescription() const { return is_key_ ? "key" : "value"; }
 
-  private:
+   private:
     const Context* const parent_context_;
     const dynamic& key_;
     bool is_key_;
@@ -154,7 +154,7 @@ struct Printer {
     }
   }
 
-private:
+ private:
   void printKV(
       dynamic const& o,
       const std::pair<const dynamic, dynamic>& p,
@@ -270,7 +270,7 @@ struct Printer {
     out_ += ']';
   }
 
-private:
+ private:
   void outdent() const {
     if (indentLevel_) {
       --*indentLevel_;
@@ -292,7 +292,7 @@ struct Printer {
 
   void mapColon() const { out_ += indentLevel_ ? ": " : ":"; }
 
-private:
+ private:
   std::string& out_;
   unsigned* const indentLevel_;
   serialization_opts const& opts_;
@@ -427,10 +427,10 @@ struct Input {
 
   void decrementRecursionLevel() { currentRecursionLevel_--; }
 
-private:
+ private:
   void storeCurrent() { current_ = range_.empty() ? EOF : range_.front(); }
 
-private:
+ private:
   StringPiece range_;
   json::serialization_opts const& opts_;
   unsigned lineNum_;
@@ -439,14 +439,14 @@ struct Input {
 };
 
 class RecursionGuard {
-public:
+ public:
   explicit RecursionGuard(Input& in) : in_(in) {
     in_.incrementRecursionLevel();
   }
 
   ~RecursionGuard() { in_.decrementRecursionLevel(); }
 
-private:
+ private:
   Input& in_;
 };
 
@@ -683,7 +683,7 @@ std::string parseString(Input& in) {
     if (*in == '\\') {
       ++in;
       switch (*in) {
-          // clang-format off
+        // clang-format off
         case '\"':    ret.push_back('\"'); ++in; break;
         case '\\':    ret.push_back('\\'); ++in; break;
         case '/':     ret.push_back('/');  ++in; break;
@@ -705,12 +705,12 @@ std::string parseString(Input& in) {
     }
     if (!*in) {
       /*
-      * Apparently we're actually supposed to ban all control
-      * characters from strings.  This seems unnecessarily
-      * restrictive, so we're only banning zero bytes.  (Since the
-      * string is presumed to be UTF-8 encoded it's fine to just
-      * check this way.)
-      */
+       * Apparently we're actually supposed to ban all control
+       * characters from strings.  This seems unnecessarily
+       * restrictive, so we're only banning zero bytes.  (Since the
+       * string is presumed to be UTF-8 encoded it's fine to just
+       * check this way.)
+       */
       in.error("null byte in string");
     }
 
@@ -852,10 +852,10 @@ void escapeStringImpl(
       }
       auto prefix = firstEscapableInWord<EnableExtraAsciiEscapes>(word, opts);
       DCHECK_LE(prefix, avail);
-    // [Windows Sometimes prefix is completely wrong (corrupt?), only in Release, causing a later AV (see issue #14394).
-    // Prefix should always be <= avail, capping it here as a workaround, hoping the assert above eventually catches this in Debug.
-    prefix = std::min(prefix, (size_t)avail);
-    // Windows]
+      // [Windows Sometimes prefix is completely wrong (corrupt?), only in Release, causing a later AV (see issue #14394).
+      // Prefix should always be <= avail, capping it here as a workaround, hoping the assert above eventually catches this in Debug.
+      prefix = std::min(prefix, (size_t)avail);
+      // Windows]
       firstEsc += prefix;
       if (prefix < 8) {
         break;
@@ -901,7 +901,7 @@ void escapeStringImpl(
     if /* constexpr */ (EnableExtraAsciiEscapes) {
       encodeUnicode = encodeUnicode ||
           (*p >= 0x20 && *p < 0x80 &&
-          (opts.extra_ascii_to_escape_bitmap[*p / 64] &
+           (opts.extra_ascii_to_escape_bitmap[*p / 64] &
             (uint64_t(1) << (*p % 64))));
     }
 
@@ -940,7 +940,7 @@ void escapeStringImpl(
       out.append(buf, 2);
     } else if (*p <= 0x1f) {
       switch (*p) {
-          // clang-format off
+        // clang-format off
         case '\b': out.append("\\b"); p++; break;
         case '\f': out.append("\\f"); p++; break;
         case '\n': out.append("\\n"); p++; break;
diff --git a/vnext/Folly/TEMP_UntilFollyUpdate/lang/SafeAssert.h b/vnext/Folly/TEMP_UntilFollyUpdate/lang/SafeAssert.h
index e0fa799ac04..0d9ff21b55d 100644
--- a/vnext/Folly/TEMP_UntilFollyUpdate/lang/SafeAssert.h
+++ b/vnext/Folly/TEMP_UntilFollyUpdate/lang/SafeAssert.h
@@ -1,18 +1,18 @@
 /*
-* Copyright (c) Meta Platforms, Inc. and affiliates.
-*
-* 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.
-*/
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * 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.
+ */
 
 #pragma once
 
diff --git a/vnext/Folly/TEMP_UntilFollyUpdate/lang/ToAscii.h b/vnext/Folly/TEMP_UntilFollyUpdate/lang/ToAscii.h
index 87858453650..487a21a6e21 100644
--- a/vnext/Folly/TEMP_UntilFollyUpdate/lang/ToAscii.h
+++ b/vnext/Folly/TEMP_UntilFollyUpdate/lang/ToAscii.h
@@ -1,18 +1,18 @@
 /*
-* Copyright (c) Meta Platforms, Inc. and affiliates.
-*
-* 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.
-*/
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * 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.
+ */
 
 #pragma once
 
@@ -39,14 +39,14 @@ namespace folly {
 //  the constructibility/destructibility and the interface of this one.
 template <bool Upper>
 struct to_ascii_alphabet {
-//  operator()
-//
-//  Translates a single digit to 0-9,a-z or 0-9,A-Z.
-//
-//  async-signal-safe
-constexpr char operator()(uint8_t b) const {
-  return b < 10 ? '0' + b : (Upper ? 'A' : 'a') + (b - 10);
-}
+  //  operator()
+  //
+  //  Translates a single digit to 0-9,a-z or 0-9,A-Z.
+  //
+  //  async-signal-safe
+  constexpr char operator()(uint8_t b) const {
+    return b < 10 ? '0' + b : (Upper ? 'A' : 'a') + (b - 10);
+  }
 };
 using to_ascii_alphabet_lower = to_ascii_alphabet<false>;
 using to_ascii_alphabet_upper = to_ascii_alphabet<true>;
@@ -104,7 +104,7 @@ FOLLY_ALWAYS_INLINE size_t to_ascii_with_route(char (&out)[N], uint64_t v);
 //  async-signal-safe
 template <uint64_t Base>
 size_t to_ascii_size(uint64_t v) {
-return detail::to_ascii_size_route<Base>(v);
+  return detail::to_ascii_size_route<Base>(v);
 }
 
 //  to_ascii_size_decimal
@@ -113,7 +113,7 @@ return detail::to_ascii_size_route<Base>(v);
 //
 //  async-signal-safe
 inline size_t to_ascii_size_decimal(uint64_t v) {
-return to_ascii_size<10>(v);
+  return to_ascii_size<10>(v);
 }
 
 //  to_ascii_with
@@ -131,11 +131,11 @@ return to_ascii_size<10>(v);
 //  async-signal-safe
 template <uint64_t Base, typename Alphabet>
 size_t to_ascii_with(char* outb, char const* oute, uint64_t v) {
-return detail::to_ascii_with_route<Base, Alphabet>(outb, oute, v);
+  return detail::to_ascii_with_route<Base, Alphabet>(outb, oute, v);
 }
 template <uint64_t Base, typename Alphabet, size_t N>
 size_t to_ascii_with(char (&out)[N], uint64_t v) {
-return detail::to_ascii_with_route<Base, Alphabet>(out, v);
+  return detail::to_ascii_with_route<Base, Alphabet>(out, v);
 }
 
 //  to_ascii_lower
@@ -145,11 +145,11 @@ return detail::to_ascii_with_route<Base, Alphabet>(out, v);
 //  async-signal-safe
 template <uint64_t Base>
 size_t to_ascii_lower(char* outb, char const* oute, uint64_t v) {
-return to_ascii_with<Base, to_ascii_alphabet_lower>(outb, oute, v);
+  return to_ascii_with<Base, to_ascii_alphabet_lower>(outb, oute, v);
 }
 template <uint64_t Base, size_t N>
 size_t to_ascii_lower(char (&out)[N], uint64_t v) {
-return to_ascii_with<Base, to_ascii_alphabet_lower>(out, v);
+  return to_ascii_with<Base, to_ascii_alphabet_lower>(out, v);
 }
 
 //  to_ascii_upper
@@ -159,11 +159,11 @@ return to_ascii_with<Base, to_ascii_alphabet_lower>(out, v);
 //  async-signal-safe
 template <uint64_t Base>
 size_t to_ascii_upper(char* outb, char const* oute, uint64_t v) {
-return to_ascii_with<Base, to_ascii_alphabet_upper>(outb, oute, v);
+  return to_ascii_with<Base, to_ascii_alphabet_upper>(outb, oute, v);
 }
 template <uint64_t Base, size_t N>
 size_t to_ascii_upper(char (&out)[N], uint64_t v) {
-return to_ascii_with<Base, to_ascii_alphabet_upper>(out, v);
+  return to_ascii_with<Base, to_ascii_alphabet_upper>(out, v);
 }
 
 //  to_ascii_decimal
@@ -172,11 +172,11 @@ return to_ascii_with<Base, to_ascii_alphabet_upper>(out, v);
 //
 //  async-signal-safe
 inline size_t to_ascii_decimal(char* outb, char const* oute, uint64_t v) {
-return to_ascii_lower<10>(outb, oute, v);
+  return to_ascii_lower<10>(outb, oute, v);
 }
 template <size_t N>
 inline size_t to_ascii_decimal(char (&out)[N], uint64_t v) {
-return to_ascii_lower<10>(out, v);
+  return to_ascii_lower<10>(out, v);
 }
 
 } // namespace folly
\ No newline at end of file
diff --git a/vnext/Microsoft.ReactNative.Managed/packages.lock.json b/vnext/Microsoft.ReactNative.Managed/packages.lock.json
index 8d89bc1efd5..0d7d0738511 100644
--- a/vnext/Microsoft.ReactNative.Managed/packages.lock.json
+++ b/vnext/Microsoft.ReactNative.Managed/packages.lock.json
@@ -24,11 +24,21 @@
           "Microsoft.SourceLink.Common": "1.1.1"
         }
       },
+      "boost": {
+        "type": "Transitive",
+        "resolved": "1.83.0",
+        "contentHash": "cy53VNMzysEMvhBixDe8ujPk67Fcj3v6FPHQnH91NYJNLHpc6jxa2xq9ruCaaJjE4M3YrGSHDi4uUSTGBWw6EQ=="
+      },
       "Microsoft.Build.Tasks.Git": {
         "type": "Transitive",
         "resolved": "1.1.1",
         "contentHash": "AT3HlgTjsqHnWpBHSNeR0KxbLZD7bztlZVj7I8vgeYG9SYqbeFGh0TM/KVtC6fg53nrWHl3VfZFvb5BiQFcY6Q=="
       },
+      "Microsoft.JavaScript.Hermes": {
+        "type": "Transitive",
+        "resolved": "0.1.23",
+        "contentHash": "cA9t1GjY4Yo0JD1AfA//e1lOwk48hLANfuX6GXrikmEBNZVr2TIX5ONJt5tqCnpZyLz6xGiPDgTfFNKbSfb21g=="
+      },
       "Microsoft.Net.Native.Compiler": {
         "type": "Transitive",
         "resolved": "2.2.12-rel-31116-00",
@@ -60,6 +70,19 @@
         "resolved": "1.1.1",
         "contentHash": "WMcGpWKrmJmzrNeuaEb23bEMnbtR/vLmvZtkAP5qWu7vQsY59GqfRJd65sFpBszbd2k/bQ8cs8eWawQKAabkVg=="
       },
+      "Microsoft.UI.Xaml": {
+        "type": "Transitive",
+        "resolved": "2.8.0",
+        "contentHash": "vxdHxTr63s5KVtNddMFpgvjBjUH50z7seq/5jLWmmSuf8poxg+sXrywkofUdE8ZstbpO9y3FL/IXXUcPYbeesA==",
+        "dependencies": {
+          "Microsoft.Web.WebView2": "1.0.1264.42"
+        }
+      },
+      "Microsoft.Web.WebView2": {
+        "type": "Transitive",
+        "resolved": "1.0.1264.42",
+        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
+      },
       "NETStandard.Library": {
         "type": "Transitive",
         "resolved": "2.0.3",
@@ -136,7 +159,10 @@
         "contentHash": "V/hZioMMAwoKZFmfq/SuMA/mfoNFu4+Aedwdld/tpL8ZheehFab0RlAR3pgsPgOWOU+GjyePNIgyUXM5J/Y3Ig=="
       },
       "common": {
-        "type": "Project"
+        "type": "Project",
+        "dependencies": {
+          "boost": "[1.83.0, )"
+        }
       },
       "fmt": {
         "type": "Project"
@@ -144,6 +170,7 @@
       "folly": {
         "type": "Project",
         "dependencies": {
+          "boost": "[1.83.0, )",
           "fmt": "[1.0.0, )"
         }
       },
@@ -152,13 +179,18 @@
         "dependencies": {
           "Common": "[1.0.0, )",
           "Folly": "[1.0.0, )",
-          "ReactCommon": "[1.0.0, )"
+          "Microsoft.JavaScript.Hermes": "[0.1.23, )",
+          "Microsoft.SourceLink.GitHub": "[1.1.1, )",
+          "Microsoft.UI.Xaml": "[2.8.0, )",
+          "ReactCommon": "[1.0.0, )",
+          "boost": "[1.83.0, )"
         }
       },
       "reactcommon": {
         "type": "Project",
         "dependencies": {
-          "Folly": "[1.0.0, )"
+          "Folly": "[1.0.0, )",
+          "boost": "[1.83.0, )"
         }
       }
     },
@@ -176,6 +208,11 @@
           "runtime.win10-arm.Microsoft.NETCore.UniversalWindowsPlatform": "6.2.14"
         }
       },
+      "Microsoft.Web.WebView2": {
+        "type": "Transitive",
+        "resolved": "1.0.1264.42",
+        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
+      },
       "runtime.win10-arm.Microsoft.NETCore.UniversalWindowsPlatform": {
         "type": "Transitive",
         "resolved": "6.2.14",
@@ -196,6 +233,11 @@
           "runtime.win10-arm-aot.Microsoft.NETCore.UniversalWindowsPlatform": "6.2.14"
         }
       },
+      "Microsoft.Web.WebView2": {
+        "type": "Transitive",
+        "resolved": "1.0.1264.42",
+        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
+      },
       "runtime.win10-arm-aot.Microsoft.NETCore.UniversalWindowsPlatform": {
         "type": "Transitive",
         "resolved": "6.2.14",
@@ -216,6 +258,11 @@
           "runtime.win10-arm64-aot.Microsoft.NETCore.UniversalWindowsPlatform": "6.2.14"
         }
       },
+      "Microsoft.Web.WebView2": {
+        "type": "Transitive",
+        "resolved": "1.0.1264.42",
+        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
+      },
       "runtime.win10-arm64-aot.Microsoft.NETCore.UniversalWindowsPlatform": {
         "type": "Transitive",
         "resolved": "6.2.14",
@@ -236,6 +283,11 @@
           "runtime.win10-x64.Microsoft.NETCore.UniversalWindowsPlatform": "6.2.14"
         }
       },
+      "Microsoft.Web.WebView2": {
+        "type": "Transitive",
+        "resolved": "1.0.1264.42",
+        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
+      },
       "runtime.win10-x64.Microsoft.NETCore.UniversalWindowsPlatform": {
         "type": "Transitive",
         "resolved": "6.2.14",
@@ -256,6 +308,11 @@
           "runtime.win10-x64-aot.Microsoft.NETCore.UniversalWindowsPlatform": "6.2.14"
         }
       },
+      "Microsoft.Web.WebView2": {
+        "type": "Transitive",
+        "resolved": "1.0.1264.42",
+        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
+      },
       "runtime.win10-x64-aot.Microsoft.NETCore.UniversalWindowsPlatform": {
         "type": "Transitive",
         "resolved": "6.2.14",
@@ -276,6 +333,11 @@
           "runtime.win10-x86.Microsoft.NETCore.UniversalWindowsPlatform": "6.2.14"
         }
       },
+      "Microsoft.Web.WebView2": {
+        "type": "Transitive",
+        "resolved": "1.0.1264.42",
+        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
+      },
       "runtime.win10-x86.Microsoft.NETCore.UniversalWindowsPlatform": {
         "type": "Transitive",
         "resolved": "6.2.14",
@@ -296,6 +358,11 @@
           "runtime.win10-x86-aot.Microsoft.NETCore.UniversalWindowsPlatform": "6.2.14"
         }
       },
+      "Microsoft.Web.WebView2": {
+        "type": "Transitive",
+        "resolved": "1.0.1264.42",
+        "contentHash": "7OBUTkzQ5VI/3gb0ufi5U4zjuCowAJwQg2li0zXXzqkM+S1kmOlivTy1R4jAW+gY5Vyg510M+qMAESCQUjrfgA=="
+      },
       "runtime.win10-x86-aot.Microsoft.NETCore.UniversalWindowsPlatform": {
         "type": "Transitive",
         "resolved": "6.2.14",

From 5d5a0f54caace6d1f04cbe3f70d832774b35dd5c Mon Sep 17 00:00:00 2001
From: Tatiana Kapos <tatianakapos@microsoft.com>
Date: Wed, 23 Apr 2025 14:10:37 -0700
Subject: [PATCH 13/13] feedback

---
 vnext/Folly/TEMP_UntilFollyUpdate/json/json.cpp |  3 ++-
 vnext/Folly/cgmanifest.json                     | 10 ++++++++++
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/vnext/Folly/TEMP_UntilFollyUpdate/json/json.cpp b/vnext/Folly/TEMP_UntilFollyUpdate/json/json.cpp
index 2f8c7944e14..b8696322386 100644
--- a/vnext/Folly/TEMP_UntilFollyUpdate/json/json.cpp
+++ b/vnext/Folly/TEMP_UntilFollyUpdate/json/json.cpp
@@ -347,7 +347,8 @@ struct Input {
   }
 
   void skipWhitespace() {
-    unsigned index = 0;
+    // [Windows #12703 - CodeQL patch]
+    std::size_t index = 0;
     while (true) {
       while (index < range_.size() && range_[index] == ' ') {
         index++;
diff --git a/vnext/Folly/cgmanifest.json b/vnext/Folly/cgmanifest.json
index 975cfc38d44..10a2c5dd499 100644
--- a/vnext/Folly/cgmanifest.json
+++ b/vnext/Folly/cgmanifest.json
@@ -10,6 +10,16 @@
                 }
             },
             "DevelopmentDependency": false
+        },
+        {
+            "Component": {
+                "Type": "git",
+                "Git": {
+                  "RepositoryUrl": "https://github.com/fastfloat/fast_float",
+                  "CommitHash": "ad90720829db5ba0c3d0e44994856dcce33d7940"
+                }
+            },
+            "DevelopmentDependency": false
         }
     ]
 }