Restoring authorship annotation for <prime@yandex-team.ru>. Commit 2 of 2.

17 files changed, 2192 insertions, 2192 deletions

diff --git a/contrib/restricted/abseil-cpp/absl/strings/internal/absl_strings_internal/ya.make b/contrib/restricted/abseil-cpp/absl/strings/internal/absl_strings_internal/ya.make
index a1c2096292..2c62f6421a 100644
--- a/contrib/restricted/abseil-cpp/absl/strings/internal/absl_strings_internal/ya.make
+++ b/contrib/restricted/abseil-cpp/absl/strings/internal/absl_strings_internal/ya.make
@@ -9,9 +9,9 @@ OWNER(g:cpp-contrib)
 LICENSE(Apache-2.0)
 
 PEERDIR(
-    contrib/restricted/abseil-cpp/absl/base 
+    contrib/restricted/abseil-cpp/absl/base
     contrib/restricted/abseil-cpp/absl/base/internal/raw_logging
-    contrib/restricted/abseil-cpp/absl/base/internal/spinlock_wait 
+    contrib/restricted/abseil-cpp/absl/base/internal/spinlock_wait
     contrib/restricted/abseil-cpp/absl/base/log_severity
 )
 
diff --git a/contrib/restricted/abseil-cpp/absl/strings/internal/charconv_parse.cc b/contrib/restricted/abseil-cpp/absl/strings/internal/charconv_parse.cc
index a476cd262c..d29acaf462 100644
--- a/contrib/restricted/abseil-cpp/absl/strings/internal/charconv_parse.cc
+++ b/contrib/restricted/abseil-cpp/absl/strings/internal/charconv_parse.cc
@@ -246,8 +246,8 @@ constexpr int DigitMagnitude<16>() {
 // ConsumeDigits does not protect against overflow on *out; max_digits must
 // be chosen with respect to type T to avoid the possibility of overflow.
 template <int base, typename T>
-int ConsumeDigits(const char* begin, const char* end, int max_digits, T* out, 
-                  bool* dropped_nonzero_digit) { 
+int ConsumeDigits(const char* begin, const char* end, int max_digits, T* out,
+                  bool* dropped_nonzero_digit) {
   if (base == 10) {
     assert(max_digits <= std::numeric_limits<T>::digits10);
   } else if (base == 16) {
@@ -282,7 +282,7 @@ int ConsumeDigits(const char* begin, const char* end, int max_digits, T* out,
     *dropped_nonzero_digit = true;
   }
   *out = accumulator;
-  return static_cast<int>(begin - original_begin); 
+  return static_cast<int>(begin - original_begin);
 }
 
 // Returns true if `v` is one of the chars allowed inside parentheses following
@@ -372,7 +372,7 @@ strings_internal::ParsedFloat ParseFloat(const char* begin, const char* end,
 
   int exponent_adjustment = 0;
   bool mantissa_is_inexact = false;
-  int pre_decimal_digits = ConsumeDigits<base>( 
+  int pre_decimal_digits = ConsumeDigits<base>(
       begin, end, MantissaDigitsMax<base>(), &mantissa, &mantissa_is_inexact);
   begin += pre_decimal_digits;
   int digits_left;
@@ -398,14 +398,14 @@ strings_internal::ParsedFloat ParseFloat(const char* begin, const char* end,
       while (begin < end && *begin == '0') {
         ++begin;
       }
-      int zeros_skipped = static_cast<int>(begin - begin_zeros); 
+      int zeros_skipped = static_cast<int>(begin - begin_zeros);
       if (zeros_skipped >= DigitLimit<base>()) {
         // refuse to parse pathological inputs
         return result;
       }
       exponent_adjustment -= static_cast<int>(zeros_skipped);
     }
-    int post_decimal_digits = ConsumeDigits<base>( 
+    int post_decimal_digits = ConsumeDigits<base>(
         begin, end, digits_left, &mantissa, &mantissa_is_inexact);
     begin += post_decimal_digits;
 
diff --git a/contrib/restricted/abseil-cpp/absl/strings/internal/cord_internal.cc b/contrib/restricted/abseil-cpp/absl/strings/internal/cord_internal.cc
index 2fdbd88583..1767e6fcc5 100644
--- a/contrib/restricted/abseil-cpp/absl/strings/internal/cord_internal.cc
+++ b/contrib/restricted/abseil-cpp/absl/strings/internal/cord_internal.cc
@@ -1,89 +1,89 @@
-// Copyright 2020 The Abseil Authors. 
-// 
-// Licensed under the Apache License, Version 2.0 (the "License"); 
-// you may not use this file except in compliance with the License. 
-// You may obtain a copy of the License at 
-// 
-//      https://www.apache.org/licenses/LICENSE-2.0 
-// 
-// Unless required by applicable law or agreed to in writing, software 
-// distributed under the License is distributed on an "AS IS" BASIS, 
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-// See the License for the specific language governing permissions and 
-// limitations under the License. 
-#include "absl/strings/internal/cord_internal.h" 
- 
-#include <atomic> 
-#include <cassert> 
-#include <memory> 
- 
-#include "absl/container/inlined_vector.h" 
+// Copyright 2020 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#include "absl/strings/internal/cord_internal.h"
+
+#include <atomic>
+#include <cassert>
+#include <memory>
+
+#include "absl/container/inlined_vector.h"
 #include "absl/strings/internal/cord_rep_btree.h"
-#include "absl/strings/internal/cord_rep_flat.h" 
-#include "absl/strings/internal/cord_rep_ring.h" 
- 
-namespace absl { 
-ABSL_NAMESPACE_BEGIN 
-namespace cord_internal { 
- 
+#include "absl/strings/internal/cord_rep_flat.h"
+#include "absl/strings/internal/cord_rep_ring.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace cord_internal {
+
 ABSL_CONST_INIT std::atomic<bool> cord_btree_enabled(kCordEnableBtreeDefault);
-ABSL_CONST_INIT std::atomic<bool> cord_ring_buffer_enabled( 
-    kCordEnableRingBufferDefault); 
-ABSL_CONST_INIT std::atomic<bool> shallow_subcords_enabled( 
-    kCordShallowSubcordsDefault); 
+ABSL_CONST_INIT std::atomic<bool> cord_ring_buffer_enabled(
+    kCordEnableRingBufferDefault);
+ABSL_CONST_INIT std::atomic<bool> shallow_subcords_enabled(
+    kCordShallowSubcordsDefault);
 ABSL_CONST_INIT std::atomic<bool> cord_btree_exhaustive_validation(false);
- 
-void CordRep::Destroy(CordRep* rep) { 
-  assert(rep != nullptr); 
- 
-  absl::InlinedVector<CordRep*, Constants::kInlinedVectorSize> pending; 
-  while (true) { 
-    assert(!rep->refcount.IsImmortal()); 
-    if (rep->tag == CONCAT) { 
-      CordRepConcat* rep_concat = rep->concat(); 
-      CordRep* right = rep_concat->right; 
-      if (!right->refcount.Decrement()) { 
-        pending.push_back(right); 
-      } 
-      CordRep* left = rep_concat->left; 
-      delete rep_concat; 
-      rep = nullptr; 
-      if (!left->refcount.Decrement()) { 
-        rep = left; 
-        continue; 
-      } 
+
+void CordRep::Destroy(CordRep* rep) {
+  assert(rep != nullptr);
+
+  absl::InlinedVector<CordRep*, Constants::kInlinedVectorSize> pending;
+  while (true) {
+    assert(!rep->refcount.IsImmortal());
+    if (rep->tag == CONCAT) {
+      CordRepConcat* rep_concat = rep->concat();
+      CordRep* right = rep_concat->right;
+      if (!right->refcount.Decrement()) {
+        pending.push_back(right);
+      }
+      CordRep* left = rep_concat->left;
+      delete rep_concat;
+      rep = nullptr;
+      if (!left->refcount.Decrement()) {
+        rep = left;
+        continue;
+      }
     } else if (rep->tag == BTREE) {
       CordRepBtree::Destroy(rep->btree());
       rep = nullptr;
-    } else if (rep->tag == RING) { 
-      CordRepRing::Destroy(rep->ring()); 
-      rep = nullptr; 
-    } else if (rep->tag == EXTERNAL) { 
-      CordRepExternal::Delete(rep); 
-      rep = nullptr; 
-    } else if (rep->tag == SUBSTRING) { 
-      CordRepSubstring* rep_substring = rep->substring(); 
-      CordRep* child = rep_substring->child; 
-      delete rep_substring; 
-      rep = nullptr; 
-      if (!child->refcount.Decrement()) { 
-        rep = child; 
-        continue; 
-      } 
-    } else { 
-      CordRepFlat::Delete(rep); 
-      rep = nullptr; 
-    } 
- 
-    if (!pending.empty()) { 
-      rep = pending.back(); 
-      pending.pop_back(); 
-    } else { 
-      break; 
-    } 
-  } 
-} 
- 
-}  // namespace cord_internal 
-ABSL_NAMESPACE_END 
-}  // namespace absl 
+    } else if (rep->tag == RING) {
+      CordRepRing::Destroy(rep->ring());
+      rep = nullptr;
+    } else if (rep->tag == EXTERNAL) {
+      CordRepExternal::Delete(rep);
+      rep = nullptr;
+    } else if (rep->tag == SUBSTRING) {
+      CordRepSubstring* rep_substring = rep->substring();
+      CordRep* child = rep_substring->child;
+      delete rep_substring;
+      rep = nullptr;
+      if (!child->refcount.Decrement()) {
+        rep = child;
+        continue;
+      }
+    } else {
+      CordRepFlat::Delete(rep);
+      rep = nullptr;
+    }
+
+    if (!pending.empty()) {
+      rep = pending.back();
+      pending.pop_back();
+    } else {
+      break;
+    }
+  }
+}
+
+}  // namespace cord_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
diff --git a/contrib/restricted/abseil-cpp/absl/strings/internal/cord_internal.h b/contrib/restricted/abseil-cpp/absl/strings/internal/cord_internal.h
index 6aaad5021a..bfe5564e46 100644
--- a/contrib/restricted/abseil-cpp/absl/strings/internal/cord_internal.h
+++ b/contrib/restricted/abseil-cpp/absl/strings/internal/cord_internal.h
@@ -1,4 +1,4 @@
-// Copyright 2021 The Abseil Authors. 
+// Copyright 2021 The Abseil Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -21,10 +21,10 @@
 #include <cstdint>
 #include <type_traits>
 
-#include "absl/base/config.h" 
-#include "absl/base/internal/endian.h" 
+#include "absl/base/config.h"
+#include "absl/base/internal/endian.h"
 #include "absl/base/internal/invoke.h"
-#include "absl/base/optimization.h" 
+#include "absl/base/optimization.h"
 #include "absl/container/internal/compressed_tuple.h"
 #include "absl/meta/type_traits.h"
 #include "absl/strings/string_view.h"
@@ -33,19 +33,19 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace cord_internal {
 
-class CordzInfo; 
- 
-// Default feature enable states for cord ring buffers 
-enum CordFeatureDefaults { 
+class CordzInfo;
+
+// Default feature enable states for cord ring buffers
+enum CordFeatureDefaults {
   kCordEnableBtreeDefault = true,
-  kCordEnableRingBufferDefault = false, 
-  kCordShallowSubcordsDefault = false 
-}; 
- 
+  kCordEnableRingBufferDefault = false,
+  kCordShallowSubcordsDefault = false
+};
+
 extern std::atomic<bool> cord_btree_enabled;
-extern std::atomic<bool> cord_ring_buffer_enabled; 
-extern std::atomic<bool> shallow_subcords_enabled; 
- 
+extern std::atomic<bool> cord_ring_buffer_enabled;
+extern std::atomic<bool> shallow_subcords_enabled;
+
 // `cord_btree_exhaustive_validation` can be set to force exhaustive validation
 // in debug assertions, and code that calls `IsValid()` explicitly. By default,
 // assertions should be relatively cheap and AssertValid() can easily lead to
@@ -56,48 +56,48 @@ inline void enable_cord_btree(bool enable) {
   cord_btree_enabled.store(enable, std::memory_order_relaxed);
 }
 
-inline void enable_cord_ring_buffer(bool enable) { 
-  cord_ring_buffer_enabled.store(enable, std::memory_order_relaxed); 
-} 
- 
-inline void enable_shallow_subcords(bool enable) { 
-  shallow_subcords_enabled.store(enable, std::memory_order_relaxed); 
-} 
- 
-enum Constants { 
-  // The inlined size to use with absl::InlinedVector. 
-  // 
-  // Note: The InlinedVectors in this file (and in cord.h) do not need to use 
-  // the same value for their inlined size. The fact that they do is historical. 
-  // It may be desirable for each to use a different inlined size optimized for 
-  // that InlinedVector's usage. 
-  // 
-  // TODO(jgm): Benchmark to see if there's a more optimal value than 47 for 
-  // the inlined vector size (47 exists for backward compatibility). 
-  kInlinedVectorSize = 47, 
- 
-  // Prefer copying blocks of at most this size, otherwise reference count. 
-  kMaxBytesToCopy = 511 
-}; 
- 
+inline void enable_cord_ring_buffer(bool enable) {
+  cord_ring_buffer_enabled.store(enable, std::memory_order_relaxed);
+}
+
+inline void enable_shallow_subcords(bool enable) {
+  shallow_subcords_enabled.store(enable, std::memory_order_relaxed);
+}
+
+enum Constants {
+  // The inlined size to use with absl::InlinedVector.
+  //
+  // Note: The InlinedVectors in this file (and in cord.h) do not need to use
+  // the same value for their inlined size. The fact that they do is historical.
+  // It may be desirable for each to use a different inlined size optimized for
+  // that InlinedVector's usage.
+  //
+  // TODO(jgm): Benchmark to see if there's a more optimal value than 47 for
+  // the inlined vector size (47 exists for backward compatibility).
+  kInlinedVectorSize = 47,
+
+  // Prefer copying blocks of at most this size, otherwise reference count.
+  kMaxBytesToCopy = 511
+};
+
 // Compact class for tracking the reference count and state flags for CordRep
 // instances.  Data is stored in an atomic int32_t for compactness and speed.
 class RefcountAndFlags {
  public:
   constexpr RefcountAndFlags() : count_{kRefIncrement} {}
-  struct Immortal {}; 
+  struct Immortal {};
   explicit constexpr RefcountAndFlags(Immortal) : count_(kImmortalFlag) {}
   struct WithCrc {};
   explicit constexpr RefcountAndFlags(WithCrc)
       : count_(kCrcFlag | kRefIncrement) {}
 
-  // Increments the reference count. Imposes no memory ordering. 
-  inline void Increment() { 
-    count_.fetch_add(kRefIncrement, std::memory_order_relaxed); 
-  } 
+  // Increments the reference count. Imposes no memory ordering.
+  inline void Increment() {
+    count_.fetch_add(kRefIncrement, std::memory_order_relaxed);
+  }
 
   // Asserts that the current refcount is greater than 0. If the refcount is
-  // greater than 1, decrements the reference count. 
+  // greater than 1, decrements the reference count.
   //
   // Returns false if there are no references outstanding; true otherwise.
   // Inserts barriers to ensure that state written before this method returns
@@ -106,24 +106,24 @@ class RefcountAndFlags {
   inline bool Decrement() {
     int32_t refcount = count_.load(std::memory_order_acquire) & kRefcountMask;
     assert(refcount > 0 || refcount & kImmortalFlag);
-    return refcount != kRefIncrement && 
+    return refcount != kRefIncrement &&
            (count_.fetch_sub(kRefIncrement, std::memory_order_acq_rel) &
             kRefcountMask) != kRefIncrement;
   }
 
   // Same as Decrement but expect that refcount is greater than 1.
   inline bool DecrementExpectHighRefcount() {
-    int32_t refcount = 
+    int32_t refcount =
         count_.fetch_sub(kRefIncrement, std::memory_order_acq_rel) &
         kRefcountMask;
     assert(refcount > 0 || refcount & kImmortalFlag);
-    return refcount != kRefIncrement; 
+    return refcount != kRefIncrement;
   }
 
   // Returns the current reference count using acquire semantics.
-  inline int32_t Get() const { 
+  inline int32_t Get() const {
     return count_.load(std::memory_order_acquire) >> kNumFlags;
-  } 
+  }
 
   // Returns true if the referenced object carries a CRC value.
   bool HasCrc() const {
@@ -151,22 +151,22 @@ class RefcountAndFlags {
   //
   // When this returns true, there are no other references, and data sinks
   // may safely adopt the children of the CordRep.
-  inline bool IsOne() { 
+  inline bool IsOne() {
     return (count_.load(std::memory_order_acquire) & kRefcountMask) ==
            kRefIncrement;
-  } 
+  }
 
-  bool IsImmortal() const { 
+  bool IsImmortal() const {
     return (count_.load(std::memory_order_relaxed) & kImmortalFlag) != 0;
-  } 
- 
+  }
+
  private:
   // We reserve the bottom bits for flags.
   // kImmortalBit indicates that this entity should never be collected; it is
   // used for the StringConstant constructor to avoid collecting immutable
   // constant cords.
   // kReservedFlag is reserved for future use.
-  enum { 
+  enum {
     kNumFlags = 2,
 
     kImmortalFlag = 0x1,
@@ -178,8 +178,8 @@ class RefcountAndFlags {
     // purposes of equality.  (A refcount of 0 or 1 does not count as 0 or 1
     // if the immortal bit is set.)
     kRefcountMask = ~kCrcFlag,
-  }; 
- 
+  };
+
   std::atomic<int32_t> count_;
 };
 
@@ -189,26 +189,26 @@ class RefcountAndFlags {
 // functions in the base class.
 
 struct CordRepConcat;
-struct CordRepExternal; 
-struct CordRepFlat; 
+struct CordRepExternal;
+struct CordRepFlat;
 struct CordRepSubstring;
-class CordRepRing; 
+class CordRepRing;
 class CordRepBtree;
 
 // Various representations that we allow
 enum CordRepKind {
-  CONCAT = 0, 
+  CONCAT = 0,
   SUBSTRING = 1,
   BTREE = 2,
-  RING = 3, 
+  RING = 3,
   EXTERNAL = 4,
 
   // We have different tags for different sized flat arrays,
   // starting with FLAT, and limited to MAX_FLAT_TAG. The 225 value is based on
-  // the current 'size to tag' encoding of 8 / 32 bytes. If a new tag is needed 
-  // in the future, then 'FLAT' and 'MAX_FLAT_TAG' should be adjusted as well 
-  // as the Tag <---> Size logic so that FLAT stil represents the minimum flat 
-  // allocation size. (32 bytes as of now). 
+  // the current 'size to tag' encoding of 8 / 32 bytes. If a new tag is needed
+  // in the future, then 'FLAT' and 'MAX_FLAT_TAG' should be adjusted as well
+  // as the Tag <---> Size logic so that FLAT stil represents the minimum flat
+  // allocation size. (32 bytes as of now).
   FLAT = 5,
   MAX_FLAT_TAG = 225
 };
@@ -225,10 +225,10 @@ static_assert(EXTERNAL == RING + 1, "BTREE and EXTERNAL not consecutive");
 static_assert(FLAT == EXTERNAL + 1, "EXTERNAL and FLAT not consecutive");
 
 struct CordRep {
-  CordRep() = default; 
+  CordRep() = default;
   constexpr CordRep(RefcountAndFlags::Immortal immortal, size_t l)
-      : length(l), refcount(immortal), tag(EXTERNAL), storage{} {} 
- 
+      : length(l), refcount(immortal), tag(EXTERNAL), storage{} {}
+
   // The following three fields have to be less than 32 bytes since
   // that is the smallest supported flat node size.
   size_t length;
@@ -255,32 +255,32 @@ struct CordRep {
   constexpr bool IsFlat() const { return tag >= FLAT; }
   constexpr bool IsBtree() const { return tag == BTREE; }
 
-  inline CordRepRing* ring(); 
-  inline const CordRepRing* ring() const; 
+  inline CordRepRing* ring();
+  inline const CordRepRing* ring() const;
   inline CordRepConcat* concat();
   inline const CordRepConcat* concat() const;
   inline CordRepSubstring* substring();
   inline const CordRepSubstring* substring() const;
   inline CordRepExternal* external();
   inline const CordRepExternal* external() const;
-  inline CordRepFlat* flat(); 
-  inline const CordRepFlat* flat() const; 
+  inline CordRepFlat* flat();
+  inline const CordRepFlat* flat() const;
   inline CordRepBtree* btree();
   inline const CordRepBtree* btree() const;
- 
-  // -------------------------------------------------------------------- 
-  // Memory management 
- 
-  // Destroys the provided `rep`. 
-  static void Destroy(CordRep* rep); 
- 
-  // Increments the reference count of `rep`. 
-  // Requires `rep` to be a non-null pointer value. 
-  static inline CordRep* Ref(CordRep* rep); 
- 
-  // Decrements the reference count of `rep`. Destroys rep if count reaches 
-  // zero. Requires `rep` to be a non-null pointer value. 
-  static inline void Unref(CordRep* rep); 
+
+  // --------------------------------------------------------------------
+  // Memory management
+
+  // Destroys the provided `rep`.
+  static void Destroy(CordRep* rep);
+
+  // Increments the reference count of `rep`.
+  // Requires `rep` to be a non-null pointer value.
+  static inline CordRep* Ref(CordRep* rep);
+
+  // Decrements the reference count of `rep`. Destroys rep if count reaches
+  // zero. Requires `rep` to be a non-null pointer value.
+  static inline void Unref(CordRep* rep);
 };
 
 struct CordRepConcat : public CordRep {
@@ -304,19 +304,19 @@ using ExternalReleaserInvoker = void (*)(CordRepExternal*);
 // External CordReps are allocated together with a type erased releaser. The
 // releaser is stored in the memory directly following the CordRepExternal.
 struct CordRepExternal : public CordRep {
-  CordRepExternal() = default; 
-  explicit constexpr CordRepExternal(absl::string_view str) 
+  CordRepExternal() = default;
+  explicit constexpr CordRepExternal(absl::string_view str)
       : CordRep(RefcountAndFlags::Immortal{}, str.size()),
-        base(str.data()), 
-        releaser_invoker(nullptr) {} 
- 
+        base(str.data()),
+        releaser_invoker(nullptr) {}
+
   const char* base;
   // Pointer to function that knows how to call and destroy the releaser.
   ExternalReleaserInvoker releaser_invoker;
- 
-  // Deletes (releases) the external rep. 
+
+  // Deletes (releases) the external rep.
   // Requires rep != nullptr and rep->IsExternal()
-  static void Delete(CordRep* rep); 
+  static void Delete(CordRep* rep);
 };
 
 struct Rank1 {};
@@ -357,90 +357,90 @@ struct CordRepExternalImpl
   }
 };
 
-inline void CordRepExternal::Delete(CordRep* rep) { 
+inline void CordRepExternal::Delete(CordRep* rep) {
   assert(rep != nullptr && rep->IsExternal());
-  auto* rep_external = static_cast<CordRepExternal*>(rep); 
-  assert(rep_external->releaser_invoker != nullptr); 
-  rep_external->releaser_invoker(rep_external); 
-} 
- 
-template <typename Str> 
-struct ConstInitExternalStorage { 
-  ABSL_CONST_INIT static CordRepExternal value; 
-}; 
- 
-template <typename Str> 
-CordRepExternal ConstInitExternalStorage<Str>::value(Str::value); 
- 
+  auto* rep_external = static_cast<CordRepExternal*>(rep);
+  assert(rep_external->releaser_invoker != nullptr);
+  rep_external->releaser_invoker(rep_external);
+}
+
+template <typename Str>
+struct ConstInitExternalStorage {
+  ABSL_CONST_INIT static CordRepExternal value;
+};
+
+template <typename Str>
+CordRepExternal ConstInitExternalStorage<Str>::value(Str::value);
+
 enum {
   kMaxInline = 15,
 };
 
-constexpr char GetOrNull(absl::string_view data, size_t pos) { 
-  return pos < data.size() ? data[pos] : '\0'; 
-} 
- 
-// We store cordz_info as 64 bit pointer value in big endian format. This 
-// guarantees that the least significant byte of cordz_info matches the last 
-// byte of the inline data representation in as_chars_, which holds the inlined 
-// size or the 'is_tree' bit. 
-using cordz_info_t = int64_t; 
- 
-// Assert that the `cordz_info` pointer value perfectly overlaps the last half 
-// of `as_chars_` and can hold a pointer value. 
-static_assert(sizeof(cordz_info_t) * 2 == kMaxInline + 1, ""); 
-static_assert(sizeof(cordz_info_t) >= sizeof(intptr_t), ""); 
- 
-// BigEndianByte() creates a big endian representation of 'value', i.e.: a big 
-// endian value where the last byte in the host's representation holds 'value`, 
-// with all other bytes being 0. 
-static constexpr cordz_info_t BigEndianByte(unsigned char value) { 
-#if defined(ABSL_IS_BIG_ENDIAN) 
-  return value; 
-#else 
-  return static_cast<cordz_info_t>(value) << ((sizeof(cordz_info_t) - 1) * 8); 
-#endif 
-} 
- 
-class InlineData { 
- public: 
+constexpr char GetOrNull(absl::string_view data, size_t pos) {
+  return pos < data.size() ? data[pos] : '\0';
+}
+
+// We store cordz_info as 64 bit pointer value in big endian format. This
+// guarantees that the least significant byte of cordz_info matches the last
+// byte of the inline data representation in as_chars_, which holds the inlined
+// size or the 'is_tree' bit.
+using cordz_info_t = int64_t;
+
+// Assert that the `cordz_info` pointer value perfectly overlaps the last half
+// of `as_chars_` and can hold a pointer value.
+static_assert(sizeof(cordz_info_t) * 2 == kMaxInline + 1, "");
+static_assert(sizeof(cordz_info_t) >= sizeof(intptr_t), "");
+
+// BigEndianByte() creates a big endian representation of 'value', i.e.: a big
+// endian value where the last byte in the host's representation holds 'value`,
+// with all other bytes being 0.
+static constexpr cordz_info_t BigEndianByte(unsigned char value) {
+#if defined(ABSL_IS_BIG_ENDIAN)
+  return value;
+#else
+  return static_cast<cordz_info_t>(value) << ((sizeof(cordz_info_t) - 1) * 8);
+#endif
+}
+
+class InlineData {
+ public:
   // DefaultInitType forces the use of the default initialization constructor.
   enum DefaultInitType { kDefaultInit };
 
-  // kNullCordzInfo holds the big endian representation of intptr_t(1) 
-  // This is the 'null' / initial value of 'cordz_info'. The null value 
-  // is specifically big endian 1 as with 64-bit pointers, the last 
-  // byte of cordz_info overlaps with the last byte holding the tag. 
-  static constexpr cordz_info_t kNullCordzInfo = BigEndianByte(1); 
- 
-  constexpr InlineData() : as_chars_{0} {} 
+  // kNullCordzInfo holds the big endian representation of intptr_t(1)
+  // This is the 'null' / initial value of 'cordz_info'. The null value
+  // is specifically big endian 1 as with 64-bit pointers, the last
+  // byte of cordz_info overlaps with the last byte holding the tag.
+  static constexpr cordz_info_t kNullCordzInfo = BigEndianByte(1);
+
+  constexpr InlineData() : as_chars_{0} {}
   explicit InlineData(DefaultInitType) {}
-  explicit constexpr InlineData(CordRep* rep) : as_tree_(rep) {} 
-  explicit constexpr InlineData(absl::string_view chars) 
-      : as_chars_{ 
-            GetOrNull(chars, 0),  GetOrNull(chars, 1), 
-            GetOrNull(chars, 2),  GetOrNull(chars, 3), 
-            GetOrNull(chars, 4),  GetOrNull(chars, 5), 
-            GetOrNull(chars, 6),  GetOrNull(chars, 7), 
-            GetOrNull(chars, 8),  GetOrNull(chars, 9), 
-            GetOrNull(chars, 10), GetOrNull(chars, 11), 
-            GetOrNull(chars, 12), GetOrNull(chars, 13), 
-            GetOrNull(chars, 14), static_cast<char>((chars.size() << 1))} {} 
- 
-  // Returns true if the current instance is empty. 
-  // The 'empty value' is an inlined data value of zero length. 
-  bool is_empty() const { return tag() == 0; } 
- 
-  // Returns true if the current instance holds a tree value. 
-  bool is_tree() const { return (tag() & 1) != 0; } 
- 
-  // Returns true if the current instance holds a cordz_info value. 
-  // Requires the current instance to hold a tree value. 
-  bool is_profiled() const { 
-    assert(is_tree()); 
-    return as_tree_.cordz_info != kNullCordzInfo; 
-  } 
- 
+  explicit constexpr InlineData(CordRep* rep) : as_tree_(rep) {}
+  explicit constexpr InlineData(absl::string_view chars)
+      : as_chars_{
+            GetOrNull(chars, 0),  GetOrNull(chars, 1),
+            GetOrNull(chars, 2),  GetOrNull(chars, 3),
+            GetOrNull(chars, 4),  GetOrNull(chars, 5),
+            GetOrNull(chars, 6),  GetOrNull(chars, 7),
+            GetOrNull(chars, 8),  GetOrNull(chars, 9),
+            GetOrNull(chars, 10), GetOrNull(chars, 11),
+            GetOrNull(chars, 12), GetOrNull(chars, 13),
+            GetOrNull(chars, 14), static_cast<char>((chars.size() << 1))} {}
+
+  // Returns true if the current instance is empty.
+  // The 'empty value' is an inlined data value of zero length.
+  bool is_empty() const { return tag() == 0; }
+
+  // Returns true if the current instance holds a tree value.
+  bool is_tree() const { return (tag() & 1) != 0; }
+
+  // Returns true if the current instance holds a cordz_info value.
+  // Requires the current instance to hold a tree value.
+  bool is_profiled() const {
+    assert(is_tree());
+    return as_tree_.cordz_info != kNullCordzInfo;
+  }
+
   // Returns true if either of the provided instances hold a cordz_info value.
   // This method is more efficient than the equivalent `data1.is_profiled() ||
   // data2.is_profiled()`. Requires both arguments to hold a tree.
@@ -451,170 +451,170 @@ class InlineData {
            kNullCordzInfo;
   }
 
-  // Returns the cordz_info sampling instance for this instance, or nullptr 
-  // if the current instance is not sampled and does not have CordzInfo data. 
-  // Requires the current instance to hold a tree value. 
-  CordzInfo* cordz_info() const { 
-    assert(is_tree()); 
-    intptr_t info = 
-        static_cast<intptr_t>(absl::big_endian::ToHost64(as_tree_.cordz_info)); 
-    assert(info & 1); 
-    return reinterpret_cast<CordzInfo*>(info - 1); 
-  } 
- 
-  // Sets the current cordz_info sampling instance for this instance, or nullptr 
-  // if the current instance is not sampled and does not have CordzInfo data. 
-  // Requires the current instance to hold a tree value. 
-  void set_cordz_info(CordzInfo* cordz_info) { 
-    assert(is_tree()); 
-    intptr_t info = reinterpret_cast<intptr_t>(cordz_info) | 1; 
-    as_tree_.cordz_info = absl::big_endian::FromHost64(info); 
-  } 
- 
-  // Resets the current cordz_info to null / empty. 
-  void clear_cordz_info() { 
-    assert(is_tree()); 
-    as_tree_.cordz_info = kNullCordzInfo; 
-  } 
- 
-  // Returns a read only pointer to the character data inside this instance. 
-  // Requires the current instance to hold inline data. 
-  const char* as_chars() const { 
-    assert(!is_tree()); 
-    return as_chars_; 
-  } 
- 
-  // Returns a mutable pointer to the character data inside this instance. 
-  // Should be used for 'write only' operations setting an inlined value. 
-  // Applications can set the value of inlined data either before or after 
-  // setting the inlined size, i.e., both of the below are valid: 
-  // 
-  //   // Set inlined data and inline size 
-  //   memcpy(data_.as_chars(), data, size); 
-  //   data_.set_inline_size(size); 
-  // 
-  //   // Set inlined size and inline data 
-  //   data_.set_inline_size(size); 
-  //   memcpy(data_.as_chars(), data, size); 
-  // 
-  // It's an error to read from the returned pointer without a preceding write 
-  // if the current instance does not hold inline data, i.e.: is_tree() == true. 
-  char* as_chars() { return as_chars_; } 
- 
-  // Returns the tree value of this value. 
-  // Requires the current instance to hold a tree value. 
-  CordRep* as_tree() const { 
-    assert(is_tree()); 
-    return as_tree_.rep; 
-  } 
- 
-  // Initialize this instance to holding the tree value `rep`, 
-  // initializing the cordz_info to null, i.e.: 'not profiled'. 
-  void make_tree(CordRep* rep) { 
-    as_tree_.rep = rep; 
-    as_tree_.cordz_info = kNullCordzInfo; 
-  } 
- 
-  // Set the tree value of this instance to 'rep`. 
-  // Requires the current instance to already hold a tree value. 
-  // Does not affect the value of cordz_info. 
-  void set_tree(CordRep* rep) { 
-    assert(is_tree()); 
-    as_tree_.rep = rep; 
-  } 
- 
-  // Returns the size of the inlined character data inside this instance. 
-  // Requires the current instance to hold inline data. 
-  size_t inline_size() const { 
-    assert(!is_tree()); 
-    return tag() >> 1; 
-  } 
- 
-  // Sets the size of the inlined character data inside this instance. 
-  // Requires `size` to be <= kMaxInline. 
-  // See the documentation on 'as_chars()' for more information and examples. 
-  void set_inline_size(size_t size) { 
-    ABSL_ASSERT(size <= kMaxInline); 
-    tag() = static_cast<char>(size << 1); 
-  } 
- 
- private: 
-  // See cordz_info_t for forced alignment and size of `cordz_info` details. 
-  struct AsTree { 
-    explicit constexpr AsTree(absl::cord_internal::CordRep* tree) 
-        : rep(tree), cordz_info(kNullCordzInfo) {} 
-    // This union uses up extra space so that whether rep is 32 or 64 bits, 
-    // cordz_info will still start at the eighth byte, and the last 
-    // byte of cordz_info will still be the last byte of InlineData. 
-    union { 
-      absl::cord_internal::CordRep* rep; 
-      cordz_info_t unused_aligner; 
-    }; 
-    cordz_info_t cordz_info; 
-  }; 
- 
-  char& tag() { return reinterpret_cast<char*>(this)[kMaxInline]; } 
-  char tag() const { return reinterpret_cast<const char*>(this)[kMaxInline]; } 
- 
-  // If the data has length <= kMaxInline, we store it in `as_chars_`, and 
-  // store the size in the last char of `as_chars_` shifted left + 1. 
-  // Else we store it in a tree and store a pointer to that tree in 
-  // `as_tree_.rep` and store a tag in `tagged_size`. 
+  // Returns the cordz_info sampling instance for this instance, or nullptr
+  // if the current instance is not sampled and does not have CordzInfo data.
+  // Requires the current instance to hold a tree value.
+  CordzInfo* cordz_info() const {
+    assert(is_tree());
+    intptr_t info =
+        static_cast<intptr_t>(absl::big_endian::ToHost64(as_tree_.cordz_info));
+    assert(info & 1);
+    return reinterpret_cast<CordzInfo*>(info - 1);
+  }
+
+  // Sets the current cordz_info sampling instance for this instance, or nullptr
+  // if the current instance is not sampled and does not have CordzInfo data.
+  // Requires the current instance to hold a tree value.
+  void set_cordz_info(CordzInfo* cordz_info) {
+    assert(is_tree());
+    intptr_t info = reinterpret_cast<intptr_t>(cordz_info) | 1;
+    as_tree_.cordz_info = absl::big_endian::FromHost64(info);
+  }
+
+  // Resets the current cordz_info to null / empty.
+  void clear_cordz_info() {
+    assert(is_tree());
+    as_tree_.cordz_info = kNullCordzInfo;
+  }
+
+  // Returns a read only pointer to the character data inside this instance.
+  // Requires the current instance to hold inline data.
+  const char* as_chars() const {
+    assert(!is_tree());
+    return as_chars_;
+  }
+
+  // Returns a mutable pointer to the character data inside this instance.
+  // Should be used for 'write only' operations setting an inlined value.
+  // Applications can set the value of inlined data either before or after
+  // setting the inlined size, i.e., both of the below are valid:
+  //
+  //   // Set inlined data and inline size
+  //   memcpy(data_.as_chars(), data, size);
+  //   data_.set_inline_size(size);
+  //
+  //   // Set inlined size and inline data
+  //   data_.set_inline_size(size);
+  //   memcpy(data_.as_chars(), data, size);
+  //
+  // It's an error to read from the returned pointer without a preceding write
+  // if the current instance does not hold inline data, i.e.: is_tree() == true.
+  char* as_chars() { return as_chars_; }
+
+  // Returns the tree value of this value.
+  // Requires the current instance to hold a tree value.
+  CordRep* as_tree() const {
+    assert(is_tree());
+    return as_tree_.rep;
+  }
+
+  // Initialize this instance to holding the tree value `rep`,
+  // initializing the cordz_info to null, i.e.: 'not profiled'.
+  void make_tree(CordRep* rep) {
+    as_tree_.rep = rep;
+    as_tree_.cordz_info = kNullCordzInfo;
+  }
+
+  // Set the tree value of this instance to 'rep`.
+  // Requires the current instance to already hold a tree value.
+  // Does not affect the value of cordz_info.
+  void set_tree(CordRep* rep) {
+    assert(is_tree());
+    as_tree_.rep = rep;
+  }
+
+  // Returns the size of the inlined character data inside this instance.
+  // Requires the current instance to hold inline data.
+  size_t inline_size() const {
+    assert(!is_tree());
+    return tag() >> 1;
+  }
+
+  // Sets the size of the inlined character data inside this instance.
+  // Requires `size` to be <= kMaxInline.
+  // See the documentation on 'as_chars()' for more information and examples.
+  void set_inline_size(size_t size) {
+    ABSL_ASSERT(size <= kMaxInline);
+    tag() = static_cast<char>(size << 1);
+  }
+
+ private:
+  // See cordz_info_t for forced alignment and size of `cordz_info` details.
+  struct AsTree {
+    explicit constexpr AsTree(absl::cord_internal::CordRep* tree)
+        : rep(tree), cordz_info(kNullCordzInfo) {}
+    // This union uses up extra space so that whether rep is 32 or 64 bits,
+    // cordz_info will still start at the eighth byte, and the last
+    // byte of cordz_info will still be the last byte of InlineData.
+    union {
+      absl::cord_internal::CordRep* rep;
+      cordz_info_t unused_aligner;
+    };
+    cordz_info_t cordz_info;
+  };
+
+  char& tag() { return reinterpret_cast<char*>(this)[kMaxInline]; }
+  char tag() const { return reinterpret_cast<const char*>(this)[kMaxInline]; }
+
+  // If the data has length <= kMaxInline, we store it in `as_chars_`, and
+  // store the size in the last char of `as_chars_` shifted left + 1.
+  // Else we store it in a tree and store a pointer to that tree in
+  // `as_tree_.rep` and store a tag in `tagged_size`.
   union {
-    char as_chars_[kMaxInline + 1]; 
-    AsTree as_tree_; 
-  }; 
+    char as_chars_[kMaxInline + 1];
+    AsTree as_tree_;
+  };
 };
 
 static_assert(sizeof(InlineData) == kMaxInline + 1, "");
 
-inline CordRepConcat* CordRep::concat() { 
+inline CordRepConcat* CordRep::concat() {
   assert(IsConcat());
-  return static_cast<CordRepConcat*>(this); 
-} 
- 
-inline const CordRepConcat* CordRep::concat() const { 
+  return static_cast<CordRepConcat*>(this);
+}
+
+inline const CordRepConcat* CordRep::concat() const {
   assert(IsConcat());
-  return static_cast<const CordRepConcat*>(this); 
-} 
- 
-inline CordRepSubstring* CordRep::substring() { 
+  return static_cast<const CordRepConcat*>(this);
+}
+
+inline CordRepSubstring* CordRep::substring() {
   assert(IsSubstring());
-  return static_cast<CordRepSubstring*>(this); 
-} 
- 
-inline const CordRepSubstring* CordRep::substring() const { 
+  return static_cast<CordRepSubstring*>(this);
+}
+
+inline const CordRepSubstring* CordRep::substring() const {
   assert(IsSubstring());
-  return static_cast<const CordRepSubstring*>(this); 
-} 
- 
-inline CordRepExternal* CordRep::external() { 
+  return static_cast<const CordRepSubstring*>(this);
+}
+
+inline CordRepExternal* CordRep::external() {
   assert(IsExternal());
-  return static_cast<CordRepExternal*>(this); 
-} 
- 
-inline const CordRepExternal* CordRep::external() const { 
+  return static_cast<CordRepExternal*>(this);
+}
+
+inline const CordRepExternal* CordRep::external() const {
   assert(IsExternal());
-  return static_cast<const CordRepExternal*>(this); 
-} 
- 
-inline CordRep* CordRep::Ref(CordRep* rep) { 
-  assert(rep != nullptr); 
-  rep->refcount.Increment(); 
-  return rep; 
-} 
- 
-inline void CordRep::Unref(CordRep* rep) { 
-  assert(rep != nullptr); 
-  // Expect refcount to be 0. Avoiding the cost of an atomic decrement should 
-  // typically outweigh the cost of an extra branch checking for ref == 1. 
-  if (ABSL_PREDICT_FALSE(!rep->refcount.DecrementExpectHighRefcount())) { 
-    Destroy(rep); 
-  } 
-} 
- 
+  return static_cast<const CordRepExternal*>(this);
+}
+
+inline CordRep* CordRep::Ref(CordRep* rep) {
+  assert(rep != nullptr);
+  rep->refcount.Increment();
+  return rep;
+}
+
+inline void CordRep::Unref(CordRep* rep) {
+  assert(rep != nullptr);
+  // Expect refcount to be 0. Avoiding the cost of an atomic decrement should
+  // typically outweigh the cost of an extra branch checking for ref == 1.
+  if (ABSL_PREDICT_FALSE(!rep->refcount.DecrementExpectHighRefcount())) {
+    Destroy(rep);
+  }
+}
+
 }  // namespace cord_internal
- 
+
 ABSL_NAMESPACE_END
 }  // namespace absl
 #endif  // ABSL_STRINGS_INTERNAL_CORD_INTERNAL_H_
diff --git a/contrib/restricted/abseil-cpp/absl/strings/internal/cord_rep_flat.h b/contrib/restricted/abseil-cpp/absl/strings/internal/cord_rep_flat.h
index c9249798a1..4d0f988697 100644
--- a/contrib/restricted/abseil-cpp/absl/strings/internal/cord_rep_flat.h
+++ b/contrib/restricted/abseil-cpp/absl/strings/internal/cord_rep_flat.h
@@ -1,146 +1,146 @@
-// Copyright 2020 The Abseil Authors 
-// 
-// Licensed under the Apache License, Version 2.0 (the "License"); 
-// you may not use this file except in compliance with the License. 
-// You may obtain a copy of the License at 
-// 
-//     https://www.apache.org/licenses/LICENSE-2.0 
-// 
-// Unless required by applicable law or agreed to in writing, software 
-// distributed under the License is distributed on an "AS IS" BASIS, 
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-// See the License for the specific language governing permissions and 
-// limitations under the License. 
- 
-#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_FLAT_H_ 
-#define ABSL_STRINGS_INTERNAL_CORD_REP_FLAT_H_ 
- 
-#include <cassert> 
-#include <cstddef> 
-#include <cstdint> 
-#include <memory> 
- 
-#include "absl/strings/internal/cord_internal.h" 
- 
-namespace absl { 
-ABSL_NAMESPACE_BEGIN 
-namespace cord_internal { 
- 
-// Note: all constants below are never ODR used and internal to cord, we define 
-// these as static constexpr to avoid 'in struct' definition and usage clutter. 
- 
-// Largest and smallest flat node lengths we are willing to allocate 
-// Flat allocation size is stored in tag, which currently can encode sizes up 
-// to 4K, encoded as multiple of either 8 or 32 bytes. 
-// If we allow for larger sizes, we need to change this to 8/64, 16/128, etc. 
-// kMinFlatSize is bounded by tag needing to be at least FLAT * 8 bytes, and 
-// ideally a 'nice' size aligning with allocation and cacheline sizes like 32. 
-// kMaxFlatSize is bounded by the size resulting in a computed tag no greater 
-// than MAX_FLAT_TAG. MAX_FLAT_TAG provides for additional 'high' tag values. 
-static constexpr size_t kFlatOverhead = offsetof(CordRep, storage); 
-static constexpr size_t kMinFlatSize = 32; 
-static constexpr size_t kMaxFlatSize = 4096; 
-static constexpr size_t kMaxFlatLength = kMaxFlatSize - kFlatOverhead; 
-static constexpr size_t kMinFlatLength = kMinFlatSize - kFlatOverhead; 
- 
-constexpr uint8_t AllocatedSizeToTagUnchecked(size_t size) { 
+// Copyright 2020 The Abseil Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_FLAT_H_
+#define ABSL_STRINGS_INTERNAL_CORD_REP_FLAT_H_
+
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+
+#include "absl/strings/internal/cord_internal.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace cord_internal {
+
+// Note: all constants below are never ODR used and internal to cord, we define
+// these as static constexpr to avoid 'in struct' definition and usage clutter.
+
+// Largest and smallest flat node lengths we are willing to allocate
+// Flat allocation size is stored in tag, which currently can encode sizes up
+// to 4K, encoded as multiple of either 8 or 32 bytes.
+// If we allow for larger sizes, we need to change this to 8/64, 16/128, etc.
+// kMinFlatSize is bounded by tag needing to be at least FLAT * 8 bytes, and
+// ideally a 'nice' size aligning with allocation and cacheline sizes like 32.
+// kMaxFlatSize is bounded by the size resulting in a computed tag no greater
+// than MAX_FLAT_TAG. MAX_FLAT_TAG provides for additional 'high' tag values.
+static constexpr size_t kFlatOverhead = offsetof(CordRep, storage);
+static constexpr size_t kMinFlatSize = 32;
+static constexpr size_t kMaxFlatSize = 4096;
+static constexpr size_t kMaxFlatLength = kMaxFlatSize - kFlatOverhead;
+static constexpr size_t kMinFlatLength = kMinFlatSize - kFlatOverhead;
+
+constexpr uint8_t AllocatedSizeToTagUnchecked(size_t size) {
   return static_cast<uint8_t>((size <= 1024) ? size / 8 + 1
                                              : 129 + size / 32 - 1024 / 32);
-} 
- 
+}
+
 static_assert(kMinFlatSize / 8 + 1 >= FLAT, "");
-static_assert(AllocatedSizeToTagUnchecked(kMaxFlatSize) <= MAX_FLAT_TAG, ""); 
- 
-// Helper functions for rounded div, and rounding to exact sizes. 
-constexpr size_t DivUp(size_t n, size_t m) { return (n + m - 1) / m; } 
-constexpr size_t RoundUp(size_t n, size_t m) { return DivUp(n, m) * m; } 
- 
-// Returns the size to the nearest equal or larger value that can be 
-// expressed exactly as a tag value. 
-inline size_t RoundUpForTag(size_t size) { 
-  return RoundUp(size, (size <= 1024) ? 8 : 32); 
-} 
- 
-// Converts the allocated size to a tag, rounding down if the size 
-// does not exactly match a 'tag expressible' size value. The result is 
-// undefined if the size exceeds the maximum size that can be encoded in 
-// a tag, i.e., if size is larger than TagToAllocatedSize(<max tag>). 
-inline uint8_t AllocatedSizeToTag(size_t size) { 
-  const uint8_t tag = AllocatedSizeToTagUnchecked(size); 
-  assert(tag <= MAX_FLAT_TAG); 
-  return tag; 
-} 
- 
-// Converts the provided tag to the corresponding allocated size 
-constexpr size_t TagToAllocatedSize(uint8_t tag) { 
+static_assert(AllocatedSizeToTagUnchecked(kMaxFlatSize) <= MAX_FLAT_TAG, "");
+
+// Helper functions for rounded div, and rounding to exact sizes.
+constexpr size_t DivUp(size_t n, size_t m) { return (n + m - 1) / m; }
+constexpr size_t RoundUp(size_t n, size_t m) { return DivUp(n, m) * m; }
+
+// Returns the size to the nearest equal or larger value that can be
+// expressed exactly as a tag value.
+inline size_t RoundUpForTag(size_t size) {
+  return RoundUp(size, (size <= 1024) ? 8 : 32);
+}
+
+// Converts the allocated size to a tag, rounding down if the size
+// does not exactly match a 'tag expressible' size value. The result is
+// undefined if the size exceeds the maximum size that can be encoded in
+// a tag, i.e., if size is larger than TagToAllocatedSize(<max tag>).
+inline uint8_t AllocatedSizeToTag(size_t size) {
+  const uint8_t tag = AllocatedSizeToTagUnchecked(size);
+  assert(tag <= MAX_FLAT_TAG);
+  return tag;
+}
+
+// Converts the provided tag to the corresponding allocated size
+constexpr size_t TagToAllocatedSize(uint8_t tag) {
   return (tag <= 129) ? ((tag - 1) * 8) : (1024 + (tag - 129) * 32);
-} 
- 
-// Converts the provided tag to the corresponding available data length 
-constexpr size_t TagToLength(uint8_t tag) { 
-  return TagToAllocatedSize(tag) - kFlatOverhead; 
-} 
- 
-// Enforce that kMaxFlatSize maps to a well-known exact tag value. 
+}
+
+// Converts the provided tag to the corresponding available data length
+constexpr size_t TagToLength(uint8_t tag) {
+  return TagToAllocatedSize(tag) - kFlatOverhead;
+}
+
+// Enforce that kMaxFlatSize maps to a well-known exact tag value.
 static_assert(TagToAllocatedSize(225) == kMaxFlatSize, "Bad tag logic");
- 
-struct CordRepFlat : public CordRep { 
-  // Creates a new flat node. 
-  static CordRepFlat* New(size_t len) { 
-    if (len <= kMinFlatLength) { 
-      len = kMinFlatLength; 
-    } else if (len > kMaxFlatLength) { 
-      len = kMaxFlatLength; 
-    } 
- 
-    // Round size up so it matches a size we can exactly express in a tag. 
-    const size_t size = RoundUpForTag(len + kFlatOverhead); 
-    void* const raw_rep = ::operator new(size); 
-    CordRepFlat* rep = new (raw_rep) CordRepFlat(); 
-    rep->tag = AllocatedSizeToTag(size); 
-    return rep; 
-  } 
- 
-  // Deletes a CordRepFlat instance created previously through a call to New(). 
-  // Flat CordReps are allocated and constructed with raw ::operator new and 
-  // placement new, and must be destructed and deallocated accordingly. 
-  static void Delete(CordRep*rep) { 
-    assert(rep->tag >= FLAT && rep->tag <= MAX_FLAT_TAG); 
- 
-#if defined(__cpp_sized_deallocation) 
-    size_t size = TagToAllocatedSize(rep->tag); 
-    rep->~CordRep(); 
-    ::operator delete(rep, size); 
-#else 
-    rep->~CordRep(); 
-    ::operator delete(rep); 
-#endif 
-  } 
- 
-  // Returns a pointer to the data inside this flat rep. 
+
+struct CordRepFlat : public CordRep {
+  // Creates a new flat node.
+  static CordRepFlat* New(size_t len) {
+    if (len <= kMinFlatLength) {
+      len = kMinFlatLength;
+    } else if (len > kMaxFlatLength) {
+      len = kMaxFlatLength;
+    }
+
+    // Round size up so it matches a size we can exactly express in a tag.
+    const size_t size = RoundUpForTag(len + kFlatOverhead);
+    void* const raw_rep = ::operator new(size);
+    CordRepFlat* rep = new (raw_rep) CordRepFlat();
+    rep->tag = AllocatedSizeToTag(size);
+    return rep;
+  }
+
+  // Deletes a CordRepFlat instance created previously through a call to New().
+  // Flat CordReps are allocated and constructed with raw ::operator new and
+  // placement new, and must be destructed and deallocated accordingly.
+  static void Delete(CordRep*rep) {
+    assert(rep->tag >= FLAT && rep->tag <= MAX_FLAT_TAG);
+
+#if defined(__cpp_sized_deallocation)
+    size_t size = TagToAllocatedSize(rep->tag);
+    rep->~CordRep();
+    ::operator delete(rep, size);
+#else
+    rep->~CordRep();
+    ::operator delete(rep);
+#endif
+  }
+
+  // Returns a pointer to the data inside this flat rep.
   char* Data() { return reinterpret_cast<char*>(storage); }
   const char* Data() const { return reinterpret_cast<const char*>(storage); }
- 
-  // Returns the maximum capacity (payload size) of this instance. 
-  size_t Capacity() const { return TagToLength(tag); } 
- 
-  // Returns the allocated size (payload + overhead) of this instance. 
-  size_t AllocatedSize() const { return TagToAllocatedSize(tag); } 
-}; 
- 
-// Now that CordRepFlat is defined, we can define CordRep's helper casts: 
-inline CordRepFlat* CordRep::flat() { 
-  assert(tag >= FLAT && tag <= MAX_FLAT_TAG); 
-  return reinterpret_cast<CordRepFlat*>(this); 
-} 
- 
-inline const CordRepFlat* CordRep::flat() const { 
-  assert(tag >= FLAT && tag <= MAX_FLAT_TAG); 
-  return reinterpret_cast<const CordRepFlat*>(this); 
-} 
- 
-}  // namespace cord_internal 
-ABSL_NAMESPACE_END 
-}  // namespace absl 
- 
-#endif  // ABSL_STRINGS_INTERNAL_CORD_REP_FLAT_H_ 
+
+  // Returns the maximum capacity (payload size) of this instance.
+  size_t Capacity() const { return TagToLength(tag); }
+
+  // Returns the allocated size (payload + overhead) of this instance.
+  size_t AllocatedSize() const { return TagToAllocatedSize(tag); }
+};
+
+// Now that CordRepFlat is defined, we can define CordRep's helper casts:
+inline CordRepFlat* CordRep::flat() {
+  assert(tag >= FLAT && tag <= MAX_FLAT_TAG);
+  return reinterpret_cast<CordRepFlat*>(this);
+}
+
+inline const CordRepFlat* CordRep::flat() const {
+  assert(tag >= FLAT && tag <= MAX_FLAT_TAG);
+  return reinterpret_cast<const CordRepFlat*>(this);
+}
+
+}  // namespace cord_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_CORD_REP_FLAT_H_
diff --git a/contrib/restricted/abseil-cpp/absl/strings/internal/cord_rep_ring.cc b/contrib/restricted/abseil-cpp/absl/strings/internal/cord_rep_ring.cc
index 2635fe1558..07c77eb3e5 100644
--- a/contrib/restricted/abseil-cpp/absl/strings/internal/cord_rep_ring.cc
+++ b/contrib/restricted/abseil-cpp/absl/strings/internal/cord_rep_ring.cc
@@ -1,771 +1,771 @@
-// Copyright 2020 The Abseil Authors 
-// 
-// Licensed under the Apache License, Version 2.0 (the "License"); 
-// you may not use this file except in compliance with the License. 
-// You may obtain a copy of the License at 
-// 
-//     https://www.apache.org/licenses/LICENSE-2.0 
-// 
-// Unless required by applicable law or agreed to in writing, software 
-// distributed under the License is distributed on an "AS IS" BASIS, 
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-// See the License for the specific language governing permissions and 
-// limitations under the License. 
-#include "absl/strings/internal/cord_rep_ring.h" 
- 
-#include <cassert> 
-#include <cstddef> 
-#include <cstdint> 
-#include <iostream> 
-#include <limits> 
-#include <memory> 
-#include <string> 
- 
-#include "absl/base/internal/raw_logging.h" 
-#include "absl/base/internal/throw_delegate.h" 
-#include "absl/base/macros.h" 
-#include "absl/container/inlined_vector.h" 
-#include "absl/strings/internal/cord_internal.h" 
+// Copyright 2020 The Abseil Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#include "absl/strings/internal/cord_rep_ring.h"
+
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <iostream>
+#include <limits>
+#include <memory>
+#include <string>
+
+#include "absl/base/internal/raw_logging.h"
+#include "absl/base/internal/throw_delegate.h"
+#include "absl/base/macros.h"
+#include "absl/container/inlined_vector.h"
+#include "absl/strings/internal/cord_internal.h"
 #include "absl/strings/internal/cord_rep_consume.h"
-#include "absl/strings/internal/cord_rep_flat.h" 
- 
-namespace absl { 
-ABSL_NAMESPACE_BEGIN 
-namespace cord_internal { 
- 
-namespace { 
- 
-using index_type = CordRepRing::index_type; 
- 
-enum class Direction { kForward, kReversed }; 
- 
-inline bool IsFlatOrExternal(CordRep* rep) { 
+#include "absl/strings/internal/cord_rep_flat.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace cord_internal {
+
+namespace {
+
+using index_type = CordRepRing::index_type;
+
+enum class Direction { kForward, kReversed };
+
+inline bool IsFlatOrExternal(CordRep* rep) {
   return rep->IsFlat() || rep->IsExternal();
-} 
- 
-// Verifies that n + extra <= kMaxCapacity: throws std::length_error otherwise. 
-inline void CheckCapacity(size_t n, size_t extra) { 
-  if (ABSL_PREDICT_FALSE(extra > CordRepRing::kMaxCapacity - n)) { 
-    base_internal::ThrowStdLengthError("Maximum capacity exceeded"); 
-  } 
-} 
- 
-// Creates a flat from the provided string data, allocating up to `extra` 
-// capacity in the returned flat depending on kMaxFlatLength limitations. 
-// Requires `len` to be less or equal to `kMaxFlatLength` 
-CordRepFlat* CreateFlat(const char* s, size_t n, size_t extra = 0) {  // NOLINT 
-  assert(n <= kMaxFlatLength); 
-  auto* rep = CordRepFlat::New(n + extra); 
-  rep->length = n; 
-  memcpy(rep->Data(), s, n); 
-  return rep; 
-} 
- 
-// Unrefs the entries in `[head, tail)`. 
-// Requires all entries to be a FLAT or EXTERNAL node. 
-void UnrefEntries(const CordRepRing* rep, index_type head, index_type tail) { 
-  rep->ForEach(head, tail, [rep](index_type ix) { 
-    CordRep* child = rep->entry_child(ix); 
-    if (!child->refcount.Decrement()) { 
-      if (child->tag >= FLAT) { 
-        CordRepFlat::Delete(child->flat()); 
-      } else { 
-        CordRepExternal::Delete(child->external()); 
-      } 
-    } 
-  }); 
-} 
- 
-}  // namespace 
- 
-std::ostream& operator<<(std::ostream& s, const CordRepRing& rep) { 
-  // Note: 'pos' values are defined as size_t (for overflow reasons), but that 
-  // prints really awkward for small prepended values such as -5. ssize_t is not 
-  // portable (POSIX), so we use ptrdiff_t instead to cast to signed values. 
-  s << "  CordRepRing(" << &rep << ", length = " << rep.length 
-    << ", head = " << rep.head_ << ", tail = " << rep.tail_ 
-    << ", cap = " << rep.capacity_ << ", rc = " << rep.refcount.Get() 
-    << ", begin_pos_ = " << static_cast<ptrdiff_t>(rep.begin_pos_) << ") {\n"; 
-  CordRepRing::index_type head = rep.head(); 
-  do { 
-    CordRep* child = rep.entry_child(head); 
-    s << " entry[" << head << "] length = " << rep.entry_length(head) 
-      << ", child " << child << ", clen = " << child->length 
-      << ", tag = " << static_cast<int>(child->tag) 
-      << ", rc = " << child->refcount.Get() 
-      << ", offset = " << rep.entry_data_offset(head) 
-      << ", end_pos = " << static_cast<ptrdiff_t>(rep.entry_end_pos(head)) 
-      << "\n"; 
-    head = rep.advance(head); 
-  } while (head != rep.tail()); 
-  return s << "}\n"; 
-} 
- 
-void CordRepRing::AddDataOffset(index_type index, size_t n) { 
-  entry_data_offset()[index] += static_cast<offset_type>(n); 
-} 
- 
-void CordRepRing::SubLength(index_type index, size_t n) { 
-  entry_end_pos()[index] -= n; 
-} 
- 
-class CordRepRing::Filler { 
- public: 
-  Filler(CordRepRing* rep, index_type pos) : rep_(rep), head_(pos), pos_(pos) {} 
- 
-  index_type head() const { return head_; } 
-  index_type pos() const { return pos_; } 
- 
-  void Add(CordRep* child, size_t offset, pos_type end_pos) { 
-    rep_->entry_end_pos()[pos_] = end_pos; 
-    rep_->entry_child()[pos_] = child; 
-    rep_->entry_data_offset()[pos_] = static_cast<offset_type>(offset); 
-    pos_ = rep_->advance(pos_); 
-  } 
- 
- private: 
-  CordRepRing* rep_; 
-  index_type head_; 
-  index_type pos_; 
-}; 
- 
-constexpr size_t CordRepRing::kMaxCapacity; // NOLINT: needed for c++11 
- 
-bool CordRepRing::IsValid(std::ostream& output) const { 
-  if (capacity_ == 0) { 
-    output << "capacity == 0"; 
-    return false; 
-  } 
- 
-  if (head_ >= capacity_ || tail_ >= capacity_) { 
-    output << "head " << head_ << " and/or tail " << tail_ << "exceed capacity " 
-           << capacity_; 
-    return false; 
-  } 
- 
-  const index_type back = retreat(tail_); 
-  size_t pos_length = Distance(begin_pos_, entry_end_pos(back)); 
-  if (pos_length != length) { 
-    output << "length " << length << " does not match positional length " 
-           << pos_length << " from begin_pos " << begin_pos_ << " and entry[" 
-           << back << "].end_pos " << entry_end_pos(back); 
-    return false; 
-  } 
- 
-  index_type head = head_; 
-  pos_type begin_pos = begin_pos_; 
-  do { 
-    pos_type end_pos = entry_end_pos(head); 
-    size_t entry_length = Distance(begin_pos, end_pos); 
-    if (entry_length == 0) { 
-      output << "entry[" << head << "] has an invalid length " << entry_length 
-             << " from begin_pos " << begin_pos << " and end_pos " << end_pos; 
-      return false; 
-    } 
- 
-    CordRep* child = entry_child(head); 
-    if (child == nullptr) { 
-      output << "entry[" << head << "].child == nullptr"; 
-      return false; 
-    } 
-    if (child->tag < FLAT && child->tag != EXTERNAL) { 
-      output << "entry[" << head << "].child has an invalid tag " 
-             << static_cast<int>(child->tag); 
-      return false; 
-    } 
- 
-    size_t offset = entry_data_offset(head); 
-    if (offset >= child->length || entry_length > child->length - offset) { 
-      output << "entry[" << head << "] has offset " << offset 
-             << " and entry length " << entry_length 
+}
+
+// Verifies that n + extra <= kMaxCapacity: throws std::length_error otherwise.
+inline void CheckCapacity(size_t n, size_t extra) {
+  if (ABSL_PREDICT_FALSE(extra > CordRepRing::kMaxCapacity - n)) {
+    base_internal::ThrowStdLengthError("Maximum capacity exceeded");
+  }
+}
+
+// Creates a flat from the provided string data, allocating up to `extra`
+// capacity in the returned flat depending on kMaxFlatLength limitations.
+// Requires `len` to be less or equal to `kMaxFlatLength`
+CordRepFlat* CreateFlat(const char* s, size_t n, size_t extra = 0) {  // NOLINT
+  assert(n <= kMaxFlatLength);
+  auto* rep = CordRepFlat::New(n + extra);
+  rep->length = n;
+  memcpy(rep->Data(), s, n);
+  return rep;
+}
+
+// Unrefs the entries in `[head, tail)`.
+// Requires all entries to be a FLAT or EXTERNAL node.
+void UnrefEntries(const CordRepRing* rep, index_type head, index_type tail) {
+  rep->ForEach(head, tail, [rep](index_type ix) {
+    CordRep* child = rep->entry_child(ix);
+    if (!child->refcount.Decrement()) {
+      if (child->tag >= FLAT) {
+        CordRepFlat::Delete(child->flat());
+      } else {
+        CordRepExternal::Delete(child->external());
+      }
+    }
+  });
+}
+
+}  // namespace
+
+std::ostream& operator<<(std::ostream& s, const CordRepRing& rep) {
+  // Note: 'pos' values are defined as size_t (for overflow reasons), but that
+  // prints really awkward for small prepended values such as -5. ssize_t is not
+  // portable (POSIX), so we use ptrdiff_t instead to cast to signed values.
+  s << "  CordRepRing(" << &rep << ", length = " << rep.length
+    << ", head = " << rep.head_ << ", tail = " << rep.tail_
+    << ", cap = " << rep.capacity_ << ", rc = " << rep.refcount.Get()
+    << ", begin_pos_ = " << static_cast<ptrdiff_t>(rep.begin_pos_) << ") {\n";
+  CordRepRing::index_type head = rep.head();
+  do {
+    CordRep* child = rep.entry_child(head);
+    s << " entry[" << head << "] length = " << rep.entry_length(head)
+      << ", child " << child << ", clen = " << child->length
+      << ", tag = " << static_cast<int>(child->tag)
+      << ", rc = " << child->refcount.Get()
+      << ", offset = " << rep.entry_data_offset(head)
+      << ", end_pos = " << static_cast<ptrdiff_t>(rep.entry_end_pos(head))
+      << "\n";
+    head = rep.advance(head);
+  } while (head != rep.tail());
+  return s << "}\n";
+}
+
+void CordRepRing::AddDataOffset(index_type index, size_t n) {
+  entry_data_offset()[index] += static_cast<offset_type>(n);
+}
+
+void CordRepRing::SubLength(index_type index, size_t n) {
+  entry_end_pos()[index] -= n;
+}
+
+class CordRepRing::Filler {
+ public:
+  Filler(CordRepRing* rep, index_type pos) : rep_(rep), head_(pos), pos_(pos) {}
+
+  index_type head() const { return head_; }
+  index_type pos() const { return pos_; }
+
+  void Add(CordRep* child, size_t offset, pos_type end_pos) {
+    rep_->entry_end_pos()[pos_] = end_pos;
+    rep_->entry_child()[pos_] = child;
+    rep_->entry_data_offset()[pos_] = static_cast<offset_type>(offset);
+    pos_ = rep_->advance(pos_);
+  }
+
+ private:
+  CordRepRing* rep_;
+  index_type head_;
+  index_type pos_;
+};
+
+constexpr size_t CordRepRing::kMaxCapacity; // NOLINT: needed for c++11
+
+bool CordRepRing::IsValid(std::ostream& output) const {
+  if (capacity_ == 0) {
+    output << "capacity == 0";
+    return false;
+  }
+
+  if (head_ >= capacity_ || tail_ >= capacity_) {
+    output << "head " << head_ << " and/or tail " << tail_ << "exceed capacity "
+           << capacity_;
+    return false;
+  }
+
+  const index_type back = retreat(tail_);
+  size_t pos_length = Distance(begin_pos_, entry_end_pos(back));
+  if (pos_length != length) {
+    output << "length " << length << " does not match positional length "
+           << pos_length << " from begin_pos " << begin_pos_ << " and entry["
+           << back << "].end_pos " << entry_end_pos(back);
+    return false;
+  }
+
+  index_type head = head_;
+  pos_type begin_pos = begin_pos_;
+  do {
+    pos_type end_pos = entry_end_pos(head);
+    size_t entry_length = Distance(begin_pos, end_pos);
+    if (entry_length == 0) {
+      output << "entry[" << head << "] has an invalid length " << entry_length
+             << " from begin_pos " << begin_pos << " and end_pos " << end_pos;
+      return false;
+    }
+
+    CordRep* child = entry_child(head);
+    if (child == nullptr) {
+      output << "entry[" << head << "].child == nullptr";
+      return false;
+    }
+    if (child->tag < FLAT && child->tag != EXTERNAL) {
+      output << "entry[" << head << "].child has an invalid tag "
+             << static_cast<int>(child->tag);
+      return false;
+    }
+
+    size_t offset = entry_data_offset(head);
+    if (offset >= child->length || entry_length > child->length - offset) {
+      output << "entry[" << head << "] has offset " << offset
+             << " and entry length " << entry_length
              << " which are outside of the child's length of " << child->length;
-      return false; 
-    } 
- 
-    begin_pos = end_pos; 
-    head = advance(head); 
-  } while (head != tail_); 
- 
-  return true; 
-} 
- 
-#ifdef EXTRA_CORD_RING_VALIDATION 
-CordRepRing* CordRepRing::Validate(CordRepRing* rep, const char* file, 
-                                   int line) { 
-  if (!rep->IsValid(std::cerr)) { 
-    std::cerr << "\nERROR: CordRepRing corrupted"; 
-    if (line) std::cerr << " at line " << line; 
-    if (file) std::cerr << " in file " << file; 
-    std::cerr << "\nContent = " << *rep; 
-    abort(); 
-  } 
-  return rep; 
-} 
-#endif  // EXTRA_CORD_RING_VALIDATION 
- 
-CordRepRing* CordRepRing::New(size_t capacity, size_t extra) { 
-  CheckCapacity(capacity, extra); 
- 
-  size_t size = AllocSize(capacity += extra); 
-  void* mem = ::operator new(size); 
-  auto* rep = new (mem) CordRepRing(static_cast<index_type>(capacity)); 
-  rep->tag = RING; 
-  rep->capacity_ = static_cast<index_type>(capacity); 
-  rep->begin_pos_ = 0; 
-  return rep; 
-} 
- 
-void CordRepRing::SetCapacityForTesting(size_t capacity) { 
-  // Adjust for the changed layout 
-  assert(capacity <= capacity_); 
-  assert(head() == 0 || head() < tail()); 
-  memmove(Layout::Partial(capacity).Pointer<1>(data_) + head(), 
-          Layout::Partial(capacity_).Pointer<1>(data_) + head(), 
-          entries() * sizeof(Layout::ElementType<1>)); 
-  memmove(Layout::Partial(capacity, capacity).Pointer<2>(data_) + head(), 
-          Layout::Partial(capacity_, capacity_).Pointer<2>(data_) + head(), 
-          entries() * sizeof(Layout::ElementType<2>)); 
-  capacity_ = static_cast<index_type>(capacity); 
-} 
- 
-void CordRepRing::Delete(CordRepRing* rep) { 
+      return false;
+    }
+
+    begin_pos = end_pos;
+    head = advance(head);
+  } while (head != tail_);
+
+  return true;
+}
+
+#ifdef EXTRA_CORD_RING_VALIDATION
+CordRepRing* CordRepRing::Validate(CordRepRing* rep, const char* file,
+                                   int line) {
+  if (!rep->IsValid(std::cerr)) {
+    std::cerr << "\nERROR: CordRepRing corrupted";
+    if (line) std::cerr << " at line " << line;
+    if (file) std::cerr << " in file " << file;
+    std::cerr << "\nContent = " << *rep;
+    abort();
+  }
+  return rep;
+}
+#endif  // EXTRA_CORD_RING_VALIDATION
+
+CordRepRing* CordRepRing::New(size_t capacity, size_t extra) {
+  CheckCapacity(capacity, extra);
+
+  size_t size = AllocSize(capacity += extra);
+  void* mem = ::operator new(size);
+  auto* rep = new (mem) CordRepRing(static_cast<index_type>(capacity));
+  rep->tag = RING;
+  rep->capacity_ = static_cast<index_type>(capacity);
+  rep->begin_pos_ = 0;
+  return rep;
+}
+
+void CordRepRing::SetCapacityForTesting(size_t capacity) {
+  // Adjust for the changed layout
+  assert(capacity <= capacity_);
+  assert(head() == 0 || head() < tail());
+  memmove(Layout::Partial(capacity).Pointer<1>(data_) + head(),
+          Layout::Partial(capacity_).Pointer<1>(data_) + head(),
+          entries() * sizeof(Layout::ElementType<1>));
+  memmove(Layout::Partial(capacity, capacity).Pointer<2>(data_) + head(),
+          Layout::Partial(capacity_, capacity_).Pointer<2>(data_) + head(),
+          entries() * sizeof(Layout::ElementType<2>));
+  capacity_ = static_cast<index_type>(capacity);
+}
+
+void CordRepRing::Delete(CordRepRing* rep) {
   assert(rep != nullptr && rep->IsRing());
-#if defined(__cpp_sized_deallocation) 
-  size_t size = AllocSize(rep->capacity_); 
-  rep->~CordRepRing(); 
-  ::operator delete(rep, size); 
-#else 
-  rep->~CordRepRing(); 
-  ::operator delete(rep); 
-#endif 
-} 
- 
-void CordRepRing::Destroy(CordRepRing* rep) { 
-  UnrefEntries(rep, rep->head(), rep->tail()); 
-  Delete(rep); 
-} 
- 
-template <bool ref> 
-void CordRepRing::Fill(const CordRepRing* src, index_type head, 
-                       index_type tail) { 
-  this->length = src->length; 
-  head_ = 0; 
-  tail_ = advance(0, src->entries(head, tail)); 
-  begin_pos_ = src->begin_pos_; 
- 
-  // TODO(mvels): there may be opportunities here for large buffers. 
-  auto* dst_pos = entry_end_pos(); 
-  auto* dst_child = entry_child(); 
-  auto* dst_offset = entry_data_offset(); 
-  src->ForEach(head, tail, [&](index_type index) { 
-    *dst_pos++ = src->entry_end_pos(index); 
-    CordRep* child = src->entry_child(index); 
-    *dst_child++ = ref ? CordRep::Ref(child) : child; 
-    *dst_offset++ = src->entry_data_offset(index); 
-  }); 
-} 
- 
-CordRepRing* CordRepRing::Copy(CordRepRing* rep, index_type head, 
-                               index_type tail, size_t extra) { 
-  CordRepRing* newrep = CordRepRing::New(rep->entries(head, tail), extra); 
-  newrep->Fill<true>(rep, head, tail); 
-  CordRep::Unref(rep); 
-  return newrep; 
-} 
- 
-CordRepRing* CordRepRing::Mutable(CordRepRing* rep, size_t extra) { 
-  // Get current number of entries, and check for max capacity. 
-  size_t entries = rep->entries(); 
- 
+#if defined(__cpp_sized_deallocation)
+  size_t size = AllocSize(rep->capacity_);
+  rep->~CordRepRing();
+  ::operator delete(rep, size);
+#else
+  rep->~CordRepRing();
+  ::operator delete(rep);
+#endif
+}
+
+void CordRepRing::Destroy(CordRepRing* rep) {
+  UnrefEntries(rep, rep->head(), rep->tail());
+  Delete(rep);
+}
+
+template <bool ref>
+void CordRepRing::Fill(const CordRepRing* src, index_type head,
+                       index_type tail) {
+  this->length = src->length;
+  head_ = 0;
+  tail_ = advance(0, src->entries(head, tail));
+  begin_pos_ = src->begin_pos_;
+
+  // TODO(mvels): there may be opportunities here for large buffers.
+  auto* dst_pos = entry_end_pos();
+  auto* dst_child = entry_child();
+  auto* dst_offset = entry_data_offset();
+  src->ForEach(head, tail, [&](index_type index) {
+    *dst_pos++ = src->entry_end_pos(index);
+    CordRep* child = src->entry_child(index);
+    *dst_child++ = ref ? CordRep::Ref(child) : child;
+    *dst_offset++ = src->entry_data_offset(index);
+  });
+}
+
+CordRepRing* CordRepRing::Copy(CordRepRing* rep, index_type head,
+                               index_type tail, size_t extra) {
+  CordRepRing* newrep = CordRepRing::New(rep->entries(head, tail), extra);
+  newrep->Fill<true>(rep, head, tail);
+  CordRep::Unref(rep);
+  return newrep;
+}
+
+CordRepRing* CordRepRing::Mutable(CordRepRing* rep, size_t extra) {
+  // Get current number of entries, and check for max capacity.
+  size_t entries = rep->entries();
+
   if (!rep->refcount.IsMutable()) {
     return Copy(rep, rep->head(), rep->tail(), extra);
-  } else if (entries + extra > rep->capacity()) { 
+  } else if (entries + extra > rep->capacity()) {
     const size_t min_grow = rep->capacity() + rep->capacity() / 2;
     const size_t min_extra = (std::max)(extra, min_grow - entries);
-    CordRepRing* newrep = CordRepRing::New(entries, min_extra); 
-    newrep->Fill<false>(rep, rep->head(), rep->tail()); 
-    CordRepRing::Delete(rep); 
-    return newrep; 
-  } else { 
-    return rep; 
-  } 
-} 
- 
-Span<char> CordRepRing::GetAppendBuffer(size_t size) { 
+    CordRepRing* newrep = CordRepRing::New(entries, min_extra);
+    newrep->Fill<false>(rep, rep->head(), rep->tail());
+    CordRepRing::Delete(rep);
+    return newrep;
+  } else {
+    return rep;
+  }
+}
+
+Span<char> CordRepRing::GetAppendBuffer(size_t size) {
   assert(refcount.IsMutable());
-  index_type back = retreat(tail_); 
-  CordRep* child = entry_child(back); 
+  index_type back = retreat(tail_);
+  CordRep* child = entry_child(back);
   if (child->tag >= FLAT && child->refcount.IsMutable()) {
-    size_t capacity = child->flat()->Capacity(); 
-    pos_type end_pos = entry_end_pos(back); 
-    size_t data_offset = entry_data_offset(back); 
-    size_t entry_length = Distance(entry_begin_pos(back), end_pos); 
-    size_t used = data_offset + entry_length; 
-    if (size_t n = (std::min)(capacity - used, size)) { 
-      child->length = data_offset + entry_length + n; 
-      entry_end_pos()[back] = end_pos + n; 
-      this->length += n; 
-      return {child->flat()->Data() + used, n}; 
-    } 
-  } 
-  return {nullptr, 0}; 
-} 
- 
-Span<char> CordRepRing::GetPrependBuffer(size_t size) { 
+    size_t capacity = child->flat()->Capacity();
+    pos_type end_pos = entry_end_pos(back);
+    size_t data_offset = entry_data_offset(back);
+    size_t entry_length = Distance(entry_begin_pos(back), end_pos);
+    size_t used = data_offset + entry_length;
+    if (size_t n = (std::min)(capacity - used, size)) {
+      child->length = data_offset + entry_length + n;
+      entry_end_pos()[back] = end_pos + n;
+      this->length += n;
+      return {child->flat()->Data() + used, n};
+    }
+  }
+  return {nullptr, 0};
+}
+
+Span<char> CordRepRing::GetPrependBuffer(size_t size) {
   assert(refcount.IsMutable());
-  CordRep* child = entry_child(head_); 
-  size_t data_offset = entry_data_offset(head_); 
+  CordRep* child = entry_child(head_);
+  size_t data_offset = entry_data_offset(head_);
   if (data_offset && child->refcount.IsMutable() && child->tag >= FLAT) {
-    size_t n = (std::min)(data_offset, size); 
-    this->length += n; 
-    begin_pos_ -= n; 
-    data_offset -= n; 
-    entry_data_offset()[head_] = static_cast<offset_type>(data_offset); 
-    return {child->flat()->Data() + data_offset, n}; 
-  } 
-  return {nullptr, 0}; 
-} 
- 
-CordRepRing* CordRepRing::CreateFromLeaf(CordRep* child, size_t offset, 
+    size_t n = (std::min)(data_offset, size);
+    this->length += n;
+    begin_pos_ -= n;
+    data_offset -= n;
+    entry_data_offset()[head_] = static_cast<offset_type>(data_offset);
+    return {child->flat()->Data() + data_offset, n};
+  }
+  return {nullptr, 0};
+}
+
+CordRepRing* CordRepRing::CreateFromLeaf(CordRep* child, size_t offset,
                                          size_t len, size_t extra) {
-  CordRepRing* rep = CordRepRing::New(1, extra); 
-  rep->head_ = 0; 
-  rep->tail_ = rep->advance(0); 
+  CordRepRing* rep = CordRepRing::New(1, extra);
+  rep->head_ = 0;
+  rep->tail_ = rep->advance(0);
   rep->length = len;
   rep->entry_end_pos()[0] = len;
-  rep->entry_child()[0] = child; 
-  rep->entry_data_offset()[0] = static_cast<offset_type>(offset); 
-  return Validate(rep); 
-} 
- 
-CordRepRing* CordRepRing::CreateSlow(CordRep* child, size_t extra) { 
-  CordRepRing* rep = nullptr; 
+  rep->entry_child()[0] = child;
+  rep->entry_data_offset()[0] = static_cast<offset_type>(offset);
+  return Validate(rep);
+}
+
+CordRepRing* CordRepRing::CreateSlow(CordRep* child, size_t extra) {
+  CordRepRing* rep = nullptr;
   Consume(child, [&](CordRep* child_arg, size_t offset, size_t len) {
     if (IsFlatOrExternal(child_arg)) {
       rep = rep ? AppendLeaf(rep, child_arg, offset, len)
                 : CreateFromLeaf(child_arg, offset, len, extra);
-    } else if (rep) { 
+    } else if (rep) {
       rep = AddRing<AddMode::kAppend>(rep, child_arg->ring(), offset, len);
     } else if (offset == 0 && child_arg->length == len) {
       rep = Mutable(child_arg->ring(), extra);
-    } else { 
+    } else {
       rep = SubRing(child_arg->ring(), offset, len, extra);
-    } 
-  }); 
-  return Validate(rep, nullptr, __LINE__); 
-} 
- 
-CordRepRing* CordRepRing::Create(CordRep* child, size_t extra) { 
-  size_t length = child->length; 
-  if (IsFlatOrExternal(child)) { 
-    return CreateFromLeaf(child, 0, length, extra); 
-  } 
+    }
+  });
+  return Validate(rep, nullptr, __LINE__);
+}
+
+CordRepRing* CordRepRing::Create(CordRep* child, size_t extra) {
+  size_t length = child->length;
+  if (IsFlatOrExternal(child)) {
+    return CreateFromLeaf(child, 0, length, extra);
+  }
   if (child->IsRing()) {
-    return Mutable(child->ring(), extra); 
-  } 
-  return CreateSlow(child, extra); 
-} 
- 
-template <CordRepRing::AddMode mode> 
-CordRepRing* CordRepRing::AddRing(CordRepRing* rep, CordRepRing* ring, 
+    return Mutable(child->ring(), extra);
+  }
+  return CreateSlow(child, extra);
+}
+
+template <CordRepRing::AddMode mode>
+CordRepRing* CordRepRing::AddRing(CordRepRing* rep, CordRepRing* ring,
                                   size_t offset, size_t len) {
-  assert(offset < ring->length); 
-  constexpr bool append = mode == AddMode::kAppend; 
-  Position head = ring->Find(offset); 
+  assert(offset < ring->length);
+  constexpr bool append = mode == AddMode::kAppend;
+  Position head = ring->Find(offset);
   Position tail = ring->FindTail(head.index, offset + len);
-  const index_type entries = ring->entries(head.index, tail.index); 
- 
-  rep = Mutable(rep, entries); 
- 
-  // The delta for making ring[head].end_pos into 'len - offset' 
-  const pos_type delta_length = 
+  const index_type entries = ring->entries(head.index, tail.index);
+
+  rep = Mutable(rep, entries);
+
+  // The delta for making ring[head].end_pos into 'len - offset'
+  const pos_type delta_length =
       (append ? rep->begin_pos_ + rep->length : rep->begin_pos_ - len) -
-      ring->entry_begin_pos(head.index) - head.offset; 
- 
-  // Start filling at `tail`, or `entries` before `head` 
-  Filler filler(rep, append ? rep->tail_ : rep->retreat(rep->head_, entries)); 
- 
-  if (ring->refcount.IsOne()) { 
-    // Copy entries from source stealing the ref and adjusting the end position. 
-    // Commit the filler as this is no-op. 
-    ring->ForEach(head.index, tail.index, [&](index_type ix) { 
-      filler.Add(ring->entry_child(ix), ring->entry_data_offset(ix), 
-                 ring->entry_end_pos(ix) + delta_length); 
-    }); 
- 
-    // Unref entries we did not copy over, and delete source. 
-    if (head.index != ring->head_) UnrefEntries(ring, ring->head_, head.index); 
-    if (tail.index != ring->tail_) UnrefEntries(ring, tail.index, ring->tail_); 
-    CordRepRing::Delete(ring); 
-  } else { 
-    ring->ForEach(head.index, tail.index, [&](index_type ix) { 
-      CordRep* child = ring->entry_child(ix); 
-      filler.Add(child, ring->entry_data_offset(ix), 
-                 ring->entry_end_pos(ix) + delta_length); 
-      CordRep::Ref(child); 
-    }); 
-    CordRepRing::Unref(ring); 
-  } 
- 
-  if (head.offset) { 
-    // Increase offset of first 'source' entry appended or prepended. 
-    // This is always the entry in `filler.head()` 
-    rep->AddDataOffset(filler.head(), head.offset); 
-  } 
- 
-  if (tail.offset) { 
-    // Reduce length of last 'source' entry appended or prepended. 
-    // This is always the entry tailed by `filler.pos()` 
-    rep->SubLength(rep->retreat(filler.pos()), tail.offset); 
-  } 
- 
-  // Commit changes 
+      ring->entry_begin_pos(head.index) - head.offset;
+
+  // Start filling at `tail`, or `entries` before `head`
+  Filler filler(rep, append ? rep->tail_ : rep->retreat(rep->head_, entries));
+
+  if (ring->refcount.IsOne()) {
+    // Copy entries from source stealing the ref and adjusting the end position.
+    // Commit the filler as this is no-op.
+    ring->ForEach(head.index, tail.index, [&](index_type ix) {
+      filler.Add(ring->entry_child(ix), ring->entry_data_offset(ix),
+                 ring->entry_end_pos(ix) + delta_length);
+    });
+
+    // Unref entries we did not copy over, and delete source.
+    if (head.index != ring->head_) UnrefEntries(ring, ring->head_, head.index);
+    if (tail.index != ring->tail_) UnrefEntries(ring, tail.index, ring->tail_);
+    CordRepRing::Delete(ring);
+  } else {
+    ring->ForEach(head.index, tail.index, [&](index_type ix) {
+      CordRep* child = ring->entry_child(ix);
+      filler.Add(child, ring->entry_data_offset(ix),
+                 ring->entry_end_pos(ix) + delta_length);
+      CordRep::Ref(child);
+    });
+    CordRepRing::Unref(ring);
+  }
+
+  if (head.offset) {
+    // Increase offset of first 'source' entry appended or prepended.
+    // This is always the entry in `filler.head()`
+    rep->AddDataOffset(filler.head(), head.offset);
+  }
+
+  if (tail.offset) {
+    // Reduce length of last 'source' entry appended or prepended.
+    // This is always the entry tailed by `filler.pos()`
+    rep->SubLength(rep->retreat(filler.pos()), tail.offset);
+  }
+
+  // Commit changes
   rep->length += len;
-  if (append) { 
-    rep->tail_ = filler.pos(); 
-  } else { 
-    rep->head_ = filler.head(); 
+  if (append) {
+    rep->tail_ = filler.pos();
+  } else {
+    rep->head_ = filler.head();
     rep->begin_pos_ -= len;
-  } 
- 
-  return Validate(rep); 
-} 
- 
-CordRepRing* CordRepRing::AppendSlow(CordRepRing* rep, CordRep* child) { 
+  }
+
+  return Validate(rep);
+}
+
+CordRepRing* CordRepRing::AppendSlow(CordRepRing* rep, CordRep* child) {
   Consume(child, [&rep](CordRep* child_arg, size_t offset, size_t len) {
     if (child_arg->IsRing()) {
       rep = AddRing<AddMode::kAppend>(rep, child_arg->ring(), offset, len);
-    } else { 
+    } else {
       rep = AppendLeaf(rep, child_arg, offset, len);
-    } 
-  }); 
-  return rep; 
-} 
- 
-CordRepRing* CordRepRing::AppendLeaf(CordRepRing* rep, CordRep* child, 
+    }
+  });
+  return rep;
+}
+
+CordRepRing* CordRepRing::AppendLeaf(CordRepRing* rep, CordRep* child,
                                      size_t offset, size_t len) {
-  rep = Mutable(rep, 1); 
-  index_type back = rep->tail_; 
-  const pos_type begin_pos = rep->begin_pos_ + rep->length; 
-  rep->tail_ = rep->advance(rep->tail_); 
+  rep = Mutable(rep, 1);
+  index_type back = rep->tail_;
+  const pos_type begin_pos = rep->begin_pos_ + rep->length;
+  rep->tail_ = rep->advance(rep->tail_);
   rep->length += len;
   rep->entry_end_pos()[back] = begin_pos + len;
-  rep->entry_child()[back] = child; 
-  rep->entry_data_offset()[back] = static_cast<offset_type>(offset); 
-  return Validate(rep, nullptr, __LINE__); 
-} 
- 
-CordRepRing* CordRepRing::Append(CordRepRing* rep, CordRep* child) { 
-  size_t length = child->length; 
-  if (IsFlatOrExternal(child)) { 
-    return AppendLeaf(rep, child, 0, length); 
-  } 
+  rep->entry_child()[back] = child;
+  rep->entry_data_offset()[back] = static_cast<offset_type>(offset);
+  return Validate(rep, nullptr, __LINE__);
+}
+
+CordRepRing* CordRepRing::Append(CordRepRing* rep, CordRep* child) {
+  size_t length = child->length;
+  if (IsFlatOrExternal(child)) {
+    return AppendLeaf(rep, child, 0, length);
+  }
   if (child->IsRing()) {
-    return AddRing<AddMode::kAppend>(rep, child->ring(), 0, length); 
-  } 
-  return AppendSlow(rep, child); 
-} 
- 
-CordRepRing* CordRepRing::PrependSlow(CordRepRing* rep, CordRep* child) { 
+    return AddRing<AddMode::kAppend>(rep, child->ring(), 0, length);
+  }
+  return AppendSlow(rep, child);
+}
+
+CordRepRing* CordRepRing::PrependSlow(CordRepRing* rep, CordRep* child) {
   ReverseConsume(child, [&](CordRep* child_arg, size_t offset, size_t len) {
     if (IsFlatOrExternal(child_arg)) {
       rep = PrependLeaf(rep, child_arg, offset, len);
-    } else { 
+    } else {
       rep = AddRing<AddMode::kPrepend>(rep, child_arg->ring(), offset, len);
-    } 
-  }); 
-  return Validate(rep); 
-} 
- 
-CordRepRing* CordRepRing::PrependLeaf(CordRepRing* rep, CordRep* child, 
+    }
+  });
+  return Validate(rep);
+}
+
+CordRepRing* CordRepRing::PrependLeaf(CordRepRing* rep, CordRep* child,
                                       size_t offset, size_t len) {
-  rep = Mutable(rep, 1); 
-  index_type head = rep->retreat(rep->head_); 
-  pos_type end_pos = rep->begin_pos_; 
-  rep->head_ = head; 
+  rep = Mutable(rep, 1);
+  index_type head = rep->retreat(rep->head_);
+  pos_type end_pos = rep->begin_pos_;
+  rep->head_ = head;
   rep->length += len;
   rep->begin_pos_ -= len;
-  rep->entry_end_pos()[head] = end_pos; 
-  rep->entry_child()[head] = child; 
-  rep->entry_data_offset()[head] = static_cast<offset_type>(offset); 
-  return Validate(rep); 
-} 
- 
-CordRepRing* CordRepRing::Prepend(CordRepRing* rep, CordRep* child) { 
-  size_t length = child->length; 
-  if (IsFlatOrExternal(child)) { 
-    return PrependLeaf(rep, child, 0, length); 
-  } 
+  rep->entry_end_pos()[head] = end_pos;
+  rep->entry_child()[head] = child;
+  rep->entry_data_offset()[head] = static_cast<offset_type>(offset);
+  return Validate(rep);
+}
+
+CordRepRing* CordRepRing::Prepend(CordRepRing* rep, CordRep* child) {
+  size_t length = child->length;
+  if (IsFlatOrExternal(child)) {
+    return PrependLeaf(rep, child, 0, length);
+  }
   if (child->IsRing()) {
-    return AddRing<AddMode::kPrepend>(rep, child->ring(), 0, length); 
-  } 
-  return PrependSlow(rep, child); 
-} 
- 
-CordRepRing* CordRepRing::Append(CordRepRing* rep, absl::string_view data, 
-                                 size_t extra) { 
+    return AddRing<AddMode::kPrepend>(rep, child->ring(), 0, length);
+  }
+  return PrependSlow(rep, child);
+}
+
+CordRepRing* CordRepRing::Append(CordRepRing* rep, absl::string_view data,
+                                 size_t extra) {
   if (rep->refcount.IsMutable()) {
-    Span<char> avail = rep->GetAppendBuffer(data.length()); 
-    if (!avail.empty()) { 
-      memcpy(avail.data(), data.data(), avail.length()); 
-      data.remove_prefix(avail.length()); 
-    } 
-  } 
-  if (data.empty()) return Validate(rep); 
- 
-  const size_t flats = (data.length() - 1) / kMaxFlatLength + 1; 
-  rep = Mutable(rep, flats); 
- 
-  Filler filler(rep, rep->tail_); 
-  pos_type pos = rep->begin_pos_ + rep->length; 
- 
-  while (data.length() >= kMaxFlatLength) { 
-    auto* flat = CreateFlat(data.data(), kMaxFlatLength); 
-    filler.Add(flat, 0, pos += kMaxFlatLength); 
-    data.remove_prefix(kMaxFlatLength); 
-  } 
- 
-  if (data.length()) { 
-    auto* flat = CreateFlat(data.data(), data.length(), extra); 
-    filler.Add(flat, 0, pos += data.length()); 
-  } 
- 
-  rep->length = pos - rep->begin_pos_; 
-  rep->tail_ = filler.pos(); 
- 
-  return Validate(rep); 
-} 
- 
-CordRepRing* CordRepRing::Prepend(CordRepRing* rep, absl::string_view data, 
-                                  size_t extra) { 
+    Span<char> avail = rep->GetAppendBuffer(data.length());
+    if (!avail.empty()) {
+      memcpy(avail.data(), data.data(), avail.length());
+      data.remove_prefix(avail.length());
+    }
+  }
+  if (data.empty()) return Validate(rep);
+
+  const size_t flats = (data.length() - 1) / kMaxFlatLength + 1;
+  rep = Mutable(rep, flats);
+
+  Filler filler(rep, rep->tail_);
+  pos_type pos = rep->begin_pos_ + rep->length;
+
+  while (data.length() >= kMaxFlatLength) {
+    auto* flat = CreateFlat(data.data(), kMaxFlatLength);
+    filler.Add(flat, 0, pos += kMaxFlatLength);
+    data.remove_prefix(kMaxFlatLength);
+  }
+
+  if (data.length()) {
+    auto* flat = CreateFlat(data.data(), data.length(), extra);
+    filler.Add(flat, 0, pos += data.length());
+  }
+
+  rep->length = pos - rep->begin_pos_;
+  rep->tail_ = filler.pos();
+
+  return Validate(rep);
+}
+
+CordRepRing* CordRepRing::Prepend(CordRepRing* rep, absl::string_view data,
+                                  size_t extra) {
   if (rep->refcount.IsMutable()) {
-    Span<char> avail = rep->GetPrependBuffer(data.length()); 
-    if (!avail.empty()) { 
-      const char* tail = data.data() + data.length() - avail.length(); 
-      memcpy(avail.data(), tail, avail.length()); 
-      data.remove_suffix(avail.length()); 
-    } 
-  } 
-  if (data.empty()) return rep; 
- 
-  const size_t flats = (data.length() - 1) / kMaxFlatLength + 1; 
-  rep = Mutable(rep, flats); 
-  pos_type pos = rep->begin_pos_; 
-  Filler filler(rep, rep->retreat(rep->head_, static_cast<index_type>(flats))); 
- 
-  size_t first_size = data.size() - (flats - 1) * kMaxFlatLength; 
-  CordRepFlat* flat = CordRepFlat::New(first_size + extra); 
-  flat->length = first_size + extra; 
-  memcpy(flat->Data() + extra, data.data(), first_size); 
-  data.remove_prefix(first_size); 
-  filler.Add(flat, extra, pos); 
-  pos -= first_size; 
- 
-  while (!data.empty()) { 
-    assert(data.size() >= kMaxFlatLength); 
-    flat = CreateFlat(data.data(), kMaxFlatLength); 
-    filler.Add(flat, 0, pos); 
-    pos -= kMaxFlatLength; 
-    data.remove_prefix(kMaxFlatLength); 
-  } 
- 
-  rep->head_ = filler.head(); 
-  rep->length += rep->begin_pos_ - pos; 
-  rep->begin_pos_ = pos; 
- 
-  return Validate(rep); 
-} 
- 
-// 32 entries is 32 * sizeof(pos_type) = 4 cache lines on x86 
-static constexpr index_type kBinarySearchThreshold = 32; 
-static constexpr index_type kBinarySearchEndCount = 8; 
- 
-template <bool wrap> 
-CordRepRing::index_type CordRepRing::FindBinary(index_type head, 
-                                                index_type tail, 
-                                                size_t offset) const { 
-  index_type count = tail + (wrap ? capacity_ : 0) - head; 
-  do { 
-    count = (count - 1) / 2; 
-    assert(count < entries(head, tail_)); 
-    index_type mid = wrap ? advance(head, count) : head + count; 
-    index_type after_mid = wrap ? advance(mid) : mid + 1; 
-    bool larger = (offset >= entry_end_offset(mid)); 
-    head = larger ? after_mid : head; 
-    tail = larger ? tail : mid; 
-    assert(head != tail); 
-  } while (ABSL_PREDICT_TRUE(count > kBinarySearchEndCount)); 
-  return head; 
-} 
- 
-CordRepRing::Position CordRepRing::FindSlow(index_type head, 
-                                            size_t offset) const { 
-  index_type tail = tail_; 
- 
-  // Binary search until we are good for linear search 
-  // Optimize for branchless / non wrapping ops 
-  if (tail > head) { 
-    index_type count = tail - head; 
-    if (count > kBinarySearchThreshold) { 
-      head = FindBinary<false>(head, tail, offset); 
-    } 
-  } else { 
-    index_type count = capacity_ + tail - head; 
-    if (count > kBinarySearchThreshold) { 
-      head = FindBinary<true>(head, tail, offset); 
-    } 
-  } 
- 
-  pos_type pos = entry_begin_pos(head); 
-  pos_type end_pos = entry_end_pos(head); 
-  while (offset >= Distance(begin_pos_, end_pos)) { 
-    head = advance(head); 
-    pos = end_pos; 
-    end_pos = entry_end_pos(head); 
-  } 
- 
-  return {head, offset - Distance(begin_pos_, pos)}; 
-} 
- 
-CordRepRing::Position CordRepRing::FindTailSlow(index_type head, 
-                                                size_t offset) const { 
-  index_type tail = tail_; 
-  const size_t tail_offset = offset - 1; 
- 
-  // Binary search until we are good for linear search 
-  // Optimize for branchless / non wrapping ops 
-  if (tail > head) { 
-    index_type count = tail - head; 
-    if (count > kBinarySearchThreshold) { 
-      head = FindBinary<false>(head, tail, tail_offset); 
-    } 
-  } else { 
-    index_type count = capacity_ + tail - head; 
-    if (count > kBinarySearchThreshold) { 
-      head = FindBinary<true>(head, tail, tail_offset); 
-    } 
-  } 
- 
-  size_t end_offset = entry_end_offset(head); 
-  while (tail_offset >= end_offset) { 
-    head = advance(head); 
-    end_offset = entry_end_offset(head); 
-  } 
- 
-  return {advance(head), end_offset - offset}; 
-} 
- 
-char CordRepRing::GetCharacter(size_t offset) const { 
-  assert(offset < length); 
- 
-  Position pos = Find(offset); 
-  size_t data_offset = entry_data_offset(pos.index) + pos.offset; 
-  return GetRepData(entry_child(pos.index))[data_offset]; 
-} 
- 
-CordRepRing* CordRepRing::SubRing(CordRepRing* rep, size_t offset, 
+    Span<char> avail = rep->GetPrependBuffer(data.length());
+    if (!avail.empty()) {
+      const char* tail = data.data() + data.length() - avail.length();
+      memcpy(avail.data(), tail, avail.length());
+      data.remove_suffix(avail.length());
+    }
+  }
+  if (data.empty()) return rep;
+
+  const size_t flats = (data.length() - 1) / kMaxFlatLength + 1;
+  rep = Mutable(rep, flats);
+  pos_type pos = rep->begin_pos_;
+  Filler filler(rep, rep->retreat(rep->head_, static_cast<index_type>(flats)));
+
+  size_t first_size = data.size() - (flats - 1) * kMaxFlatLength;
+  CordRepFlat* flat = CordRepFlat::New(first_size + extra);
+  flat->length = first_size + extra;
+  memcpy(flat->Data() + extra, data.data(), first_size);
+  data.remove_prefix(first_size);
+  filler.Add(flat, extra, pos);
+  pos -= first_size;
+
+  while (!data.empty()) {
+    assert(data.size() >= kMaxFlatLength);
+    flat = CreateFlat(data.data(), kMaxFlatLength);
+    filler.Add(flat, 0, pos);
+    pos -= kMaxFlatLength;
+    data.remove_prefix(kMaxFlatLength);
+  }
+
+  rep->head_ = filler.head();
+  rep->length += rep->begin_pos_ - pos;
+  rep->begin_pos_ = pos;
+
+  return Validate(rep);
+}
+
+// 32 entries is 32 * sizeof(pos_type) = 4 cache lines on x86
+static constexpr index_type kBinarySearchThreshold = 32;
+static constexpr index_type kBinarySearchEndCount = 8;
+
+template <bool wrap>
+CordRepRing::index_type CordRepRing::FindBinary(index_type head,
+                                                index_type tail,
+                                                size_t offset) const {
+  index_type count = tail + (wrap ? capacity_ : 0) - head;
+  do {
+    count = (count - 1) / 2;
+    assert(count < entries(head, tail_));
+    index_type mid = wrap ? advance(head, count) : head + count;
+    index_type after_mid = wrap ? advance(mid) : mid + 1;
+    bool larger = (offset >= entry_end_offset(mid));
+    head = larger ? after_mid : head;
+    tail = larger ? tail : mid;
+    assert(head != tail);
+  } while (ABSL_PREDICT_TRUE(count > kBinarySearchEndCount));
+  return head;
+}
+
+CordRepRing::Position CordRepRing::FindSlow(index_type head,
+                                            size_t offset) const {
+  index_type tail = tail_;
+
+  // Binary search until we are good for linear search
+  // Optimize for branchless / non wrapping ops
+  if (tail > head) {
+    index_type count = tail - head;
+    if (count > kBinarySearchThreshold) {
+      head = FindBinary<false>(head, tail, offset);
+    }
+  } else {
+    index_type count = capacity_ + tail - head;
+    if (count > kBinarySearchThreshold) {
+      head = FindBinary<true>(head, tail, offset);
+    }
+  }
+
+  pos_type pos = entry_begin_pos(head);
+  pos_type end_pos = entry_end_pos(head);
+  while (offset >= Distance(begin_pos_, end_pos)) {
+    head = advance(head);
+    pos = end_pos;
+    end_pos = entry_end_pos(head);
+  }
+
+  return {head, offset - Distance(begin_pos_, pos)};
+}
+
+CordRepRing::Position CordRepRing::FindTailSlow(index_type head,
+                                                size_t offset) const {
+  index_type tail = tail_;
+  const size_t tail_offset = offset - 1;
+
+  // Binary search until we are good for linear search
+  // Optimize for branchless / non wrapping ops
+  if (tail > head) {
+    index_type count = tail - head;
+    if (count > kBinarySearchThreshold) {
+      head = FindBinary<false>(head, tail, tail_offset);
+    }
+  } else {
+    index_type count = capacity_ + tail - head;
+    if (count > kBinarySearchThreshold) {
+      head = FindBinary<true>(head, tail, tail_offset);
+    }
+  }
+
+  size_t end_offset = entry_end_offset(head);
+  while (tail_offset >= end_offset) {
+    head = advance(head);
+    end_offset = entry_end_offset(head);
+  }
+
+  return {advance(head), end_offset - offset};
+}
+
+char CordRepRing::GetCharacter(size_t offset) const {
+  assert(offset < length);
+
+  Position pos = Find(offset);
+  size_t data_offset = entry_data_offset(pos.index) + pos.offset;
+  return GetRepData(entry_child(pos.index))[data_offset];
+}
+
+CordRepRing* CordRepRing::SubRing(CordRepRing* rep, size_t offset,
                                   size_t len, size_t extra) {
-  assert(offset <= rep->length); 
+  assert(offset <= rep->length);
   assert(offset <= rep->length - len);
- 
+
   if (len == 0) {
-    CordRep::Unref(rep); 
-    return nullptr; 
-  } 
- 
-  // Find position of first byte 
-  Position head = rep->Find(offset); 
+    CordRep::Unref(rep);
+    return nullptr;
+  }
+
+  // Find position of first byte
+  Position head = rep->Find(offset);
   Position tail = rep->FindTail(head.index, offset + len);
-  const size_t new_entries = rep->entries(head.index, tail.index); 
- 
+  const size_t new_entries = rep->entries(head.index, tail.index);
+
   if (rep->refcount.IsMutable() && extra <= (rep->capacity() - new_entries)) {
-    // We adopt a privately owned rep and no extra entries needed. 
-    if (head.index != rep->head_) UnrefEntries(rep, rep->head_, head.index); 
-    if (tail.index != rep->tail_) UnrefEntries(rep, tail.index, rep->tail_); 
-    rep->head_ = head.index; 
-    rep->tail_ = tail.index; 
-  } else { 
-    // Copy subset to new rep 
-    rep = Copy(rep, head.index, tail.index, extra); 
-    head.index = rep->head_; 
-    tail.index = rep->tail_; 
-  } 
- 
-  // Adjust begin_pos and length 
+    // We adopt a privately owned rep and no extra entries needed.
+    if (head.index != rep->head_) UnrefEntries(rep, rep->head_, head.index);
+    if (tail.index != rep->tail_) UnrefEntries(rep, tail.index, rep->tail_);
+    rep->head_ = head.index;
+    rep->tail_ = tail.index;
+  } else {
+    // Copy subset to new rep
+    rep = Copy(rep, head.index, tail.index, extra);
+    head.index = rep->head_;
+    tail.index = rep->tail_;
+  }
+
+  // Adjust begin_pos and length
   rep->length = len;
-  rep->begin_pos_ += offset; 
- 
-  // Adjust head and tail blocks 
-  if (head.offset) { 
-    rep->AddDataOffset(head.index, head.offset); 
-  } 
-  if (tail.offset) { 
-    rep->SubLength(rep->retreat(tail.index), tail.offset); 
-  } 
- 
-  return Validate(rep); 
-} 
- 
-CordRepRing* CordRepRing::RemovePrefix(CordRepRing* rep, size_t len, 
-                                       size_t extra) { 
-  assert(len <= rep->length); 
-  if (len == rep->length) { 
-    CordRep::Unref(rep); 
-    return nullptr; 
-  } 
- 
-  Position head = rep->Find(len); 
+  rep->begin_pos_ += offset;
+
+  // Adjust head and tail blocks
+  if (head.offset) {
+    rep->AddDataOffset(head.index, head.offset);
+  }
+  if (tail.offset) {
+    rep->SubLength(rep->retreat(tail.index), tail.offset);
+  }
+
+  return Validate(rep);
+}
+
+CordRepRing* CordRepRing::RemovePrefix(CordRepRing* rep, size_t len,
+                                       size_t extra) {
+  assert(len <= rep->length);
+  if (len == rep->length) {
+    CordRep::Unref(rep);
+    return nullptr;
+  }
+
+  Position head = rep->Find(len);
   if (rep->refcount.IsMutable()) {
-    if (head.index != rep->head_) UnrefEntries(rep, rep->head_, head.index); 
-    rep->head_ = head.index; 
-  } else { 
-    rep = Copy(rep, head.index, rep->tail_, extra); 
-    head.index = rep->head_; 
-  } 
- 
-  // Adjust begin_pos and length 
-  rep->length -= len; 
-  rep->begin_pos_ += len; 
- 
-  // Adjust head block 
-  if (head.offset) { 
-    rep->AddDataOffset(head.index, head.offset); 
-  } 
- 
-  return Validate(rep); 
-} 
- 
-CordRepRing* CordRepRing::RemoveSuffix(CordRepRing* rep, size_t len, 
-                                       size_t extra) { 
-  assert(len <= rep->length); 
- 
-  if (len == rep->length) { 
-    CordRep::Unref(rep); 
-    return nullptr; 
-  } 
- 
-  Position tail = rep->FindTail(rep->length - len); 
+    if (head.index != rep->head_) UnrefEntries(rep, rep->head_, head.index);
+    rep->head_ = head.index;
+  } else {
+    rep = Copy(rep, head.index, rep->tail_, extra);
+    head.index = rep->head_;
+  }
+
+  // Adjust begin_pos and length
+  rep->length -= len;
+  rep->begin_pos_ += len;
+
+  // Adjust head block
+  if (head.offset) {
+    rep->AddDataOffset(head.index, head.offset);
+  }
+
+  return Validate(rep);
+}
+
+CordRepRing* CordRepRing::RemoveSuffix(CordRepRing* rep, size_t len,
+                                       size_t extra) {
+  assert(len <= rep->length);
+
+  if (len == rep->length) {
+    CordRep::Unref(rep);
+    return nullptr;
+  }
+
+  Position tail = rep->FindTail(rep->length - len);
   if (rep->refcount.IsMutable()) {
-    // We adopt a privately owned rep, scrub. 
-    if (tail.index != rep->tail_) UnrefEntries(rep, tail.index, rep->tail_); 
-    rep->tail_ = tail.index; 
-  } else { 
-    // Copy subset to new rep 
-    rep = Copy(rep, rep->head_, tail.index, extra); 
-    tail.index = rep->tail_; 
-  } 
- 
-  // Adjust length 
-  rep->length -= len; 
- 
-  // Adjust tail block 
-  if (tail.offset) { 
-    rep->SubLength(rep->retreat(tail.index), tail.offset); 
-  } 
- 
-  return Validate(rep); 
-} 
- 
-}  // namespace cord_internal 
-ABSL_NAMESPACE_END 
-}  // namespace absl 
+    // We adopt a privately owned rep, scrub.
+    if (tail.index != rep->tail_) UnrefEntries(rep, tail.index, rep->tail_);
+    rep->tail_ = tail.index;
+  } else {
+    // Copy subset to new rep
+    rep = Copy(rep, rep->head_, tail.index, extra);
+    tail.index = rep->tail_;
+  }
+
+  // Adjust length
+  rep->length -= len;
+
+  // Adjust tail block
+  if (tail.offset) {
+    rep->SubLength(rep->retreat(tail.index), tail.offset);
+  }
+
+  return Validate(rep);
+}
+
+}  // namespace cord_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
diff --git a/contrib/restricted/abseil-cpp/absl/strings/internal/cord_rep_ring.h b/contrib/restricted/abseil-cpp/absl/strings/internal/cord_rep_ring.h
index f9b57a8bbf..2000e21ea0 100644
--- a/contrib/restricted/abseil-cpp/absl/strings/internal/cord_rep_ring.h
+++ b/contrib/restricted/abseil-cpp/absl/strings/internal/cord_rep_ring.h
@@ -1,233 +1,233 @@
-// Copyright 2020 The Abseil Authors 
-// 
-// Licensed under the Apache License, Version 2.0 (the "License"); 
-// you may not use this file except in compliance with the License. 
-// You may obtain a copy of the License at 
-// 
-//     https://www.apache.org/licenses/LICENSE-2.0 
-// 
-// Unless required by applicable law or agreed to in writing, software 
-// distributed under the License is distributed on an "AS IS" BASIS, 
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-// See the License for the specific language governing permissions and 
-// limitations under the License. 
- 
-#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_RING_H_ 
-#define ABSL_STRINGS_INTERNAL_CORD_REP_RING_H_ 
- 
-#include <cassert> 
-#include <cstddef> 
-#include <cstdint> 
-#include <iosfwd> 
-#include <limits> 
-#include <memory> 
- 
-#include "absl/container/internal/layout.h" 
-#include "absl/strings/internal/cord_internal.h" 
-#include "absl/strings/internal/cord_rep_flat.h" 
- 
-namespace absl { 
-ABSL_NAMESPACE_BEGIN 
-namespace cord_internal { 
- 
-// All operations modifying a ring buffer are implemented as static methods 
-// requiring a CordRepRing instance with a reference adopted by the method. 
-// 
-// The methods return the modified ring buffer, which may be equal to the input 
-// if the input was not shared, and having large enough capacity to accommodate 
-// any newly added node(s). Otherwise, a copy of the input rep with the new 
-// node(s) added is returned. 
-// 
-// Any modification on non shared ring buffers with enough capacity will then 
-// require minimum atomic operations. Caller should where possible provide 
-// reasonable `extra` hints for both anticipated extra `flat` byte space, as 
-// well as anticipated extra nodes required for complex operations. 
-// 
-// Example of code creating a ring buffer, adding some data to it, 
-// and discarding the buffer when done: 
-// 
-//   void FunWithRings() { 
-//     // Create ring with 3 flats 
-//     CordRep* flat = CreateFlat("Hello"); 
-//     CordRepRing* ring = CordRepRing::Create(flat, 2); 
-//     ring = CordRepRing::Append(ring, CreateFlat(" ")); 
-//     ring = CordRepRing::Append(ring, CreateFlat("world")); 
-//     DoSomethingWithRing(ring); 
-//     CordRep::Unref(ring); 
-//   } 
-// 
-// Example of code Copying an existing ring buffer and modifying it: 
-// 
-//   void MoreFunWithRings(CordRepRing* src) { 
-//     CordRepRing* ring = CordRep::Ref(src)->ring(); 
-//     ring = CordRepRing::Append(ring, CreateFlat("Hello")); 
-//     ring = CordRepRing::Append(ring, CreateFlat(" ")); 
-//     ring = CordRepRing::Append(ring, CreateFlat("world")); 
-//     DoSomethingWithRing(ring); 
-//     CordRep::Unref(ring); 
-//   } 
-// 
-class CordRepRing : public CordRep { 
- public: 
-  // `pos_type` represents a 'logical position'. A CordRepRing instance has a 
-  // `begin_pos` (default 0), and each node inside the buffer will have an 
-  // `end_pos` which is the `end_pos` of the previous node (or `begin_pos`) plus 
-  // this node's length. The purpose is to allow for a binary search on this 
-  // position, while allowing O(1) prepend and append operations. 
-  using pos_type = size_t; 
- 
-  // `index_type` is the type for the `head`, `tail` and `capacity` indexes. 
-  // Ring buffers are limited to having no more than four billion entries. 
-  using index_type = uint32_t; 
- 
-  // `offset_type` is the type for the data offset inside a child rep's data. 
-  using offset_type = uint32_t; 
- 
-  // Position holds the node index and relative offset into the node for 
-  // some physical offset in the contained data as returned by the Find() 
-  // and FindTail() methods. 
-  struct Position { 
-    index_type index; 
-    size_t offset; 
-  }; 
- 
-  // The maximum # of child nodes that can be hosted inside a CordRepRing. 
-  static constexpr size_t kMaxCapacity = (std::numeric_limits<uint32_t>::max)(); 
- 
-  // CordRepring can not be default constructed, moved, copied or assigned. 
-  CordRepRing() = delete; 
-  CordRepRing(const CordRepRing&) = delete; 
-  CordRepRing& operator=(const CordRepRing&) = delete; 
- 
-  // Returns true if this instance is valid, false if some or all of the 
-  // invariants are broken. Intended for debug purposes only. 
-  // `output` receives an explanation of the broken invariants. 
-  bool IsValid(std::ostream& output) const; 
- 
-  // Returns the size in bytes for a CordRepRing with `capacity' entries. 
-  static constexpr size_t AllocSize(size_t capacity); 
- 
-  // Returns the distance in bytes from `pos` to `end_pos`. 
-  static constexpr size_t Distance(pos_type pos, pos_type end_pos); 
- 
-  // Creates a new ring buffer from the provided `rep`. Adopts a reference 
-  // on `rep`. The returned ring buffer has a capacity of at least `extra + 1` 
-  static CordRepRing* Create(CordRep* child, size_t extra = 0); 
- 
-  // `head`, `tail` and `capacity` indexes defining the ring buffer boundaries. 
-  index_type head() const { return head_; } 
-  index_type tail() const { return tail_; } 
-  index_type capacity() const { return capacity_; } 
- 
-  // Returns the number of entries in this instance. 
-  index_type entries() const { return entries(head_, tail_); } 
- 
-  // Returns the logical begin position of this instance. 
-  pos_type begin_pos() const { return begin_pos_; } 
- 
-  // Returns the number of entries for a given head-tail range. 
-  // Requires `head` and `tail` values to be less than `capacity()`. 
-  index_type entries(index_type head, index_type tail) const { 
-    assert(head < capacity_ && tail < capacity_); 
-    return tail - head + ((tail > head) ? 0 : capacity_); 
-  } 
- 
-  // Returns the logical end position of entry `index`. 
-  pos_type const& entry_end_pos(index_type index) const { 
-    assert(IsValidIndex(index)); 
-    return Layout::Partial().Pointer<0>(data_)[index]; 
-  } 
- 
-  // Returns the child pointer of entry `index`. 
-  CordRep* const& entry_child(index_type index) const { 
-    assert(IsValidIndex(index)); 
-    return Layout::Partial(capacity()).Pointer<1>(data_)[index]; 
-  } 
- 
-  // Returns the data offset of entry `index` 
-  offset_type const& entry_data_offset(index_type index) const { 
-    assert(IsValidIndex(index)); 
-    return Layout::Partial(capacity(), capacity()).Pointer<2>(data_)[index]; 
-  } 
- 
-  // Appends the provided child node to the `rep` instance. 
-  // Adopts a reference from `rep` and `child` which may not be null. 
-  // If the provided child is a FLAT or EXTERNAL node, or a SUBSTRING node 
-  // containing a FLAT or EXTERNAL node, then flat or external the node is added 
-  // 'as is', with an offset added for the SUBSTRING case. 
-  // If the provided child is a RING or CONCAT tree, or a SUBSTRING of a RING or 
-  // CONCAT tree, then all child nodes not excluded by any start offset or 
-  // length values are added recursively. 
-  static CordRepRing* Append(CordRepRing* rep, CordRep* child); 
- 
-  // Appends the provided string data to the `rep` instance. 
-  // This function will attempt to utilize any remaining capacity in the last 
-  // node of the input if that node is not shared (directly or indirectly), and 
-  // of type FLAT. Remaining data will be added as one or more FLAT nodes. 
-  // Any last node added to the ring buffer will be allocated with up to 
-  // `extra` bytes of capacity for (anticipated) subsequent append actions. 
-  static CordRepRing* Append(CordRepRing* rep, string_view data, 
-                             size_t extra = 0); 
- 
-  // Prepends the provided child node to the `rep` instance. 
-  // Adopts a reference from `rep` and `child` which may not be null. 
-  // If the provided child is a FLAT or EXTERNAL node, or a SUBSTRING node 
-  // containing a FLAT or EXTERNAL node, then flat or external the node is 
-  // prepended 'as is', with an optional offset added for the SUBSTRING case. 
-  // If the provided child is a RING or CONCAT tree, or a SUBSTRING of a RING 
-  // or CONCAT tree, then all child nodes not excluded by any start offset or 
-  // length values are added recursively. 
-  static CordRepRing* Prepend(CordRepRing* rep, CordRep* child); 
- 
-  // Prepends the provided string data to the `rep` instance. 
-  // This function will attempt to utilize any remaining capacity in the first 
-  // node of the input if that node is not shared (directly or indirectly), and 
-  // of type FLAT. Remaining data will be added as one or more FLAT nodes. 
-  // Any first node prepnded to the ring buffer will be allocated with up to 
-  // `extra` bytes of capacity for (anticipated) subsequent prepend actions. 
-  static CordRepRing* Prepend(CordRepRing* rep, string_view data, 
-                              size_t extra = 0); 
- 
-  // Returns a span referencing potentially unused capacity in the last node. 
-  // The returned span may be empty if no such capacity is available, or if the 
-  // current instance is shared. Else, a span of size `n <= size` is returned. 
-  // If non empty, the ring buffer is adjusted to the new length, with the newly 
-  // added capacity left uninitialized. Callers should assign a value to the 
-  // entire span before any other operations on this instance. 
-  Span<char> GetAppendBuffer(size_t size); 
- 
-  // Returns a span referencing potentially unused capacity in the first node. 
-  // This function is identical to GetAppendBuffer except that it returns a span 
-  // referencing up to `size` capacity directly before the existing data. 
-  Span<char> GetPrependBuffer(size_t size); 
- 
+// Copyright 2020 The Abseil Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_RING_H_
+#define ABSL_STRINGS_INTERNAL_CORD_REP_RING_H_
+
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <iosfwd>
+#include <limits>
+#include <memory>
+
+#include "absl/container/internal/layout.h"
+#include "absl/strings/internal/cord_internal.h"
+#include "absl/strings/internal/cord_rep_flat.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace cord_internal {
+
+// All operations modifying a ring buffer are implemented as static methods
+// requiring a CordRepRing instance with a reference adopted by the method.
+//
+// The methods return the modified ring buffer, which may be equal to the input
+// if the input was not shared, and having large enough capacity to accommodate
+// any newly added node(s). Otherwise, a copy of the input rep with the new
+// node(s) added is returned.
+//
+// Any modification on non shared ring buffers with enough capacity will then
+// require minimum atomic operations. Caller should where possible provide
+// reasonable `extra` hints for both anticipated extra `flat` byte space, as
+// well as anticipated extra nodes required for complex operations.
+//
+// Example of code creating a ring buffer, adding some data to it,
+// and discarding the buffer when done:
+//
+//   void FunWithRings() {
+//     // Create ring with 3 flats
+//     CordRep* flat = CreateFlat("Hello");
+//     CordRepRing* ring = CordRepRing::Create(flat, 2);
+//     ring = CordRepRing::Append(ring, CreateFlat(" "));
+//     ring = CordRepRing::Append(ring, CreateFlat("world"));
+//     DoSomethingWithRing(ring);
+//     CordRep::Unref(ring);
+//   }
+//
+// Example of code Copying an existing ring buffer and modifying it:
+//
+//   void MoreFunWithRings(CordRepRing* src) {
+//     CordRepRing* ring = CordRep::Ref(src)->ring();
+//     ring = CordRepRing::Append(ring, CreateFlat("Hello"));
+//     ring = CordRepRing::Append(ring, CreateFlat(" "));
+//     ring = CordRepRing::Append(ring, CreateFlat("world"));
+//     DoSomethingWithRing(ring);
+//     CordRep::Unref(ring);
+//   }
+//
+class CordRepRing : public CordRep {
+ public:
+  // `pos_type` represents a 'logical position'. A CordRepRing instance has a
+  // `begin_pos` (default 0), and each node inside the buffer will have an
+  // `end_pos` which is the `end_pos` of the previous node (or `begin_pos`) plus
+  // this node's length. The purpose is to allow for a binary search on this
+  // position, while allowing O(1) prepend and append operations.
+  using pos_type = size_t;
+
+  // `index_type` is the type for the `head`, `tail` and `capacity` indexes.
+  // Ring buffers are limited to having no more than four billion entries.
+  using index_type = uint32_t;
+
+  // `offset_type` is the type for the data offset inside a child rep's data.
+  using offset_type = uint32_t;
+
+  // Position holds the node index and relative offset into the node for
+  // some physical offset in the contained data as returned by the Find()
+  // and FindTail() methods.
+  struct Position {
+    index_type index;
+    size_t offset;
+  };
+
+  // The maximum # of child nodes that can be hosted inside a CordRepRing.
+  static constexpr size_t kMaxCapacity = (std::numeric_limits<uint32_t>::max)();
+
+  // CordRepring can not be default constructed, moved, copied or assigned.
+  CordRepRing() = delete;
+  CordRepRing(const CordRepRing&) = delete;
+  CordRepRing& operator=(const CordRepRing&) = delete;
+
+  // Returns true if this instance is valid, false if some or all of the
+  // invariants are broken. Intended for debug purposes only.
+  // `output` receives an explanation of the broken invariants.
+  bool IsValid(std::ostream& output) const;
+
+  // Returns the size in bytes for a CordRepRing with `capacity' entries.
+  static constexpr size_t AllocSize(size_t capacity);
+
+  // Returns the distance in bytes from `pos` to `end_pos`.
+  static constexpr size_t Distance(pos_type pos, pos_type end_pos);
+
+  // Creates a new ring buffer from the provided `rep`. Adopts a reference
+  // on `rep`. The returned ring buffer has a capacity of at least `extra + 1`
+  static CordRepRing* Create(CordRep* child, size_t extra = 0);
+
+  // `head`, `tail` and `capacity` indexes defining the ring buffer boundaries.
+  index_type head() const { return head_; }
+  index_type tail() const { return tail_; }
+  index_type capacity() const { return capacity_; }
+
+  // Returns the number of entries in this instance.
+  index_type entries() const { return entries(head_, tail_); }
+
+  // Returns the logical begin position of this instance.
+  pos_type begin_pos() const { return begin_pos_; }
+
+  // Returns the number of entries for a given head-tail range.
+  // Requires `head` and `tail` values to be less than `capacity()`.
+  index_type entries(index_type head, index_type tail) const {
+    assert(head < capacity_ && tail < capacity_);
+    return tail - head + ((tail > head) ? 0 : capacity_);
+  }
+
+  // Returns the logical end position of entry `index`.
+  pos_type const& entry_end_pos(index_type index) const {
+    assert(IsValidIndex(index));
+    return Layout::Partial().Pointer<0>(data_)[index];
+  }
+
+  // Returns the child pointer of entry `index`.
+  CordRep* const& entry_child(index_type index) const {
+    assert(IsValidIndex(index));
+    return Layout::Partial(capacity()).Pointer<1>(data_)[index];
+  }
+
+  // Returns the data offset of entry `index`
+  offset_type const& entry_data_offset(index_type index) const {
+    assert(IsValidIndex(index));
+    return Layout::Partial(capacity(), capacity()).Pointer<2>(data_)[index];
+  }
+
+  // Appends the provided child node to the `rep` instance.
+  // Adopts a reference from `rep` and `child` which may not be null.
+  // If the provided child is a FLAT or EXTERNAL node, or a SUBSTRING node
+  // containing a FLAT or EXTERNAL node, then flat or external the node is added
+  // 'as is', with an offset added for the SUBSTRING case.
+  // If the provided child is a RING or CONCAT tree, or a SUBSTRING of a RING or
+  // CONCAT tree, then all child nodes not excluded by any start offset or
+  // length values are added recursively.
+  static CordRepRing* Append(CordRepRing* rep, CordRep* child);
+
+  // Appends the provided string data to the `rep` instance.
+  // This function will attempt to utilize any remaining capacity in the last
+  // node of the input if that node is not shared (directly or indirectly), and
+  // of type FLAT. Remaining data will be added as one or more FLAT nodes.
+  // Any last node added to the ring buffer will be allocated with up to
+  // `extra` bytes of capacity for (anticipated) subsequent append actions.
+  static CordRepRing* Append(CordRepRing* rep, string_view data,
+                             size_t extra = 0);
+
+  // Prepends the provided child node to the `rep` instance.
+  // Adopts a reference from `rep` and `child` which may not be null.
+  // If the provided child is a FLAT or EXTERNAL node, or a SUBSTRING node
+  // containing a FLAT or EXTERNAL node, then flat or external the node is
+  // prepended 'as is', with an optional offset added for the SUBSTRING case.
+  // If the provided child is a RING or CONCAT tree, or a SUBSTRING of a RING
+  // or CONCAT tree, then all child nodes not excluded by any start offset or
+  // length values are added recursively.
+  static CordRepRing* Prepend(CordRepRing* rep, CordRep* child);
+
+  // Prepends the provided string data to the `rep` instance.
+  // This function will attempt to utilize any remaining capacity in the first
+  // node of the input if that node is not shared (directly or indirectly), and
+  // of type FLAT. Remaining data will be added as one or more FLAT nodes.
+  // Any first node prepnded to the ring buffer will be allocated with up to
+  // `extra` bytes of capacity for (anticipated) subsequent prepend actions.
+  static CordRepRing* Prepend(CordRepRing* rep, string_view data,
+                              size_t extra = 0);
+
+  // Returns a span referencing potentially unused capacity in the last node.
+  // The returned span may be empty if no such capacity is available, or if the
+  // current instance is shared. Else, a span of size `n <= size` is returned.
+  // If non empty, the ring buffer is adjusted to the new length, with the newly
+  // added capacity left uninitialized. Callers should assign a value to the
+  // entire span before any other operations on this instance.
+  Span<char> GetAppendBuffer(size_t size);
+
+  // Returns a span referencing potentially unused capacity in the first node.
+  // This function is identical to GetAppendBuffer except that it returns a span
+  // referencing up to `size` capacity directly before the existing data.
+  Span<char> GetPrependBuffer(size_t size);
+
   // Returns a cord ring buffer containing `len` bytes of data starting at
-  // `offset`. If the input is not shared, this function will remove all head 
-  // and tail child nodes outside of the requested range, and adjust the new 
-  // head and tail nodes as required. If the input is shared, this function 
-  // returns a new instance sharing some or all of the nodes from the input. 
+  // `offset`. If the input is not shared, this function will remove all head
+  // and tail child nodes outside of the requested range, and adjust the new
+  // head and tail nodes as required. If the input is shared, this function
+  // returns a new instance sharing some or all of the nodes from the input.
   static CordRepRing* SubRing(CordRepRing* r, size_t offset, size_t len,
-                              size_t extra = 0); 
- 
+                              size_t extra = 0);
+
   // Returns a cord ring buffer with the first `len` bytes removed.
-  // If the input is not shared, this function will remove all head child nodes 
-  // fully inside the first `length` bytes, and adjust the new head as required. 
-  // If the input is shared, this function returns a new instance sharing some 
-  // or all of the nodes from the input. 
+  // If the input is not shared, this function will remove all head child nodes
+  // fully inside the first `length` bytes, and adjust the new head as required.
+  // If the input is shared, this function returns a new instance sharing some
+  // or all of the nodes from the input.
   static CordRepRing* RemoveSuffix(CordRepRing* r, size_t len,
-                                   size_t extra = 0); 
- 
+                                   size_t extra = 0);
+
   // Returns a cord ring buffer with the last `len` bytes removed.
-  // If the input is not shared, this function will remove all head child nodes 
-  // fully inside the first `length` bytes, and adjust the new head as required. 
-  // If the input is shared, this function returns a new instance sharing some 
-  // or all of the nodes from the input. 
-  static CordRepRing* RemovePrefix(CordRepRing* r, size_t len, 
-                                   size_t extra = 0); 
- 
-  // Returns the character at `offset`. Requires that `offset < length`. 
-  char GetCharacter(size_t offset) const; 
- 
+  // If the input is not shared, this function will remove all head child nodes
+  // fully inside the first `length` bytes, and adjust the new head as required.
+  // If the input is shared, this function returns a new instance sharing some
+  // or all of the nodes from the input.
+  static CordRepRing* RemovePrefix(CordRepRing* r, size_t len,
+                                   size_t extra = 0);
+
+  // Returns the character at `offset`. Requires that `offset < length`.
+  char GetCharacter(size_t offset) const;
+
   // Returns true if this instance manages a single contiguous buffer, in which
   // case the (optional) output parameter `fragment` is set. Otherwise, the
   // function returns false, and `fragment` is left unchanged.
@@ -240,345 +240,345 @@ class CordRepRing : public CordRep {
   // returns false, and `fragment` is left unchanged.
   bool IsFlat(size_t offset, size_t len, absl::string_view* fragment) const;
 
-  // Testing only: set capacity to requested capacity. 
-  void SetCapacityForTesting(size_t capacity); 
- 
-  // Returns the CordRep data pointer for the provided CordRep. 
-  // Requires that the provided `rep` is either a FLAT or EXTERNAL CordRep. 
-  static const char* GetLeafData(const CordRep* rep); 
- 
-  // Returns the CordRep data pointer for the provided CordRep. 
-  // Requires that `rep` is either a FLAT, EXTERNAL, or SUBSTRING CordRep. 
-  static const char* GetRepData(const CordRep* rep); 
- 
-  // Advances the provided position, wrapping around capacity as needed. 
-  // Requires `index` < capacity() 
-  inline index_type advance(index_type index) const; 
- 
-  // Advances the provided position by 'n`, wrapping around capacity as needed. 
-  // Requires `index` < capacity() and `n` <= capacity. 
-  inline index_type advance(index_type index, index_type n) const; 
- 
-  // Retreats the provided position, wrapping around 0 as needed. 
-  // Requires `index` < capacity() 
-  inline index_type retreat(index_type index) const; 
- 
-  // Retreats the provided position by 'n', wrapping around 0 as needed. 
-  // Requires `index` < capacity() 
-  inline index_type retreat(index_type index, index_type n) const; 
- 
-  // Returns the logical begin position of entry `index` 
-  pos_type const& entry_begin_pos(index_type index) const { 
-    return (index == head_) ? begin_pos_ : entry_end_pos(retreat(index)); 
-  } 
- 
-  // Returns the physical start offset of entry `index` 
-  size_t entry_start_offset(index_type index) const { 
-    return Distance(begin_pos_, entry_begin_pos(index)); 
-  } 
- 
-  // Returns the physical end offset of entry `index` 
-  size_t entry_end_offset(index_type index) const { 
-    return Distance(begin_pos_, entry_end_pos(index)); 
-  } 
- 
-  // Returns the data length for entry `index` 
-  size_t entry_length(index_type index) const { 
-    return Distance(entry_begin_pos(index), entry_end_pos(index)); 
-  } 
- 
-  // Returns the data for entry `index` 
-  absl::string_view entry_data(index_type index) const; 
- 
-  // Returns the position for `offset` as {index, prefix}. `index` holds the 
-  // index of the entry at the specified offset and `prefix` holds the relative 
-  // offset inside that entry. 
-  // Requires `offset` < length. 
-  // 
-  // For example we can implement GetCharacter(offset) as: 
-  //   char GetCharacter(size_t offset) { 
-  //     Position pos = this->Find(offset); 
-  //     return this->entry_data(pos.pos)[pos.offset]; 
-  //   } 
-  inline Position Find(size_t offset) const; 
- 
-  // Find starting at `head` 
-  inline Position Find(index_type head, size_t offset) const; 
- 
-  // Returns the tail position for `offset` as {tail index, suffix}. 
-  // `tail index` holds holds the index of the entry holding the offset directly 
-  // before 'offset` advanced by one. 'suffix` holds the relative offset from 
-  // that relative offset in the entry to the end of the entry. 
-  // For example, FindTail(length) will return {tail(), 0}, FindTail(length - 5) 
-  // will return {retreat(tail), 5)} provided the preceding entry contains at 
-  // least 5 bytes of data. 
-  // Requires offset >= 1 && offset <= length. 
-  // 
-  // This function is very useful in functions that need to clip the end of some 
-  // ring buffer such as 'RemovePrefix'. 
-  // For example, we could implement RemovePrefix for non shared instances as: 
-  //   void RemoveSuffix(size_t n) { 
-  //     Position pos = FindTail(length - n); 
-  //     UnrefEntries(pos.pos, this->tail_); 
-  //     this->tail_ = pos.pos; 
-  //     entry(retreat(pos.pos)).end_pos -= pos.offset; 
-  //   } 
-  inline Position FindTail(size_t offset) const; 
- 
-  // Find tail starting at `head` 
-  inline Position FindTail(index_type head, size_t offset) const; 
- 
-  // Invokes f(index_type index) for each entry inside the range [head, tail> 
-  template <typename F> 
-  void ForEach(index_type head, index_type tail, F&& f) const { 
-    index_type n1 = (tail > head) ? tail : capacity_; 
-    for (index_type i = head; i < n1; ++i) f(i); 
-    if (tail <= head) { 
-      for (index_type i = 0; i < tail; ++i) f(i); 
-    } 
-  } 
- 
-  // Invokes f(index_type index) for each entry inside this instance. 
-  template <typename F> 
-  void ForEach(F&& f) const { 
-    ForEach(head_, tail_, std::forward<F>(f)); 
-  } 
- 
-  // Dump this instance's data tp stream `s` in human readable format, excluding 
-  // the actual data content itself. Intended for debug purposes only. 
-  friend std::ostream& operator<<(std::ostream& s, const CordRepRing& rep); 
- 
- private: 
-  enum class AddMode { kAppend, kPrepend }; 
- 
-  using Layout = container_internal::Layout<pos_type, CordRep*, offset_type>; 
- 
-  class Filler; 
-  class Transaction; 
-  class CreateTransaction; 
- 
-  static constexpr size_t kLayoutAlignment = Layout::Partial().Alignment(); 
- 
-  // Creates a new CordRepRing. 
-  explicit CordRepRing(index_type capacity) : capacity_(capacity) {} 
- 
-  // Returns true if `index` is a valid index into this instance. 
-  bool IsValidIndex(index_type index) const; 
- 
-  // Debug use only: validates the provided CordRepRing invariants. 
-  // Verification of all CordRepRing methods can be enabled by defining 
-  // EXTRA_CORD_RING_VALIDATION, i.e.: `--copts=-DEXTRA_CORD_RING_VALIDATION` 
-  // Verification is VERY expensive, so only do it for debugging purposes. 
-  static CordRepRing* Validate(CordRepRing* rep, const char* file = nullptr, 
-                               int line = 0); 
- 
-  // Allocates a CordRepRing large enough to hold `capacity + extra' entries. 
-  // The returned capacity may be larger if the allocated memory allows for it. 
-  // The maximum capacity of a CordRepRing is capped at kMaxCapacity. 
-  // Throws `std::length_error` if `capacity + extra' exceeds kMaxCapacity. 
-  static CordRepRing* New(size_t capacity, size_t extra); 
- 
-  // Deallocates (but does not destroy) the provided ring buffer. 
-  static void Delete(CordRepRing* rep); 
- 
-  // Destroys the provided ring buffer, decrementing the reference count of all 
-  // contained child CordReps. The provided 1\`rep` should have a ref count of 
+  // Testing only: set capacity to requested capacity.
+  void SetCapacityForTesting(size_t capacity);
+
+  // Returns the CordRep data pointer for the provided CordRep.
+  // Requires that the provided `rep` is either a FLAT or EXTERNAL CordRep.
+  static const char* GetLeafData(const CordRep* rep);
+
+  // Returns the CordRep data pointer for the provided CordRep.
+  // Requires that `rep` is either a FLAT, EXTERNAL, or SUBSTRING CordRep.
+  static const char* GetRepData(const CordRep* rep);
+
+  // Advances the provided position, wrapping around capacity as needed.
+  // Requires `index` < capacity()
+  inline index_type advance(index_type index) const;
+
+  // Advances the provided position by 'n`, wrapping around capacity as needed.
+  // Requires `index` < capacity() and `n` <= capacity.
+  inline index_type advance(index_type index, index_type n) const;
+
+  // Retreats the provided position, wrapping around 0 as needed.
+  // Requires `index` < capacity()
+  inline index_type retreat(index_type index) const;
+
+  // Retreats the provided position by 'n', wrapping around 0 as needed.
+  // Requires `index` < capacity()
+  inline index_type retreat(index_type index, index_type n) const;
+
+  // Returns the logical begin position of entry `index`
+  pos_type const& entry_begin_pos(index_type index) const {
+    return (index == head_) ? begin_pos_ : entry_end_pos(retreat(index));
+  }
+
+  // Returns the physical start offset of entry `index`
+  size_t entry_start_offset(index_type index) const {
+    return Distance(begin_pos_, entry_begin_pos(index));
+  }
+
+  // Returns the physical end offset of entry `index`
+  size_t entry_end_offset(index_type index) const {
+    return Distance(begin_pos_, entry_end_pos(index));
+  }
+
+  // Returns the data length for entry `index`
+  size_t entry_length(index_type index) const {
+    return Distance(entry_begin_pos(index), entry_end_pos(index));
+  }
+
+  // Returns the data for entry `index`
+  absl::string_view entry_data(index_type index) const;
+
+  // Returns the position for `offset` as {index, prefix}. `index` holds the
+  // index of the entry at the specified offset and `prefix` holds the relative
+  // offset inside that entry.
+  // Requires `offset` < length.
+  //
+  // For example we can implement GetCharacter(offset) as:
+  //   char GetCharacter(size_t offset) {
+  //     Position pos = this->Find(offset);
+  //     return this->entry_data(pos.pos)[pos.offset];
+  //   }
+  inline Position Find(size_t offset) const;
+
+  // Find starting at `head`
+  inline Position Find(index_type head, size_t offset) const;
+
+  // Returns the tail position for `offset` as {tail index, suffix}.
+  // `tail index` holds holds the index of the entry holding the offset directly
+  // before 'offset` advanced by one. 'suffix` holds the relative offset from
+  // that relative offset in the entry to the end of the entry.
+  // For example, FindTail(length) will return {tail(), 0}, FindTail(length - 5)
+  // will return {retreat(tail), 5)} provided the preceding entry contains at
+  // least 5 bytes of data.
+  // Requires offset >= 1 && offset <= length.
+  //
+  // This function is very useful in functions that need to clip the end of some
+  // ring buffer such as 'RemovePrefix'.
+  // For example, we could implement RemovePrefix for non shared instances as:
+  //   void RemoveSuffix(size_t n) {
+  //     Position pos = FindTail(length - n);
+  //     UnrefEntries(pos.pos, this->tail_);
+  //     this->tail_ = pos.pos;
+  //     entry(retreat(pos.pos)).end_pos -= pos.offset;
+  //   }
+  inline Position FindTail(size_t offset) const;
+
+  // Find tail starting at `head`
+  inline Position FindTail(index_type head, size_t offset) const;
+
+  // Invokes f(index_type index) for each entry inside the range [head, tail>
+  template <typename F>
+  void ForEach(index_type head, index_type tail, F&& f) const {
+    index_type n1 = (tail > head) ? tail : capacity_;
+    for (index_type i = head; i < n1; ++i) f(i);
+    if (tail <= head) {
+      for (index_type i = 0; i < tail; ++i) f(i);
+    }
+  }
+
+  // Invokes f(index_type index) for each entry inside this instance.
+  template <typename F>
+  void ForEach(F&& f) const {
+    ForEach(head_, tail_, std::forward<F>(f));
+  }
+
+  // Dump this instance's data tp stream `s` in human readable format, excluding
+  // the actual data content itself. Intended for debug purposes only.
+  friend std::ostream& operator<<(std::ostream& s, const CordRepRing& rep);
+
+ private:
+  enum class AddMode { kAppend, kPrepend };
+
+  using Layout = container_internal::Layout<pos_type, CordRep*, offset_type>;
+
+  class Filler;
+  class Transaction;
+  class CreateTransaction;
+
+  static constexpr size_t kLayoutAlignment = Layout::Partial().Alignment();
+
+  // Creates a new CordRepRing.
+  explicit CordRepRing(index_type capacity) : capacity_(capacity) {}
+
+  // Returns true if `index` is a valid index into this instance.
+  bool IsValidIndex(index_type index) const;
+
+  // Debug use only: validates the provided CordRepRing invariants.
+  // Verification of all CordRepRing methods can be enabled by defining
+  // EXTRA_CORD_RING_VALIDATION, i.e.: `--copts=-DEXTRA_CORD_RING_VALIDATION`
+  // Verification is VERY expensive, so only do it for debugging purposes.
+  static CordRepRing* Validate(CordRepRing* rep, const char* file = nullptr,
+                               int line = 0);
+
+  // Allocates a CordRepRing large enough to hold `capacity + extra' entries.
+  // The returned capacity may be larger if the allocated memory allows for it.
+  // The maximum capacity of a CordRepRing is capped at kMaxCapacity.
+  // Throws `std::length_error` if `capacity + extra' exceeds kMaxCapacity.
+  static CordRepRing* New(size_t capacity, size_t extra);
+
+  // Deallocates (but does not destroy) the provided ring buffer.
+  static void Delete(CordRepRing* rep);
+
+  // Destroys the provided ring buffer, decrementing the reference count of all
+  // contained child CordReps. The provided 1\`rep` should have a ref count of
   // one (pre decrement destroy call observing `refcount.IsOne()`) or zero
   // (post decrement destroy call observing `!refcount.Decrement()`).
-  static void Destroy(CordRepRing* rep); 
- 
-  // Returns a mutable reference to the logical end position array. 
-  pos_type* entry_end_pos() { 
-    return Layout::Partial().Pointer<0>(data_); 
-  } 
- 
-  // Returns a mutable reference to the child pointer array. 
-  CordRep** entry_child() { 
-    return Layout::Partial(capacity()).Pointer<1>(data_); 
-  } 
- 
-  // Returns a mutable reference to the data offset array. 
-  offset_type* entry_data_offset() { 
-    return Layout::Partial(capacity(), capacity()).Pointer<2>(data_); 
-  } 
- 
-  // Find implementations for the non fast path 0 / length cases. 
-  Position FindSlow(index_type head, size_t offset) const; 
-  Position FindTailSlow(index_type head, size_t offset) const; 
- 
-  // Finds the index of the first node that is inside a reasonable distance 
-  // of the node at `offset` from which we can continue with a linear search. 
-  template <bool wrap> 
-  index_type FindBinary(index_type head, index_type tail, size_t offset) const; 
- 
-  // Fills the current (initialized) instance from the provided source, copying 
-  // entries [head, tail). Adds a reference to copied entries if `ref` is true. 
-  template <bool ref> 
-  void Fill(const CordRepRing* src, index_type head, index_type tail); 
- 
-  // Create a copy of 'rep', copying all entries [head, tail), allocating room 
-  // for `extra` entries. Adds a reference on all copied entries. 
-  static CordRepRing* Copy(CordRepRing* rep, index_type head, index_type tail, 
-                           size_t extra = 0); 
- 
-  // Returns a Mutable CordRepRing reference from `rep` with room for at least 
-  // `extra` additional nodes. Adopts a reference count from `rep`. 
-  // This function will return `rep` if, and only if: 
-  // - rep.entries + extra <= rep.capacity 
-  // - rep.refcount == 1 
-  // Otherwise, this function will create a new copy of `rep` with additional 
-  // capacity to satisfy `extra` extra nodes, and unref the old `rep` instance. 
-  // 
-  // If a new CordRepRing can not be allocated, or the new capacity would exceed 
-  // the maxmimum capacity, then the input is consumed only, and an exception is 
-  // thrown. 
-  static CordRepRing* Mutable(CordRepRing* rep, size_t extra); 
- 
-  // Slow path for Append(CordRepRing* rep, CordRep* child). This function is 
-  // exercised if the provided `child` in Append() is not a leaf node, i.e., a 
-  // ring buffer or old (concat) cord tree. 
-  static CordRepRing* AppendSlow(CordRepRing* rep, CordRep* child); 
- 
-  // Appends the provided leaf node. Requires `child` to be FLAT or EXTERNAL. 
-  static CordRepRing* AppendLeaf(CordRepRing* rep, CordRep* child, 
-                                 size_t offset, size_t length); 
- 
-  // Prepends the provided leaf node. Requires `child` to be FLAT or EXTERNAL. 
-  static CordRepRing* PrependLeaf(CordRepRing* rep, CordRep* child, 
-                                  size_t offset, size_t length); 
- 
-  // Slow path for Prepend(CordRepRing* rep, CordRep* child). This function is 
-  // exercised if the provided `child` in Prepend() is not a leaf node, i.e., a 
-  // ring buffer or old (concat) cord tree. 
-  static CordRepRing* PrependSlow(CordRepRing* rep, CordRep* child); 
- 
-  // Slow path for Create(CordRep* child, size_t extra). This function is 
-  // exercised if the provided `child` in Prepend() is not a leaf node, i.e., a 
-  // ring buffer or old (concat) cord tree. 
-  static CordRepRing* CreateSlow(CordRep* child, size_t extra); 
- 
-  // Creates a new ring buffer from the provided `child` leaf node. Requires 
-  // `child` to be FLAT or EXTERNAL. on `rep`. 
-  // The returned ring buffer has a capacity of at least `1 + extra` 
-  static CordRepRing* CreateFromLeaf(CordRep* child, size_t offset, 
-                                     size_t length, size_t extra); 
- 
-  // Appends or prepends (depending on AddMode) the ring buffer in `ring' to 
+  static void Destroy(CordRepRing* rep);
+
+  // Returns a mutable reference to the logical end position array.
+  pos_type* entry_end_pos() {
+    return Layout::Partial().Pointer<0>(data_);
+  }
+
+  // Returns a mutable reference to the child pointer array.
+  CordRep** entry_child() {
+    return Layout::Partial(capacity()).Pointer<1>(data_);
+  }
+
+  // Returns a mutable reference to the data offset array.
+  offset_type* entry_data_offset() {
+    return Layout::Partial(capacity(), capacity()).Pointer<2>(data_);
+  }
+
+  // Find implementations for the non fast path 0 / length cases.
+  Position FindSlow(index_type head, size_t offset) const;
+  Position FindTailSlow(index_type head, size_t offset) const;
+
+  // Finds the index of the first node that is inside a reasonable distance
+  // of the node at `offset` from which we can continue with a linear search.
+  template <bool wrap>
+  index_type FindBinary(index_type head, index_type tail, size_t offset) const;
+
+  // Fills the current (initialized) instance from the provided source, copying
+  // entries [head, tail). Adds a reference to copied entries if `ref` is true.
+  template <bool ref>
+  void Fill(const CordRepRing* src, index_type head, index_type tail);
+
+  // Create a copy of 'rep', copying all entries [head, tail), allocating room
+  // for `extra` entries. Adds a reference on all copied entries.
+  static CordRepRing* Copy(CordRepRing* rep, index_type head, index_type tail,
+                           size_t extra = 0);
+
+  // Returns a Mutable CordRepRing reference from `rep` with room for at least
+  // `extra` additional nodes. Adopts a reference count from `rep`.
+  // This function will return `rep` if, and only if:
+  // - rep.entries + extra <= rep.capacity
+  // - rep.refcount == 1
+  // Otherwise, this function will create a new copy of `rep` with additional
+  // capacity to satisfy `extra` extra nodes, and unref the old `rep` instance.
+  //
+  // If a new CordRepRing can not be allocated, or the new capacity would exceed
+  // the maxmimum capacity, then the input is consumed only, and an exception is
+  // thrown.
+  static CordRepRing* Mutable(CordRepRing* rep, size_t extra);
+
+  // Slow path for Append(CordRepRing* rep, CordRep* child). This function is
+  // exercised if the provided `child` in Append() is not a leaf node, i.e., a
+  // ring buffer or old (concat) cord tree.
+  static CordRepRing* AppendSlow(CordRepRing* rep, CordRep* child);
+
+  // Appends the provided leaf node. Requires `child` to be FLAT or EXTERNAL.
+  static CordRepRing* AppendLeaf(CordRepRing* rep, CordRep* child,
+                                 size_t offset, size_t length);
+
+  // Prepends the provided leaf node. Requires `child` to be FLAT or EXTERNAL.
+  static CordRepRing* PrependLeaf(CordRepRing* rep, CordRep* child,
+                                  size_t offset, size_t length);
+
+  // Slow path for Prepend(CordRepRing* rep, CordRep* child). This function is
+  // exercised if the provided `child` in Prepend() is not a leaf node, i.e., a
+  // ring buffer or old (concat) cord tree.
+  static CordRepRing* PrependSlow(CordRepRing* rep, CordRep* child);
+
+  // Slow path for Create(CordRep* child, size_t extra). This function is
+  // exercised if the provided `child` in Prepend() is not a leaf node, i.e., a
+  // ring buffer or old (concat) cord tree.
+  static CordRepRing* CreateSlow(CordRep* child, size_t extra);
+
+  // Creates a new ring buffer from the provided `child` leaf node. Requires
+  // `child` to be FLAT or EXTERNAL. on `rep`.
+  // The returned ring buffer has a capacity of at least `1 + extra`
+  static CordRepRing* CreateFromLeaf(CordRep* child, size_t offset,
+                                     size_t length, size_t extra);
+
+  // Appends or prepends (depending on AddMode) the ring buffer in `ring' to
   // `rep` starting at `offset` with length `len`.
-  template <AddMode mode> 
-  static CordRepRing* AddRing(CordRepRing* rep, CordRepRing* ring, 
+  template <AddMode mode>
+  static CordRepRing* AddRing(CordRepRing* rep, CordRepRing* ring,
                               size_t offset, size_t len);
- 
-  // Increases the data offset for entry `index` by `n`. 
-  void AddDataOffset(index_type index, size_t n); 
- 
-  // Descreases the length for entry `index` by `n`. 
-  void SubLength(index_type index, size_t n); 
- 
-  index_type head_; 
-  index_type tail_; 
-  index_type capacity_; 
-  pos_type begin_pos_; 
- 
-  alignas(kLayoutAlignment) char data_[kLayoutAlignment]; 
- 
-  friend struct CordRep; 
-}; 
- 
-constexpr size_t CordRepRing::AllocSize(size_t capacity) { 
-  return sizeof(CordRepRing) - sizeof(data_) + 
-         Layout(capacity, capacity, capacity).AllocSize(); 
-} 
- 
-inline constexpr size_t CordRepRing::Distance(pos_type pos, pos_type end_pos) { 
-  return (end_pos - pos); 
-} 
- 
-inline const char* CordRepRing::GetLeafData(const CordRep* rep) { 
-  return rep->tag != EXTERNAL ? rep->flat()->Data() : rep->external()->base; 
-} 
- 
-inline const char* CordRepRing::GetRepData(const CordRep* rep) { 
-  if (rep->tag >= FLAT) return rep->flat()->Data(); 
-  if (rep->tag == EXTERNAL) return rep->external()->base; 
-  return GetLeafData(rep->substring()->child) + rep->substring()->start; 
-} 
- 
-inline CordRepRing::index_type CordRepRing::advance(index_type index) const { 
-  assert(index < capacity_); 
-  return ++index == capacity_ ? 0 : index; 
-} 
- 
-inline CordRepRing::index_type CordRepRing::advance(index_type index, 
-                                                    index_type n) const { 
-  assert(index < capacity_ && n <= capacity_); 
-  return (index += n) >= capacity_ ? index - capacity_ : index; 
-} 
- 
-inline CordRepRing::index_type CordRepRing::retreat(index_type index) const { 
-  assert(index < capacity_); 
-  return (index > 0 ? index : capacity_) - 1; 
-} 
- 
-inline CordRepRing::index_type CordRepRing::retreat(index_type index, 
-                                                    index_type n) const { 
-  assert(index < capacity_ && n <= capacity_); 
-  return index >= n ? index - n : capacity_ - n + index; 
-} 
- 
-inline absl::string_view CordRepRing::entry_data(index_type index) const { 
-  size_t data_offset = entry_data_offset(index); 
-  return {GetRepData(entry_child(index)) + data_offset, entry_length(index)}; 
-} 
- 
-inline bool CordRepRing::IsValidIndex(index_type index) const { 
-  if (index >= capacity_) return false; 
-  return (tail_ > head_) ? (index >= head_ && index < tail_) 
-                         : (index >= head_ || index < tail_); 
-} 
- 
-#ifndef EXTRA_CORD_RING_VALIDATION 
-inline CordRepRing* CordRepRing::Validate(CordRepRing* rep, 
-                                          const char* /*file*/, int /*line*/) { 
-  return rep; 
-} 
-#endif 
- 
-inline CordRepRing::Position CordRepRing::Find(size_t offset) const { 
-  assert(offset < length); 
-  return (offset == 0) ? Position{head_, 0} : FindSlow(head_, offset); 
-} 
- 
-inline CordRepRing::Position CordRepRing::Find(index_type head, 
-                                               size_t offset) const { 
-  assert(offset < length); 
-  assert(IsValidIndex(head) && offset >= entry_start_offset(head)); 
-  return (offset == 0) ? Position{head_, 0} : FindSlow(head, offset); 
-} 
- 
-inline CordRepRing::Position CordRepRing::FindTail(size_t offset) const { 
-  assert(offset > 0 && offset <= length); 
-  return (offset == length) ? Position{tail_, 0} : FindTailSlow(head_, offset); 
-} 
- 
-inline CordRepRing::Position CordRepRing::FindTail(index_type head, 
-                                                   size_t offset) const { 
-  assert(offset > 0 && offset <= length); 
-  assert(IsValidIndex(head) && offset >= entry_start_offset(head) + 1); 
-  return (offset == length) ? Position{tail_, 0} : FindTailSlow(head, offset); 
-} 
- 
-// Now that CordRepRing is defined, we can define CordRep's helper casts: 
-inline CordRepRing* CordRep::ring() { 
+
+  // Increases the data offset for entry `index` by `n`.
+  void AddDataOffset(index_type index, size_t n);
+
+  // Descreases the length for entry `index` by `n`.
+  void SubLength(index_type index, size_t n);
+
+  index_type head_;
+  index_type tail_;
+  index_type capacity_;
+  pos_type begin_pos_;
+
+  alignas(kLayoutAlignment) char data_[kLayoutAlignment];
+
+  friend struct CordRep;
+};
+
+constexpr size_t CordRepRing::AllocSize(size_t capacity) {
+  return sizeof(CordRepRing) - sizeof(data_) +
+         Layout(capacity, capacity, capacity).AllocSize();
+}
+
+inline constexpr size_t CordRepRing::Distance(pos_type pos, pos_type end_pos) {
+  return (end_pos - pos);
+}
+
+inline const char* CordRepRing::GetLeafData(const CordRep* rep) {
+  return rep->tag != EXTERNAL ? rep->flat()->Data() : rep->external()->base;
+}
+
+inline const char* CordRepRing::GetRepData(const CordRep* rep) {
+  if (rep->tag >= FLAT) return rep->flat()->Data();
+  if (rep->tag == EXTERNAL) return rep->external()->base;
+  return GetLeafData(rep->substring()->child) + rep->substring()->start;
+}
+
+inline CordRepRing::index_type CordRepRing::advance(index_type index) const {
+  assert(index < capacity_);
+  return ++index == capacity_ ? 0 : index;
+}
+
+inline CordRepRing::index_type CordRepRing::advance(index_type index,
+                                                    index_type n) const {
+  assert(index < capacity_ && n <= capacity_);
+  return (index += n) >= capacity_ ? index - capacity_ : index;
+}
+
+inline CordRepRing::index_type CordRepRing::retreat(index_type index) const {
+  assert(index < capacity_);
+  return (index > 0 ? index : capacity_) - 1;
+}
+
+inline CordRepRing::index_type CordRepRing::retreat(index_type index,
+                                                    index_type n) const {
+  assert(index < capacity_ && n <= capacity_);
+  return index >= n ? index - n : capacity_ - n + index;
+}
+
+inline absl::string_view CordRepRing::entry_data(index_type index) const {
+  size_t data_offset = entry_data_offset(index);
+  return {GetRepData(entry_child(index)) + data_offset, entry_length(index)};
+}
+
+inline bool CordRepRing::IsValidIndex(index_type index) const {
+  if (index >= capacity_) return false;
+  return (tail_ > head_) ? (index >= head_ && index < tail_)
+                         : (index >= head_ || index < tail_);
+}
+
+#ifndef EXTRA_CORD_RING_VALIDATION
+inline CordRepRing* CordRepRing::Validate(CordRepRing* rep,
+                                          const char* /*file*/, int /*line*/) {
+  return rep;
+}
+#endif
+
+inline CordRepRing::Position CordRepRing::Find(size_t offset) const {
+  assert(offset < length);
+  return (offset == 0) ? Position{head_, 0} : FindSlow(head_, offset);
+}
+
+inline CordRepRing::Position CordRepRing::Find(index_type head,
+                                               size_t offset) const {
+  assert(offset < length);
+  assert(IsValidIndex(head) && offset >= entry_start_offset(head));
+  return (offset == 0) ? Position{head_, 0} : FindSlow(head, offset);
+}
+
+inline CordRepRing::Position CordRepRing::FindTail(size_t offset) const {
+  assert(offset > 0 && offset <= length);
+  return (offset == length) ? Position{tail_, 0} : FindTailSlow(head_, offset);
+}
+
+inline CordRepRing::Position CordRepRing::FindTail(index_type head,
+                                                   size_t offset) const {
+  assert(offset > 0 && offset <= length);
+  assert(IsValidIndex(head) && offset >= entry_start_offset(head) + 1);
+  return (offset == length) ? Position{tail_, 0} : FindTailSlow(head, offset);
+}
+
+// Now that CordRepRing is defined, we can define CordRep's helper casts:
+inline CordRepRing* CordRep::ring() {
   assert(IsRing());
-  return static_cast<CordRepRing*>(this); 
-} 
- 
-inline const CordRepRing* CordRep::ring() const { 
+  return static_cast<CordRepRing*>(this);
+}
+
+inline const CordRepRing* CordRep::ring() const {
   assert(IsRing());
-  return static_cast<const CordRepRing*>(this); 
-} 
- 
+  return static_cast<const CordRepRing*>(this);
+}
+
 inline bool CordRepRing::IsFlat(absl::string_view* fragment) const {
   if (entries() == 1) {
     if (fragment) *fragment = entry_data(head());
@@ -598,10 +598,10 @@ inline bool CordRepRing::IsFlat(size_t offset, size_t len,
   return false;
 }
 
-std::ostream& operator<<(std::ostream& s, const CordRepRing& rep); 
- 
-}  // namespace cord_internal 
-ABSL_NAMESPACE_END 
-}  // namespace absl 
- 
-#endif  // ABSL_STRINGS_INTERNAL_CORD_REP_RING_H_ 
+std::ostream& operator<<(std::ostream& s, const CordRepRing& rep);
+
+}  // namespace cord_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_CORD_REP_RING_H_
diff --git a/contrib/restricted/abseil-cpp/absl/strings/internal/cord_rep_ring_reader.h b/contrib/restricted/abseil-cpp/absl/strings/internal/cord_rep_ring_reader.h
index 9578154b12..7ceeaa000e 100644
--- a/contrib/restricted/abseil-cpp/absl/strings/internal/cord_rep_ring_reader.h
+++ b/contrib/restricted/abseil-cpp/absl/strings/internal/cord_rep_ring_reader.h
@@ -1,118 +1,118 @@
-// Copyright 2021 The Abseil Authors 
-// 
-// Licensed under the Apache License, Version 2.0 (the "License"); 
-// you may not use this file except in compliance with the License. 
-// You may obtain a copy of the License at 
-// 
-//     https://www.apache.org/licenses/LICENSE-2.0 
-// 
-// Unless required by applicable law or agreed to in writing, software 
-// distributed under the License is distributed on an "AS IS" BASIS, 
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-// See the License for the specific language governing permissions and 
-// limitations under the License. 
- 
-#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_RING_READER_H_ 
-#define ABSL_STRINGS_INTERNAL_CORD_REP_RING_READER_H_ 
- 
-#include <cassert> 
-#include <cstddef> 
-#include <cstdint> 
- 
-#include "absl/strings/internal/cord_internal.h" 
-#include "absl/strings/internal/cord_rep_ring.h" 
-#include "absl/strings/string_view.h" 
- 
-namespace absl { 
-ABSL_NAMESPACE_BEGIN 
-namespace cord_internal { 
- 
-// CordRepRingReader provides basic navigation over CordRepRing data. 
-class CordRepRingReader { 
- public: 
-  // Returns true if this instance is not empty. 
-  explicit operator bool() const { return ring_ != nullptr; } 
- 
-  // Returns the ring buffer reference for this instance, or nullptr if empty. 
-  CordRepRing* ring() const { return ring_; } 
- 
-  // Returns the current node index inside the ring buffer for this instance. 
-  // The returned value is undefined if this instance is empty. 
-  CordRepRing::index_type index() const { return index_; } 
- 
+// Copyright 2021 The Abseil Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_RING_READER_H_
+#define ABSL_STRINGS_INTERNAL_CORD_REP_RING_READER_H_
+
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+
+#include "absl/strings/internal/cord_internal.h"
+#include "absl/strings/internal/cord_rep_ring.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace cord_internal {
+
+// CordRepRingReader provides basic navigation over CordRepRing data.
+class CordRepRingReader {
+ public:
+  // Returns true if this instance is not empty.
+  explicit operator bool() const { return ring_ != nullptr; }
+
+  // Returns the ring buffer reference for this instance, or nullptr if empty.
+  CordRepRing* ring() const { return ring_; }
+
+  // Returns the current node index inside the ring buffer for this instance.
+  // The returned value is undefined if this instance is empty.
+  CordRepRing::index_type index() const { return index_; }
+
   // Returns the current node inside the ring buffer for this instance.
   // The returned value is undefined if this instance is empty.
   CordRep* node() const { return ring_->entry_child(index_); }
 
-  // Returns the length of the referenced ring buffer. 
-  // Requires the current instance to be non empty. 
-  size_t length() const { 
-    assert(ring_); 
-    return ring_->length; 
-  } 
- 
-  // Returns the end offset of the last navigated-to chunk, which represents the 
-  // total bytes 'consumed' relative to the start of the ring. The returned 
-  // value is never zero. For example, initializing a reader with a ring buffer 
-  // with a first chunk of 19 bytes will return consumed() = 19. 
-  // Requires the current instance to be non empty. 
-  size_t consumed() const { 
-    assert(ring_); 
-    return ring_->entry_end_offset(index_); 
-  } 
- 
-  // Returns the number of bytes remaining beyond the last navigated-to chunk. 
-  // Requires the current instance to be non empty. 
-  size_t remaining() const { 
-    assert(ring_); 
-    return length() - consumed(); 
-  } 
- 
-  // Resets this instance to an empty value 
-  void Reset() { ring_ = nullptr; } 
- 
-  // Resets this instance to the start of `ring`. `ring` must not be null. 
-  // Returns a reference into the first chunk of the provided ring. 
-  absl::string_view Reset(CordRepRing* ring) { 
-    assert(ring); 
-    ring_ = ring; 
-    index_ = ring_->head(); 
-    return ring_->entry_data(index_); 
-  } 
- 
-  // Navigates to the next chunk inside the reference ring buffer. 
-  // Returns a reference into the navigated-to chunk. 
-  // Requires remaining() to be non zero. 
-  absl::string_view Next() { 
-    assert(remaining()); 
-    index_ = ring_->advance(index_); 
-    return ring_->entry_data(index_); 
-  } 
- 
-  // Navigates to the chunk at offset `offset`. 
-  // Returns a reference into the navigated-to chunk, adjusted for the relative 
-  // position of `offset` into that chunk. For example, calling Seek(13) on a 
-  // ring buffer containing 2 chunks of 10 and 20 bytes respectively will return 
-  // a string view into the second chunk starting at offset 3 with a size of 17. 
-  // Requires `offset` to be less than `length()` 
-  absl::string_view Seek(size_t offset) { 
-    assert(offset < length()); 
-    size_t current = ring_->entry_end_offset(index_); 
-    CordRepRing::index_type hint = (offset >= current) ? index_ : ring_->head(); 
-    const CordRepRing::Position head = ring_->Find(hint, offset); 
-    index_ = head.index; 
-    auto data = ring_->entry_data(head.index); 
-    data.remove_prefix(head.offset); 
-    return data; 
-  } 
- 
- private: 
-  CordRepRing* ring_ = nullptr; 
-  CordRepRing::index_type index_; 
-}; 
- 
-}  // namespace cord_internal 
-ABSL_NAMESPACE_END 
-}  // namespace absl 
- 
-#endif  // ABSL_STRINGS_INTERNAL_CORD_REP_RING_READER_H_ 
+  // Returns the length of the referenced ring buffer.
+  // Requires the current instance to be non empty.
+  size_t length() const {
+    assert(ring_);
+    return ring_->length;
+  }
+
+  // Returns the end offset of the last navigated-to chunk, which represents the
+  // total bytes 'consumed' relative to the start of the ring. The returned
+  // value is never zero. For example, initializing a reader with a ring buffer
+  // with a first chunk of 19 bytes will return consumed() = 19.
+  // Requires the current instance to be non empty.
+  size_t consumed() const {
+    assert(ring_);
+    return ring_->entry_end_offset(index_);
+  }
+
+  // Returns the number of bytes remaining beyond the last navigated-to chunk.
+  // Requires the current instance to be non empty.
+  size_t remaining() const {
+    assert(ring_);
+    return length() - consumed();
+  }
+
+  // Resets this instance to an empty value
+  void Reset() { ring_ = nullptr; }
+
+  // Resets this instance to the start of `ring`. `ring` must not be null.
+  // Returns a reference into the first chunk of the provided ring.
+  absl::string_view Reset(CordRepRing* ring) {
+    assert(ring);
+    ring_ = ring;
+    index_ = ring_->head();
+    return ring_->entry_data(index_);
+  }
+
+  // Navigates to the next chunk inside the reference ring buffer.
+  // Returns a reference into the navigated-to chunk.
+  // Requires remaining() to be non zero.
+  absl::string_view Next() {
+    assert(remaining());
+    index_ = ring_->advance(index_);
+    return ring_->entry_data(index_);
+  }
+
+  // Navigates to the chunk at offset `offset`.
+  // Returns a reference into the navigated-to chunk, adjusted for the relative
+  // position of `offset` into that chunk. For example, calling Seek(13) on a
+  // ring buffer containing 2 chunks of 10 and 20 bytes respectively will return
+  // a string view into the second chunk starting at offset 3 with a size of 17.
+  // Requires `offset` to be less than `length()`
+  absl::string_view Seek(size_t offset) {
+    assert(offset < length());
+    size_t current = ring_->entry_end_offset(index_);
+    CordRepRing::index_type hint = (offset >= current) ? index_ : ring_->head();
+    const CordRepRing::Position head = ring_->Find(hint, offset);
+    index_ = head.index;
+    auto data = ring_->entry_data(head.index);
+    data.remove_prefix(head.offset);
+    return data;
+  }
+
+ private:
+  CordRepRing* ring_ = nullptr;
+  CordRepRing::index_type index_;
+};
+
+}  // namespace cord_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_CORD_REP_RING_READER_H_
diff --git a/contrib/restricted/abseil-cpp/absl/strings/internal/cordz_handle/ya.make b/contrib/restricted/abseil-cpp/absl/strings/internal/cordz_handle/ya.make
index b18d14d614..47e1c6006c 100644
--- a/contrib/restricted/abseil-cpp/absl/strings/internal/cordz_handle/ya.make
+++ b/contrib/restricted/abseil-cpp/absl/strings/internal/cordz_handle/ya.make
@@ -1,50 +1,50 @@
-# Generated by devtools/yamaker. 
- 
-LIBRARY() 
- 
+# Generated by devtools/yamaker.
+
+LIBRARY()
+
 WITHOUT_LICENSE_TEXTS()
 
-OWNER(g:cpp-contrib) 
- 
-LICENSE(Apache-2.0) 
- 
-PEERDIR( 
-    contrib/restricted/abseil-cpp/absl/base 
+OWNER(g:cpp-contrib)
+
+LICENSE(Apache-2.0)
+
+PEERDIR(
+    contrib/restricted/abseil-cpp/absl/base
     contrib/restricted/abseil-cpp/absl/base/internal/low_level_alloc
-    contrib/restricted/abseil-cpp/absl/base/internal/raw_logging 
-    contrib/restricted/abseil-cpp/absl/base/internal/spinlock_wait 
-    contrib/restricted/abseil-cpp/absl/base/internal/throw_delegate 
-    contrib/restricted/abseil-cpp/absl/base/log_severity 
+    contrib/restricted/abseil-cpp/absl/base/internal/raw_logging
+    contrib/restricted/abseil-cpp/absl/base/internal/spinlock_wait
+    contrib/restricted/abseil-cpp/absl/base/internal/throw_delegate
+    contrib/restricted/abseil-cpp/absl/base/log_severity
     contrib/restricted/abseil-cpp/absl/debugging
     contrib/restricted/abseil-cpp/absl/debugging/stacktrace
     contrib/restricted/abseil-cpp/absl/debugging/symbolize
     contrib/restricted/abseil-cpp/absl/demangle
-    contrib/restricted/abseil-cpp/absl/numeric 
-    contrib/restricted/abseil-cpp/absl/strings 
+    contrib/restricted/abseil-cpp/absl/numeric
+    contrib/restricted/abseil-cpp/absl/strings
     contrib/restricted/abseil-cpp/absl/strings/internal/absl_strings_internal
     contrib/restricted/abseil-cpp/absl/synchronization
     contrib/restricted/abseil-cpp/absl/synchronization/internal
     contrib/restricted/abseil-cpp/absl/time
     contrib/restricted/abseil-cpp/absl/time/civil_time
     contrib/restricted/abseil-cpp/absl/time/time_zone
-) 
- 
-ADDINCL( 
-    GLOBAL contrib/restricted/abseil-cpp 
-) 
- 
-NO_COMPILER_WARNINGS() 
- 
-NO_UTIL() 
- 
-CFLAGS( 
-    -DNOMINMAX 
-) 
- 
+)
+
+ADDINCL(
+    GLOBAL contrib/restricted/abseil-cpp
+)
+
+NO_COMPILER_WARNINGS()
+
+NO_UTIL()
+
+CFLAGS(
+    -DNOMINMAX
+)
+
 SRCDIR(contrib/restricted/abseil-cpp/absl/strings/internal)
- 
-SRCS( 
+
+SRCS(
     cordz_handle.cc
-) 
- 
-END() 
+)
+
+END()
diff --git a/contrib/restricted/abseil-cpp/absl/strings/internal/cordz_info/ya.make b/contrib/restricted/abseil-cpp/absl/strings/internal/cordz_info/ya.make
index e571f5dcf6..56243dd401 100644
--- a/contrib/restricted/abseil-cpp/absl/strings/internal/cordz_info/ya.make
+++ b/contrib/restricted/abseil-cpp/absl/strings/internal/cordz_info/ya.make
@@ -1,27 +1,27 @@
-# Generated by devtools/yamaker. 
- 
-LIBRARY() 
- 
+# Generated by devtools/yamaker.
+
+LIBRARY()
+
 WITHOUT_LICENSE_TEXTS()
 
-OWNER(g:cpp-contrib) 
- 
-LICENSE(Apache-2.0) 
- 
-PEERDIR( 
-    contrib/restricted/abseil-cpp/absl/base 
+OWNER(g:cpp-contrib)
+
+LICENSE(Apache-2.0)
+
+PEERDIR(
+    contrib/restricted/abseil-cpp/absl/base
     contrib/restricted/abseil-cpp/absl/base/internal/low_level_alloc
-    contrib/restricted/abseil-cpp/absl/base/internal/raw_logging 
-    contrib/restricted/abseil-cpp/absl/base/internal/spinlock_wait 
-    contrib/restricted/abseil-cpp/absl/base/internal/throw_delegate 
-    contrib/restricted/abseil-cpp/absl/base/log_severity 
+    contrib/restricted/abseil-cpp/absl/base/internal/raw_logging
+    contrib/restricted/abseil-cpp/absl/base/internal/spinlock_wait
+    contrib/restricted/abseil-cpp/absl/base/internal/throw_delegate
+    contrib/restricted/abseil-cpp/absl/base/log_severity
     contrib/restricted/abseil-cpp/absl/debugging
     contrib/restricted/abseil-cpp/absl/debugging/stacktrace
     contrib/restricted/abseil-cpp/absl/debugging/symbolize
     contrib/restricted/abseil-cpp/absl/demangle
-    contrib/restricted/abseil-cpp/absl/numeric 
+    contrib/restricted/abseil-cpp/absl/numeric
     contrib/restricted/abseil-cpp/absl/profiling/internal/exponential_biased
-    contrib/restricted/abseil-cpp/absl/strings 
+    contrib/restricted/abseil-cpp/absl/strings
     contrib/restricted/abseil-cpp/absl/strings/internal/absl_cord_internal
     contrib/restricted/abseil-cpp/absl/strings/internal/absl_strings_internal
     contrib/restricted/abseil-cpp/absl/strings/internal/cordz_functions
@@ -31,24 +31,24 @@ PEERDIR(
     contrib/restricted/abseil-cpp/absl/time
     contrib/restricted/abseil-cpp/absl/time/civil_time
     contrib/restricted/abseil-cpp/absl/time/time_zone
-) 
- 
-ADDINCL( 
-    GLOBAL contrib/restricted/abseil-cpp 
-) 
- 
-NO_COMPILER_WARNINGS() 
- 
-NO_UTIL() 
- 
-CFLAGS( 
-    -DNOMINMAX 
-) 
- 
+)
+
+ADDINCL(
+    GLOBAL contrib/restricted/abseil-cpp
+)
+
+NO_COMPILER_WARNINGS()
+
+NO_UTIL()
+
+CFLAGS(
+    -DNOMINMAX
+)
+
 SRCDIR(contrib/restricted/abseil-cpp/absl/strings/internal)
- 
-SRCS( 
+
+SRCS(
     cordz_info.cc
-) 
- 
-END() 
+)
+
+END()
diff --git a/contrib/restricted/abseil-cpp/absl/strings/internal/cordz_sample_token/ya.make b/contrib/restricted/abseil-cpp/absl/strings/internal/cordz_sample_token/ya.make
index 3765399311..1ad95a8a05 100644
--- a/contrib/restricted/abseil-cpp/absl/strings/internal/cordz_sample_token/ya.make
+++ b/contrib/restricted/abseil-cpp/absl/strings/internal/cordz_sample_token/ya.make
@@ -1,27 +1,27 @@
-# Generated by devtools/yamaker. 
- 
-LIBRARY() 
- 
+# Generated by devtools/yamaker.
+
+LIBRARY()
+
 WITHOUT_LICENSE_TEXTS()
 
-OWNER(g:cpp-contrib) 
- 
-LICENSE(Apache-2.0) 
- 
-PEERDIR( 
-    contrib/restricted/abseil-cpp/absl/base 
+OWNER(g:cpp-contrib)
+
+LICENSE(Apache-2.0)
+
+PEERDIR(
+    contrib/restricted/abseil-cpp/absl/base
     contrib/restricted/abseil-cpp/absl/base/internal/low_level_alloc
-    contrib/restricted/abseil-cpp/absl/base/internal/raw_logging 
-    contrib/restricted/abseil-cpp/absl/base/internal/spinlock_wait 
-    contrib/restricted/abseil-cpp/absl/base/internal/throw_delegate 
-    contrib/restricted/abseil-cpp/absl/base/log_severity 
+    contrib/restricted/abseil-cpp/absl/base/internal/raw_logging
+    contrib/restricted/abseil-cpp/absl/base/internal/spinlock_wait
+    contrib/restricted/abseil-cpp/absl/base/internal/throw_delegate
+    contrib/restricted/abseil-cpp/absl/base/log_severity
     contrib/restricted/abseil-cpp/absl/debugging
     contrib/restricted/abseil-cpp/absl/debugging/stacktrace
     contrib/restricted/abseil-cpp/absl/debugging/symbolize
     contrib/restricted/abseil-cpp/absl/demangle
-    contrib/restricted/abseil-cpp/absl/numeric 
+    contrib/restricted/abseil-cpp/absl/numeric
     contrib/restricted/abseil-cpp/absl/profiling/internal/exponential_biased
-    contrib/restricted/abseil-cpp/absl/strings 
+    contrib/restricted/abseil-cpp/absl/strings
     contrib/restricted/abseil-cpp/absl/strings/internal/absl_cord_internal
     contrib/restricted/abseil-cpp/absl/strings/internal/absl_strings_internal
     contrib/restricted/abseil-cpp/absl/strings/internal/cordz_functions
@@ -32,24 +32,24 @@ PEERDIR(
     contrib/restricted/abseil-cpp/absl/time
     contrib/restricted/abseil-cpp/absl/time/civil_time
     contrib/restricted/abseil-cpp/absl/time/time_zone
-) 
- 
-ADDINCL( 
-    GLOBAL contrib/restricted/abseil-cpp 
-) 
- 
-NO_COMPILER_WARNINGS() 
- 
-NO_UTIL() 
- 
-CFLAGS( 
-    -DNOMINMAX 
-) 
- 
+)
+
+ADDINCL(
+    GLOBAL contrib/restricted/abseil-cpp
+)
+
+NO_COMPILER_WARNINGS()
+
+NO_UTIL()
+
+CFLAGS(
+    -DNOMINMAX
+)
+
 SRCDIR(contrib/restricted/abseil-cpp/absl/strings/internal)
- 
-SRCS( 
+
+SRCS(
     cordz_sample_token.cc
-) 
- 
-END() 
+)
+
+END()
diff --git a/contrib/restricted/abseil-cpp/absl/strings/internal/str_format/bind.cc b/contrib/restricted/abseil-cpp/absl/strings/internal/str_format/bind.cc
index 9f5e8aae3d..c988ba8fd2 100644
--- a/contrib/restricted/abseil-cpp/absl/strings/internal/str_format/bind.cc
+++ b/contrib/restricted/abseil-cpp/absl/strings/internal/str_format/bind.cc
@@ -234,7 +234,7 @@ int FprintF(std::FILE* output, const UntypedFormatSpecImpl format,
     errno = sink.error();
     return -1;
   }
-  if (sink.count() > static_cast<size_t>(std::numeric_limits<int>::max())) { 
+  if (sink.count() > static_cast<size_t>(std::numeric_limits<int>::max())) {
     errno = EFBIG;
     return -1;
   }
diff --git a/contrib/restricted/abseil-cpp/absl/strings/internal/str_format/bind.h b/contrib/restricted/abseil-cpp/absl/strings/internal/str_format/bind.h
index bbca0fdcfb..b26cff6648 100644
--- a/contrib/restricted/abseil-cpp/absl/strings/internal/str_format/bind.h
+++ b/contrib/restricted/abseil-cpp/absl/strings/internal/str_format/bind.h
@@ -133,11 +133,11 @@ class FormatSpecTemplate
 
 #endif  // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
 
-  template < 
-      FormatConversionCharSet... C, 
-      typename = typename std::enable_if<sizeof...(C) == sizeof...(Args)>::type, 
-      typename = typename std::enable_if<AllOf(Contains(Args, 
-                                                        C)...)>::type> 
+  template <
+      FormatConversionCharSet... C,
+      typename = typename std::enable_if<sizeof...(C) == sizeof...(Args)>::type,
+      typename = typename std::enable_if<AllOf(Contains(Args,
+                                                        C)...)>::type>
   FormatSpecTemplate(const ExtendedParsedFormat<C...>& pc)  // NOLINT
       : Base(&pc) {}
 };
diff --git a/contrib/restricted/abseil-cpp/absl/strings/internal/str_format/float_conversion.cc b/contrib/restricted/abseil-cpp/absl/strings/internal/str_format/float_conversion.cc
index 73381fb0a4..b1c4068475 100644
--- a/contrib/restricted/abseil-cpp/absl/strings/internal/str_format/float_conversion.cc
+++ b/contrib/restricted/abseil-cpp/absl/strings/internal/str_format/float_conversion.cc
@@ -27,9 +27,9 @@
 #include "absl/base/optimization.h"
 #include "absl/functional/function_ref.h"
 #include "absl/meta/type_traits.h"
-#include "absl/numeric/bits.h" 
+#include "absl/numeric/bits.h"
 #include "absl/numeric/int128.h"
-#include "absl/numeric/internal/representation.h" 
+#include "absl/numeric/internal/representation.h"
 #include "absl/strings/numbers.h"
 #include "absl/types/optional.h"
 #include "absl/types/span.h"
@@ -40,8 +40,8 @@ namespace str_format_internal {
 
 namespace {
 
-using ::absl::numeric_internal::IsDoubleDouble; 
- 
+using ::absl::numeric_internal::IsDoubleDouble;
+
 // The code below wants to avoid heap allocations.
 // To do so it needs to allocate memory on the stack.
 // `StackArray` will allocate memory on the stack in the form of a uint32_t
@@ -115,15 +115,15 @@ inline uint64_t DivideBy10WithCarry(uint64_t *v, uint64_t carry) {
   return next_carry % divisor;
 }
 
-using MaxFloatType = 
-    typename std::conditional<IsDoubleDouble(), double, long double>::type; 
- 
+using MaxFloatType =
+    typename std::conditional<IsDoubleDouble(), double, long double>::type;
+
 // Generates the decimal representation for an integer of the form `v * 2^exp`,
 // where `v` and `exp` are both positive integers.
 // It generates the digits from the left (ie the most significant digit first)
 // to allow for direct printing into the sink.
 //
-// Requires `0 <= exp` and `exp <= numeric_limits<MaxFloatType>::max_exponent`. 
+// Requires `0 <= exp` and `exp <= numeric_limits<MaxFloatType>::max_exponent`.
 class BinaryToDecimal {
   static constexpr int ChunksNeeded(int exp) {
     // We will left shift a uint128 by `exp` bits, so we need `128+exp` total
@@ -138,10 +138,10 @@ class BinaryToDecimal {
   static void RunConversion(uint128 v, int exp,
                             absl::FunctionRef<void(BinaryToDecimal)> f) {
     assert(exp > 0);
-    assert(exp <= std::numeric_limits<MaxFloatType>::max_exponent); 
+    assert(exp <= std::numeric_limits<MaxFloatType>::max_exponent);
     static_assert(
-        static_cast<int>(StackArray::kMaxCapacity) >= 
-            ChunksNeeded(std::numeric_limits<MaxFloatType>::max_exponent), 
+        static_cast<int>(StackArray::kMaxCapacity) >=
+            ChunksNeeded(std::numeric_limits<MaxFloatType>::max_exponent),
         "");
 
     StackArray::RunWithCapacity(
@@ -238,14 +238,14 @@ class BinaryToDecimal {
 
 // Converts a value of the form `x * 2^-exp` into a sequence of decimal digits.
 // Requires `-exp < 0` and
-// `-exp >= limits<MaxFloatType>::min_exponent - limits<MaxFloatType>::digits`. 
+// `-exp >= limits<MaxFloatType>::min_exponent - limits<MaxFloatType>::digits`.
 class FractionalDigitGenerator {
  public:
   // Run the conversion for `v * 2^exp` and call `f(generator)`.
   // This function will allocate enough stack space to perform the conversion.
   static void RunConversion(
       uint128 v, int exp, absl::FunctionRef<void(FractionalDigitGenerator)> f) {
-    using Limits = std::numeric_limits<MaxFloatType>; 
+    using Limits = std::numeric_limits<MaxFloatType>;
     assert(-exp < 0);
     assert(-exp >= Limits::min_exponent - 128);
     static_assert(StackArray::kMaxCapacity >=
@@ -321,11 +321,11 @@ class FractionalDigitGenerator {
 };
 
 // Count the number of leading zero bits.
-int LeadingZeros(uint64_t v) { return countl_zero(v); } 
+int LeadingZeros(uint64_t v) { return countl_zero(v); }
 int LeadingZeros(uint128 v) {
   auto high = static_cast<uint64_t>(v >> 64);
   auto low = static_cast<uint64_t>(v);
-  return high != 0 ? countl_zero(high) : 64 + countl_zero(low); 
+  return high != 0 ? countl_zero(high) : 64 + countl_zero(low);
 }
 
 // Round up the text digits starting at `p`.
@@ -877,10 +877,10 @@ void FormatA(const HexFloatTypeParams float_traits, Int mantissa, int exp,
   // This buffer holds the "0x1.ab1de3" portion of "0x1.ab1de3pe+2". Compute the
   // size with long double which is the largest of the floats.
   constexpr size_t kBufSizeForHexFloatRepr =
-      2                                                // 0x 
-      + std::numeric_limits<MaxFloatType>::digits / 4  // number of hex digits 
-      + 1                                              // round up 
-      + 1;                                             // "." (dot) 
+      2                                                // 0x
+      + std::numeric_limits<MaxFloatType>::digits / 4  // number of hex digits
+      + 1                                              // round up
+      + 1;                                             // "." (dot)
   char digits_buffer[kBufSizeForHexFloatRepr];
   char *digits_iter = digits_buffer;
   const char *const digits =
@@ -1399,9 +1399,9 @@ bool FloatToSink(const Float v, const FormatConversionSpecImpl &conv,
 
 bool ConvertFloatImpl(long double v, const FormatConversionSpecImpl &conv,
                       FormatSinkImpl *sink) {
-  if (IsDoubleDouble()) { 
-    // This is the `double-double` representation of `long double`. We do not 
-    // handle it natively. Fallback to snprintf. 
+  if (IsDoubleDouble()) {
+    // This is the `double-double` representation of `long double`. We do not
+    // handle it natively. Fallback to snprintf.
     return FallbackToSnprintf(v, conv, sink);
   }
 
diff --git a/contrib/restricted/abseil-cpp/absl/strings/internal/str_format/ya.make b/contrib/restricted/abseil-cpp/absl/strings/internal/str_format/ya.make
index ae934819e5..1f07f02b2e 100644
--- a/contrib/restricted/abseil-cpp/absl/strings/internal/str_format/ya.make
+++ b/contrib/restricted/abseil-cpp/absl/strings/internal/str_format/ya.make
@@ -1,43 +1,43 @@
-# Generated by devtools/yamaker. 
- 
-LIBRARY() 
- 
-OWNER(g:cpp-contrib) 
- 
-LICENSE(Apache-2.0) 
- 
+# Generated by devtools/yamaker.
+
+LIBRARY()
+
+OWNER(g:cpp-contrib)
+
+LICENSE(Apache-2.0)
+
 LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
 
-PEERDIR( 
-    contrib/restricted/abseil-cpp/absl/base 
-    contrib/restricted/abseil-cpp/absl/base/internal/raw_logging 
-    contrib/restricted/abseil-cpp/absl/base/internal/spinlock_wait 
-    contrib/restricted/abseil-cpp/absl/base/internal/throw_delegate 
-    contrib/restricted/abseil-cpp/absl/base/log_severity 
-    contrib/restricted/abseil-cpp/absl/numeric 
-    contrib/restricted/abseil-cpp/absl/strings 
+PEERDIR(
+    contrib/restricted/abseil-cpp/absl/base
+    contrib/restricted/abseil-cpp/absl/base/internal/raw_logging
+    contrib/restricted/abseil-cpp/absl/base/internal/spinlock_wait
+    contrib/restricted/abseil-cpp/absl/base/internal/throw_delegate
+    contrib/restricted/abseil-cpp/absl/base/log_severity
+    contrib/restricted/abseil-cpp/absl/numeric
+    contrib/restricted/abseil-cpp/absl/strings
     contrib/restricted/abseil-cpp/absl/strings/internal/absl_strings_internal
-) 
- 
-ADDINCL( 
-    GLOBAL contrib/restricted/abseil-cpp 
-) 
- 
-NO_COMPILER_WARNINGS() 
- 
-NO_UTIL() 
- 
-CFLAGS( 
-    -DNOMINMAX 
-) 
- 
-SRCS( 
+)
+
+ADDINCL(
+    GLOBAL contrib/restricted/abseil-cpp
+)
+
+NO_COMPILER_WARNINGS()
+
+NO_UTIL()
+
+CFLAGS(
+    -DNOMINMAX
+)
+
+SRCS(
     arg.cc
     bind.cc
     extension.cc
     float_conversion.cc
     output.cc
     parser.cc
-) 
- 
-END() 
+)
+
+END()
diff --git a/contrib/restricted/abseil-cpp/absl/strings/internal/str_split_internal.h b/contrib/restricted/abseil-cpp/absl/strings/internal/str_split_internal.h
index bc503bc9a9..e766421617 100644
--- a/contrib/restricted/abseil-cpp/absl/strings/internal/str_split_internal.h
+++ b/contrib/restricted/abseil-cpp/absl/strings/internal/str_split_internal.h
@@ -51,9 +51,9 @@ ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 // This class is implicitly constructible from everything that absl::string_view
-// is implicitly constructible from, except for rvalue strings.  This means it 
-// can be used as a function parameter in places where passing a temporary 
-// string might cause memory lifetime issues. 
+// is implicitly constructible from, except for rvalue strings.  This means it
+// can be used as a function parameter in places where passing a temporary
+// string might cause memory lifetime issues.
 class ConvertibleToStringView {
  public:
   ConvertibleToStringView(const char* s)  // NOLINT(runtime/explicit)
@@ -65,8 +65,8 @@ class ConvertibleToStringView {
       : value_(s) {}
 
   // Disable conversion from rvalue strings.
-  ConvertibleToStringView(std::string&& s) = delete; 
-  ConvertibleToStringView(const std::string&& s) = delete; 
+  ConvertibleToStringView(std::string&& s) = delete;
+  ConvertibleToStringView(const std::string&& s) = delete;
 
   absl::string_view value() const { return value_; }
 
@@ -251,11 +251,11 @@ struct SplitterIsConvertibleTo
 // the split strings: only strings for which the predicate returns true will be
 // kept. A Predicate object is any unary functor that takes an absl::string_view
 // and returns bool.
-// 
-// The StringType parameter can be either string_view or string, depending on 
-// whether the Splitter refers to a string stored elsewhere, or if the string 
-// resides inside the Splitter itself. 
-template <typename Delimiter, typename Predicate, typename StringType> 
+//
+// The StringType parameter can be either string_view or string, depending on
+// whether the Splitter refers to a string stored elsewhere, or if the string
+// resides inside the Splitter itself.
+template <typename Delimiter, typename Predicate, typename StringType>
 class Splitter {
  public:
   using DelimiterType = Delimiter;
@@ -263,12 +263,12 @@ class Splitter {
   using const_iterator = strings_internal::SplitIterator<Splitter>;
   using value_type = typename std::iterator_traits<const_iterator>::value_type;
 
-  Splitter(StringType input_text, Delimiter d, Predicate p) 
+  Splitter(StringType input_text, Delimiter d, Predicate p)
       : text_(std::move(input_text)),
         delimiter_(std::move(d)),
         predicate_(std::move(p)) {}
 
-  absl::string_view text() const { return text_; } 
+  absl::string_view text() const { return text_; }
   const Delimiter& delimiter() const { return delimiter_; }
   const Predicate& predicate() const { return predicate_; }
 
@@ -418,7 +418,7 @@ class Splitter {
     static iterator ToIter(iterator iter) { return iter; }
   };
 
-  StringType text_; 
+  StringType text_;
   Delimiter delimiter_;
   Predicate predicate_;
 };
diff --git a/contrib/restricted/abseil-cpp/absl/strings/internal/string_constant.h b/contrib/restricted/abseil-cpp/absl/strings/internal/string_constant.h
index ade2a38ff5..a11336b7f0 100644
--- a/contrib/restricted/abseil-cpp/absl/strings/internal/string_constant.h
+++ b/contrib/restricted/abseil-cpp/absl/strings/internal/string_constant.h
@@ -1,64 +1,64 @@
-// Copyright 2020 The Abseil Authors. 
-// 
-// Licensed under the Apache License, Version 2.0 (the "License"); 
-// you may not use this file except in compliance with the License. 
-// You may obtain a copy of the License at 
-// 
-//      https://www.apache.org/licenses/LICENSE-2.0 
-// 
-// Unless required by applicable law or agreed to in writing, software 
-// distributed under the License is distributed on an "AS IS" BASIS, 
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-// See the License for the specific language governing permissions and 
-// limitations under the License. 
- 
-#ifndef ABSL_STRINGS_INTERNAL_STRING_CONSTANT_H_ 
-#define ABSL_STRINGS_INTERNAL_STRING_CONSTANT_H_ 
- 
-#include "absl/meta/type_traits.h" 
-#include "absl/strings/string_view.h" 
- 
-namespace absl { 
-ABSL_NAMESPACE_BEGIN 
-namespace strings_internal { 
- 
-// StringConstant<T> represents a compile time string constant. 
-// It can be accessed via its `absl::string_view value` static member. 
-// It is guaranteed that the `string_view` returned has constant `.data()`, 
-// constant `.size()` and constant `value[i]` for all `0 <= i < .size()` 
-// 
-// The `T` is an opaque type. It is guaranteed that different string constants 
-// will have different values of `T`. This allows users to associate the string 
-// constant with other static state at compile time. 
-// 
-// Instances should be made using the `MakeStringConstant()` factory function 
-// below. 
-template <typename T> 
-struct StringConstant { 
-  static constexpr absl::string_view value = T{}(); 
-  constexpr absl::string_view operator()() const { return value; } 
- 
-  // Check to be sure `view` points to constant data. 
-  // Otherwise, it can't be constant evaluated. 
-  static_assert(value.empty() || 2 * value[0] != 1, 
-                "The input string_view must point to constant data."); 
-}; 
- 
-template <typename T> 
-constexpr absl::string_view StringConstant<T>::value;  // NOLINT 
- 
-// Factory function for `StringConstant` instances. 
-// It supports callables that have a constexpr default constructor and a 
-// constexpr operator(). 
-// It must return an `absl::string_view` or `const char*` pointing to constant 
-// data. This is validated at compile time. 
-template <typename T> 
-constexpr StringConstant<T> MakeStringConstant(T) { 
-  return {}; 
-} 
- 
-}  // namespace strings_internal 
-ABSL_NAMESPACE_END 
-}  // namespace absl 
- 
-#endif  // ABSL_STRINGS_INTERNAL_STRING_CONSTANT_H_ 
+// Copyright 2020 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_STRINGS_INTERNAL_STRING_CONSTANT_H_
+#define ABSL_STRINGS_INTERNAL_STRING_CONSTANT_H_
+
+#include "absl/meta/type_traits.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace strings_internal {
+
+// StringConstant<T> represents a compile time string constant.
+// It can be accessed via its `absl::string_view value` static member.
+// It is guaranteed that the `string_view` returned has constant `.data()`,
+// constant `.size()` and constant `value[i]` for all `0 <= i < .size()`
+//
+// The `T` is an opaque type. It is guaranteed that different string constants
+// will have different values of `T`. This allows users to associate the string
+// constant with other static state at compile time.
+//
+// Instances should be made using the `MakeStringConstant()` factory function
+// below.
+template <typename T>
+struct StringConstant {
+  static constexpr absl::string_view value = T{}();
+  constexpr absl::string_view operator()() const { return value; }
+
+  // Check to be sure `view` points to constant data.
+  // Otherwise, it can't be constant evaluated.
+  static_assert(value.empty() || 2 * value[0] != 1,
+                "The input string_view must point to constant data.");
+};
+
+template <typename T>
+constexpr absl::string_view StringConstant<T>::value;  // NOLINT
+
+// Factory function for `StringConstant` instances.
+// It supports callables that have a constexpr default constructor and a
+// constexpr operator().
+// It must return an `absl::string_view` or `const char*` pointing to constant
+// data. This is validated at compile time.
+template <typename T>
+constexpr StringConstant<T> MakeStringConstant(T) {
+  return {};
+}
+
+}  // namespace strings_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_STRING_CONSTANT_H_