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

157 files changed, 6367 insertions, 6367 deletions

diff --git a/contrib/restricted/abseil-cpp/absl/algorithm/container.h b/contrib/restricted/abseil-cpp/absl/algorithm/container.h
index c38a4a63db..ccd257fa53 100644
--- a/contrib/restricted/abseil-cpp/absl/algorithm/container.h
+++ b/contrib/restricted/abseil-cpp/absl/algorithm/container.h
@@ -188,7 +188,7 @@ bool c_any_of(const C& c, Pred&& pred) {
 // c_none_of()
 //
 // Container-based version of the <algorithm> `std::none_of()` function to
-// test if no elements in a container fulfill a condition.
+// test if no elements in a container fulfill a condition. 
 template <typename C, typename Pred>
 bool c_none_of(const C& c, Pred&& pred) {
   return std::none_of(container_algorithm_internal::c_begin(c),
diff --git a/contrib/restricted/abseil-cpp/absl/base/attributes.h b/contrib/restricted/abseil-cpp/absl/base/attributes.h
index e3907827d6..03cf88c270 100644
--- a/contrib/restricted/abseil-cpp/absl/base/attributes.h
+++ b/contrib/restricted/abseil-cpp/absl/base/attributes.h
@@ -119,7 +119,7 @@
 #if ABSL_HAVE_ATTRIBUTE(disable_tail_calls)
 #define ABSL_HAVE_ATTRIBUTE_NO_TAIL_CALL 1
 #define ABSL_ATTRIBUTE_NO_TAIL_CALL __attribute__((disable_tail_calls))
-#elif defined(__GNUC__) && !defined(__clang__) && !defined(__e2k__)
+#elif defined(__GNUC__) && !defined(__clang__) && !defined(__e2k__) 
 #define ABSL_HAVE_ATTRIBUTE_NO_TAIL_CALL 1
 #define ABSL_ATTRIBUTE_NO_TAIL_CALL \
   __attribute__((optimize("no-optimize-sibling-calls")))
@@ -621,7 +621,7 @@
 // When used with unsupported compilers, the ABSL_FALLTHROUGH_INTENDED macro has
 // no effect on diagnostics. In any case this macro has no effect on runtime
 // behavior and performance of code.
-
+ 
 #ifdef ABSL_FALLTHROUGH_INTENDED
 #error "ABSL_FALLTHROUGH_INTENDED should not be defined."
 #elif ABSL_HAVE_CPP_ATTRIBUTE(fallthrough)
@@ -655,7 +655,7 @@
 // Every usage of a deprecated entity will trigger a warning when compiled with
 // clang's `-Wdeprecated-declarations` option. This option is turned off by
 // default, but the warnings will be reported by clang-tidy.
-#if defined(__clang__) && defined(__cplusplus) && __cplusplus >= 201103L
+#if defined(__clang__) && defined(__cplusplus) && __cplusplus >= 201103L 
 #define ABSL_DEPRECATED(message) __attribute__((deprecated(message)))
 #endif
 
@@ -689,27 +689,27 @@
 #define ABSL_CONST_INIT
 #endif  // ABSL_HAVE_CPP_ATTRIBUTE(clang::require_constant_initialization)
 
-// ABSL_ATTRIBUTE_PURE_FUNCTION
-//
-// ABSL_ATTRIBUTE_PURE_FUNCTION is used to annotate declarations of "pure"
-// functions. A function is pure if its return value is only a function of its
-// arguments. The pure attribute prohibits a function from modifying the state
-// of the program that is observable by means other than inspecting the
-// function's return value. Declaring such functions with the pure attribute
-// allows the compiler to avoid emitting some calls in repeated invocations of
-// the function with the same argument values.
-//
-// Example:
-//
-//  ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Milliseconds(Duration d);
-#if ABSL_HAVE_CPP_ATTRIBUTE(gnu::pure)
-#define ABSL_ATTRIBUTE_PURE_FUNCTION [[gnu::pure]]
-#elif ABSL_HAVE_ATTRIBUTE(pure)
-#define ABSL_ATTRIBUTE_PURE_FUNCTION __attribute__((pure))
-#else
-#define ABSL_ATTRIBUTE_PURE_FUNCTION
-#endif
-
+// ABSL_ATTRIBUTE_PURE_FUNCTION 
+// 
+// ABSL_ATTRIBUTE_PURE_FUNCTION is used to annotate declarations of "pure" 
+// functions. A function is pure if its return value is only a function of its 
+// arguments. The pure attribute prohibits a function from modifying the state 
+// of the program that is observable by means other than inspecting the 
+// function's return value. Declaring such functions with the pure attribute 
+// allows the compiler to avoid emitting some calls in repeated invocations of 
+// the function with the same argument values. 
+// 
+// Example: 
+// 
+//  ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Milliseconds(Duration d); 
+#if ABSL_HAVE_CPP_ATTRIBUTE(gnu::pure) 
+#define ABSL_ATTRIBUTE_PURE_FUNCTION [[gnu::pure]] 
+#elif ABSL_HAVE_ATTRIBUTE(pure) 
+#define ABSL_ATTRIBUTE_PURE_FUNCTION __attribute__((pure)) 
+#else 
+#define ABSL_ATTRIBUTE_PURE_FUNCTION 
+#endif 
+ 
 // ABSL_ATTRIBUTE_LIFETIME_BOUND indicates that a resource owned by a function
 // parameter or implicit object parameter is retained by the return value of the
 // annotated function (or, for a parameter of a constructor, in the value of the
diff --git a/contrib/restricted/abseil-cpp/absl/base/call_once.h b/contrib/restricted/abseil-cpp/absl/base/call_once.h
index 96109f537c..86635bbee0 100644
--- a/contrib/restricted/abseil-cpp/absl/base/call_once.h
+++ b/contrib/restricted/abseil-cpp/absl/base/call_once.h
@@ -177,8 +177,8 @@ void CallOnceImpl(std::atomic<uint32_t>* control,
                                   scheduling_mode) == kOnceInit) {
     base_internal::invoke(std::forward<Callable>(fn),
                           std::forward<Args>(args)...);
-    old_control =
-        control->exchange(base_internal::kOnceDone, std::memory_order_release);
+    old_control = 
+        control->exchange(base_internal::kOnceDone, std::memory_order_release); 
     if (old_control == base_internal::kOnceWaiter) {
       base_internal::SpinLockWake(control, true);
     }
diff --git a/contrib/restricted/abseil-cpp/absl/base/config.h b/contrib/restricted/abseil-cpp/absl/base/config.h
index 450d00bc4c..21244de01e 100644
--- a/contrib/restricted/abseil-cpp/absl/base/config.h
+++ b/contrib/restricted/abseil-cpp/absl/base/config.h
@@ -150,16 +150,16 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 #if ABSL_OPTION_USE_INLINE_NAMESPACE == 0
 #define ABSL_NAMESPACE_BEGIN
 #define ABSL_NAMESPACE_END
-#define ABSL_INTERNAL_C_SYMBOL(x) x
+#define ABSL_INTERNAL_C_SYMBOL(x) x 
 #elif ABSL_OPTION_USE_INLINE_NAMESPACE == 1
 #define ABSL_NAMESPACE_BEGIN \
   inline namespace ABSL_OPTION_INLINE_NAMESPACE_NAME {
 #define ABSL_NAMESPACE_END }
-#define ABSL_INTERNAL_C_SYMBOL_HELPER_2(x, v) x##_##v
-#define ABSL_INTERNAL_C_SYMBOL_HELPER_1(x, v) \
-  ABSL_INTERNAL_C_SYMBOL_HELPER_2(x, v)
-#define ABSL_INTERNAL_C_SYMBOL(x) \
-  ABSL_INTERNAL_C_SYMBOL_HELPER_1(x, ABSL_OPTION_INLINE_NAMESPACE_NAME)
+#define ABSL_INTERNAL_C_SYMBOL_HELPER_2(x, v) x##_##v 
+#define ABSL_INTERNAL_C_SYMBOL_HELPER_1(x, v) \ 
+  ABSL_INTERNAL_C_SYMBOL_HELPER_2(x, v) 
+#define ABSL_INTERNAL_C_SYMBOL(x) \ 
+  ABSL_INTERNAL_C_SYMBOL_HELPER_1(x, ABSL_OPTION_INLINE_NAMESPACE_NAME) 
 #else
 #error options.h is misconfigured.
 #endif
@@ -268,7 +268,7 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
     ABSL_INTERNAL_HAS_KEYWORD(__builtin_FILE)
 #define ABSL_HAVE_SOURCE_LOCATION_CURRENT 1
 #elif ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(5, 0)
-#define ABSL_HAVE_SOURCE_LOCATION_CURRENT 1
+#define ABSL_HAVE_SOURCE_LOCATION_CURRENT 1 
 #endif
 #endif
 
@@ -429,15 +429,15 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 #define ABSL_HAVE_PTHREAD_GETSCHEDPARAM 1
 #endif
 
-// ABSL_HAVE_SCHED_GETCPU
-//
-// Checks whether sched_getcpu is available.
-#ifdef ABSL_HAVE_SCHED_GETCPU
-#error ABSL_HAVE_SCHED_GETCPU cannot be directly set
-#elif defined(__linux__)
-#define ABSL_HAVE_SCHED_GETCPU 1
-#endif
-
+// ABSL_HAVE_SCHED_GETCPU 
+// 
+// Checks whether sched_getcpu is available. 
+#ifdef ABSL_HAVE_SCHED_GETCPU 
+#error ABSL_HAVE_SCHED_GETCPU cannot be directly set 
+#elif defined(__linux__) 
+#define ABSL_HAVE_SCHED_GETCPU 1 
+#endif 
+ 
 // ABSL_HAVE_SCHED_YIELD
 //
 // Checks whether the platform implements sched_yield(2) as defined in
@@ -549,7 +549,7 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 #endif
 
 #ifdef __has_include
-#if __has_include(<any>) && defined(__cplusplus) && __cplusplus >= 201703L && \
+#if __has_include(<any>) && defined(__cplusplus) && __cplusplus >= 201703L && \ 
     !ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE
 #define ABSL_HAVE_STD_ANY 1
 #endif
@@ -563,8 +563,8 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 #endif
 
 #ifdef __has_include
-#if __has_include(<optional>) && defined(__cplusplus) && \
-    __cplusplus >= 201703L && !ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE
+#if __has_include(<optional>) && defined(__cplusplus) && \ 
+    __cplusplus >= 201703L && !ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE 
 #define ABSL_HAVE_STD_OPTIONAL 1
 #endif
 #endif
@@ -577,8 +577,8 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 #endif
 
 #ifdef __has_include
-#if __has_include(<variant>) && defined(__cplusplus) && \
-    __cplusplus >= 201703L && !ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE
+#if __has_include(<variant>) && defined(__cplusplus) && \ 
+    __cplusplus >= 201703L && !ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE 
 #define ABSL_HAVE_STD_VARIANT 1
 #endif
 #endif
@@ -599,9 +599,9 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 // not correctly set by MSVC, so we use `_MSVC_LANG` to check the language
 // version.
 // TODO(zhangxy): fix tests before enabling aliasing for `std::any`.
-#if defined(_MSC_VER) && _MSC_VER >= 1910 &&         \
-    ((defined(_MSVC_LANG) && _MSVC_LANG > 201402) || \
-     (defined(__cplusplus) && __cplusplus > 201402))
+#if defined(_MSC_VER) && _MSC_VER >= 1910 &&         \ 
+    ((defined(_MSVC_LANG) && _MSVC_LANG > 201402) || \ 
+     (defined(__cplusplus) && __cplusplus > 201402)) 
 // #define ABSL_HAVE_STD_ANY 1
 #define ABSL_HAVE_STD_OPTIONAL 1
 #define ABSL_HAVE_STD_VARIANT 1
@@ -755,13 +755,13 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 #define ABSL_HAVE_ADDRESS_SANITIZER 1
 #endif
 
-// ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION
-//
-// Class template argument deduction is a language feature added in C++17.
-#ifdef ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION
-#error "ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION cannot be directly set."
-#elif defined(__cpp_deduction_guides)
-#define ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION 1
-#endif
-
+// ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION 
+// 
+// Class template argument deduction is a language feature added in C++17. 
+#ifdef ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION 
+#error "ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION cannot be directly set." 
+#elif defined(__cpp_deduction_guides) 
+#define ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION 1 
+#endif 
+ 
 #endif  // ABSL_BASE_CONFIG_H_
diff --git a/contrib/restricted/abseil-cpp/absl/base/dynamic_annotations.h b/contrib/restricted/abseil-cpp/absl/base/dynamic_annotations.h
index 3ea7c1568c..bc823c0a7d 100644
--- a/contrib/restricted/abseil-cpp/absl/base/dynamic_annotations.h
+++ b/contrib/restricted/abseil-cpp/absl/base/dynamic_annotations.h
@@ -110,9 +110,9 @@
 // Define race annotations.
 
 #if ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED == 1
-// Some of the symbols used in this section (e.g. AnnotateBenignRaceSized) are
-// defined by the compiler-based santizer implementation, not by the Abseil
-// library. Therefore they do not use ABSL_INTERNAL_C_SYMBOL.
+// Some of the symbols used in this section (e.g. AnnotateBenignRaceSized) are 
+// defined by the compiler-based santizer implementation, not by the Abseil 
+// library. Therefore they do not use ABSL_INTERNAL_C_SYMBOL. 
 
 // -------------------------------------------------------------
 // Annotations that suppress errors. It is usually better to express the
@@ -289,22 +289,22 @@ ABSL_INTERNAL_END_EXTERN_C
 // Define IGNORE_READS_BEGIN/_END annotations.
 
 #if ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED == 1
-// Some of the symbols used in this section (e.g. AnnotateIgnoreReadsBegin) are
-// defined by the compiler-based implementation, not by the Abseil
-// library. Therefore they do not use ABSL_INTERNAL_C_SYMBOL.
+// Some of the symbols used in this section (e.g. AnnotateIgnoreReadsBegin) are 
+// defined by the compiler-based implementation, not by the Abseil 
+// library. Therefore they do not use ABSL_INTERNAL_C_SYMBOL. 
 
 // Request the analysis tool to ignore all reads in the current thread until
 // ABSL_ANNOTATE_IGNORE_READS_END is called. Useful to ignore intentional racey
 // reads, while still checking other reads and all writes.
 // See also ABSL_ANNOTATE_UNPROTECTED_READ.
-#define ABSL_ANNOTATE_IGNORE_READS_BEGIN()              \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsBegin) \
-  (__FILE__, __LINE__)
+#define ABSL_ANNOTATE_IGNORE_READS_BEGIN()              \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsBegin) \ 
+  (__FILE__, __LINE__) 
 
 // Stop ignoring reads.
-#define ABSL_ANNOTATE_IGNORE_READS_END()              \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsEnd) \
-  (__FILE__, __LINE__)
+#define ABSL_ANNOTATE_IGNORE_READS_END()              \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsEnd) \ 
+  (__FILE__, __LINE__) 
 
 // Function prototypes of annotations provided by the compiler-based sanitizer
 // implementation.
@@ -324,22 +324,22 @@ ABSL_INTERNAL_END_EXTERN_C
 // TODO(delesley) -- The exclusive lock here ignores writes as well, but
 // allows IGNORE_READS_AND_WRITES to work properly.
 
-#define ABSL_ANNOTATE_IGNORE_READS_BEGIN()                          \
-  ABSL_INTERNAL_GLOBAL_SCOPED(                                      \
-      ABSL_INTERNAL_C_SYMBOL(AbslInternalAnnotateIgnoreReadsBegin)) \
-  ()
+#define ABSL_ANNOTATE_IGNORE_READS_BEGIN()                          \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(                                      \ 
+      ABSL_INTERNAL_C_SYMBOL(AbslInternalAnnotateIgnoreReadsBegin)) \ 
+  () 
 
-#define ABSL_ANNOTATE_IGNORE_READS_END()                          \
-  ABSL_INTERNAL_GLOBAL_SCOPED(                                    \
-      ABSL_INTERNAL_C_SYMBOL(AbslInternalAnnotateIgnoreReadsEnd)) \
-  ()
+#define ABSL_ANNOTATE_IGNORE_READS_END()                          \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(                                    \ 
+      ABSL_INTERNAL_C_SYMBOL(AbslInternalAnnotateIgnoreReadsEnd)) \ 
+  () 
 
-ABSL_INTERNAL_STATIC_INLINE void ABSL_INTERNAL_C_SYMBOL(
-    AbslInternalAnnotateIgnoreReadsBegin)()
+ABSL_INTERNAL_STATIC_INLINE void ABSL_INTERNAL_C_SYMBOL( 
+    AbslInternalAnnotateIgnoreReadsBegin)() 
     ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE {}
 
-ABSL_INTERNAL_STATIC_INLINE void ABSL_INTERNAL_C_SYMBOL(
-    AbslInternalAnnotateIgnoreReadsEnd)()
+ABSL_INTERNAL_STATIC_INLINE void ABSL_INTERNAL_C_SYMBOL( 
+    AbslInternalAnnotateIgnoreReadsEnd)() 
     ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE {}
 
 #else
diff --git a/contrib/restricted/abseil-cpp/absl/base/internal/direct_mmap.h b/contrib/restricted/abseil-cpp/absl/base/internal/direct_mmap.h
index 274054cd5a..6a83966333 100644
--- a/contrib/restricted/abseil-cpp/absl/base/internal/direct_mmap.h
+++ b/contrib/restricted/abseil-cpp/absl/base/internal/direct_mmap.h
@@ -74,13 +74,13 @@ namespace base_internal {
 inline void* DirectMmap(void* start, size_t length, int prot, int flags, int fd,
                         off64_t offset) noexcept {
 #if defined(__i386__) || defined(__ARM_ARCH_3__) || defined(__ARM_EABI__) || \
-    defined(__m68k__) || defined(__sh__) ||                                  \
-    (defined(__hppa__) && !defined(__LP64__)) ||                             \
+    defined(__m68k__) || defined(__sh__) ||                                  \ 
+    (defined(__hppa__) && !defined(__LP64__)) ||                             \ 
     (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32) ||                   \
     (defined(__PPC__) && !defined(__PPC64__)) ||                             \
     (defined(__riscv) && __riscv_xlen == 32) ||                              \
-    (defined(__s390__) && !defined(__s390x__)) ||                            \
-    (defined(__sparc__) && !defined(__arch64__))
+    (defined(__s390__) && !defined(__s390x__)) ||                            \ 
+    (defined(__sparc__) && !defined(__arch64__)) 
   // On these architectures, implement mmap with mmap2.
   static int pagesize = 0;
   if (pagesize == 0) {
diff --git a/contrib/restricted/abseil-cpp/absl/base/internal/endian.h b/contrib/restricted/abseil-cpp/absl/base/internal/endian.h
index dad0e9aeb0..acd60cd340 100644
--- a/contrib/restricted/abseil-cpp/absl/base/internal/endian.h
+++ b/contrib/restricted/abseil-cpp/absl/base/internal/endian.h
@@ -26,7 +26,7 @@
 #endif
 
 #include <cstdint>
-#include "absl/base/casts.h"
+#include "absl/base/casts.h" 
 #include "absl/base/config.h"
 #include "absl/base/internal/unaligned_access.h"
 #include "absl/base/port.h"
@@ -174,36 +174,36 @@ inline constexpr bool IsLittleEndian() { return false; }
 
 #endif /* ENDIAN */
 
-inline uint8_t FromHost(uint8_t x) { return x; }
-inline uint16_t FromHost(uint16_t x) { return FromHost16(x); }
-inline uint32_t FromHost(uint32_t x) { return FromHost32(x); }
-inline uint64_t FromHost(uint64_t x) { return FromHost64(x); }
-inline uint8_t ToHost(uint8_t x) { return x; }
-inline uint16_t ToHost(uint16_t x) { return ToHost16(x); }
-inline uint32_t ToHost(uint32_t x) { return ToHost32(x); }
-inline uint64_t ToHost(uint64_t x) { return ToHost64(x); }
-
-inline int8_t FromHost(int8_t x) { return x; }
-inline int16_t FromHost(int16_t x) {
-  return bit_cast<int16_t>(FromHost16(bit_cast<uint16_t>(x)));
-}
-inline int32_t FromHost(int32_t x) {
-  return bit_cast<int32_t>(FromHost32(bit_cast<uint32_t>(x)));
-}
-inline int64_t FromHost(int64_t x) {
-  return bit_cast<int64_t>(FromHost64(bit_cast<uint64_t>(x)));
-}
-inline int8_t ToHost(int8_t x) { return x; }
-inline int16_t ToHost(int16_t x) {
-  return bit_cast<int16_t>(ToHost16(bit_cast<uint16_t>(x)));
-}
-inline int32_t ToHost(int32_t x) {
-  return bit_cast<int32_t>(ToHost32(bit_cast<uint32_t>(x)));
-}
-inline int64_t ToHost(int64_t x) {
-  return bit_cast<int64_t>(ToHost64(bit_cast<uint64_t>(x)));
-}
-
+inline uint8_t FromHost(uint8_t x) { return x; } 
+inline uint16_t FromHost(uint16_t x) { return FromHost16(x); } 
+inline uint32_t FromHost(uint32_t x) { return FromHost32(x); } 
+inline uint64_t FromHost(uint64_t x) { return FromHost64(x); } 
+inline uint8_t ToHost(uint8_t x) { return x; } 
+inline uint16_t ToHost(uint16_t x) { return ToHost16(x); } 
+inline uint32_t ToHost(uint32_t x) { return ToHost32(x); } 
+inline uint64_t ToHost(uint64_t x) { return ToHost64(x); } 
+ 
+inline int8_t FromHost(int8_t x) { return x; } 
+inline int16_t FromHost(int16_t x) { 
+  return bit_cast<int16_t>(FromHost16(bit_cast<uint16_t>(x))); 
+} 
+inline int32_t FromHost(int32_t x) { 
+  return bit_cast<int32_t>(FromHost32(bit_cast<uint32_t>(x))); 
+} 
+inline int64_t FromHost(int64_t x) { 
+  return bit_cast<int64_t>(FromHost64(bit_cast<uint64_t>(x))); 
+} 
+inline int8_t ToHost(int8_t x) { return x; } 
+inline int16_t ToHost(int16_t x) { 
+  return bit_cast<int16_t>(ToHost16(bit_cast<uint16_t>(x))); 
+} 
+inline int32_t ToHost(int32_t x) { 
+  return bit_cast<int32_t>(ToHost32(bit_cast<uint32_t>(x))); 
+} 
+inline int64_t ToHost(int64_t x) { 
+  return bit_cast<int64_t>(ToHost64(bit_cast<uint64_t>(x))); 
+} 
+ 
 // Functions to do unaligned loads and stores in little-endian order.
 inline uint16_t Load16(const void *p) {
   return ToHost16(ABSL_INTERNAL_UNALIGNED_LOAD16(p));
@@ -264,36 +264,36 @@ inline constexpr bool IsLittleEndian() { return false; }
 
 #endif /* ENDIAN */
 
-inline uint8_t FromHost(uint8_t x) { return x; }
-inline uint16_t FromHost(uint16_t x) { return FromHost16(x); }
-inline uint32_t FromHost(uint32_t x) { return FromHost32(x); }
-inline uint64_t FromHost(uint64_t x) { return FromHost64(x); }
-inline uint8_t ToHost(uint8_t x) { return x; }
-inline uint16_t ToHost(uint16_t x) { return ToHost16(x); }
-inline uint32_t ToHost(uint32_t x) { return ToHost32(x); }
-inline uint64_t ToHost(uint64_t x) { return ToHost64(x); }
-
-inline int8_t FromHost(int8_t x) { return x; }
-inline int16_t FromHost(int16_t x) {
-  return bit_cast<int16_t>(FromHost16(bit_cast<uint16_t>(x)));
-}
-inline int32_t FromHost(int32_t x) {
-  return bit_cast<int32_t>(FromHost32(bit_cast<uint32_t>(x)));
-}
-inline int64_t FromHost(int64_t x) {
-  return bit_cast<int64_t>(FromHost64(bit_cast<uint64_t>(x)));
-}
-inline int8_t ToHost(int8_t x) { return x; }
-inline int16_t ToHost(int16_t x) {
-  return bit_cast<int16_t>(ToHost16(bit_cast<uint16_t>(x)));
-}
-inline int32_t ToHost(int32_t x) {
-  return bit_cast<int32_t>(ToHost32(bit_cast<uint32_t>(x)));
-}
-inline int64_t ToHost(int64_t x) {
-  return bit_cast<int64_t>(ToHost64(bit_cast<uint64_t>(x)));
-}
-
+inline uint8_t FromHost(uint8_t x) { return x; } 
+inline uint16_t FromHost(uint16_t x) { return FromHost16(x); } 
+inline uint32_t FromHost(uint32_t x) { return FromHost32(x); } 
+inline uint64_t FromHost(uint64_t x) { return FromHost64(x); } 
+inline uint8_t ToHost(uint8_t x) { return x; } 
+inline uint16_t ToHost(uint16_t x) { return ToHost16(x); } 
+inline uint32_t ToHost(uint32_t x) { return ToHost32(x); } 
+inline uint64_t ToHost(uint64_t x) { return ToHost64(x); } 
+ 
+inline int8_t FromHost(int8_t x) { return x; } 
+inline int16_t FromHost(int16_t x) { 
+  return bit_cast<int16_t>(FromHost16(bit_cast<uint16_t>(x))); 
+} 
+inline int32_t FromHost(int32_t x) { 
+  return bit_cast<int32_t>(FromHost32(bit_cast<uint32_t>(x))); 
+} 
+inline int64_t FromHost(int64_t x) { 
+  return bit_cast<int64_t>(FromHost64(bit_cast<uint64_t>(x))); 
+} 
+inline int8_t ToHost(int8_t x) { return x; } 
+inline int16_t ToHost(int16_t x) { 
+  return bit_cast<int16_t>(ToHost16(bit_cast<uint16_t>(x))); 
+} 
+inline int32_t ToHost(int32_t x) { 
+  return bit_cast<int32_t>(ToHost32(bit_cast<uint32_t>(x))); 
+} 
+inline int64_t ToHost(int64_t x) { 
+  return bit_cast<int64_t>(ToHost64(bit_cast<uint64_t>(x))); 
+} 
+ 
 // Functions to do unaligned loads and stores in big-endian order.
 inline uint16_t Load16(const void *p) {
   return ToHost16(ABSL_INTERNAL_UNALIGNED_LOAD16(p));
diff --git a/contrib/restricted/abseil-cpp/absl/base/internal/low_level_scheduling.h b/contrib/restricted/abseil-cpp/absl/base/internal/low_level_scheduling.h
index 9baccc0659..e306ead646 100644
--- a/contrib/restricted/abseil-cpp/absl/base/internal/low_level_scheduling.h
+++ b/contrib/restricted/abseil-cpp/absl/base/internal/low_level_scheduling.h
@@ -61,8 +61,8 @@ class SchedulingGuard {
  public:
   // Returns true iff the calling thread may be cooperatively rescheduled.
   static bool ReschedulingIsAllowed();
-  SchedulingGuard(const SchedulingGuard&) = delete;
-  SchedulingGuard& operator=(const SchedulingGuard&) = delete;
+  SchedulingGuard(const SchedulingGuard&) = delete; 
+  SchedulingGuard& operator=(const SchedulingGuard&) = delete; 
 
  private:
   // Disable cooperative rescheduling of the calling thread.  It may still
diff --git a/contrib/restricted/abseil-cpp/absl/base/internal/raw_logging.cc b/contrib/restricted/abseil-cpp/absl/base/internal/raw_logging.cc
index 074e026adb..26560af1f8 100644
--- a/contrib/restricted/abseil-cpp/absl/base/internal/raw_logging.cc
+++ b/contrib/restricted/abseil-cpp/absl/base/internal/raw_logging.cc
@@ -67,32 +67,32 @@
 #undef ABSL_HAVE_RAW_IO
 #endif
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace raw_logging_internal {
-namespace {
-
+namespace absl { 
+ABSL_NAMESPACE_BEGIN 
+namespace raw_logging_internal { 
+namespace { 
+ 
 // TODO(gfalcon): We want raw-logging to work on as many platforms as possible.
-// Explicitly `#error` out when not `ABSL_LOW_LEVEL_WRITE_SUPPORTED`, except for
-// a selected set of platforms for which we expect not to be able to raw log.
+// Explicitly `#error` out when not `ABSL_LOW_LEVEL_WRITE_SUPPORTED`, except for 
+// a selected set of platforms for which we expect not to be able to raw log. 
 
-ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES
-    absl::base_internal::AtomicHook<LogPrefixHook>
-        log_prefix_hook;
-ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES
-    absl::base_internal::AtomicHook<AbortHook>
-        abort_hook;
+ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES 
+    absl::base_internal::AtomicHook<LogPrefixHook> 
+        log_prefix_hook; 
+ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES 
+    absl::base_internal::AtomicHook<AbortHook> 
+        abort_hook; 
 
 #ifdef ABSL_LOW_LEVEL_WRITE_SUPPORTED
-constexpr char kTruncated[] = " ... (message truncated)\n";
+constexpr char kTruncated[] = " ... (message truncated)\n"; 
 
 // sprintf the format to the buffer, adjusting *buf and *size to reflect the
 // consumed bytes, and return whether the message fit without truncation.  If
 // truncation occurred, if possible leave room in the buffer for the message
 // kTruncated[].
-bool VADoRawLog(char** buf, int* size, const char* format, va_list ap)
-    ABSL_PRINTF_ATTRIBUTE(3, 0);
-bool VADoRawLog(char** buf, int* size, const char* format, va_list ap) {
+bool VADoRawLog(char** buf, int* size, const char* format, va_list ap) 
+    ABSL_PRINTF_ATTRIBUTE(3, 0); 
+bool VADoRawLog(char** buf, int* size, const char* format, va_list ap) { 
   int n = vsnprintf(*buf, *size, format, ap);
   bool result = true;
   if (n < 0 || n > *size) {
@@ -100,7 +100,7 @@ bool VADoRawLog(char** buf, int* size, const char* format, va_list ap) {
     if (static_cast<size_t>(*size) > sizeof(kTruncated)) {
       n = *size - sizeof(kTruncated);  // room for truncation message
     } else {
-      n = 0;  // no room for truncation message
+      n = 0;  // no room for truncation message 
     }
   }
   *size -= n;
@@ -109,7 +109,7 @@ bool VADoRawLog(char** buf, int* size, const char* format, va_list ap) {
 }
 #endif  // ABSL_LOW_LEVEL_WRITE_SUPPORTED
 
-constexpr int kLogBufSize = 3000;
+constexpr int kLogBufSize = 3000; 
 
 // CAVEAT: vsnprintf called from *DoRawLog below has some (exotic) code paths
 // that invoke malloc() and getenv() that might acquire some locks.
@@ -168,7 +168,7 @@ void RawLogVA(absl::LogSeverity severity, const char* file, int line,
     } else {
       DoRawLog(&buf, &size, "%s", kTruncated);
     }
-    SafeWriteToStderr(buffer, strlen(buffer));
+    SafeWriteToStderr(buffer, strlen(buffer)); 
   }
 #else
   static_cast<void>(format);
@@ -183,16 +183,16 @@ void RawLogVA(absl::LogSeverity severity, const char* file, int line,
   }
 }
 
-// Non-formatting version of RawLog().
-//
-// TODO(gfalcon): When string_view no longer depends on base, change this
-// interface to take its message as a string_view instead.
-void DefaultInternalLog(absl::LogSeverity severity, const char* file, int line,
-                        const std::string& message) {
-  RawLog(severity, file, line, "%.*s", static_cast<int>(message.size()),
-         message.data());
-}
-
+// Non-formatting version of RawLog(). 
+// 
+// TODO(gfalcon): When string_view no longer depends on base, change this 
+// interface to take its message as a string_view instead. 
+void DefaultInternalLog(absl::LogSeverity severity, const char* file, int line, 
+                        const std::string& message) { 
+  RawLog(severity, file, line, "%.*s", static_cast<int>(message.size()), 
+         message.data()); 
+} 
+ 
 }  // namespace
 
 void SafeWriteToStderr(const char *s, size_t len) {
@@ -229,10 +229,10 @@ ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES ABSL_DLL
     absl::base_internal::AtomicHook<InternalLogFunction>
         internal_log_function(DefaultInternalLog);
 
-void RegisterLogPrefixHook(LogPrefixHook func) { log_prefix_hook.Store(func); }
-
-void RegisterAbortHook(AbortHook func) { abort_hook.Store(func); }
-
+void RegisterLogPrefixHook(LogPrefixHook func) { log_prefix_hook.Store(func); } 
+ 
+void RegisterAbortHook(AbortHook func) { abort_hook.Store(func); } 
+ 
 void RegisterInternalLogFunction(InternalLogFunction func) {
   internal_log_function.Store(func);
 }
diff --git a/contrib/restricted/abseil-cpp/absl/base/internal/raw_logging.h b/contrib/restricted/abseil-cpp/absl/base/internal/raw_logging.h
index 2bf7aabac1..4a5ba01071 100644
--- a/contrib/restricted/abseil-cpp/absl/base/internal/raw_logging.h
+++ b/contrib/restricted/abseil-cpp/absl/base/internal/raw_logging.h
@@ -72,14 +72,14 @@
 //
 // The API is a subset of the above: each macro only takes two arguments.  Use
 // StrCat if you need to build a richer message.
-#define ABSL_INTERNAL_LOG(severity, message)                                 \
-  do {                                                                       \
-    constexpr const char* absl_raw_logging_internal_filename = __FILE__;     \
-    ::absl::raw_logging_internal::internal_log_function(                     \
-        ABSL_RAW_LOGGING_INTERNAL_##severity,                                \
-        absl_raw_logging_internal_filename, __LINE__, message);              \
-    if (ABSL_RAW_LOGGING_INTERNAL_##severity == ::absl::LogSeverity::kFatal) \
-      ABSL_INTERNAL_UNREACHABLE;                                             \
+#define ABSL_INTERNAL_LOG(severity, message)                                 \ 
+  do {                                                                       \ 
+    constexpr const char* absl_raw_logging_internal_filename = __FILE__;     \ 
+    ::absl::raw_logging_internal::internal_log_function(                     \ 
+        ABSL_RAW_LOGGING_INTERNAL_##severity,                                \ 
+        absl_raw_logging_internal_filename, __LINE__, message);              \ 
+    if (ABSL_RAW_LOGGING_INTERNAL_##severity == ::absl::LogSeverity::kFatal) \ 
+      ABSL_INTERNAL_UNREACHABLE;                                             \ 
   } while (0)
 
 #define ABSL_INTERNAL_CHECK(condition, message)                    \
@@ -178,14 +178,14 @@ ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES ABSL_DLL extern base_internal::AtomicHook<
     InternalLogFunction>
     internal_log_function;
 
-// Registers hooks of the above types.  Only a single hook of each type may be
-// registered.  It is an error to call these functions multiple times with
-// different input arguments.
-//
-// These functions are safe to call at any point during initialization; they do
-// not block or malloc, and are async-signal safe.
-void RegisterLogPrefixHook(LogPrefixHook func);
-void RegisterAbortHook(AbortHook func);
+// Registers hooks of the above types.  Only a single hook of each type may be 
+// registered.  It is an error to call these functions multiple times with 
+// different input arguments. 
+// 
+// These functions are safe to call at any point during initialization; they do 
+// not block or malloc, and are async-signal safe. 
+void RegisterLogPrefixHook(LogPrefixHook func); 
+void RegisterAbortHook(AbortHook func); 
 void RegisterInternalLogFunction(InternalLogFunction func);
 
 }  // namespace raw_logging_internal
diff --git a/contrib/restricted/abseil-cpp/absl/base/internal/spinlock.cc b/contrib/restricted/abseil-cpp/absl/base/internal/spinlock.cc
index 35c0696a34..62dc4c7869 100644
--- a/contrib/restricted/abseil-cpp/absl/base/internal/spinlock.cc
+++ b/contrib/restricted/abseil-cpp/absl/base/internal/spinlock.cc
@@ -125,9 +125,9 @@ void SpinLock::SlowLock() {
     // it as having a sleeper.
     if ((lock_value & kWaitTimeMask) == 0) {
       // Here, just "mark" that the thread is going to sleep.  Don't store the
-      // lock wait time in the lock -- the lock word stores the amount of time
-      // that the current holder waited before acquiring the lock, not the wait
-      // time of any thread currently waiting to acquire it.
+      // lock wait time in the lock -- the lock word stores the amount of time 
+      // that the current holder waited before acquiring the lock, not the wait 
+      // time of any thread currently waiting to acquire it. 
       if (lockword_.compare_exchange_strong(
               lock_value, lock_value | kSpinLockSleeper,
               std::memory_order_relaxed, std::memory_order_relaxed)) {
@@ -141,14 +141,14 @@ void SpinLock::SlowLock() {
         // this thread obtains the lock.
         lock_value = TryLockInternal(lock_value, wait_cycles);
         continue;   // Skip the delay at the end of the loop.
-      } else if ((lock_value & kWaitTimeMask) == 0) {
-        // The lock is still held, without a waiter being marked, but something
-        // else about the lock word changed, causing our CAS to fail. For
-        // example, a new lock holder may have acquired the lock with
-        // kSpinLockDisabledScheduling set, whereas the previous holder had not
-        // set that flag. In this case, attempt again to mark ourselves as a
-        // waiter.
-        continue;
+      } else if ((lock_value & kWaitTimeMask) == 0) { 
+        // The lock is still held, without a waiter being marked, but something 
+        // else about the lock word changed, causing our CAS to fail. For 
+        // example, a new lock holder may have acquired the lock with 
+        // kSpinLockDisabledScheduling set, whereas the previous holder had not 
+        // set that flag. In this case, attempt again to mark ourselves as a 
+        // waiter. 
+        continue; 
       }
     }
 
diff --git a/contrib/restricted/abseil-cpp/absl/base/internal/spinlock.h b/contrib/restricted/abseil-cpp/absl/base/internal/spinlock.h
index ac40daff12..f00df6da26 100644
--- a/contrib/restricted/abseil-cpp/absl/base/internal/spinlock.h
+++ b/contrib/restricted/abseil-cpp/absl/base/internal/spinlock.h
@@ -15,7 +15,7 @@
 //
 
 //  Most users requiring mutual exclusion should use Mutex.
-//  SpinLock is provided for use in two situations:
+//  SpinLock is provided for use in two situations: 
 //   - for use by Abseil internal code that Mutex itself depends on
 //   - for async signal safety (see below)
 
@@ -139,20 +139,20 @@ class ABSL_LOCKABLE SpinLock {
   //
   // bit[0] encodes whether a lock is being held.
   // bit[1] encodes whether a lock uses cooperative scheduling.
-  // bit[2] encodes whether the current lock holder disabled scheduling when
-  //        acquiring the lock. Only set when kSpinLockHeld is also set.
+  // bit[2] encodes whether the current lock holder disabled scheduling when 
+  //        acquiring the lock. Only set when kSpinLockHeld is also set. 
   // bit[3:31] encodes time a lock spent on waiting as a 29-bit unsigned int.
-  //        This is set by the lock holder to indicate how long it waited on
-  //        the lock before eventually acquiring it. The number of cycles is
-  //        encoded as a 29-bit unsigned int, or in the case that the current
-  //        holder did not wait but another waiter is queued, the LSB
-  //        (kSpinLockSleeper) is set. The implementation does not explicitly
-  //        track the number of queued waiters beyond this. It must always be
-  //        assumed that waiters may exist if the current holder was required to
-  //        queue.
-  //
-  // Invariant: if the lock is not held, the value is either 0 or
-  // kSpinLockCooperative.
+  //        This is set by the lock holder to indicate how long it waited on 
+  //        the lock before eventually acquiring it. The number of cycles is 
+  //        encoded as a 29-bit unsigned int, or in the case that the current 
+  //        holder did not wait but another waiter is queued, the LSB 
+  //        (kSpinLockSleeper) is set. The implementation does not explicitly 
+  //        track the number of queued waiters beyond this. It must always be 
+  //        assumed that waiters may exist if the current holder was required to 
+  //        queue. 
+  // 
+  // Invariant: if the lock is not held, the value is either 0 or 
+  // kSpinLockCooperative. 
   static constexpr uint32_t kSpinLockHeld = 1;
   static constexpr uint32_t kSpinLockCooperative = 2;
   static constexpr uint32_t kSpinLockDisabledScheduling = 4;
diff --git a/contrib/restricted/abseil-cpp/absl/base/internal/spinlock_akaros.inc b/contrib/restricted/abseil-cpp/absl/base/internal/spinlock_akaros.inc
index 7b0cada4f1..12d3f713d1 100644
--- a/contrib/restricted/abseil-cpp/absl/base/internal/spinlock_akaros.inc
+++ b/contrib/restricted/abseil-cpp/absl/base/internal/spinlock_akaros.inc
@@ -20,7 +20,7 @@
 
 extern "C" {
 
-ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)(
+ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)( 
     std::atomic<uint32_t>* /* lock_word */, uint32_t /* value */,
     int /* loop */, absl::base_internal::SchedulingMode /* mode */) {
   // In Akaros, one must take care not to call anything that could cause a
@@ -29,7 +29,7 @@ ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)(
   // arbitrary code.
 }
 
-ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)(
+ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)( 
     std::atomic<uint32_t>* /* lock_word */, bool /* all */) {}
 
 }  // extern "C"
diff --git a/contrib/restricted/abseil-cpp/absl/base/internal/spinlock_linux.inc b/contrib/restricted/abseil-cpp/absl/base/internal/spinlock_linux.inc
index 202f7cdfc8..cb9806de5f 100644
--- a/contrib/restricted/abseil-cpp/absl/base/internal/spinlock_linux.inc
+++ b/contrib/restricted/abseil-cpp/absl/base/internal/spinlock_linux.inc
@@ -56,7 +56,7 @@ static_assert(sizeof(std::atomic<uint32_t>) == sizeof(int),
 
 extern "C" {
 
-ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)(
+ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)( 
     std::atomic<uint32_t> *w, uint32_t value, int loop,
     absl::base_internal::SchedulingMode) {
   absl::base_internal::ErrnoSaver errno_saver;
@@ -66,8 +66,8 @@ ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)(
   syscall(SYS_futex, w, FUTEX_WAIT | FUTEX_PRIVATE_FLAG, value, &tm);
 }
 
-ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)(
-    std::atomic<uint32_t> *w, bool all) {
+ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)( 
+    std::atomic<uint32_t> *w, bool all) { 
   syscall(SYS_futex, w, FUTEX_WAKE | FUTEX_PRIVATE_FLAG, all ? INT_MAX : 1, 0);
 }
 
diff --git a/contrib/restricted/abseil-cpp/absl/base/internal/spinlock_posix.inc b/contrib/restricted/abseil-cpp/absl/base/internal/spinlock_posix.inc
index 4f6f887d99..5ab5cbf816 100644
--- a/contrib/restricted/abseil-cpp/absl/base/internal/spinlock_posix.inc
+++ b/contrib/restricted/abseil-cpp/absl/base/internal/spinlock_posix.inc
@@ -25,7 +25,7 @@
 
 extern "C" {
 
-ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)(
+ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)( 
     std::atomic<uint32_t>* /* lock_word */, uint32_t /* value */, int loop,
     absl::base_internal::SchedulingMode /* mode */) {
   absl::base_internal::ErrnoSaver errno_saver;
@@ -40,7 +40,7 @@ ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)(
   }
 }
 
-ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)(
+ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)( 
     std::atomic<uint32_t>* /* lock_word */, bool /* all */) {}
 
 }  // extern "C"
diff --git a/contrib/restricted/abseil-cpp/absl/base/internal/spinlock_wait.h b/contrib/restricted/abseil-cpp/absl/base/internal/spinlock_wait.h
index 9a1adcda5e..5c4a783bb5 100644
--- a/contrib/restricted/abseil-cpp/absl/base/internal/spinlock_wait.h
+++ b/contrib/restricted/abseil-cpp/absl/base/internal/spinlock_wait.h
@@ -45,16 +45,16 @@ uint32_t SpinLockWait(std::atomic<uint32_t> *w, int n,
                       const SpinLockWaitTransition trans[],
                       SchedulingMode scheduling_mode);
 
-// If possible, wake some thread that has called SpinLockDelay(w, ...). If `all`
-// is true, wake all such threads. On some systems, this may be a no-op; on
-// those systems, threads calling SpinLockDelay() will always wake eventually
-// even if SpinLockWake() is never called.
+// If possible, wake some thread that has called SpinLockDelay(w, ...). If `all` 
+// is true, wake all such threads. On some systems, this may be a no-op; on 
+// those systems, threads calling SpinLockDelay() will always wake eventually 
+// even if SpinLockWake() is never called. 
 void SpinLockWake(std::atomic<uint32_t> *w, bool all);
 
 // Wait for an appropriate spin delay on iteration "loop" of a
 // spin loop on location *w, whose previously observed value was "value".
 // SpinLockDelay() may do nothing, may yield the CPU, may sleep a clock tick,
-// or may wait for a call to SpinLockWake(w).
+// or may wait for a call to SpinLockWake(w). 
 void SpinLockDelay(std::atomic<uint32_t> *w, uint32_t value, int loop,
                    base_internal::SchedulingMode scheduling_mode);
 
@@ -73,23 +73,23 @@ ABSL_NAMESPACE_END
 // By changing our extension points to be extern "C", we dodge this
 // check.
 extern "C" {
-void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)(std::atomic<uint32_t> *w,
-                                                      bool all);
-void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)(
+void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)(std::atomic<uint32_t> *w, 
+                                                      bool all); 
+void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)( 
     std::atomic<uint32_t> *w, uint32_t value, int loop,
     absl::base_internal::SchedulingMode scheduling_mode);
 }
 
 inline void absl::base_internal::SpinLockWake(std::atomic<uint32_t> *w,
                                               bool all) {
-  ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)(w, all);
+  ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)(w, all); 
 }
 
 inline void absl::base_internal::SpinLockDelay(
     std::atomic<uint32_t> *w, uint32_t value, int loop,
     absl::base_internal::SchedulingMode scheduling_mode) {
-  ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)
-  (w, value, loop, scheduling_mode);
+  ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay) 
+  (w, value, loop, scheduling_mode); 
 }
 
 #endif  // ABSL_BASE_INTERNAL_SPINLOCK_WAIT_H_
diff --git a/contrib/restricted/abseil-cpp/absl/base/internal/spinlock_win32.inc b/contrib/restricted/abseil-cpp/absl/base/internal/spinlock_win32.inc
index 9d224813a5..5ce0dbad8c 100644
--- a/contrib/restricted/abseil-cpp/absl/base/internal/spinlock_win32.inc
+++ b/contrib/restricted/abseil-cpp/absl/base/internal/spinlock_win32.inc
@@ -20,9 +20,9 @@
 
 extern "C" {
 
-void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)(
-    std::atomic<uint32_t>* /* lock_word */, uint32_t /* value */, int loop,
-    absl::base_internal::SchedulingMode /* mode */) {
+void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)( 
+    std::atomic<uint32_t>* /* lock_word */, uint32_t /* value */, int loop, 
+    absl::base_internal::SchedulingMode /* mode */) { 
   if (loop == 0) {
   } else if (loop == 1) {
     Sleep(0);
@@ -31,7 +31,7 @@ void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)(
   }
 }
 
-void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)(
-    std::atomic<uint32_t>* /* lock_word */, bool /* all */) {}
+void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)( 
+    std::atomic<uint32_t>* /* lock_word */, bool /* all */) {} 
 
 }  // extern "C"
diff --git a/contrib/restricted/abseil-cpp/absl/base/internal/strerror.cc b/contrib/restricted/abseil-cpp/absl/base/internal/strerror.cc
index 0d6226fd0a..ba1af09bee 100644
--- a/contrib/restricted/abseil-cpp/absl/base/internal/strerror.cc
+++ b/contrib/restricted/abseil-cpp/absl/base/internal/strerror.cc
@@ -75,7 +75,7 @@ std::array<std::string, kSysNerr>* NewStrErrorTable() {
 }  // namespace
 
 std::string StrError(int errnum) {
-  absl::base_internal::ErrnoSaver errno_saver;
+  absl::base_internal::ErrnoSaver errno_saver; 
   static const auto* table = NewStrErrorTable();
   if (errnum >= 0 && errnum < static_cast<int>(table->size())) {
     return (*table)[errnum];
diff --git a/contrib/restricted/abseil-cpp/absl/base/internal/sysinfo.cc b/contrib/restricted/abseil-cpp/absl/base/internal/sysinfo.cc
index 8c2e6c87fa..823608d3d7 100644
--- a/contrib/restricted/abseil-cpp/absl/base/internal/sysinfo.cc
+++ b/contrib/restricted/abseil-cpp/absl/base/internal/sysinfo.cc
@@ -495,7 +495,7 @@ pid_t GetTID() {
 // userspace construct) to avoid unnecessary system calls. Without this caching,
 // it can take roughly 98ns, while it takes roughly 1ns with this caching.
 pid_t GetCachedTID() {
-#ifdef ABSL_HAVE_THREAD_LOCAL
+#ifdef ABSL_HAVE_THREAD_LOCAL 
   static thread_local pid_t thread_id = GetTID();
   return thread_id;
 #else
diff --git a/contrib/restricted/abseil-cpp/absl/base/internal/thread_identity.cc b/contrib/restricted/abseil-cpp/absl/base/internal/thread_identity.cc
index 9950e63a79..f1e9a35994 100644
--- a/contrib/restricted/abseil-cpp/absl/base/internal/thread_identity.cc
+++ b/contrib/restricted/abseil-cpp/absl/base/internal/thread_identity.cc
@@ -23,7 +23,7 @@
 #include <cassert>
 #include <memory>
 
-#include "absl/base/attributes.h"
+#include "absl/base/attributes.h" 
 #include "absl/base/call_once.h"
 #include "absl/base/internal/raw_logging.h"
 #include "absl/base/internal/spinlock.h"
@@ -54,11 +54,11 @@ void AllocateThreadIdentityKey(ThreadIdentityReclaimerFunction reclaimer) {
 // exist within a process (via dlopen() or similar), references to
 // thread_identity_ptr from each instance of the code will refer to
 // *different* instances of this ptr.
-// Apple platforms have the visibility attribute, but issue a compile warning
-// that protected visibility is unsupported.
-#if ABSL_HAVE_ATTRIBUTE(visibility) && !defined(__APPLE__)
+// Apple platforms have the visibility attribute, but issue a compile warning 
+// that protected visibility is unsupported. 
+#if ABSL_HAVE_ATTRIBUTE(visibility) && !defined(__APPLE__) 
 __attribute__((visibility("protected")))
-#endif  // ABSL_HAVE_ATTRIBUTE(visibility) && !defined(__APPLE__)
+#endif  // ABSL_HAVE_ATTRIBUTE(visibility) && !defined(__APPLE__) 
 #if ABSL_PER_THREAD_TLS
 // Prefer __thread to thread_local as benchmarks indicate it is a bit faster.
 ABSL_PER_THREAD_TLS_KEYWORD ThreadIdentity* thread_identity_ptr = nullptr;
@@ -120,10 +120,10 @@ void SetCurrentThreadIdentity(
     ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_CPP11
 
 // Please see the comment on `CurrentThreadIdentityIfPresent` in
-// thread_identity.h. When we cannot expose thread_local variables in
-// headers, we opt for the correct-but-slower option of not inlining this
-// function.
-#ifndef ABSL_INTERNAL_INLINE_CURRENT_THREAD_IDENTITY_IF_PRESENT
+// thread_identity.h. When we cannot expose thread_local variables in 
+// headers, we opt for the correct-but-slower option of not inlining this 
+// function. 
+#ifndef ABSL_INTERNAL_INLINE_CURRENT_THREAD_IDENTITY_IF_PRESENT 
 ThreadIdentity* CurrentThreadIdentityIfPresent() { return thread_identity_ptr; }
 #endif
 #endif
diff --git a/contrib/restricted/abseil-cpp/absl/base/internal/thread_identity.h b/contrib/restricted/abseil-cpp/absl/base/internal/thread_identity.h
index 659694b326..2920a5bfff 100644
--- a/contrib/restricted/abseil-cpp/absl/base/internal/thread_identity.h
+++ b/contrib/restricted/abseil-cpp/absl/base/internal/thread_identity.h
@@ -32,7 +32,7 @@
 
 #include "absl/base/config.h"
 #include "absl/base/internal/per_thread_tls.h"
-#include "absl/base/optimization.h"
+#include "absl/base/optimization.h" 
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
@@ -70,28 +70,28 @@ struct PerThreadSynch {
                          // is using this PerThreadSynch as a terminator.  Its
                          // skip field must not be filled in because the loop
                          // might then skip over the terminator.
-  bool wake;             // This thread is to be woken from a Mutex.
-  // If "x" is on a waiter list for a mutex, "x->cond_waiter" is true iff the
-  // waiter is waiting on the mutex as part of a CV Wait or Mutex Await.
-  //
-  // The value of "x->cond_waiter" is meaningless if "x" is not on a
-  // Mutex waiter list.
-  bool cond_waiter;
-  bool maybe_unlocking;  // Valid at head of Mutex waiter queue;
-                         // true if UnlockSlow could be searching
-                         // for a waiter to wake.  Used for an optimization
-                         // in Enqueue().  true is always a valid value.
-                         // Can be reset to false when the unlocker or any
-                         // writer releases the lock, or a reader fully
-                         // releases the lock.  It may not be set to false
-                         // by a reader that decrements the count to
-                         // non-zero. protected by mutex spinlock
-  bool suppress_fatal_errors;  // If true, try to proceed even in the face
-                               // of broken invariants.  This is used within
-                               // fatal signal handlers to improve the
-                               // chances of debug logging information being
-                               // output successfully.
-  int priority;                // Priority of thread (updated every so often).
+  bool wake;             // This thread is to be woken from a Mutex. 
+  // If "x" is on a waiter list for a mutex, "x->cond_waiter" is true iff the 
+  // waiter is waiting on the mutex as part of a CV Wait or Mutex Await. 
+  // 
+  // The value of "x->cond_waiter" is meaningless if "x" is not on a 
+  // Mutex waiter list. 
+  bool cond_waiter; 
+  bool maybe_unlocking;  // Valid at head of Mutex waiter queue; 
+                         // true if UnlockSlow could be searching 
+                         // for a waiter to wake.  Used for an optimization 
+                         // in Enqueue().  true is always a valid value. 
+                         // Can be reset to false when the unlocker or any 
+                         // writer releases the lock, or a reader fully 
+                         // releases the lock.  It may not be set to false 
+                         // by a reader that decrements the count to 
+                         // non-zero. protected by mutex spinlock 
+  bool suppress_fatal_errors;  // If true, try to proceed even in the face 
+                               // of broken invariants.  This is used within 
+                               // fatal signal handlers to improve the 
+                               // chances of debug logging information being 
+                               // output successfully. 
+  int priority;                // Priority of thread (updated every so often). 
 
   // State values:
   //   kAvailable: This PerThreadSynch is available.
@@ -110,30 +110,30 @@ struct PerThreadSynch {
   };
   std::atomic<State> state;
 
-  // The wait parameters of the current wait.  waitp is null if the
-  // thread is not waiting. Transitions from null to non-null must
-  // occur before the enqueue commit point (state = kQueued in
-  // Enqueue() and CondVarEnqueue()). Transitions from non-null to
-  // null must occur after the wait is finished (state = kAvailable in
-  // Mutex::Block() and CondVar::WaitCommon()). This field may be
-  // changed only by the thread that describes this PerThreadSynch.  A
-  // special case is Fer(), which calls Enqueue() on another thread,
-  // but with an identical SynchWaitParams pointer, thus leaving the
-  // pointer unchanged.
-  SynchWaitParams* waitp;
+  // The wait parameters of the current wait.  waitp is null if the 
+  // thread is not waiting. Transitions from null to non-null must 
+  // occur before the enqueue commit point (state = kQueued in 
+  // Enqueue() and CondVarEnqueue()). Transitions from non-null to 
+  // null must occur after the wait is finished (state = kAvailable in 
+  // Mutex::Block() and CondVar::WaitCommon()). This field may be 
+  // changed only by the thread that describes this PerThreadSynch.  A 
+  // special case is Fer(), which calls Enqueue() on another thread, 
+  // but with an identical SynchWaitParams pointer, thus leaving the 
+  // pointer unchanged. 
+  SynchWaitParams* waitp; 
 
-  intptr_t readers;     // Number of readers in mutex.
+  intptr_t readers;     // Number of readers in mutex. 
 
-  // When priority will next be read (cycles).
-  int64_t next_priority_read_cycles;
+  // When priority will next be read (cycles). 
+  int64_t next_priority_read_cycles; 
 
   // Locks held; used during deadlock detection.
   // Allocated in Synch_GetAllLocks() and freed in ReclaimThreadIdentity().
   SynchLocksHeld *all_locks;
 };
 
-// The instances of this class are allocated in NewThreadIdentity() with an
-// alignment of PerThreadSynch::kAlignment.
+// The instances of this class are allocated in NewThreadIdentity() with an 
+// alignment of PerThreadSynch::kAlignment. 
 struct ThreadIdentity {
   // Must be the first member.  The Mutex implementation requires that
   // the PerThreadSynch object associated with each thread is
@@ -143,7 +143,7 @@ struct ThreadIdentity {
 
   // Private: Reserved for absl::synchronization_internal::Waiter.
   struct WaiterState {
-    alignas(void*) char data[128];
+    alignas(void*) char data[128]; 
   } waiter_state;
 
   // Used by PerThreadSem::{Get,Set}ThreadBlockedCounter().
@@ -211,9 +211,9 @@ void ClearCurrentThreadIdentity();
 #define ABSL_THREAD_IDENTITY_MODE ABSL_FORCE_THREAD_IDENTITY_MODE
 #elif defined(_WIN32) && !defined(__MINGW32__)
 #define ABSL_THREAD_IDENTITY_MODE ABSL_THREAD_IDENTITY_MODE_USE_CPP11
-#elif defined(__APPLE__) && defined(ABSL_HAVE_THREAD_LOCAL)
-#define ABSL_THREAD_IDENTITY_MODE ABSL_THREAD_IDENTITY_MODE_USE_CPP11
-#elif ABSL_PER_THREAD_TLS && defined(__GOOGLE_GRTE_VERSION__) &&        \
+#elif defined(__APPLE__) && defined(ABSL_HAVE_THREAD_LOCAL) 
+#define ABSL_THREAD_IDENTITY_MODE ABSL_THREAD_IDENTITY_MODE_USE_CPP11 
+#elif ABSL_PER_THREAD_TLS && defined(__GOOGLE_GRTE_VERSION__) &&        \ 
     (__GOOGLE_GRTE_VERSION__ >= 20140228L)
 // Support for async-safe TLS was specifically added in GRTEv4.  It's not
 // present in the upstream eglibc.
@@ -236,18 +236,18 @@ ABSL_CONST_INIT extern thread_local ThreadIdentity* thread_identity_ptr;
 #error Thread-local storage not detected on this platform
 #endif
 
-// thread_local variables cannot be in headers exposed by DLLs or in certain
-// build configurations on Apple platforms. However, it is important for
-// performance reasons in general that `CurrentThreadIdentityIfPresent` be
-// inlined. In the other cases we opt to have the function not be inlined. Note
+// thread_local variables cannot be in headers exposed by DLLs or in certain 
+// build configurations on Apple platforms. However, it is important for 
+// performance reasons in general that `CurrentThreadIdentityIfPresent` be 
+// inlined. In the other cases we opt to have the function not be inlined. Note 
 // that `CurrentThreadIdentityIfPresent` is declared above so we can exclude
-// this entire inline definition.
-#if !defined(__APPLE__) && !defined(ABSL_BUILD_DLL) && \
-    !defined(ABSL_CONSUME_DLL)
-#define ABSL_INTERNAL_INLINE_CURRENT_THREAD_IDENTITY_IF_PRESENT 1
-#endif
-
-#ifdef ABSL_INTERNAL_INLINE_CURRENT_THREAD_IDENTITY_IF_PRESENT
+// this entire inline definition. 
+#if !defined(__APPLE__) && !defined(ABSL_BUILD_DLL) && \ 
+    !defined(ABSL_CONSUME_DLL) 
+#define ABSL_INTERNAL_INLINE_CURRENT_THREAD_IDENTITY_IF_PRESENT 1 
+#endif 
+ 
+#ifdef ABSL_INTERNAL_INLINE_CURRENT_THREAD_IDENTITY_IF_PRESENT 
 inline ThreadIdentity* CurrentThreadIdentityIfPresent() {
   return thread_identity_ptr;
 }
diff --git a/contrib/restricted/abseil-cpp/absl/base/internal/throw_delegate.cc b/contrib/restricted/abseil-cpp/absl/base/internal/throw_delegate.cc
index c260ff1eed..37b4c38b5a 100644
--- a/contrib/restricted/abseil-cpp/absl/base/internal/throw_delegate.cc
+++ b/contrib/restricted/abseil-cpp/absl/base/internal/throw_delegate.cc
@@ -18,7 +18,7 @@
 #include <functional>
 #include <new>
 #include <stdexcept>
-
+ 
 #include "absl/base/config.h"
 #include "absl/base/internal/raw_logging.h"
 
@@ -26,186 +26,186 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 
-// NOTE: The various STL exception throwing functions are placed within the
-// #ifdef blocks so the symbols aren't exposed on platforms that don't support
-// them, such as the Android NDK. For example, ANGLE fails to link when building
-// within AOSP without them, since the STL functions don't exist.
+// NOTE: The various STL exception throwing functions are placed within the 
+// #ifdef blocks so the symbols aren't exposed on platforms that don't support 
+// them, such as the Android NDK. For example, ANGLE fails to link when building 
+// within AOSP without them, since the STL functions don't exist. 
 namespace {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef ABSL_HAVE_EXCEPTIONS 
 template <typename T>
 [[noreturn]] void Throw(const T& error) {
   throw error;
-}
+} 
 #endif
 }  // namespace
 
 void ThrowStdLogicError(const std::string& what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef ABSL_HAVE_EXCEPTIONS 
   Throw(std::logic_error(what_arg));
-#else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str());
-  std::abort();
-#endif
+#else 
+  ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str()); 
+  std::abort(); 
+#endif 
 }
 void ThrowStdLogicError(const char* what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef ABSL_HAVE_EXCEPTIONS 
   Throw(std::logic_error(what_arg));
-#else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg);
-  std::abort();
-#endif
+#else 
+  ABSL_RAW_LOG(FATAL, "%s", what_arg); 
+  std::abort(); 
+#endif 
 }
 void ThrowStdInvalidArgument(const std::string& what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef ABSL_HAVE_EXCEPTIONS 
   Throw(std::invalid_argument(what_arg));
-#else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str());
-  std::abort();
-#endif
+#else 
+  ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str()); 
+  std::abort(); 
+#endif 
 }
 void ThrowStdInvalidArgument(const char* what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef ABSL_HAVE_EXCEPTIONS 
   Throw(std::invalid_argument(what_arg));
-#else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg);
-  std::abort();
-#endif
+#else 
+  ABSL_RAW_LOG(FATAL, "%s", what_arg); 
+  std::abort(); 
+#endif 
 }
 
 void ThrowStdDomainError(const std::string& what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef ABSL_HAVE_EXCEPTIONS 
   Throw(std::domain_error(what_arg));
-#else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str());
-  std::abort();
-#endif
+#else 
+  ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str()); 
+  std::abort(); 
+#endif 
 }
 void ThrowStdDomainError(const char* what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef ABSL_HAVE_EXCEPTIONS 
   Throw(std::domain_error(what_arg));
-#else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg);
-  std::abort();
-#endif
+#else 
+  ABSL_RAW_LOG(FATAL, "%s", what_arg); 
+  std::abort(); 
+#endif 
 }
 
 void ThrowStdLengthError(const std::string& what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef ABSL_HAVE_EXCEPTIONS 
   Throw(std::length_error(what_arg));
-#else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str());
-  std::abort();
-#endif
+#else 
+  ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str()); 
+  std::abort(); 
+#endif 
 }
 void ThrowStdLengthError(const char* what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef ABSL_HAVE_EXCEPTIONS 
   Throw(std::length_error(what_arg));
-#else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg);
-  std::abort();
-#endif
+#else 
+  ABSL_RAW_LOG(FATAL, "%s", what_arg); 
+  std::abort(); 
+#endif 
 }
 
 void ThrowStdOutOfRange(const std::string& what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef ABSL_HAVE_EXCEPTIONS 
   Throw(std::out_of_range(what_arg));
-#else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str());
-  std::abort();
-#endif
+#else 
+  ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str()); 
+  std::abort(); 
+#endif 
 }
 void ThrowStdOutOfRange(const char* what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef ABSL_HAVE_EXCEPTIONS 
   Throw(std::out_of_range(what_arg));
-#else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg);
-  std::abort();
-#endif
+#else 
+  ABSL_RAW_LOG(FATAL, "%s", what_arg); 
+  std::abort(); 
+#endif 
 }
 
 void ThrowStdRuntimeError(const std::string& what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef ABSL_HAVE_EXCEPTIONS 
   Throw(std::runtime_error(what_arg));
-#else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str());
-  std::abort();
-#endif
+#else 
+  ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str()); 
+  std::abort(); 
+#endif 
 }
 void ThrowStdRuntimeError(const char* what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef ABSL_HAVE_EXCEPTIONS 
   Throw(std::runtime_error(what_arg));
-#else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg);
-  std::abort();
-#endif
+#else 
+  ABSL_RAW_LOG(FATAL, "%s", what_arg); 
+  std::abort(); 
+#endif 
 }
 
 void ThrowStdRangeError(const std::string& what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef ABSL_HAVE_EXCEPTIONS 
   Throw(std::range_error(what_arg));
-#else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str());
-  std::abort();
-#endif
+#else 
+  ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str()); 
+  std::abort(); 
+#endif 
 }
 void ThrowStdRangeError(const char* what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef ABSL_HAVE_EXCEPTIONS 
   Throw(std::range_error(what_arg));
-#else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg);
-  std::abort();
-#endif
+#else 
+  ABSL_RAW_LOG(FATAL, "%s", what_arg); 
+  std::abort(); 
+#endif 
 }
 
 void ThrowStdOverflowError(const std::string& what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef ABSL_HAVE_EXCEPTIONS 
   Throw(std::overflow_error(what_arg));
-#else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str());
-  std::abort();
-#endif
+#else 
+  ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str()); 
+  std::abort(); 
+#endif 
 }
 void ThrowStdOverflowError(const char* what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef ABSL_HAVE_EXCEPTIONS 
   Throw(std::overflow_error(what_arg));
-#else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg);
-  std::abort();
-#endif
+#else 
+  ABSL_RAW_LOG(FATAL, "%s", what_arg); 
+  std::abort(); 
+#endif 
 }
 
 void ThrowStdUnderflowError(const std::string& what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef ABSL_HAVE_EXCEPTIONS 
   Throw(std::underflow_error(what_arg));
-#else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str());
-  std::abort();
-#endif
+#else 
+  ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str()); 
+  std::abort(); 
+#endif 
 }
 void ThrowStdUnderflowError(const char* what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef ABSL_HAVE_EXCEPTIONS 
   Throw(std::underflow_error(what_arg));
-#else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg);
-  std::abort();
-#endif
-}
-
-void ThrowStdBadFunctionCall() {
-#ifdef ABSL_HAVE_EXCEPTIONS
-  Throw(std::bad_function_call());
-#else
-  std::abort();
-#endif
-}
-
-void ThrowStdBadAlloc() {
-#ifdef ABSL_HAVE_EXCEPTIONS
-  Throw(std::bad_alloc());
-#else
-  std::abort();
-#endif
-}
+#else 
+  ABSL_RAW_LOG(FATAL, "%s", what_arg); 
+  std::abort(); 
+#endif 
+}
+
+void ThrowStdBadFunctionCall() { 
+#ifdef ABSL_HAVE_EXCEPTIONS 
+  Throw(std::bad_function_call()); 
+#else 
+  std::abort(); 
+#endif 
+} 
+
+void ThrowStdBadAlloc() { 
+#ifdef ABSL_HAVE_EXCEPTIONS 
+  Throw(std::bad_alloc()); 
+#else 
+  std::abort(); 
+#endif 
+} 
 
 }  // namespace base_internal
 ABSL_NAMESPACE_END
diff --git a/contrib/restricted/abseil-cpp/absl/base/log_severity.h b/contrib/restricted/abseil-cpp/absl/base/log_severity.h
index 2236422462..760c91babd 100644
--- a/contrib/restricted/abseil-cpp/absl/base/log_severity.h
+++ b/contrib/restricted/abseil-cpp/absl/base/log_severity.h
@@ -36,7 +36,7 @@ ABSL_NAMESPACE_BEGIN
 // such values to a defined severity level, however in some cases values other
 // than the defined levels are useful for comparison.
 //
-// Example:
+// Example: 
 //
 //   // Effectively disables all logging:
 //   SetMinLogLevel(static_cast<absl::LogSeverity>(100));
diff --git a/contrib/restricted/abseil-cpp/absl/base/macros.h b/contrib/restricted/abseil-cpp/absl/base/macros.h
index 3e085a916b..0d26bd5700 100644
--- a/contrib/restricted/abseil-cpp/absl/base/macros.h
+++ b/contrib/restricted/abseil-cpp/absl/base/macros.h
@@ -144,15 +144,15 @@ ABSL_NAMESPACE_END
 #define ABSL_INTERNAL_RETHROW do {} while (false)
 #endif  // ABSL_HAVE_EXCEPTIONS
 
-// `ABSL_INTERNAL_UNREACHABLE` is an unreachable statement.  A program which
-// reaches one has undefined behavior, and the compiler may optimize
-// accordingly.
-#if defined(__GNUC__) || ABSL_HAVE_BUILTIN(__builtin_unreachable)
-#define ABSL_INTERNAL_UNREACHABLE __builtin_unreachable()
-#elif defined(_MSC_VER)
-#define ABSL_INTERNAL_UNREACHABLE __assume(0)
-#else
-#define ABSL_INTERNAL_UNREACHABLE
-#endif
-
+// `ABSL_INTERNAL_UNREACHABLE` is an unreachable statement.  A program which 
+// reaches one has undefined behavior, and the compiler may optimize 
+// accordingly. 
+#if defined(__GNUC__) || ABSL_HAVE_BUILTIN(__builtin_unreachable) 
+#define ABSL_INTERNAL_UNREACHABLE __builtin_unreachable() 
+#elif defined(_MSC_VER) 
+#define ABSL_INTERNAL_UNREACHABLE __assume(0) 
+#else 
+#define ABSL_INTERNAL_UNREACHABLE 
+#endif 
+ 
 #endif  // ABSL_BASE_MACROS_H_
diff --git a/contrib/restricted/abseil-cpp/absl/base/optimization.h b/contrib/restricted/abseil-cpp/absl/base/optimization.h
index d090be1286..d3eed93ab7 100644
--- a/contrib/restricted/abseil-cpp/absl/base/optimization.h
+++ b/contrib/restricted/abseil-cpp/absl/base/optimization.h
@@ -22,15 +22,15 @@
 #ifndef ABSL_BASE_OPTIMIZATION_H_
 #define ABSL_BASE_OPTIMIZATION_H_
 
-#include <assert.h>
-
+#include <assert.h> 
+ 
 #include "absl/base/config.h"
 
 // ABSL_BLOCK_TAIL_CALL_OPTIMIZATION
 //
-// Instructs the compiler to avoid optimizing tail-call recursion. This macro is
-// useful when you wish to preserve the existing function order within a stack
-// trace for logging, debugging, or profiling purposes.
+// Instructs the compiler to avoid optimizing tail-call recursion. This macro is 
+// useful when you wish to preserve the existing function order within a stack 
+// trace for logging, debugging, or profiling purposes. 
 //
 // Example:
 //
@@ -106,10 +106,10 @@
 // Cacheline aligning objects properly allows constructive memory sharing and
 // prevents destructive (or "false") memory sharing.
 //
-// NOTE: callers should replace uses of this macro with `alignas()` using
+// NOTE: callers should replace uses of this macro with `alignas()` using 
 // `std::hardware_constructive_interference_size` and/or
-// `std::hardware_destructive_interference_size` when C++17 becomes available to
-// them.
+// `std::hardware_destructive_interference_size` when C++17 becomes available to 
+// them. 
 //
 // See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0154r1.html
 // for more information.
@@ -182,7 +182,7 @@
 #endif
 
 // ABSL_INTERNAL_ASSUME(cond)
-// Informs the compiler that a condition is always true and that it can assume
+// Informs the compiler that a condition is always true and that it can assume 
 // it to be true for optimization purposes. The call has undefined behavior if
 // the condition is false.
 // In !NDEBUG mode, the condition is checked with an assert().
@@ -219,7 +219,7 @@
 // This macro forces small unique name on a static file level symbols like
 // static local variables or static functions. This is intended to be used in
 // macro definitions to optimize the cost of generated code. Do NOT use it on
-// symbols exported from translation unit since it may cause a link time
+// symbols exported from translation unit since it may cause a link time 
 // conflict.
 //
 // Example:
diff --git a/contrib/restricted/abseil-cpp/absl/base/options.h b/contrib/restricted/abseil-cpp/absl/base/options.h
index 56b4e36ee0..40429044c3 100644
--- a/contrib/restricted/abseil-cpp/absl/base/options.h
+++ b/contrib/restricted/abseil-cpp/absl/base/options.h
@@ -205,7 +205,7 @@
 // be changed to a new, unique identifier name.  In particular "head" is not
 // allowed.
 
-#define ABSL_OPTION_USE_INLINE_NAMESPACE 1
+#define ABSL_OPTION_USE_INLINE_NAMESPACE 1 
 #define ABSL_OPTION_INLINE_NAMESPACE_NAME lts_20211102
 
 // ABSL_OPTION_HARDENED
diff --git a/contrib/restricted/abseil-cpp/absl/base/thread_annotations.h b/contrib/restricted/abseil-cpp/absl/base/thread_annotations.h
index 9695f6de67..acc61bf898 100644
--- a/contrib/restricted/abseil-cpp/absl/base/thread_annotations.h
+++ b/contrib/restricted/abseil-cpp/absl/base/thread_annotations.h
@@ -317,7 +317,7 @@ namespace base_internal {
 
 // Takes a reference to a guarded data member, and returns an unguarded
 // reference.
-// Do not use this function directly, use ABSL_TS_UNCHECKED_READ instead.
+// Do not use this function directly, use ABSL_TS_UNCHECKED_READ instead. 
 template <typename T>
 inline const T& ts_unchecked_read(const T& v) ABSL_NO_THREAD_SAFETY_ANALYSIS {
   return v;
diff --git a/contrib/restricted/abseil-cpp/absl/city/ya.make b/contrib/restricted/abseil-cpp/absl/city/ya.make
index dffd2d3a70..4acc7109f0 100644
--- a/contrib/restricted/abseil-cpp/absl/city/ya.make
+++ b/contrib/restricted/abseil-cpp/absl/city/ya.make
@@ -8,13 +8,13 @@ OWNER(g:cpp-contrib)
 
 LICENSE(Apache-2.0)
 
-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/log_severity
-)
-
+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/log_severity 
+) 
+ 
 ADDINCL(
     GLOBAL contrib/restricted/abseil-cpp
 )
diff --git a/contrib/restricted/abseil-cpp/absl/cleanup/cleanup.h b/contrib/restricted/abseil-cpp/absl/cleanup/cleanup.h
index 960ccd080e..8842d3b874 100644
--- a/contrib/restricted/abseil-cpp/absl/cleanup/cleanup.h
+++ b/contrib/restricted/abseil-cpp/absl/cleanup/cleanup.h
@@ -1,140 +1,140 @@
-// 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.
-//
-// -----------------------------------------------------------------------------
-// File: cleanup.h
-// -----------------------------------------------------------------------------
-//
-// `absl::Cleanup` implements the scope guard idiom, invoking the contained
-// callback's `operator()() &&` on scope exit.
-//
-// Example:
-//
-// ```
-//   absl::Status CopyGoodData(const char* source_path, const char* sink_path) {
-//     FILE* source_file = fopen(source_path, "r");
-//     if (source_file == nullptr) {
-//       return absl::NotFoundError("No source file");  // No cleanups execute
-//     }
-//
-//     // C++17 style cleanup using class template argument deduction
-//     absl::Cleanup source_closer = [source_file] { fclose(source_file); };
-//
-//     FILE* sink_file = fopen(sink_path, "w");
-//     if (sink_file == nullptr) {
-//       return absl::NotFoundError("No sink file");  // First cleanup executes
-//     }
-//
-//     // C++11 style cleanup using the factory function
-//     auto sink_closer = absl::MakeCleanup([sink_file] { fclose(sink_file); });
-//
-//     Data data;
-//     while (ReadData(source_file, &data)) {
-//       if (!data.IsGood()) {
-//         absl::Status result = absl::FailedPreconditionError("Read bad data");
-//         return result;  // Both cleanups execute
-//       }
-//       SaveData(sink_file, &data);
-//     }
-//
-//     return absl::OkStatus();  // Both cleanups execute
-//   }
-// ```
-//
-// Methods:
-//
-// `std::move(cleanup).Cancel()` will prevent the callback from executing.
-//
-// `std::move(cleanup).Invoke()` will execute the callback early, before
-// destruction, and prevent the callback from executing in the destructor.
-//
-// Usage:
-//
-// `absl::Cleanup` is not an interface type. It is only intended to be used
-// within the body of a function. It is not a value type and instead models a
-// control flow construct. Check out `defer` in Golang for something similar.
-
-#ifndef ABSL_CLEANUP_CLEANUP_H_
-#define ABSL_CLEANUP_CLEANUP_H_
-
-#include <utility>
-
-#include "absl/base/config.h"
-#include "absl/base/macros.h"
-#include "absl/cleanup/internal/cleanup.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-template <typename Arg, typename Callback = void()>
-class ABSL_MUST_USE_RESULT Cleanup final {
-  static_assert(cleanup_internal::WasDeduced<Arg>(),
-                "Explicit template parameters are not supported.");
-
-  static_assert(cleanup_internal::ReturnsVoid<Callback>(),
-                "Callbacks that return values are not supported.");
-
- public:
+// 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. 
+// 
+// ----------------------------------------------------------------------------- 
+// File: cleanup.h 
+// ----------------------------------------------------------------------------- 
+// 
+// `absl::Cleanup` implements the scope guard idiom, invoking the contained 
+// callback's `operator()() &&` on scope exit. 
+// 
+// Example: 
+// 
+// ``` 
+//   absl::Status CopyGoodData(const char* source_path, const char* sink_path) { 
+//     FILE* source_file = fopen(source_path, "r"); 
+//     if (source_file == nullptr) { 
+//       return absl::NotFoundError("No source file");  // No cleanups execute 
+//     } 
+// 
+//     // C++17 style cleanup using class template argument deduction 
+//     absl::Cleanup source_closer = [source_file] { fclose(source_file); }; 
+// 
+//     FILE* sink_file = fopen(sink_path, "w"); 
+//     if (sink_file == nullptr) { 
+//       return absl::NotFoundError("No sink file");  // First cleanup executes 
+//     } 
+// 
+//     // C++11 style cleanup using the factory function 
+//     auto sink_closer = absl::MakeCleanup([sink_file] { fclose(sink_file); }); 
+// 
+//     Data data; 
+//     while (ReadData(source_file, &data)) { 
+//       if (!data.IsGood()) { 
+//         absl::Status result = absl::FailedPreconditionError("Read bad data"); 
+//         return result;  // Both cleanups execute 
+//       } 
+//       SaveData(sink_file, &data); 
+//     } 
+// 
+//     return absl::OkStatus();  // Both cleanups execute 
+//   } 
+// ``` 
+// 
+// Methods: 
+// 
+// `std::move(cleanup).Cancel()` will prevent the callback from executing. 
+// 
+// `std::move(cleanup).Invoke()` will execute the callback early, before 
+// destruction, and prevent the callback from executing in the destructor. 
+// 
+// Usage: 
+// 
+// `absl::Cleanup` is not an interface type. It is only intended to be used 
+// within the body of a function. It is not a value type and instead models a 
+// control flow construct. Check out `defer` in Golang for something similar. 
+ 
+#ifndef ABSL_CLEANUP_CLEANUP_H_ 
+#define ABSL_CLEANUP_CLEANUP_H_ 
+ 
+#include <utility> 
+ 
+#include "absl/base/config.h" 
+#include "absl/base/macros.h" 
+#include "absl/cleanup/internal/cleanup.h" 
+ 
+namespace absl { 
+ABSL_NAMESPACE_BEGIN 
+ 
+template <typename Arg, typename Callback = void()> 
+class ABSL_MUST_USE_RESULT Cleanup final { 
+  static_assert(cleanup_internal::WasDeduced<Arg>(), 
+                "Explicit template parameters are not supported."); 
+ 
+  static_assert(cleanup_internal::ReturnsVoid<Callback>(), 
+                "Callbacks that return values are not supported."); 
+ 
+ public: 
   Cleanup(Callback callback) : storage_(std::move(callback)) {}  // NOLINT
-
-  Cleanup(Cleanup&& other) = default;
-
-  void Cancel() && {
-    ABSL_HARDENING_ASSERT(storage_.IsCallbackEngaged());
+ 
+  Cleanup(Cleanup&& other) = default; 
+ 
+  void Cancel() && { 
+    ABSL_HARDENING_ASSERT(storage_.IsCallbackEngaged()); 
     storage_.DestroyCallback();
-  }
-
-  void Invoke() && {
-    ABSL_HARDENING_ASSERT(storage_.IsCallbackEngaged());
-    storage_.InvokeCallback();
+  } 
+ 
+  void Invoke() && { 
+    ABSL_HARDENING_ASSERT(storage_.IsCallbackEngaged()); 
+    storage_.InvokeCallback(); 
     storage_.DestroyCallback();
-  }
-
-  ~Cleanup() {
-    if (storage_.IsCallbackEngaged()) {
-      storage_.InvokeCallback();
+  } 
+ 
+  ~Cleanup() { 
+    if (storage_.IsCallbackEngaged()) { 
+      storage_.InvokeCallback(); 
       storage_.DestroyCallback();
-    }
-  }
-
- private:
-  cleanup_internal::Storage<Callback> storage_;
-};
-
-// `absl::Cleanup c = /* callback */;`
-//
-// C++17 type deduction API for creating an instance of `absl::Cleanup`
-#if defined(ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION)
-template <typename Callback>
-Cleanup(Callback callback) -> Cleanup<cleanup_internal::Tag, Callback>;
-#endif  // defined(ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION)
-
-// `auto c = absl::MakeCleanup(/* callback */);`
-//
-// C++11 type deduction API for creating an instance of `absl::Cleanup`
-template <typename... Args, typename Callback>
-absl::Cleanup<cleanup_internal::Tag, Callback> MakeCleanup(Callback callback) {
-  static_assert(cleanup_internal::WasDeduced<cleanup_internal::Tag, Args...>(),
-                "Explicit template parameters are not supported.");
-
-  static_assert(cleanup_internal::ReturnsVoid<Callback>(),
-                "Callbacks that return values are not supported.");
-
-  return {std::move(callback)};
-}
-
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_CLEANUP_CLEANUP_H_
+    } 
+  } 
+ 
+ private: 
+  cleanup_internal::Storage<Callback> storage_; 
+}; 
+ 
+// `absl::Cleanup c = /* callback */;` 
+// 
+// C++17 type deduction API for creating an instance of `absl::Cleanup` 
+#if defined(ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION) 
+template <typename Callback> 
+Cleanup(Callback callback) -> Cleanup<cleanup_internal::Tag, Callback>; 
+#endif  // defined(ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION) 
+ 
+// `auto c = absl::MakeCleanup(/* callback */);` 
+// 
+// C++11 type deduction API for creating an instance of `absl::Cleanup` 
+template <typename... Args, typename Callback> 
+absl::Cleanup<cleanup_internal::Tag, Callback> MakeCleanup(Callback callback) { 
+  static_assert(cleanup_internal::WasDeduced<cleanup_internal::Tag, Args...>(), 
+                "Explicit template parameters are not supported."); 
+ 
+  static_assert(cleanup_internal::ReturnsVoid<Callback>(), 
+                "Callbacks that return values are not supported."); 
+ 
+  return {std::move(callback)}; 
+} 
+ 
+ABSL_NAMESPACE_END 
+}  // namespace absl 
+ 
+#endif  // ABSL_CLEANUP_CLEANUP_H_ 
diff --git a/contrib/restricted/abseil-cpp/absl/cleanup/internal/cleanup.h b/contrib/restricted/abseil-cpp/absl/cleanup/internal/cleanup.h
index 2783fcb7c1..fc90b7f6a2 100644
--- a/contrib/restricted/abseil-cpp/absl/cleanup/internal/cleanup.h
+++ b/contrib/restricted/abseil-cpp/absl/cleanup/internal/cleanup.h
@@ -1,52 +1,52 @@
-// 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_CLEANUP_INTERNAL_CLEANUP_H_
-#define ABSL_CLEANUP_INTERNAL_CLEANUP_H_
-
+// 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_CLEANUP_INTERNAL_CLEANUP_H_ 
+#define ABSL_CLEANUP_INTERNAL_CLEANUP_H_ 
+ 
 #include <new>
-#include <type_traits>
-#include <utility>
-
-#include "absl/base/internal/invoke.h"
+#include <type_traits> 
+#include <utility> 
+ 
+#include "absl/base/internal/invoke.h" 
 #include "absl/base/macros.h"
-#include "absl/base/thread_annotations.h"
-#include "absl/utility/utility.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-namespace cleanup_internal {
-
-struct Tag {};
-
-template <typename Arg, typename... Args>
-constexpr bool WasDeduced() {
-  return (std::is_same<cleanup_internal::Tag, Arg>::value) &&
-         (sizeof...(Args) == 0);
-}
-
-template <typename Callback>
-constexpr bool ReturnsVoid() {
-  return (std::is_same<base_internal::invoke_result_t<Callback>, void>::value);
-}
-
-template <typename Callback>
-class Storage {
- public:
-  Storage() = delete;
-
+#include "absl/base/thread_annotations.h" 
+#include "absl/utility/utility.h" 
+ 
+namespace absl { 
+ABSL_NAMESPACE_BEGIN 
+ 
+namespace cleanup_internal { 
+ 
+struct Tag {}; 
+ 
+template <typename Arg, typename... Args> 
+constexpr bool WasDeduced() { 
+  return (std::is_same<cleanup_internal::Tag, Arg>::value) && 
+         (sizeof...(Args) == 0); 
+} 
+ 
+template <typename Callback> 
+constexpr bool ReturnsVoid() { 
+  return (std::is_same<base_internal::invoke_result_t<Callback>, void>::value); 
+} 
+ 
+template <typename Callback> 
+class Storage { 
+ public: 
+  Storage() = delete; 
+ 
   explicit Storage(Callback callback) {
     // Placement-new into a character buffer is used for eager destruction when
     // the cleanup is invoked or cancelled. To ensure this optimizes well, the
@@ -54,47 +54,47 @@ class Storage {
     ::new (GetCallbackBuffer()) Callback(std::move(callback));
     is_callback_engaged_ = true;
   }
-
+ 
   Storage(Storage&& other) {
     ABSL_HARDENING_ASSERT(other.IsCallbackEngaged());
-
+ 
     ::new (GetCallbackBuffer()) Callback(std::move(other.GetCallback()));
     is_callback_engaged_ = true;
 
     other.DestroyCallback();
   }
 
-  Storage(const Storage& other) = delete;
-
-  Storage& operator=(Storage&& other) = delete;
-
-  Storage& operator=(const Storage& other) = delete;
-
+  Storage(const Storage& other) = delete; 
+ 
+  Storage& operator=(Storage&& other) = delete; 
+ 
+  Storage& operator=(const Storage& other) = delete; 
+ 
   void* GetCallbackBuffer() { return static_cast<void*>(+callback_buffer_); }
 
   Callback& GetCallback() {
     return *reinterpret_cast<Callback*>(GetCallbackBuffer());
   }
 
-  bool IsCallbackEngaged() const { return is_callback_engaged_; }
-
+  bool IsCallbackEngaged() const { return is_callback_engaged_; } 
+ 
   void DestroyCallback() {
     is_callback_engaged_ = false;
     GetCallback().~Callback();
   }
-
-  void InvokeCallback() ABSL_NO_THREAD_SAFETY_ANALYSIS {
+ 
+  void InvokeCallback() ABSL_NO_THREAD_SAFETY_ANALYSIS { 
     std::move(GetCallback())();
-  }
-
- private:
-  bool is_callback_engaged_;
+  } 
+ 
+ private: 
+  bool is_callback_engaged_; 
   alignas(Callback) char callback_buffer_[sizeof(Callback)];
-};
-
-}  // namespace cleanup_internal
-
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_CLEANUP_INTERNAL_CLEANUP_H_
+}; 
+ 
+}  // namespace cleanup_internal 
+ 
+ABSL_NAMESPACE_END 
+}  // namespace absl 
+ 
+#endif  // ABSL_CLEANUP_INTERNAL_CLEANUP_H_ 
diff --git a/contrib/restricted/abseil-cpp/absl/container/btree_map.h b/contrib/restricted/abseil-cpp/absl/container/btree_map.h
index f0a8d4a6a4..ba3bbc145b 100644
--- a/contrib/restricted/abseil-cpp/absl/container/btree_map.h
+++ b/contrib/restricted/abseil-cpp/absl/container/btree_map.h
@@ -384,8 +384,8 @@ class btree_map
 
   // btree_map::equal_range()
   //
-  // Returns a half-open range [first, last), defined by a `std::pair` of two
-  // iterators, containing all elements with the passed key in the `btree_map`.
+  // Returns a half-open range [first, last), defined by a `std::pair` of two 
+  // iterators, containing all elements with the passed key in the `btree_map`. 
   using Base::equal_range;
 
   // btree_map::find()
@@ -731,7 +731,7 @@ class btree_multimap
 
   // btree_multimap::equal_range()
   //
-  // Returns a half-open range [first, last), defined by a `std::pair` of two
+  // Returns a half-open range [first, last), defined by a `std::pair` of two 
   // iterators, containing all elements with the passed key in the
   // `btree_multimap`.
   using Base::equal_range;
diff --git a/contrib/restricted/abseil-cpp/absl/container/fixed_array.h b/contrib/restricted/abseil-cpp/absl/container/fixed_array.h
index 839ba0bc16..5b23df9643 100644
--- a/contrib/restricted/abseil-cpp/absl/container/fixed_array.h
+++ b/contrib/restricted/abseil-cpp/absl/container/fixed_array.h
@@ -227,8 +227,8 @@ class FixedArray {
 
   // FixedArray::at
   //
-  // Bounds-checked access.  Returns a reference to the ith element of the fixed
-  // array, or throws std::out_of_range
+  // Bounds-checked access.  Returns a reference to the ith element of the fixed 
+  // array, or throws std::out_of_range 
   reference at(size_type i) {
     if (ABSL_PREDICT_FALSE(i >= size())) {
       base_internal::ThrowStdOutOfRange("FixedArray::at failed bounds check");
diff --git a/contrib/restricted/abseil-cpp/absl/container/flat_hash_set.h b/contrib/restricted/abseil-cpp/absl/container/flat_hash_set.h
index 6b89da6571..63b014d4ce 100644
--- a/contrib/restricted/abseil-cpp/absl/container/flat_hash_set.h
+++ b/contrib/restricted/abseil-cpp/absl/container/flat_hash_set.h
@@ -324,7 +324,7 @@ class flat_hash_set
 
   // flat_hash_set::merge()
   //
-  // Extracts elements from a given `source` flat hash set into this
+  // Extracts elements from a given `source` flat hash set into this 
   // `flat_hash_set`. If the destination `flat_hash_set` already contains an
   // element with an equivalent key, that element is not extracted.
   using Base::merge;
diff --git a/contrib/restricted/abseil-cpp/absl/container/inlined_vector.h b/contrib/restricted/abseil-cpp/absl/container/inlined_vector.h
index df9e09917d..6a5b58e55a 100644
--- a/contrib/restricted/abseil-cpp/absl/container/inlined_vector.h
+++ b/contrib/restricted/abseil-cpp/absl/container/inlined_vector.h
@@ -174,13 +174,13 @@ class InlinedVector {
   // provided `allocator`.
   InlinedVector(const InlinedVector& other, const allocator_type& allocator)
       : storage_(allocator) {
-    if (other.empty()) {
-      // Empty; nothing to do.
+    if (other.empty()) { 
+      // Empty; nothing to do. 
     } else if (IsMemcpyOk<A>::value && !other.storage_.GetIsAllocated()) {
-      // Memcpy-able and do not need allocation.
+      // Memcpy-able and do not need allocation. 
       storage_.MemcpyFrom(other.storage_);
     } else {
-      storage_.InitFrom(other.storage_);
+      storage_.InitFrom(other.storage_); 
     }
   }
 
diff --git a/contrib/restricted/abseil-cpp/absl/container/internal/absl_hashtablez_sampler/ya.make b/contrib/restricted/abseil-cpp/absl/container/internal/absl_hashtablez_sampler/ya.make
index 1933289a6d..5a37c14c4a 100644
--- a/contrib/restricted/abseil-cpp/absl/container/internal/absl_hashtablez_sampler/ya.make
+++ b/contrib/restricted/abseil-cpp/absl/container/internal/absl_hashtablez_sampler/ya.make
@@ -1,52 +1,52 @@
-# 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_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/container/internal)
-
-SRCS(
+ 
+SRCS( 
     hashtablez_sampler.cc
     hashtablez_sampler_force_weak_definition.cc
-)
-
-END()
+) 
+ 
+END() 
diff --git a/contrib/restricted/abseil-cpp/absl/container/internal/btree.h b/contrib/restricted/abseil-cpp/absl/container/internal/btree.h
index f636c5fc73..60d6979c0f 100644
--- a/contrib/restricted/abseil-cpp/absl/container/internal/btree.h
+++ b/contrib/restricted/abseil-cpp/absl/container/internal/btree.h
@@ -192,38 +192,38 @@ struct key_compare_to_adapter<std::greater<absl::Cord>> {
   using type = StringBtreeDefaultGreater;
 };
 
-// Detects an 'absl_btree_prefer_linear_node_search' member. This is
-// a protocol used as an opt-in or opt-out of linear search.
-//
-//  For example, this would be useful for key types that wrap an integer
-//  and define their own cheap operator<(). For example:
-//
-//   class K {
-//    public:
-//     using absl_btree_prefer_linear_node_search = std::true_type;
-//     ...
-//    private:
-//     friend bool operator<(K a, K b) { return a.k_ < b.k_; }
-//     int k_;
-//   };
-//
-//   btree_map<K, V> m;  // Uses linear search
-//
-// If T has the preference tag, then it has a preference.
-// Btree will use the tag's truth value.
-template <typename T, typename = void>
-struct has_linear_node_search_preference : std::false_type {};
-template <typename T, typename = void>
-struct prefers_linear_node_search : std::false_type {};
-template <typename T>
-struct has_linear_node_search_preference<
-    T, absl::void_t<typename T::absl_btree_prefer_linear_node_search>>
-    : std::true_type {};
-template <typename T>
-struct prefers_linear_node_search<
-    T, absl::void_t<typename T::absl_btree_prefer_linear_node_search>>
-    : T::absl_btree_prefer_linear_node_search {};
-
+// Detects an 'absl_btree_prefer_linear_node_search' member. This is 
+// a protocol used as an opt-in or opt-out of linear search. 
+// 
+//  For example, this would be useful for key types that wrap an integer 
+//  and define their own cheap operator<(). For example: 
+// 
+//   class K { 
+//    public: 
+//     using absl_btree_prefer_linear_node_search = std::true_type; 
+//     ... 
+//    private: 
+//     friend bool operator<(K a, K b) { return a.k_ < b.k_; } 
+//     int k_; 
+//   }; 
+// 
+//   btree_map<K, V> m;  // Uses linear search 
+// 
+// If T has the preference tag, then it has a preference. 
+// Btree will use the tag's truth value. 
+template <typename T, typename = void> 
+struct has_linear_node_search_preference : std::false_type {}; 
+template <typename T, typename = void> 
+struct prefers_linear_node_search : std::false_type {}; 
+template <typename T> 
+struct has_linear_node_search_preference< 
+    T, absl::void_t<typename T::absl_btree_prefer_linear_node_search>> 
+    : std::true_type {}; 
+template <typename T> 
+struct prefers_linear_node_search< 
+    T, absl::void_t<typename T::absl_btree_prefer_linear_node_search>> 
+    : T::absl_btree_prefer_linear_node_search {}; 
+ 
 template <typename Key, typename Compare, typename Alloc, int TargetNodeSize,
           bool Multi, typename SlotPolicy>
 struct common_params {
@@ -250,23 +250,23 @@ struct common_params {
   using reference = value_type &;
   using const_reference = const value_type &;
 
-  // For the given lookup key type, returns whether we can have multiple
-  // equivalent keys in the btree. If this is a multi-container, then we can.
-  // Otherwise, we can have multiple equivalent keys only if all of the
-  // following conditions are met:
-  // - The comparator is transparent.
-  // - The lookup key type is not the same as key_type.
-  // - The comparator is not a StringBtreeDefault{Less,Greater} comparator
-  //   that we know has the same equivalence classes for all lookup types.
-  template <typename LookupKey>
-  constexpr static bool can_have_multiple_equivalent_keys() {
-    return Multi ||
-           (IsTransparent<key_compare>::value &&
-            !std::is_same<LookupKey, Key>::value &&
-            !std::is_same<key_compare, StringBtreeDefaultLess>::value &&
-            !std::is_same<key_compare, StringBtreeDefaultGreater>::value);
-  }
-
+  // For the given lookup key type, returns whether we can have multiple 
+  // equivalent keys in the btree. If this is a multi-container, then we can. 
+  // Otherwise, we can have multiple equivalent keys only if all of the 
+  // following conditions are met: 
+  // - The comparator is transparent. 
+  // - The lookup key type is not the same as key_type. 
+  // - The comparator is not a StringBtreeDefault{Less,Greater} comparator 
+  //   that we know has the same equivalence classes for all lookup types. 
+  template <typename LookupKey> 
+  constexpr static bool can_have_multiple_equivalent_keys() { 
+    return Multi || 
+           (IsTransparent<key_compare>::value && 
+            !std::is_same<LookupKey, Key>::value && 
+            !std::is_same<key_compare, StringBtreeDefaultLess>::value && 
+            !std::is_same<key_compare, StringBtreeDefaultGreater>::value); 
+  } 
+ 
   enum {
     kTargetNodeSize = TargetNodeSize,
 
@@ -452,7 +452,7 @@ struct SearchResult {
 // useful information.
 template <typename V>
 struct SearchResult<V, false> {
-  SearchResult() {}
+  SearchResult() {} 
   explicit SearchResult(V value) : value(value) {}
   SearchResult(V value, MatchKind /*match*/) : value(value) {}
 
@@ -485,22 +485,22 @@ class btree_node {
   using difference_type = typename Params::difference_type;
 
   // Btree decides whether to use linear node search as follows:
-  //   - If the comparator expresses a preference, use that.
-  //   - If the key expresses a preference, use that.
+  //   - If the comparator expresses a preference, use that. 
+  //   - If the key expresses a preference, use that. 
   //   - If the key is arithmetic and the comparator is std::less or
   //     std::greater, choose linear.
   //   - Otherwise, choose binary.
   // TODO(ezb): Might make sense to add condition(s) based on node-size.
   using use_linear_search = std::integral_constant<
       bool,
-      has_linear_node_search_preference<key_compare>::value
-          ? prefers_linear_node_search<key_compare>::value
-          : has_linear_node_search_preference<key_type>::value
-                ? prefers_linear_node_search<key_type>::value
-                : std::is_arithmetic<key_type>::value &&
-                      (std::is_same<std::less<key_type>, key_compare>::value ||
-                       std::is_same<std::greater<key_type>,
-                                    key_compare>::value)>;
+      has_linear_node_search_preference<key_compare>::value 
+          ? prefers_linear_node_search<key_compare>::value 
+          : has_linear_node_search_preference<key_type>::value 
+                ? prefers_linear_node_search<key_type>::value 
+                : std::is_arithmetic<key_type>::value && 
+                      (std::is_same<std::less<key_type>, key_compare>::value || 
+                       std::is_same<std::greater<key_type>, 
+                                    key_compare>::value)>; 
 
   // This class is organized by absl::container_internal::Layout as if it had
   // the following structure:
@@ -517,23 +517,23 @@ class btree_node {
   //   // is the same as the count of values.
   //   field_type finish;
   //   // The maximum number of values the node can hold. This is an integer in
-  //   // [1, kNodeSlots] for root leaf nodes, kNodeSlots for non-root leaf
+  //   // [1, kNodeSlots] for root leaf nodes, kNodeSlots for non-root leaf 
   //   // nodes, and kInternalNodeMaxCount (as a sentinel value) for internal
-  //   // nodes (even though there are still kNodeSlots values in the node).
+  //   // nodes (even though there are still kNodeSlots values in the node). 
   //   // TODO(ezb): make max_count use only 4 bits and record log2(capacity)
   //   // to free extra bits for is_root, etc.
   //   field_type max_count;
   //
   //   // The array of values. The capacity is `max_count` for leaf nodes and
-  //   // kNodeSlots for internal nodes. Only the values in
+  //   // kNodeSlots for internal nodes. Only the values in 
   //   // [start, finish) have been initialized and are valid.
   //   slot_type values[max_count];
   //
   //   // The array of child pointers. The keys in children[i] are all less
   //   // than key(i). The keys in children[i + 1] are all greater than key(i).
-  //   // There are 0 children for leaf nodes and kNodeSlots + 1 children for
+  //   // There are 0 children for leaf nodes and kNodeSlots + 1 children for 
   //   // internal nodes.
-  //   btree_node *children[kNodeSlots + 1];
+  //   btree_node *children[kNodeSlots + 1]; 
   //
   // This class is only constructed by EmptyNodeType. Normally, pointers to the
   // layout above are allocated, cast to btree_node*, and de-allocated within
@@ -555,62 +555,62 @@ class btree_node {
  private:
   using layout_type = absl::container_internal::Layout<btree_node *, field_type,
                                                        slot_type, btree_node *>;
-  constexpr static size_type SizeWithNSlots(size_type n) {
+  constexpr static size_type SizeWithNSlots(size_type n) { 
     return layout_type(/*parent*/ 1,
                        /*position, start, finish, max_count*/ 4,
-                       /*slots*/ n,
+                       /*slots*/ n, 
                        /*children*/ 0)
         .AllocSize();
   }
   // A lower bound for the overhead of fields other than values in a leaf node.
   constexpr static size_type MinimumOverhead() {
-    return SizeWithNSlots(1) - sizeof(value_type);
+    return SizeWithNSlots(1) - sizeof(value_type); 
   }
 
   // Compute how many values we can fit onto a leaf node taking into account
   // padding.
-  constexpr static size_type NodeTargetSlots(const int begin, const int end) {
+  constexpr static size_type NodeTargetSlots(const int begin, const int end) { 
     return begin == end ? begin
-                        : SizeWithNSlots((begin + end) / 2 + 1) >
+                        : SizeWithNSlots((begin + end) / 2 + 1) > 
                                   params_type::kTargetNodeSize
-                              ? NodeTargetSlots(begin, (begin + end) / 2)
-                              : NodeTargetSlots((begin + end) / 2 + 1, end);
+                              ? NodeTargetSlots(begin, (begin + end) / 2) 
+                              : NodeTargetSlots((begin + end) / 2 + 1, end); 
   }
 
   enum {
     kTargetNodeSize = params_type::kTargetNodeSize,
-    kNodeTargetSlots = NodeTargetSlots(0, params_type::kTargetNodeSize),
+    kNodeTargetSlots = NodeTargetSlots(0, params_type::kTargetNodeSize), 
 
-    // We need a minimum of 3 slots per internal node in order to perform
+    // We need a minimum of 3 slots per internal node in order to perform 
     // splitting (1 value for the two nodes involved in the split and 1 value
-    // propagated to the parent as the delimiter for the split). For performance
-    // reasons, we don't allow 3 slots-per-node due to bad worst case occupancy
-    // of 1/3 (for a node, not a b-tree).
-    kMinNodeSlots = 4,
-
-    kNodeSlots =
-        kNodeTargetSlots >= kMinNodeSlots ? kNodeTargetSlots : kMinNodeSlots,
-
+    // propagated to the parent as the delimiter for the split). For performance 
+    // reasons, we don't allow 3 slots-per-node due to bad worst case occupancy 
+    // of 1/3 (for a node, not a b-tree). 
+    kMinNodeSlots = 4, 
+
+    kNodeSlots = 
+        kNodeTargetSlots >= kMinNodeSlots ? kNodeTargetSlots : kMinNodeSlots, 
+ 
     // The node is internal (i.e. is not a leaf node) if and only if `max_count`
     // has this value.
     kInternalNodeMaxCount = 0,
   };
 
-  // Leaves can have less than kNodeSlots values.
-  constexpr static layout_type LeafLayout(const int slot_count = kNodeSlots) {
+  // Leaves can have less than kNodeSlots values. 
+  constexpr static layout_type LeafLayout(const int slot_count = kNodeSlots) { 
     return layout_type(/*parent*/ 1,
                        /*position, start, finish, max_count*/ 4,
-                       /*slots*/ slot_count,
+                       /*slots*/ slot_count, 
                        /*children*/ 0);
   }
   constexpr static layout_type InternalLayout() {
     return layout_type(/*parent*/ 1,
                        /*position, start, finish, max_count*/ 4,
-                       /*slots*/ kNodeSlots,
-                       /*children*/ kNodeSlots + 1);
+                       /*slots*/ kNodeSlots, 
+                       /*children*/ kNodeSlots + 1); 
   }
-  constexpr static size_type LeafSize(const int slot_count = kNodeSlots) {
-    return LeafLayout(slot_count).AllocSize();
+  constexpr static size_type LeafSize(const int slot_count = kNodeSlots) { 
+    return LeafLayout(slot_count).AllocSize(); 
   }
   constexpr static size_type InternalSize() {
     return InternalLayout().AllocSize();
@@ -667,10 +667,10 @@ class btree_node {
   }
   field_type max_count() const {
     // Internal nodes have max_count==kInternalNodeMaxCount.
-    // Leaf nodes have max_count in [1, kNodeSlots].
+    // Leaf nodes have max_count in [1, kNodeSlots]. 
     const field_type max_count = GetField<1>()[3];
     return max_count == field_type{kInternalNodeMaxCount}
-               ? field_type{kNodeSlots}
+               ? field_type{kNodeSlots} 
                : max_count;
   }
 
@@ -792,7 +792,7 @@ class btree_node {
   SearchResult<int, true> binary_search_impl(
       const K &k, int s, int e, const CompareTo &comp,
       std::true_type /* IsCompareTo */) const {
-    if (params_type::template can_have_multiple_equivalent_keys<K>()) {
+    if (params_type::template can_have_multiple_equivalent_keys<K>()) { 
       MatchKind exact_match = MatchKind::kNe;
       while (s != e) {
         const int mid = (s + e) >> 1;
@@ -803,14 +803,14 @@ class btree_node {
           e = mid;
           if (c == 0) {
             // Need to return the first value whose key is not less than k,
-            // which requires continuing the binary search if there could be
-            // multiple equivalent keys.
+            // which requires continuing the binary search if there could be 
+            // multiple equivalent keys. 
             exact_match = MatchKind::kEq;
           }
         }
       }
       return {s, exact_match};
-    } else {  // Can't have multiple equivalent keys.
+    } else {  // Can't have multiple equivalent keys. 
       while (s != e) {
         const int mid = (s + e) >> 1;
         const absl::weak_ordering c = comp(key(mid), k);
@@ -860,12 +860,12 @@ class btree_node {
         start_slot(), max_count * sizeof(slot_type));
   }
   void init_internal(btree_node *parent) {
-    init_leaf(parent, kNodeSlots);
+    init_leaf(parent, kNodeSlots); 
     // Set `max_count` to a sentinel value to indicate that this node is
     // internal.
     set_max_count(kInternalNodeMaxCount);
     absl::container_internal::SanitizerPoisonMemoryRegion(
-        &mutable_child(start()), (kNodeSlots + 1) * sizeof(btree_node *));
+        &mutable_child(start()), (kNodeSlots + 1) * sizeof(btree_node *)); 
   }
 
   static void deallocate(const size_type size, btree_node *node,
@@ -943,7 +943,7 @@ struct btree_iterator {
   using key_type = typename Node::key_type;
   using size_type = typename Node::size_type;
   using params_type = typename Node::params_type;
-  using is_map_container = typename params_type::is_map_container;
+  using is_map_container = typename params_type::is_map_container; 
 
   using node_type = Node;
   using normal_node = typename std::remove_const<Node>::type;
@@ -955,7 +955,7 @@ struct btree_iterator {
   using slot_type = typename params_type::slot_type;
 
   using iterator =
-     btree_iterator<normal_node, normal_reference, normal_pointer>;
+     btree_iterator<normal_node, normal_reference, normal_pointer>; 
   using const_iterator =
       btree_iterator<const_node, const_reference, const_pointer>;
 
@@ -972,19 +972,19 @@ struct btree_iterator {
   btree_iterator(Node *n, int p) : node(n), position(p) {}
 
   // NOTE: this SFINAE allows for implicit conversions from iterator to
-  // const_iterator, but it specifically avoids hiding the copy constructor so
-  // that the trivial one will be used when possible.
+  // const_iterator, but it specifically avoids hiding the copy constructor so 
+  // that the trivial one will be used when possible. 
   template <typename N, typename R, typename P,
             absl::enable_if_t<
                 std::is_same<btree_iterator<N, R, P>, iterator>::value &&
                     std::is_same<btree_iterator, const_iterator>::value,
                 int> = 0>
-  btree_iterator(const btree_iterator<N, R, P> other)  // NOLINT
+  btree_iterator(const btree_iterator<N, R, P> other)  // NOLINT 
       : node(other.node), position(other.position) {}
 
  private:
   // This SFINAE allows explicit conversions from const_iterator to
-  // iterator, but also avoids hiding the copy constructor.
+  // iterator, but also avoids hiding the copy constructor. 
   // NOTE: the const_cast is safe because this constructor is only called by
   // non-const methods and the container owns the nodes.
   template <typename N, typename R, typename P,
@@ -992,7 +992,7 @@ struct btree_iterator {
                 std::is_same<btree_iterator<N, R, P>, const_iterator>::value &&
                     std::is_same<btree_iterator, iterator>::value,
                 int> = 0>
-  explicit btree_iterator(const btree_iterator<N, R, P> other)
+  explicit btree_iterator(const btree_iterator<N, R, P> other) 
       : node(const_cast<node_type *>(other.node)), position(other.position) {}
 
   // Increment/decrement the iterator.
@@ -1055,8 +1055,8 @@ struct btree_iterator {
   }
 
  private:
-  friend iterator;
-  friend const_iterator;
+  friend iterator; 
+  friend const_iterator; 
   template <typename Params>
   friend class btree;
   template <typename Tree>
@@ -1122,8 +1122,8 @@ class btree {
   }
 
   enum : uint32_t {
-    kNodeSlots = node_type::kNodeSlots,
-    kMinNodeValues = kNodeSlots / 2,
+    kNodeSlots = node_type::kNodeSlots, 
+    kMinNodeValues = kNodeSlots / 2, 
   };
 
   struct node_stats {
@@ -1154,8 +1154,8 @@ class btree {
   using const_reference = typename Params::const_reference;
   using pointer = typename Params::pointer;
   using const_pointer = typename Params::const_pointer;
-  using iterator =
-      typename btree_iterator<node_type, reference, pointer>::iterator;
+  using iterator = 
+      typename btree_iterator<node_type, reference, pointer>::iterator; 
   using const_iterator = typename iterator::const_iterator;
   using reverse_iterator = std::reverse_iterator<iterator>;
   using const_reverse_iterator = std::reverse_iterator<const_iterator>;
@@ -1168,46 +1168,46 @@ class btree {
  private:
   // For use in copy_or_move_values_in_order.
   const value_type &maybe_move_from_iterator(const_iterator it) { return *it; }
-  value_type &&maybe_move_from_iterator(iterator it) {
-    // This is a destructive operation on the other container so it's safe for
-    // us to const_cast and move from the keys here even if it's a set.
-    return std::move(const_cast<value_type &>(*it));
-  }
+  value_type &&maybe_move_from_iterator(iterator it) { 
+    // This is a destructive operation on the other container so it's safe for 
+    // us to const_cast and move from the keys here even if it's a set. 
+    return std::move(const_cast<value_type &>(*it)); 
+  } 
 
   // Copies or moves (depending on the template parameter) the values in
   // other into this btree in their order in other. This btree must be empty
   // before this method is called. This method is used in copy construction,
   // copy assignment, and move assignment.
   template <typename Btree>
-  void copy_or_move_values_in_order(Btree &other);
+  void copy_or_move_values_in_order(Btree &other); 
 
   // Validates that various assumptions/requirements are true at compile time.
   constexpr static bool static_assert_validation();
 
  public:
-  btree(const key_compare &comp, const allocator_type &alloc)
-      : root_(comp, alloc, EmptyNode()), rightmost_(EmptyNode()), size_(0) {}
-
-  btree(const btree &other) : btree(other, other.allocator()) {}
-  btree(const btree &other, const allocator_type &alloc)
-      : btree(other.key_comp(), alloc) {
-    copy_or_move_values_in_order(other);
-  }
+  btree(const key_compare &comp, const allocator_type &alloc) 
+      : root_(comp, alloc, EmptyNode()), rightmost_(EmptyNode()), size_(0) {} 
+
+  btree(const btree &other) : btree(other, other.allocator()) {} 
+  btree(const btree &other, const allocator_type &alloc) 
+      : btree(other.key_comp(), alloc) { 
+    copy_or_move_values_in_order(other); 
+  } 
   btree(btree &&other) noexcept
       : root_(std::move(other.root_)),
         rightmost_(absl::exchange(other.rightmost_, EmptyNode())),
         size_(absl::exchange(other.size_, 0)) {
     other.mutable_root() = EmptyNode();
   }
-  btree(btree &&other, const allocator_type &alloc)
-      : btree(other.key_comp(), alloc) {
-    if (alloc == other.allocator()) {
-      swap(other);
-    } else {
-      // Move values from `other` one at a time when allocators are different.
-      copy_or_move_values_in_order(other);
-    }
-  }
+  btree(btree &&other, const allocator_type &alloc) 
+      : btree(other.key_comp(), alloc) { 
+    if (alloc == other.allocator()) { 
+      swap(other); 
+    } else { 
+      // Move values from `other` one at a time when allocators are different. 
+      copy_or_move_values_in_order(other); 
+    } 
+  } 
 
   ~btree() {
     // Put static_asserts in destructor to avoid triggering them before the type
@@ -1235,23 +1235,23 @@ class btree {
     return const_reverse_iterator(begin());
   }
 
-  // Finds the first element whose key is not less than `key`.
+  // Finds the first element whose key is not less than `key`. 
   template <typename K>
   iterator lower_bound(const K &key) {
-    return internal_end(internal_lower_bound(key).value);
+    return internal_end(internal_lower_bound(key).value); 
   }
   template <typename K>
   const_iterator lower_bound(const K &key) const {
-    return internal_end(internal_lower_bound(key).value);
+    return internal_end(internal_lower_bound(key).value); 
   }
 
-  // Finds the first element whose key is not less than `key` and also returns
-  // whether that element is equal to `key`.
-  template <typename K>
-  std::pair<iterator, bool> lower_bound_equal(const K &key) const;
-
-  // Finds the first element whose key is greater than `key`.
+  // Finds the first element whose key is not less than `key` and also returns 
+  // whether that element is equal to `key`. 
   template <typename K>
+  std::pair<iterator, bool> lower_bound_equal(const K &key) const; 
+ 
+  // Finds the first element whose key is greater than `key`. 
+  template <typename K> 
   iterator upper_bound(const K &key) {
     return internal_end(internal_upper_bound(key));
   }
@@ -1332,8 +1332,8 @@ class btree {
   // to the element after the last erased element.
   std::pair<size_type, iterator> erase_range(iterator begin, iterator end);
 
-  // Finds an element with key equivalent to `key` or returns `end()` if `key`
-  // is not present.
+  // Finds an element with key equivalent to `key` or returns `end()` if `key` 
+  // is not present. 
   template <typename K>
   iterator find(const K &key) {
     return internal_end(internal_find(key));
@@ -1407,14 +1407,14 @@ class btree {
     }
   }
 
-  // The average number of bytes used per value stored in the btree assuming
-  // random insertion order.
+  // The average number of bytes used per value stored in the btree assuming 
+  // random insertion order. 
   static double average_bytes_per_value() {
-    // The expected number of values per node with random insertion order is the
-    // average of the maximum and minimum numbers of values per node.
-    const double expected_values_per_node =
-        (kNodeSlots + kMinNodeValues) / 2.0;
-    return node_type::LeafSize() / expected_values_per_node;
+    // The expected number of values per node with random insertion order is the 
+    // average of the maximum and minimum numbers of values per node. 
+    const double expected_values_per_node = 
+        (kNodeSlots + kMinNodeValues) / 2.0; 
+    return node_type::LeafSize() / expected_values_per_node; 
   }
 
   // The fullness of the btree. Computed as the number of elements in the btree
@@ -1424,7 +1424,7 @@ class btree {
   // Returns 0 for empty trees.
   double fullness() const {
     if (empty()) return 0.0;
-    return static_cast<double>(size()) / (nodes() * kNodeSlots);
+    return static_cast<double>(size()) / (nodes() * kNodeSlots); 
   }
   // The overhead of the btree structure in bytes per node. Computed as the
   // total number of bytes used by the btree minus the number of bytes used for
@@ -1474,7 +1474,7 @@ class btree {
   }
   node_type *new_leaf_node(node_type *parent) {
     node_type *n = allocate(node_type::LeafSize());
-    n->init_leaf(parent, kNodeSlots);
+    n->init_leaf(parent, kNodeSlots); 
     return n;
   }
   node_type *new_leaf_root_node(const int max_count) {
@@ -1534,8 +1534,8 @@ class btree {
 
   // Internal routine which implements lower_bound().
   template <typename K>
-  SearchResult<iterator, is_key_compare_to::value> internal_lower_bound(
-      const K &key) const;
+  SearchResult<iterator, is_key_compare_to::value> internal_lower_bound( 
+      const K &key) const; 
 
   // Internal routine which implements upper_bound().
   template <typename K>
@@ -1719,7 +1719,7 @@ template <typename P>
 void btree_node<P>::split(const int insert_position, btree_node *dest,
                           allocator_type *alloc) {
   assert(dest->count() == 0);
-  assert(max_count() == kNodeSlots);
+  assert(max_count() == kNodeSlots); 
 
   // We bias the split based on the position being inserted. If we're
   // inserting at the beginning of the left node then bias the split to put
@@ -1727,7 +1727,7 @@ void btree_node<P>::split(const int insert_position, btree_node *dest,
   // right node then bias the split to put more values on the left node.
   if (insert_position == start()) {
     dest->set_finish(dest->start() + finish() - 1);
-  } else if (insert_position == kNodeSlots) {
+  } else if (insert_position == kNodeSlots) { 
     dest->set_finish(dest->start());
   } else {
     dest->set_finish(dest->start() + count() / 2);
@@ -1798,7 +1798,7 @@ void btree_node<P>::clear_and_delete(btree_node *node, allocator_type *alloc) {
 
   // Navigate to the leftmost leaf under node, and then delete upwards.
   while (!node->leaf()) node = node->start_child();
-  // Use `int` because `pos` needs to be able to hold `kNodeSlots+1`, which
+  // Use `int` because `pos` needs to be able to hold `kNodeSlots+1`, which 
   // isn't guaranteed to be a valid `field_type`.
   int pos = node->position();
   btree_node *parent = node->parent();
@@ -1886,7 +1886,7 @@ void btree_iterator<N, R, P>::decrement_slow() {
 // btree methods
 template <typename P>
 template <typename Btree>
-void btree<P>::copy_or_move_values_in_order(Btree &other) {
+void btree<P>::copy_or_move_values_in_order(Btree &other) { 
   static_assert(std::is_same<btree, Btree>::value ||
                     std::is_same<const btree, Btree>::value,
                 "Btree type must be same or const.");
@@ -1894,11 +1894,11 @@ void btree<P>::copy_or_move_values_in_order(Btree &other) {
 
   // We can avoid key comparisons because we know the order of the
   // values is the same order we'll store them in.
-  auto iter = other.begin();
-  if (iter == other.end()) return;
+  auto iter = other.begin(); 
+  if (iter == other.end()) return; 
   insert_multi(maybe_move_from_iterator(iter));
   ++iter;
-  for (; iter != other.end(); ++iter) {
+  for (; iter != other.end(); ++iter) { 
     // If the btree is not empty, we can just insert the new value at the end
     // of the tree.
     internal_emplace(end(), maybe_move_from_iterator(iter));
@@ -1917,7 +1917,7 @@ constexpr bool btree<P>::static_assert_validation() {
   // Note: We assert that kTargetValues, which is computed from
   // Params::kTargetNodeSize, must fit the node_type::field_type.
   static_assert(
-      kNodeSlots < (1 << (8 * sizeof(typename node_type::field_type))),
+      kNodeSlots < (1 << (8 * sizeof(typename node_type::field_type))), 
       "target node size too large");
 
   // Verify that key_compare returns an absl::{weak,strong}_ordering or bool.
@@ -1937,29 +1937,29 @@ constexpr bool btree<P>::static_assert_validation() {
 }
 
 template <typename P>
-template <typename K>
-auto btree<P>::lower_bound_equal(const K &key) const
-    -> std::pair<iterator, bool> {
-  const SearchResult<iterator, is_key_compare_to::value> res =
-      internal_lower_bound(key);
-  const iterator lower = iterator(internal_end(res.value));
-  const bool equal = res.HasMatch()
-                         ? res.IsEq()
-                         : lower != end() && !compare_keys(key, lower.key());
-  return {lower, equal};
+template <typename K> 
+auto btree<P>::lower_bound_equal(const K &key) const 
+    -> std::pair<iterator, bool> { 
+  const SearchResult<iterator, is_key_compare_to::value> res = 
+      internal_lower_bound(key); 
+  const iterator lower = iterator(internal_end(res.value)); 
+  const bool equal = res.HasMatch() 
+                         ? res.IsEq() 
+                         : lower != end() && !compare_keys(key, lower.key()); 
+  return {lower, equal}; 
 }
 
 template <typename P>
 template <typename K>
 auto btree<P>::equal_range(const K &key) -> std::pair<iterator, iterator> {
-  const std::pair<iterator, bool> lower_and_equal = lower_bound_equal(key);
-  const iterator lower = lower_and_equal.first;
-  if (!lower_and_equal.second) {
-    return {lower, lower};
-  }
+  const std::pair<iterator, bool> lower_and_equal = lower_bound_equal(key); 
+  const iterator lower = lower_and_equal.first; 
+  if (!lower_and_equal.second) { 
+    return {lower, lower}; 
+  } 
 
   const iterator next = std::next(lower);
-  if (!params_type::template can_have_multiple_equivalent_keys<K>()) {
+  if (!params_type::template can_have_multiple_equivalent_keys<K>()) { 
     // The next iterator after lower must point to a key greater than `key`.
     // Note: if this assert fails, then it may indicate that the comparator does
     // not meet the equivalence requirements for Compare
@@ -1970,7 +1970,7 @@ auto btree<P>::equal_range(const K &key) -> std::pair<iterator, iterator> {
   // Try once more to avoid the call to upper_bound() if there's only one
   // equivalent key. This should prevent all calls to upper_bound() in cases of
   // unique-containers with heterogeneous comparators in which all comparison
-  // operators have the same equivalence classes.
+  // operators have the same equivalence classes. 
   if (next == end() || compare_keys(key, next.key())) return {lower, next};
 
   // In this case, we need to call upper_bound() to avoid worst case O(N)
@@ -2101,7 +2101,7 @@ auto btree<P>::operator=(const btree &other) -> btree & {
       *mutable_allocator() = other.allocator();
     }
 
-    copy_or_move_values_in_order(other);
+    copy_or_move_values_in_order(other); 
   }
   return *this;
 }
@@ -2131,7 +2131,7 @@ auto btree<P>::operator=(btree &&other) noexcept -> btree & {
         // comparator while moving the values so we can't swap the key
         // comparators.
         *mutable_key_comp() = other.key_comp();
-        copy_or_move_values_in_order(other);
+        copy_or_move_values_in_order(other); 
       }
     }
   }
@@ -2298,7 +2298,7 @@ void btree<P>::rebalance_or_split(iterator *iter) {
   node_type *&node = iter->node;
   int &insert_position = iter->position;
   assert(node->count() == node->max_count());
-  assert(kNodeSlots == node->max_count());
+  assert(kNodeSlots == node->max_count()); 
 
   // First try to make room on the node by rebalancing.
   node_type *parent = node->parent();
@@ -2306,17 +2306,17 @@ void btree<P>::rebalance_or_split(iterator *iter) {
     if (node->position() > parent->start()) {
       // Try rebalancing with our left sibling.
       node_type *left = parent->child(node->position() - 1);
-      assert(left->max_count() == kNodeSlots);
-      if (left->count() < kNodeSlots) {
+      assert(left->max_count() == kNodeSlots); 
+      if (left->count() < kNodeSlots) { 
         // We bias rebalancing based on the position being inserted. If we're
         // inserting at the end of the right node then we bias rebalancing to
         // fill up the left node.
-        int to_move = (kNodeSlots - left->count()) /
-                      (1 + (insert_position < static_cast<int>(kNodeSlots)));
+        int to_move = (kNodeSlots - left->count()) / 
+                      (1 + (insert_position < static_cast<int>(kNodeSlots))); 
         to_move = (std::max)(1, to_move);
 
         if (insert_position - to_move >= node->start() ||
-            left->count() + to_move < static_cast<int>(kNodeSlots)) {
+            left->count() + to_move < static_cast<int>(kNodeSlots)) { 
           left->rebalance_right_to_left(to_move, node, mutable_allocator());
 
           assert(node->max_count() - node->count() == to_move);
@@ -2335,17 +2335,17 @@ void btree<P>::rebalance_or_split(iterator *iter) {
     if (node->position() < parent->finish()) {
       // Try rebalancing with our right sibling.
       node_type *right = parent->child(node->position() + 1);
-      assert(right->max_count() == kNodeSlots);
-      if (right->count() < kNodeSlots) {
+      assert(right->max_count() == kNodeSlots); 
+      if (right->count() < kNodeSlots) { 
         // We bias rebalancing based on the position being inserted. If we're
         // inserting at the beginning of the left node then we bias rebalancing
         // to fill up the right node.
-        int to_move = (static_cast<int>(kNodeSlots) - right->count()) /
+        int to_move = (static_cast<int>(kNodeSlots) - right->count()) / 
                       (1 + (insert_position > node->start()));
         to_move = (std::max)(1, to_move);
 
         if (insert_position <= node->finish() - to_move ||
-            right->count() + to_move < static_cast<int>(kNodeSlots)) {
+            right->count() + to_move < static_cast<int>(kNodeSlots)) { 
           node->rebalance_left_to_right(to_move, right, mutable_allocator());
 
           if (insert_position > node->finish()) {
@@ -2361,8 +2361,8 @@ void btree<P>::rebalance_or_split(iterator *iter) {
 
     // Rebalancing failed, make sure there is room on the parent node for a new
     // value.
-    assert(parent->max_count() == kNodeSlots);
-    if (parent->count() == kNodeSlots) {
+    assert(parent->max_count() == kNodeSlots); 
+    if (parent->count() == kNodeSlots) { 
       iterator parent_iter(node->parent(), node->position());
       rebalance_or_split(&parent_iter);
     }
@@ -2407,8 +2407,8 @@ bool btree<P>::try_merge_or_rebalance(iterator *iter) {
   if (iter->node->position() > parent->start()) {
     // Try merging with our left sibling.
     node_type *left = parent->child(iter->node->position() - 1);
-    assert(left->max_count() == kNodeSlots);
-    if (1U + left->count() + iter->node->count() <= kNodeSlots) {
+    assert(left->max_count() == kNodeSlots); 
+    if (1U + left->count() + iter->node->count() <= kNodeSlots) { 
       iter->position += 1 + left->count();
       merge_nodes(left, iter->node);
       iter->node = left;
@@ -2418,8 +2418,8 @@ bool btree<P>::try_merge_or_rebalance(iterator *iter) {
   if (iter->node->position() < parent->finish()) {
     // Try merging with our right sibling.
     node_type *right = parent->child(iter->node->position() + 1);
-    assert(right->max_count() == kNodeSlots);
-    if (1U + iter->node->count() + right->count() <= kNodeSlots) {
+    assert(right->max_count() == kNodeSlots); 
+    if (1U + iter->node->count() + right->count() <= kNodeSlots) { 
       merge_nodes(iter->node, right);
       return true;
     }
@@ -2500,12 +2500,12 @@ inline auto btree<P>::internal_emplace(iterator iter, Args &&... args)
   allocator_type *alloc = mutable_allocator();
   if (iter.node->count() == max_count) {
     // Make room in the leaf for the new item.
-    if (max_count < kNodeSlots) {
+    if (max_count < kNodeSlots) { 
       // Insertion into the root where the root is smaller than the full node
       // size. Simply grow the size of the root node.
       assert(iter.node == root());
       iter.node =
-          new_leaf_root_node((std::min<int>)(kNodeSlots, 2 * max_count));
+          new_leaf_root_node((std::min<int>)(kNodeSlots, 2 * max_count)); 
       // Transfer the values from the old root to the new root.
       node_type *old_root = root();
       node_type *new_root = iter.node;
@@ -2552,27 +2552,27 @@ inline auto btree<P>::internal_locate(const K &key) const
 
 template <typename P>
 template <typename K>
-auto btree<P>::internal_lower_bound(const K &key) const
-    -> SearchResult<iterator, is_key_compare_to::value> {
-  if (!params_type::template can_have_multiple_equivalent_keys<K>()) {
-    SearchResult<iterator, is_key_compare_to::value> ret = internal_locate(key);
-    ret.value = internal_last(ret.value);
-    return ret;
-  }
+auto btree<P>::internal_lower_bound(const K &key) const 
+    -> SearchResult<iterator, is_key_compare_to::value> { 
+  if (!params_type::template can_have_multiple_equivalent_keys<K>()) { 
+    SearchResult<iterator, is_key_compare_to::value> ret = internal_locate(key); 
+    ret.value = internal_last(ret.value); 
+    return ret; 
+  } 
   iterator iter(const_cast<node_type *>(root()));
-  SearchResult<int, is_key_compare_to::value> res;
-  bool seen_eq = false;
+  SearchResult<int, is_key_compare_to::value> res; 
+  bool seen_eq = false; 
   for (;;) {
-    res = iter.node->lower_bound(key, key_comp());
-    iter.position = res.value;
+    res = iter.node->lower_bound(key, key_comp()); 
+    iter.position = res.value; 
     if (iter.node->leaf()) {
       break;
     }
-    seen_eq = seen_eq || res.IsEq();
+    seen_eq = seen_eq || res.IsEq(); 
     iter.node = iter.node->child(iter.position);
   }
-  if (res.IsEq()) return {iter, MatchKind::kEq};
-  return {internal_last(iter), seen_eq ? MatchKind::kEq : MatchKind::kNe};
+  if (res.IsEq()) return {iter, MatchKind::kEq}; 
+  return {internal_last(iter), seen_eq ? MatchKind::kEq : MatchKind::kNe}; 
 }
 
 template <typename P>
diff --git a/contrib/restricted/abseil-cpp/absl/container/internal/btree_container.h b/contrib/restricted/abseil-cpp/absl/container/internal/btree_container.h
index a99668c713..83c411a6e2 100644
--- a/contrib/restricted/abseil-cpp/absl/container/internal/btree_container.h
+++ b/contrib/restricted/abseil-cpp/absl/container/internal/btree_container.h
@@ -24,7 +24,7 @@
 #include "absl/base/internal/throw_delegate.h"
 #include "absl/container/internal/btree.h"  // IWYU pragma: export
 #include "absl/container/internal/common.h"
-#include "absl/memory/memory.h"
+#include "absl/memory/memory.h" 
 #include "absl/meta/type_traits.h"
 
 namespace absl {
@@ -70,21 +70,21 @@ class btree_container {
   explicit btree_container(const key_compare &comp,
                            const allocator_type &alloc = allocator_type())
       : tree_(comp, alloc) {}
-  explicit btree_container(const allocator_type &alloc)
-      : tree_(key_compare(), alloc) {}
-
-  btree_container(const btree_container &other)
-      : btree_container(other, absl::allocator_traits<allocator_type>::
-                                   select_on_container_copy_construction(
-                                       other.get_allocator())) {}
-  btree_container(const btree_container &other, const allocator_type &alloc)
-      : tree_(other.tree_, alloc) {}
-
-  btree_container(btree_container &&other) noexcept(
-      std::is_nothrow_move_constructible<Tree>::value) = default;
-  btree_container(btree_container &&other, const allocator_type &alloc)
-      : tree_(std::move(other.tree_), alloc) {}
-
+  explicit btree_container(const allocator_type &alloc) 
+      : tree_(key_compare(), alloc) {} 
+ 
+  btree_container(const btree_container &other) 
+      : btree_container(other, absl::allocator_traits<allocator_type>:: 
+                                   select_on_container_copy_construction( 
+                                       other.get_allocator())) {} 
+  btree_container(const btree_container &other, const allocator_type &alloc) 
+      : tree_(other.tree_, alloc) {} 
+ 
+  btree_container(btree_container &&other) noexcept( 
+      std::is_nothrow_move_constructible<Tree>::value) = default; 
+  btree_container(btree_container &&other, const allocator_type &alloc) 
+      : tree_(std::move(other.tree_), alloc) {} 
+ 
   btree_container &operator=(const btree_container &other) = default;
   btree_container &operator=(btree_container &&other) noexcept(
       std::is_nothrow_move_assignable<Tree>::value) = default;
@@ -105,11 +105,11 @@ class btree_container {
 
   // Lookup routines.
   template <typename K = key_type>
-  size_type count(const key_arg<K> &key) const {
-    auto equal_range = this->equal_range(key);
-    return std::distance(equal_range.first, equal_range.second);
-  }
-  template <typename K = key_type>
+  size_type count(const key_arg<K> &key) const { 
+    auto equal_range = this->equal_range(key); 
+    return std::distance(equal_range.first, equal_range.second); 
+  } 
+  template <typename K = key_type> 
   iterator find(const key_arg<K> &key) {
     return tree_.find(key);
   }
@@ -158,11 +158,11 @@ class btree_container {
   iterator erase(const_iterator first, const_iterator last) {
     return tree_.erase_range(iterator(first), iterator(last)).second;
   }
-  template <typename K = key_type>
-  size_type erase(const key_arg<K> &key) {
-    auto equal_range = this->equal_range(key);
-    return tree_.erase_range(equal_range.first, equal_range.second).first;
-  }
+  template <typename K = key_type> 
+  size_type erase(const key_arg<K> &key) { 
+    auto equal_range = this->equal_range(key); 
+    return tree_.erase_range(equal_range.first, equal_range.second).first; 
+  } 
 
   // Extract routines.
   node_type extract(iterator position) {
@@ -259,7 +259,7 @@ class btree_set_container : public btree_container<Tree> {
   using super_type::super_type;
   btree_set_container() {}
 
-  // Range constructors.
+  // Range constructors. 
   template <class InputIterator>
   btree_set_container(InputIterator b, InputIterator e,
                       const key_compare &comp = key_compare(),
@@ -267,19 +267,19 @@ class btree_set_container : public btree_container<Tree> {
       : super_type(comp, alloc) {
     insert(b, e);
   }
-  template <class InputIterator>
-  btree_set_container(InputIterator b, InputIterator e,
-                      const allocator_type &alloc)
-      : btree_set_container(b, e, key_compare(), alloc) {}
+  template <class InputIterator> 
+  btree_set_container(InputIterator b, InputIterator e, 
+                      const allocator_type &alloc) 
+      : btree_set_container(b, e, key_compare(), alloc) {} 
 
-  // Initializer list constructors.
+  // Initializer list constructors. 
   btree_set_container(std::initializer_list<init_type> init,
                       const key_compare &comp = key_compare(),
                       const allocator_type &alloc = allocator_type())
       : btree_set_container(init.begin(), init.end(), comp, alloc) {}
-  btree_set_container(std::initializer_list<init_type> init,
-                      const allocator_type &alloc)
-      : btree_set_container(init.begin(), init.end(), alloc) {}
+  btree_set_container(std::initializer_list<init_type> init, 
+                      const allocator_type &alloc) 
+      : btree_set_container(init.begin(), init.end(), alloc) {} 
 
   // Insertion routines.
   std::pair<iterator, bool> insert(const value_type &v) {
@@ -341,10 +341,10 @@ class btree_set_container : public btree_container<Tree> {
   // Node extraction routines.
   template <typename K = key_type>
   node_type extract(const key_arg<K> &key) {
-    const std::pair<iterator, bool> lower_and_equal =
-        this->tree_.lower_bound_equal(key);
-    return lower_and_equal.second ? extract(lower_and_equal.first)
-                                  : node_type();
+    const std::pair<iterator, bool> lower_and_equal = 
+        this->tree_.lower_bound_equal(key); 
+    return lower_and_equal.second ? extract(lower_and_equal.first) 
+                                  : node_type(); 
   }
   using super_type::extract;
 
@@ -389,7 +389,7 @@ template <typename Tree>
 class btree_map_container : public btree_set_container<Tree> {
   using super_type = btree_set_container<Tree>;
   using params_type = typename Tree::params_type;
-  friend class BtreeNodePeer;
+  friend class BtreeNodePeer; 
 
  private:
   template <class K>
@@ -554,7 +554,7 @@ class btree_multiset_container : public btree_container<Tree> {
   using super_type::super_type;
   btree_multiset_container() {}
 
-  // Range constructors.
+  // Range constructors. 
   template <class InputIterator>
   btree_multiset_container(InputIterator b, InputIterator e,
                            const key_compare &comp = key_compare(),
@@ -562,19 +562,19 @@ class btree_multiset_container : public btree_container<Tree> {
       : super_type(comp, alloc) {
     insert(b, e);
   }
-  template <class InputIterator>
-  btree_multiset_container(InputIterator b, InputIterator e,
-                           const allocator_type &alloc)
-      : btree_multiset_container(b, e, key_compare(), alloc) {}
+  template <class InputIterator> 
+  btree_multiset_container(InputIterator b, InputIterator e, 
+                           const allocator_type &alloc) 
+      : btree_multiset_container(b, e, key_compare(), alloc) {} 
 
-  // Initializer list constructors.
+  // Initializer list constructors. 
   btree_multiset_container(std::initializer_list<init_type> init,
                            const key_compare &comp = key_compare(),
                            const allocator_type &alloc = allocator_type())
       : btree_multiset_container(init.begin(), init.end(), comp, alloc) {}
-  btree_multiset_container(std::initializer_list<init_type> init,
-                           const allocator_type &alloc)
-      : btree_multiset_container(init.begin(), init.end(), alloc) {}
+  btree_multiset_container(std::initializer_list<init_type> init, 
+                           const allocator_type &alloc) 
+      : btree_multiset_container(init.begin(), init.end(), alloc) {} 
 
   // Insertion routines.
   iterator insert(const value_type &v) { return this->tree_.insert_multi(v); }
@@ -623,10 +623,10 @@ class btree_multiset_container : public btree_container<Tree> {
   // Node extraction routines.
   template <typename K = key_type>
   node_type extract(const key_arg<K> &key) {
-    const std::pair<iterator, bool> lower_and_equal =
-        this->tree_.lower_bound_equal(key);
-    return lower_and_equal.second ? extract(lower_and_equal.first)
-                                  : node_type();
+    const std::pair<iterator, bool> lower_and_equal = 
+        this->tree_.lower_bound_equal(key); 
+    return lower_and_equal.second ? extract(lower_and_equal.first) 
+                                  : node_type(); 
   }
   using super_type::extract;
 
diff --git a/contrib/restricted/abseil-cpp/absl/container/internal/hashtablez_sampler.cc b/contrib/restricted/abseil-cpp/absl/container/internal/hashtablez_sampler.cc
index 40cce0479e..f1c72287ef 100644
--- a/contrib/restricted/abseil-cpp/absl/container/internal/hashtablez_sampler.cc
+++ b/contrib/restricted/abseil-cpp/absl/container/internal/hashtablez_sampler.cc
@@ -70,7 +70,7 @@ void HashtablezInfo::PrepareForSampling() {
   total_probe_length.store(0, std::memory_order_relaxed);
   hashes_bitwise_or.store(0, std::memory_order_relaxed);
   hashes_bitwise_and.store(~size_t{}, std::memory_order_relaxed);
-  hashes_bitwise_xor.store(0, std::memory_order_relaxed);
+  hashes_bitwise_xor.store(0, std::memory_order_relaxed); 
   max_reserve.store(0, std::memory_order_relaxed);
 
   create_time = absl::Now();
@@ -93,9 +93,9 @@ static bool ShouldForceSampling() {
   if (ABSL_PREDICT_TRUE(state == kDontForce)) return false;
 
   if (state == kUninitialized) {
-    state = ABSL_INTERNAL_C_SYMBOL(AbslContainerInternalSampleEverything)()
-                ? kForce
-                : kDontForce;
+    state = ABSL_INTERNAL_C_SYMBOL(AbslContainerInternalSampleEverything)() 
+                ? kForce 
+                : kDontForce; 
     global_state.store(state, std::memory_order_relaxed);
   }
   return state == kForce;
@@ -154,7 +154,7 @@ void RecordInsertSlow(HashtablezInfo* info, size_t hash,
 
   info->hashes_bitwise_and.fetch_and(hash, std::memory_order_relaxed);
   info->hashes_bitwise_or.fetch_or(hash, std::memory_order_relaxed);
-  info->hashes_bitwise_xor.fetch_xor(hash, std::memory_order_relaxed);
+  info->hashes_bitwise_xor.fetch_xor(hash, std::memory_order_relaxed); 
   info->max_probe_length.store(
       std::max(info->max_probe_length.load(std::memory_order_relaxed),
                probe_length),
diff --git a/contrib/restricted/abseil-cpp/absl/container/internal/hashtablez_sampler.h b/contrib/restricted/abseil-cpp/absl/container/internal/hashtablez_sampler.h
index 91fcdb34a3..0064307c9a 100644
--- a/contrib/restricted/abseil-cpp/absl/container/internal/hashtablez_sampler.h
+++ b/contrib/restricted/abseil-cpp/absl/container/internal/hashtablez_sampler.h
@@ -79,7 +79,7 @@ struct HashtablezInfo : public profiling_internal::Sample<HashtablezInfo> {
   std::atomic<size_t> total_probe_length;
   std::atomic<size_t> hashes_bitwise_or;
   std::atomic<size_t> hashes_bitwise_and;
-  std::atomic<size_t> hashes_bitwise_xor;
+  std::atomic<size_t> hashes_bitwise_xor; 
   std::atomic<size_t> max_reserve;
 
   // All of the fields below are set by `PrepareForSampling`, they must not be
@@ -272,7 +272,7 @@ void SetHashtablezMaxSamples(int32_t max);
 // initialization of static storage duration objects.
 // The definition of this constant is weak, which allows us to inject a
 // different value for it at link time.
-extern "C" bool ABSL_INTERNAL_C_SYMBOL(AbslContainerInternalSampleEverything)();
+extern "C" bool ABSL_INTERNAL_C_SYMBOL(AbslContainerInternalSampleEverything)(); 
 
 }  // namespace container_internal
 ABSL_NAMESPACE_END
diff --git a/contrib/restricted/abseil-cpp/absl/container/internal/hashtablez_sampler_force_weak_definition.cc b/contrib/restricted/abseil-cpp/absl/container/internal/hashtablez_sampler_force_weak_definition.cc
index ed35a7eec3..2166c3f189 100644
--- a/contrib/restricted/abseil-cpp/absl/container/internal/hashtablez_sampler_force_weak_definition.cc
+++ b/contrib/restricted/abseil-cpp/absl/container/internal/hashtablez_sampler_force_weak_definition.cc
@@ -21,8 +21,8 @@ ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
 // See hashtablez_sampler.h for details.
-extern "C" ABSL_ATTRIBUTE_WEAK bool ABSL_INTERNAL_C_SYMBOL(
-    AbslContainerInternalSampleEverything)() {
+extern "C" ABSL_ATTRIBUTE_WEAK bool ABSL_INTERNAL_C_SYMBOL( 
+    AbslContainerInternalSampleEverything)() { 
   return false;
 }
 
diff --git a/contrib/restricted/abseil-cpp/absl/container/internal/inlined_vector.h b/contrib/restricted/abseil-cpp/absl/container/internal/inlined_vector.h
index 1d7d6cda72..34a78e0498 100644
--- a/contrib/restricted/abseil-cpp/absl/container/internal/inlined_vector.h
+++ b/contrib/restricted/abseil-cpp/absl/container/internal/inlined_vector.h
@@ -36,13 +36,13 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace inlined_vector_internal {
 
-// GCC does not deal very well with the below code
-#if !defined(__clang__) && defined(__GNUC__)
-#pragma GCC diagnostic push
+// GCC does not deal very well with the below code 
+#if !defined(__clang__) && defined(__GNUC__) 
+#pragma GCC diagnostic push 
 #pragma GCC diagnostic ignored "-Warray-bounds"
-#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
-#endif
-
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized" 
+#endif 
+ 
 template <typename A>
 using AllocatorTraits = std::allocator_traits<A>;
 template <typename A>
@@ -110,7 +110,7 @@ struct Allocation {
   Pointer<A> data;
   SizeType<A> capacity;
 };
-
+ 
 template <typename A,
           bool IsOverAligned =
               (alignof(ValueType<A>) > ABSL_INTERNAL_DEFAULT_NEW_ALIGNMENT)>
@@ -119,13 +119,13 @@ struct MallocAdapter {
     return {AllocatorTraits<A>::allocate(allocator, requested_capacity),
             requested_capacity};
   }
-
+ 
   static void Deallocate(A& allocator, Pointer<A> pointer,
                          SizeType<A> capacity) {
     AllocatorTraits<A>::deallocate(allocator, pointer, capacity);
   }
 };
-
+ 
 template <typename A, typename ValueAdapter>
 void ConstructElements(NoTypeDeduction<A>& allocator,
                        Pointer<A> construct_first, ValueAdapter& values,
@@ -303,14 +303,14 @@ class Storage {
       : metadata_(allocator, /* size and is_allocated */ 0) {}
 
   ~Storage() {
-    if (GetSizeAndIsAllocated() == 0) {
-      // Empty and not allocated; nothing to do.
+    if (GetSizeAndIsAllocated() == 0) { 
+      // Empty and not allocated; nothing to do. 
     } else if (IsMemcpyOk<A>::value) {
-      // No destructors need to be run; just deallocate if necessary.
-      DeallocateIfAllocated();
-    } else {
-      DestroyContents();
-    }
+      // No destructors need to be run; just deallocate if necessary. 
+      DeallocateIfAllocated(); 
+    } else { 
+      DestroyContents(); 
+    } 
   }
 
   // ---------------------------------------------------------------------------
@@ -364,8 +364,8 @@ class Storage {
   // Storage Member Mutators
   // ---------------------------------------------------------------------------
 
-  ABSL_ATTRIBUTE_NOINLINE void InitFrom(const Storage& other);
-
+  ABSL_ATTRIBUTE_NOINLINE void InitFrom(const Storage& other); 
+ 
   template <typename ValueAdapter>
   void Initialize(ValueAdapter values, SizeType<A> new_size);
 
@@ -441,8 +441,8 @@ class Storage {
   }
 
  private:
-  ABSL_ATTRIBUTE_NOINLINE void DestroyContents();
-
+  ABSL_ATTRIBUTE_NOINLINE void DestroyContents(); 
+ 
   using Metadata = container_internal::CompressedTuple<A, SizeType<A>>;
 
   struct Allocated {
@@ -459,51 +459,51 @@ class Storage {
     Inlined inlined;
   };
 
-  template <typename... Args>
+  template <typename... Args> 
   ABSL_ATTRIBUTE_NOINLINE Reference<A> EmplaceBackSlow(Args&&... args);
-
+ 
   Metadata metadata_;
   Data data_;
 };
 
 template <typename T, size_t N, typename A>
-void Storage<T, N, A>::DestroyContents() {
+void Storage<T, N, A>::DestroyContents() { 
   Pointer<A> data = GetIsAllocated() ? GetAllocatedData() : GetInlinedData();
   DestroyElements<A>(GetAllocator(), data, GetSize());
-  DeallocateIfAllocated();
-}
-
-template <typename T, size_t N, typename A>
-void Storage<T, N, A>::InitFrom(const Storage& other) {
+  DeallocateIfAllocated(); 
+} 
+ 
+template <typename T, size_t N, typename A> 
+void Storage<T, N, A>::InitFrom(const Storage& other) { 
   const SizeType<A> n = other.GetSize();
-  assert(n > 0);  // Empty sources handled handled in caller.
+  assert(n > 0);  // Empty sources handled handled in caller. 
   ConstPointer<A> src;
   Pointer<A> dst;
-  if (!other.GetIsAllocated()) {
-    dst = GetInlinedData();
-    src = other.GetInlinedData();
-  } else {
-    // Because this is only called from the `InlinedVector` constructors, it's
-    // safe to take on the allocation with size `0`. If `ConstructElements(...)`
-    // throws, deallocation will be automatically handled by `~Storage()`.
+  if (!other.GetIsAllocated()) { 
+    dst = GetInlinedData(); 
+    src = other.GetInlinedData(); 
+  } else { 
+    // Because this is only called from the `InlinedVector` constructors, it's 
+    // safe to take on the allocation with size `0`. If `ConstructElements(...)` 
+    // throws, deallocation will be automatically handled by `~Storage()`. 
     SizeType<A> requested_capacity = ComputeCapacity(GetInlinedCapacity(), n);
     Allocation<A> allocation =
         MallocAdapter<A>::Allocate(GetAllocator(), requested_capacity);
     SetAllocation(allocation);
     dst = allocation.data;
-    src = other.GetAllocatedData();
-  }
+    src = other.GetAllocatedData(); 
+  } 
   if (IsMemcpyOk<A>::value) {
     std::memcpy(reinterpret_cast<char*>(dst),
                 reinterpret_cast<const char*>(src), n * sizeof(ValueType<A>));
-  } else {
+  } else { 
     auto values = IteratorValueAdapter<A, ConstPointer<A>>(src);
     ConstructElements<A>(GetAllocator(), dst, values, n);
-  }
-  GetSizeAndIsAllocated() = other.GetSizeAndIsAllocated();
-}
-
-template <typename T, size_t N, typename A>
+  } 
+  GetSizeAndIsAllocated() = other.GetSizeAndIsAllocated(); 
+} 
+ 
+template <typename T, size_t N, typename A> 
 template <typename ValueAdapter>
 auto Storage<T, N, A>::Initialize(ValueAdapter values, SizeType<A> new_size)
     -> void {
@@ -585,20 +585,20 @@ auto Storage<T, N, A>::Resize(ValueAdapter values, SizeType<A> new_size)
   Pointer<A> const base = storage_view.data;
   const SizeType<A> size = storage_view.size;
   A& alloc = GetAllocator();
-  if (new_size <= size) {
-    // Destroy extra old elements.
+  if (new_size <= size) { 
+    // Destroy extra old elements. 
     DestroyElements<A>(alloc, base + new_size, size - new_size);
-  } else if (new_size <= storage_view.capacity) {
-    // Construct new elements in place.
+  } else if (new_size <= storage_view.capacity) { 
+    // Construct new elements in place. 
     ConstructElements<A>(alloc, base + size, values, new_size - size);
-  } else {
-    // Steps:
-    //  a. Allocate new backing store.
-    //  b. Construct new elements in new backing store.
-    //  c. Move existing elements from old backing store to now.
-    //  d. Destroy all elements in old backing store.
-    // Use transactional wrappers for the first two steps so we can roll
-    // back if necessary due to exceptions.
+  } else { 
+    // Steps: 
+    //  a. Allocate new backing store. 
+    //  b. Construct new elements in new backing store. 
+    //  c. Move existing elements from old backing store to now. 
+    //  d. Destroy all elements in old backing store. 
+    // Use transactional wrappers for the first two steps so we can roll 
+    // back if necessary due to exceptions. 
     AllocationTransaction<A> allocation_tx(alloc);
     SizeType<A> requested_capacity =
         ComputeCapacity(storage_view.capacity, new_size);
@@ -717,20 +717,20 @@ template <typename... Args>
 auto Storage<T, N, A>::EmplaceBack(Args&&... args) -> Reference<A> {
   StorageView<A> storage_view = MakeStorageView();
   const SizeType<A> n = storage_view.size;
-  if (ABSL_PREDICT_TRUE(n != storage_view.capacity)) {
-    // Fast path; new element fits.
+  if (ABSL_PREDICT_TRUE(n != storage_view.capacity)) { 
+    // Fast path; new element fits. 
     Pointer<A> last_ptr = storage_view.data + n;
     AllocatorTraits<A>::construct(GetAllocator(), last_ptr,
                                   std::forward<Args>(args)...);
-    AddSize(1);
-    return *last_ptr;
-  }
-  // TODO(b/173712035): Annotate with musttail attribute to prevent regression.
-  return EmplaceBackSlow(std::forward<Args>(args)...);
-}
-
-template <typename T, size_t N, typename A>
-template <typename... Args>
+    AddSize(1); 
+    return *last_ptr; 
+  } 
+  // TODO(b/173712035): Annotate with musttail attribute to prevent regression. 
+  return EmplaceBackSlow(std::forward<Args>(args)...); 
+} 
+
+template <typename T, size_t N, typename A> 
+template <typename... Args> 
 auto Storage<T, N, A>::EmplaceBackSlow(Args&&... args) -> Reference<A> {
   StorageView<A> storage_view = MakeStorageView();
   AllocationTransaction<A> allocation_tx(GetAllocator());
@@ -740,24 +740,24 @@ auto Storage<T, N, A>::EmplaceBackSlow(Args&&... args) -> Reference<A> {
   Pointer<A> construct_data = allocation_tx.Allocate(requested_capacity);
   Pointer<A> last_ptr = construct_data + storage_view.size;
 
-  // Construct new element.
+  // Construct new element. 
   AllocatorTraits<A>::construct(GetAllocator(), last_ptr,
                                 std::forward<Args>(args)...);
-  // Move elements from old backing store to new backing store.
-  ABSL_INTERNAL_TRY {
+  // Move elements from old backing store to new backing store. 
+  ABSL_INTERNAL_TRY { 
     ConstructElements<A>(GetAllocator(), allocation_tx.GetData(), move_values,
                          storage_view.size);
   }
-  ABSL_INTERNAL_CATCH_ANY {
+  ABSL_INTERNAL_CATCH_ANY { 
     AllocatorTraits<A>::destroy(GetAllocator(), last_ptr);
-    ABSL_INTERNAL_RETHROW;
-  }
-  // Destroy elements in old backing store.
+    ABSL_INTERNAL_RETHROW; 
+  } 
+  // Destroy elements in old backing store. 
   DestroyElements<A>(GetAllocator(), storage_view.data, storage_view.size);
 
-  DeallocateIfAllocated();
+  DeallocateIfAllocated(); 
   SetAllocation(std::move(allocation_tx).Release());
-  SetIsAllocated();
+  SetIsAllocated(); 
   AddSize(1);
   return *last_ptr;
 }
@@ -921,10 +921,10 @@ auto Storage<T, N, A>::Swap(Storage* other_storage_ptr) -> void {
 }
 
 // End ignore "array-bounds" and "maybe-uninitialized"
-#if !defined(__clang__) && defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif
-
+#if !defined(__clang__) && defined(__GNUC__) 
+#pragma GCC diagnostic pop 
+#endif 
+ 
 }  // namespace inlined_vector_internal
 ABSL_NAMESPACE_END
 }  // namespace absl
diff --git a/contrib/restricted/abseil-cpp/absl/container/internal/layout.h b/contrib/restricted/abseil-cpp/absl/container/internal/layout.h
index a59a243059..23d44d7793 100644
--- a/contrib/restricted/abseil-cpp/absl/container/internal/layout.h
+++ b/contrib/restricted/abseil-cpp/absl/container/internal/layout.h
@@ -404,7 +404,7 @@ class LayoutImpl<std::tuple<Elements...>, absl::index_sequence<SizeSeq...>,
   constexpr size_t Offset() const {
     static_assert(N < NumOffsets, "Index out of bounds");
     return adl_barrier::Align(
-        Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * size_[N - 1],
+        Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * size_[N - 1], 
         ElementAlignment<N>::value);
   }
 
@@ -597,7 +597,7 @@ class LayoutImpl<std::tuple<Elements...>, absl::index_sequence<SizeSeq...>,
   constexpr size_t AllocSize() const {
     static_assert(NumTypes == NumSizes, "You must specify sizes of all fields");
     return Offset<NumTypes - 1>() +
-        SizeOf<ElementType<NumTypes - 1>>::value * size_[NumTypes - 1];
+        SizeOf<ElementType<NumTypes - 1>>::value * size_[NumTypes - 1]; 
   }
 
   // If built with --config=asan, poisons padding bytes (if any) in the
@@ -621,7 +621,7 @@ class LayoutImpl<std::tuple<Elements...>, absl::index_sequence<SizeSeq...>,
     // The `if` is an optimization. It doesn't affect the observable behaviour.
     if (ElementAlignment<N - 1>::value % ElementAlignment<N>::value) {
       size_t start =
-          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * size_[N - 1];
+          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * size_[N - 1]; 
       ASAN_POISON_MEMORY_REGION(p + start, Offset<N>() - start);
     }
 #endif
@@ -645,7 +645,7 @@ class LayoutImpl<std::tuple<Elements...>, absl::index_sequence<SizeSeq...>,
   // produce "unsigned*" where another produces "unsigned int *".
   std::string DebugString() const {
     const auto offsets = Offsets();
-    const size_t sizes[] = {SizeOf<ElementType<OffsetSeq>>::value...};
+    const size_t sizes[] = {SizeOf<ElementType<OffsetSeq>>::value...}; 
     const std::string types[] = {
         adl_barrier::TypeName<ElementType<OffsetSeq>>()...};
     std::string res = absl::StrCat("@0", types[0], "(", sizes[0], ")");
diff --git a/contrib/restricted/abseil-cpp/absl/container/internal/raw_hash_set.cc b/contrib/restricted/abseil-cpp/absl/container/internal/raw_hash_set.cc
index 687bcb8a4d..eea9f6ee4e 100644
--- a/contrib/restricted/abseil-cpp/absl/container/internal/raw_hash_set.cc
+++ b/contrib/restricted/abseil-cpp/absl/container/internal/raw_hash_set.cc
@@ -33,7 +33,7 @@ constexpr size_t Group::kWidth;
 
 // Returns "random" seed.
 inline size_t RandomSeed() {
-#ifdef ABSL_HAVE_THREAD_LOCAL
+#ifdef ABSL_HAVE_THREAD_LOCAL 
   static thread_local size_t counter = 0;
   size_t value = ++counter;
 #else   // ABSL_HAVE_THREAD_LOCAL
@@ -51,17 +51,17 @@ bool ShouldInsertBackwards(size_t hash, const ctrl_t* ctrl) {
 
 void ConvertDeletedToEmptyAndFullToDeleted(ctrl_t* ctrl, size_t capacity) {
   assert(ctrl[capacity] == ctrl_t::kSentinel);
-  assert(IsValidCapacity(capacity));
+  assert(IsValidCapacity(capacity)); 
   for (ctrl_t* pos = ctrl; pos < ctrl + capacity; pos += Group::kWidth) {
-    Group{pos}.ConvertSpecialToEmptyAndFullToDeleted(pos);
-  }
-  // Copy the cloned ctrl bytes.
+    Group{pos}.ConvertSpecialToEmptyAndFullToDeleted(pos); 
+  } 
+  // Copy the cloned ctrl bytes. 
   std::memcpy(ctrl + capacity + 1, ctrl, NumClonedBytes());
   ctrl[capacity] = ctrl_t::kSentinel;
-}
+} 
 // Extern template instantiotion for inline function.
 template FindInfo find_first_non_full(const ctrl_t*, size_t, size_t);
-
+ 
 }  // namespace container_internal
 ABSL_NAMESPACE_END
 }  // namespace absl
diff --git a/contrib/restricted/abseil-cpp/absl/container/internal/raw_hash_set.h b/contrib/restricted/abseil-cpp/absl/container/internal/raw_hash_set.h
index 12682b3532..24cf740296 100644
--- a/contrib/restricted/abseil-cpp/absl/container/internal/raw_hash_set.h
+++ b/contrib/restricted/abseil-cpp/absl/container/internal/raw_hash_set.h
@@ -125,7 +125,7 @@
 #include "absl/container/internal/have_sse.h"
 #include "absl/memory/memory.h"
 #include "absl/meta/type_traits.h"
-#include "absl/numeric/bits.h"
+#include "absl/numeric/bits.h" 
 #include "absl/utility/utility.h"
 
 namespace absl {
@@ -199,9 +199,9 @@ constexpr bool IsNoThrowSwappable(std::false_type /* is_swappable */) {
 }
 
 template <typename T>
-uint32_t TrailingZeros(T x) {
-  ABSL_INTERNAL_ASSUME(x != 0);
-  return countr_zero(x);
+uint32_t TrailingZeros(T x) { 
+  ABSL_INTERNAL_ASSUME(x != 0); 
+  return countr_zero(x); 
 }
 
 // An abstraction over a bitmask. It provides an easy way to iterate through the
@@ -231,24 +231,24 @@ class BitMask {
   }
   explicit operator bool() const { return mask_ != 0; }
   int operator*() const { return LowestBitSet(); }
-  uint32_t LowestBitSet() const {
+  uint32_t LowestBitSet() const { 
     return container_internal::TrailingZeros(mask_) >> Shift;
   }
-  uint32_t HighestBitSet() const {
-    return static_cast<uint32_t>((bit_width(mask_) - 1) >> Shift);
+  uint32_t HighestBitSet() const { 
+    return static_cast<uint32_t>((bit_width(mask_) - 1) >> Shift); 
   }
 
   BitMask begin() const { return *this; }
   BitMask end() const { return BitMask(0); }
 
-  uint32_t TrailingZeros() const {
+  uint32_t TrailingZeros() const { 
     return container_internal::TrailingZeros(mask_) >> Shift;
   }
 
-  uint32_t LeadingZeros() const {
+  uint32_t LeadingZeros() const { 
     constexpr int total_significant_bits = SignificantBits << Shift;
     constexpr int extra_bits = sizeof(T) * 8 - total_significant_bits;
-    return countl_zero(mask_ << extra_bits) >> Shift;
+    return countl_zero(mask_ << extra_bits) >> Shift; 
   }
 
  private:
@@ -384,8 +384,8 @@ struct GroupSse2Impl {
   // Returns the number of trailing empty or deleted elements in the group.
   uint32_t CountLeadingEmptyOrDeleted() const {
     auto special = _mm_set1_epi8(static_cast<int8_t>(ctrl_t::kSentinel));
-    return TrailingZeros(static_cast<uint32_t>(
-        _mm_movemask_epi8(_mm_cmpgt_epi8_fixed(special, ctrl)) + 1));
+    return TrailingZeros(static_cast<uint32_t>( 
+        _mm_movemask_epi8(_mm_cmpgt_epi8_fixed(special, ctrl)) + 1)); 
   }
 
   void ConvertSpecialToEmptyAndFullToDeleted(ctrl_t* dst) const {
@@ -480,23 +480,23 @@ inline bool IsValidCapacity(size_t n) { return ((n + 1) & n) == 0 && n > 0; }
 //   DELETED -> EMPTY
 //   EMPTY -> EMPTY
 //   FULL -> DELETED
-void ConvertDeletedToEmptyAndFullToDeleted(ctrl_t* ctrl, size_t capacity);
+void ConvertDeletedToEmptyAndFullToDeleted(ctrl_t* ctrl, size_t capacity); 
 
 // Rounds up the capacity to the next power of 2 minus 1, with a minimum of 1.
 inline size_t NormalizeCapacity(size_t n) {
-  return n ? ~size_t{} >> countl_zero(n) : 1;
+  return n ? ~size_t{} >> countl_zero(n) : 1; 
 }
 
-// General notes on capacity/growth methods below:
-// - We use 7/8th as maximum load factor. For 16-wide groups, that gives an
-//   average of two empty slots per group.
-// - For (capacity+1) >= Group::kWidth, growth is 7/8*capacity.
-// - For (capacity+1) < Group::kWidth, growth == capacity. In this case, we
-//   never need to probe (the whole table fits in one group) so we don't need a
-//   load factor less than 1.
-
-// Given `capacity` of the table, returns the size (i.e. number of full slots)
-// at which we should grow the capacity.
+// General notes on capacity/growth methods below: 
+// - We use 7/8th as maximum load factor. For 16-wide groups, that gives an 
+//   average of two empty slots per group. 
+// - For (capacity+1) >= Group::kWidth, growth is 7/8*capacity. 
+// - For (capacity+1) < Group::kWidth, growth == capacity. In this case, we 
+//   never need to probe (the whole table fits in one group) so we don't need a 
+//   load factor less than 1. 
+ 
+// Given `capacity` of the table, returns the size (i.e. number of full slots) 
+// at which we should grow the capacity. 
 inline size_t CapacityToGrowth(size_t capacity) {
   assert(IsValidCapacity(capacity));
   // `capacity*7/8`
@@ -507,7 +507,7 @@ inline size_t CapacityToGrowth(size_t capacity) {
   return capacity - capacity / 8;
 }
 // From desired "growth" to a lowerbound of the necessary capacity.
-// Might not be a valid one and requires NormalizeCapacity().
+// Might not be a valid one and requires NormalizeCapacity(). 
 inline size_t GrowthToLowerboundCapacity(size_t growth) {
   // `growth*8/7`
   if (Group::kWidth == 8 && growth == 7) {
@@ -545,66 +545,66 @@ inline void AssertIsValid(ctrl_t* ctrl) {
                         "been erased, or the table might have rehashed.");
 }
 
-struct FindInfo {
-  size_t offset;
-  size_t probe_length;
-};
-
-// The representation of the object has two modes:
-//  - small: For capacities < kWidth-1
-//  - large: For the rest.
-//
-// Differences:
-//  - In small mode we are able to use the whole capacity. The extra control
-//  bytes give us at least one "empty" control byte to stop the iteration.
-//  This is important to make 1 a valid capacity.
-//
-//  - In small mode only the first `capacity()` control bytes after the
+struct FindInfo { 
+  size_t offset; 
+  size_t probe_length; 
+}; 
+ 
+// The representation of the object has two modes: 
+//  - small: For capacities < kWidth-1 
+//  - large: For the rest. 
+// 
+// Differences: 
+//  - In small mode we are able to use the whole capacity. The extra control 
+//  bytes give us at least one "empty" control byte to stop the iteration. 
+//  This is important to make 1 a valid capacity. 
+// 
+//  - In small mode only the first `capacity()` control bytes after the 
 //  sentinel are valid. The rest contain dummy ctrl_t::kEmpty values that do not
-//  represent a real slot. This is important to take into account on
-//  find_first_non_full(), where we never try ShouldInsertBackwards() for
-//  small tables.
-inline bool is_small(size_t capacity) { return capacity < Group::kWidth - 1; }
-
+//  represent a real slot. This is important to take into account on 
+//  find_first_non_full(), where we never try ShouldInsertBackwards() for 
+//  small tables. 
+inline bool is_small(size_t capacity) { return capacity < Group::kWidth - 1; } 
+ 
 inline probe_seq<Group::kWidth> probe(const ctrl_t* ctrl, size_t hash,
-                                      size_t capacity) {
-  return probe_seq<Group::kWidth>(H1(hash, ctrl), capacity);
-}
-
-// Probes the raw_hash_set with the probe sequence for hash and returns the
-// pointer to the first empty or deleted slot.
+                                      size_t capacity) { 
+  return probe_seq<Group::kWidth>(H1(hash, ctrl), capacity); 
+} 
+ 
+// Probes the raw_hash_set with the probe sequence for hash and returns the 
+// pointer to the first empty or deleted slot. 
 // NOTE: this function must work with tables having both ctrl_t::kEmpty and
 // ctrl_t::kDeleted in one group. Such tables appears during
 // drop_deletes_without_resize.
-//
-// This function is very useful when insertions happen and:
-// - the input is already a set
-// - there are enough slots
-// - the element with the hash is not in the table
+// 
+// This function is very useful when insertions happen and: 
+// - the input is already a set 
+// - there are enough slots 
+// - the element with the hash is not in the table 
 template <typename = void>
 inline FindInfo find_first_non_full(const ctrl_t* ctrl, size_t hash,
-                                    size_t capacity) {
-  auto seq = probe(ctrl, hash, capacity);
-  while (true) {
-    Group g{ctrl + seq.offset()};
-    auto mask = g.MatchEmptyOrDeleted();
-    if (mask) {
-#if !defined(NDEBUG)
-      // We want to add entropy even when ASLR is not enabled.
-      // In debug build we will randomly insert in either the front or back of
-      // the group.
-      // TODO(kfm,sbenza): revisit after we do unconditional mixing
-      if (!is_small(capacity) && ShouldInsertBackwards(hash, ctrl)) {
-        return {seq.offset(mask.HighestBitSet()), seq.index()};
-      }
-#endif
-      return {seq.offset(mask.LowestBitSet()), seq.index()};
-    }
-    seq.next();
+                                    size_t capacity) { 
+  auto seq = probe(ctrl, hash, capacity); 
+  while (true) { 
+    Group g{ctrl + seq.offset()}; 
+    auto mask = g.MatchEmptyOrDeleted(); 
+    if (mask) { 
+#if !defined(NDEBUG) 
+      // We want to add entropy even when ASLR is not enabled. 
+      // In debug build we will randomly insert in either the front or back of 
+      // the group. 
+      // TODO(kfm,sbenza): revisit after we do unconditional mixing 
+      if (!is_small(capacity) && ShouldInsertBackwards(hash, ctrl)) { 
+        return {seq.offset(mask.HighestBitSet()), seq.index()}; 
+      } 
+#endif 
+      return {seq.offset(mask.LowestBitSet()), seq.index()}; 
+    } 
+    seq.next(); 
     assert(seq.index() <= capacity && "full table!");
-  }
-}
-
+  } 
+} 
+ 
 // Extern template for inline function keep possibility of inlining.
 // When compiler decided to not inline, no symbols will be added to the
 // corresponding translation unit.
@@ -872,8 +872,8 @@ class raw_hash_set {
   explicit raw_hash_set(size_t bucket_count, const hasher& hash = hasher(),
                         const key_equal& eq = key_equal(),
                         const allocator_type& alloc = allocator_type())
-      : ctrl_(EmptyGroup()),
-        settings_(0, HashtablezInfoHandle(), hash, eq, alloc) {
+      : ctrl_(EmptyGroup()), 
+        settings_(0, HashtablezInfoHandle(), hash, eq, alloc) { 
     if (bucket_count) {
       capacity_ = NormalizeCapacity(bucket_count);
       initialize_slots();
@@ -982,11 +982,11 @@ class raw_hash_set {
     // than a full `insert`.
     for (const auto& v : that) {
       const size_t hash = PolicyTraits::apply(HashElement{hash_ref()}, v);
-      auto target = find_first_non_full(ctrl_, hash, capacity_);
+      auto target = find_first_non_full(ctrl_, hash, capacity_); 
       SetCtrl(target.offset, H2(hash), capacity_, ctrl_, slots_,
               sizeof(slot_type));
       emplace_at(target.offset, v);
-      infoz().RecordInsert(hash, target.probe_length);
+      infoz().RecordInsert(hash, target.probe_length); 
     }
     size_ = that.size();
     growth_left() -= that.size();
@@ -1003,24 +1003,24 @@ class raw_hash_set {
         // Hash, equality and allocator are copied instead of moved because
         // `that` must be left valid. If Hash is std::function<Key>, moving it
         // would create a nullptr functor that cannot be called.
-        settings_(absl::exchange(that.growth_left(), 0),
-                  absl::exchange(that.infoz(), HashtablezInfoHandle()),
-                  that.hash_ref(), that.eq_ref(), that.alloc_ref()) {}
+        settings_(absl::exchange(that.growth_left(), 0), 
+                  absl::exchange(that.infoz(), HashtablezInfoHandle()), 
+                  that.hash_ref(), that.eq_ref(), that.alloc_ref()) {} 
 
   raw_hash_set(raw_hash_set&& that, const allocator_type& a)
       : ctrl_(EmptyGroup()),
         slots_(nullptr),
         size_(0),
         capacity_(0),
-        settings_(0, HashtablezInfoHandle(), that.hash_ref(), that.eq_ref(),
-                  a) {
+        settings_(0, HashtablezInfoHandle(), that.hash_ref(), that.eq_ref(), 
+                  a) { 
     if (a == that.alloc_ref()) {
       std::swap(ctrl_, that.ctrl_);
       std::swap(slots_, that.slots_);
       std::swap(size_, that.size_);
       std::swap(capacity_, that.capacity_);
       std::swap(growth_left(), that.growth_left());
-      std::swap(infoz(), that.infoz());
+      std::swap(infoz(), that.infoz()); 
     } else {
       reserve(that.size());
       // Note: this will copy elements of dense_set and unordered_set instead of
@@ -1093,7 +1093,7 @@ class raw_hash_set {
       reset_growth_left();
     }
     assert(empty());
-    infoz().RecordStorageChanged(0, capacity_);
+    infoz().RecordStorageChanged(0, capacity_); 
   }
 
   // This overload kicks in when the argument is an rvalue of insertable and
@@ -1166,7 +1166,7 @@ class raw_hash_set {
 
   template <class InputIt>
   void insert(InputIt first, InputIt last) {
-    for (; first != last; ++first) emplace(*first);
+    for (; first != last; ++first) emplace(*first); 
   }
 
   template <class T, RequiresNotInit<T> = 0, RequiresInsertable<const T&> = 0>
@@ -1193,9 +1193,9 @@ class raw_hash_set {
   }
 
   iterator insert(const_iterator, node_type&& node) {
-    auto res = insert(std::move(node));
-    node = std::move(res.node);
-    return res.position;
+    auto res = insert(std::move(node)); 
+    node = std::move(res.node); 
+    return res.position; 
   }
 
   // This overload kicks in if we can deduce the key from args. This enables us
@@ -1385,7 +1385,7 @@ class raw_hash_set {
     swap(growth_left(), that.growth_left());
     swap(hash_ref(), that.hash_ref());
     swap(eq_ref(), that.eq_ref());
-    swap(infoz(), that.infoz());
+    swap(infoz(), that.infoz()); 
     SwapAlloc(alloc_ref(), that.alloc_ref(),
               typename AllocTraits::propagate_on_container_swap{});
   }
@@ -1394,7 +1394,7 @@ class raw_hash_set {
     if (n == 0 && capacity_ == 0) return;
     if (n == 0 && size_ == 0) {
       destroy_slots();
-      infoz().RecordStorageChanged(0, 0);
+      infoz().RecordStorageChanged(0, 0); 
       infoz().RecordClearedReservation();
       return;
     }
@@ -1412,16 +1412,16 @@ class raw_hash_set {
     }
   }
 
-  void reserve(size_t n) {
+  void reserve(size_t n) { 
     if (n > size() + growth_left()) {
       size_t m = GrowthToLowerboundCapacity(n);
-      resize(NormalizeCapacity(m));
+      resize(NormalizeCapacity(m)); 
 
       // This is after resize, to ensure that we have completed the allocation
       // and have potentially sampled the hashtable.
       infoz().RecordReservation(n);
-    }
-  }
+    } 
+  } 
 
   // Extension API: support for heterogeneous keys.
   //
@@ -1447,7 +1447,7 @@ class raw_hash_set {
     (void)key;
 #if defined(__GNUC__)
     prefetch_heap_block();
-    auto seq = probe(ctrl_, hash_ref()(key), capacity_);
+    auto seq = probe(ctrl_, hash_ref()(key), capacity_); 
     __builtin_prefetch(static_cast<const void*>(ctrl_ + seq.offset()));
     __builtin_prefetch(static_cast<const void*>(slots_ + seq.offset()));
 #endif  // __GNUC__
@@ -1462,7 +1462,7 @@ class raw_hash_set {
   // called heterogeneous key support.
   template <class K = key_type>
   iterator find(const key_arg<K>& key, size_t hash) {
-    auto seq = probe(ctrl_, hash, capacity_);
+    auto seq = probe(ctrl_, hash, capacity_); 
     while (true) {
       Group g{ctrl_ + seq.offset()};
       for (int i : g.Match(H2(hash))) {
@@ -1626,7 +1626,7 @@ class raw_hash_set {
     SetCtrl(index, was_never_full ? ctrl_t::kEmpty : ctrl_t::kDeleted,
             capacity_, ctrl_, slots_, sizeof(slot_type));
     growth_left() += was_never_full;
-    infoz().RecordErase();
+    infoz().RecordErase(); 
   }
 
   void initialize_slots() {
@@ -1654,7 +1654,7 @@ class raw_hash_set {
         mem + SlotOffset(capacity_, alignof(slot_type)));
     ResetCtrl(capacity_, ctrl_, slots_, sizeof(slot_type));
     reset_growth_left();
-    infoz().RecordStorageChanged(size_, capacity_);
+    infoz().RecordStorageChanged(size_, capacity_); 
   }
 
   void destroy_slots() {
@@ -1690,7 +1690,7 @@ class raw_hash_set {
       if (IsFull(old_ctrl[i])) {
         size_t hash = PolicyTraits::apply(HashElement{hash_ref()},
                                           PolicyTraits::element(old_slots + i));
-        auto target = find_first_non_full(ctrl_, hash, capacity_);
+        auto target = find_first_non_full(ctrl_, hash, capacity_); 
         size_t new_i = target.offset;
         total_probe_length += target.probe_length;
         SetCtrl(new_i, H2(hash), capacity_, ctrl_, slots_, sizeof(slot_type));
@@ -1704,12 +1704,12 @@ class raw_hash_set {
           &alloc_ref(), old_ctrl,
           AllocSize(old_capacity, sizeof(slot_type), alignof(slot_type)));
     }
-    infoz().RecordRehash(total_probe_length);
+    infoz().RecordRehash(total_probe_length); 
   }
 
   void drop_deletes_without_resize() ABSL_ATTRIBUTE_NOINLINE {
     assert(IsValidCapacity(capacity_));
-    assert(!is_small(capacity_));
+    assert(!is_small(capacity_)); 
     // Algorithm:
     // - mark all DELETED slots as EMPTY
     // - mark all FULL slots as DELETED
@@ -1770,7 +1770,7 @@ class raw_hash_set {
       }
     }
     reset_growth_left();
-    infoz().RecordRehash(total_probe_length);
+    infoz().RecordRehash(total_probe_length); 
   }
 
   void rehash_and_grow_if_necessary() {
@@ -1829,7 +1829,7 @@ class raw_hash_set {
 
   bool has_element(const value_type& elem) const {
     size_t hash = PolicyTraits::apply(HashElement{hash_ref()}, elem);
-    auto seq = probe(ctrl_, hash, capacity_);
+    auto seq = probe(ctrl_, hash, capacity_); 
     while (true) {
       Group g{ctrl_ + seq.offset()};
       for (int i : g.Match(H2(hash))) {
@@ -1861,7 +1861,7 @@ class raw_hash_set {
   std::pair<size_t, bool> find_or_prepare_insert(const K& key) {
     prefetch_heap_block();
     auto hash = hash_ref()(key);
-    auto seq = probe(ctrl_, hash, capacity_);
+    auto seq = probe(ctrl_, hash, capacity_); 
     while (true) {
       Group g{ctrl_ + seq.offset()};
       for (int i : g.Match(H2(hash))) {
@@ -1878,17 +1878,17 @@ class raw_hash_set {
   }
 
   size_t prepare_insert(size_t hash) ABSL_ATTRIBUTE_NOINLINE {
-    auto target = find_first_non_full(ctrl_, hash, capacity_);
+    auto target = find_first_non_full(ctrl_, hash, capacity_); 
     if (ABSL_PREDICT_FALSE(growth_left() == 0 &&
                            !IsDeleted(ctrl_[target.offset]))) {
       rehash_and_grow_if_necessary();
-      target = find_first_non_full(ctrl_, hash, capacity_);
+      target = find_first_non_full(ctrl_, hash, capacity_); 
     }
     ++size_;
     growth_left() -= IsEmpty(ctrl_[target.offset]);
     SetCtrl(target.offset, H2(hash), capacity_, ctrl_, slots_,
             sizeof(slot_type));
-    infoz().RecordInsert(hash, target.probe_length);
+    infoz().RecordInsert(hash, target.probe_length); 
     return target.offset;
   }
 
@@ -1931,15 +1931,15 @@ class raw_hash_set {
 #endif  // __GNUC__
   }
 
-  HashtablezInfoHandle& infoz() { return settings_.template get<1>(); }
+  HashtablezInfoHandle& infoz() { return settings_.template get<1>(); } 
 
-  hasher& hash_ref() { return settings_.template get<2>(); }
-  const hasher& hash_ref() const { return settings_.template get<2>(); }
-  key_equal& eq_ref() { return settings_.template get<3>(); }
-  const key_equal& eq_ref() const { return settings_.template get<3>(); }
-  allocator_type& alloc_ref() { return settings_.template get<4>(); }
+  hasher& hash_ref() { return settings_.template get<2>(); } 
+  const hasher& hash_ref() const { return settings_.template get<2>(); } 
+  key_equal& eq_ref() { return settings_.template get<3>(); } 
+  const key_equal& eq_ref() const { return settings_.template get<3>(); } 
+  allocator_type& alloc_ref() { return settings_.template get<4>(); } 
   const allocator_type& alloc_ref() const {
-    return settings_.template get<4>();
+    return settings_.template get<4>(); 
   }
 
   // TODO(alkis): Investigate removing some of these fields:
@@ -1949,11 +1949,11 @@ class raw_hash_set {
   slot_type* slots_ = nullptr;   // [capacity * slot_type]
   size_t size_ = 0;              // number of full slots
   size_t capacity_ = 0;          // total number of slots
-  absl::container_internal::CompressedTuple<size_t /* growth_left */,
-                                            HashtablezInfoHandle, hasher,
+  absl::container_internal::CompressedTuple<size_t /* growth_left */, 
+                                            HashtablezInfoHandle, hasher, 
                                             key_equal, allocator_type>
-      settings_{0, HashtablezInfoHandle{}, hasher{}, key_equal{},
-                allocator_type{}};
+      settings_{0, HashtablezInfoHandle{}, hasher{}, key_equal{}, 
+                allocator_type{}}; 
 };
 
 // Erases all elements that satisfy the predicate `pred` from the container `c`.
@@ -1978,7 +1978,7 @@ struct HashtableDebugAccess<Set, absl::void_t<typename Set::raw_hash_set>> {
                              const typename Set::key_type& key) {
     size_t num_probes = 0;
     size_t hash = set.hash_ref()(key);
-    auto seq = probe(set.ctrl_, hash, set.capacity_);
+    auto seq = probe(set.ctrl_, hash, set.capacity_); 
     while (true) {
       container_internal::Group g{set.ctrl_ + seq.offset()};
       for (int i : g.Match(container_internal::H2(hash))) {
diff --git a/contrib/restricted/abseil-cpp/absl/container/internal/raw_hash_set/ya.make b/contrib/restricted/abseil-cpp/absl/container/internal/raw_hash_set/ya.make
index 3fe7e7b5c0..28951c5549 100644
--- a/contrib/restricted/abseil-cpp/absl/container/internal/raw_hash_set/ya.make
+++ b/contrib/restricted/abseil-cpp/absl/container/internal/raw_hash_set/ya.make
@@ -1,29 +1,29 @@
-# 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/container/internal/absl_hashtablez_sampler
     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/hash
-    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_strings_internal
     contrib/restricted/abseil-cpp/absl/synchronization
     contrib/restricted/abseil-cpp/absl/synchronization/internal
@@ -31,25 +31,25 @@ PEERDIR(
     contrib/restricted/abseil-cpp/absl/time/civil_time
     contrib/restricted/abseil-cpp/absl/time/time_zone
     contrib/restricted/abseil-cpp/absl/types
-    contrib/restricted/abseil-cpp/absl/types/bad_optional_access
-)
-
-ADDINCL(
-    GLOBAL contrib/restricted/abseil-cpp
-)
-
-NO_COMPILER_WARNINGS()
-
-NO_UTIL()
-
-CFLAGS(
-    -DNOMINMAX
-)
-
+    contrib/restricted/abseil-cpp/absl/types/bad_optional_access 
+) 
+ 
+ADDINCL( 
+    GLOBAL contrib/restricted/abseil-cpp 
+) 
+ 
+NO_COMPILER_WARNINGS() 
+ 
+NO_UTIL() 
+ 
+CFLAGS( 
+    -DNOMINMAX 
+) 
+ 
 SRCDIR(contrib/restricted/abseil-cpp/absl/container/internal)
-
-SRCS(
+ 
+SRCS( 
     raw_hash_set.cc
-)
-
-END()
+) 
+ 
+END() 
diff --git a/contrib/restricted/abseil-cpp/absl/container/internal/unordered_map_constructor_test.h b/contrib/restricted/abseil-cpp/absl/container/internal/unordered_map_constructor_test.h
index c1d20f3c52..f1f7369ff3 100644
--- a/contrib/restricted/abseil-cpp/absl/container/internal/unordered_map_constructor_test.h
+++ b/contrib/restricted/abseil-cpp/absl/container/internal/unordered_map_constructor_test.h
@@ -16,7 +16,7 @@
 #define ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_CONSTRUCTOR_TEST_H_
 
 #include <algorithm>
-#include <unordered_map>
+#include <unordered_map> 
 #include <vector>
 
 #include "gmock/gmock.h"
diff --git a/contrib/restricted/abseil-cpp/absl/container/node_hash_set.h b/contrib/restricted/abseil-cpp/absl/container/node_hash_set.h
index 93b15f4681..707a583f2d 100644
--- a/contrib/restricted/abseil-cpp/absl/container/node_hash_set.h
+++ b/contrib/restricted/abseil-cpp/absl/container/node_hash_set.h
@@ -18,7 +18,7 @@
 //
 // An `absl::node_hash_set<T>` is an unordered associative container designed to
 // be a more efficient replacement for `std::unordered_set`. Like
-// `unordered_set`, search, insertion, and deletion of set elements can be done
+// `unordered_set`, search, insertion, and deletion of set elements can be done 
 // as an `O(1)` operation. However, `node_hash_set` (and other unordered
 // associative containers known as the collection of Abseil "Swiss tables")
 // contain other optimizations that result in both memory and computation
@@ -60,7 +60,7 @@ struct NodeHashSetPolicy;
 // following notable differences:
 //
 // * Supports heterogeneous lookup, through `find()`, `operator[]()` and
-//   `insert()`, provided that the set is provided a compatible heterogeneous
+//   `insert()`, provided that the set is provided a compatible heterogeneous 
 //   hashing function and equality operator.
 // * Contains a `capacity()` member function indicating the number of element
 //   slots (open, deleted, and empty) within the hash set.
@@ -76,13 +76,13 @@ struct NodeHashSetPolicy;
 // Example:
 //
 //   // Create a node hash set of three strings
-//   absl::node_hash_set<std::string> ducks =
+//   absl::node_hash_set<std::string> ducks = 
 //     {"huey", "dewey", "louie"};
 //
-//  // Insert a new element into the node hash set
-//  ducks.insert("donald");
+//  // Insert a new element into the node hash set 
+//  ducks.insert("donald"); 
 //
-//  // Force a rehash of the node hash set
+//  // Force a rehash of the node hash set 
 //  ducks.rehash(0);
 //
 //  // See if "dewey" is present
@@ -100,7 +100,7 @@ class node_hash_set
  public:
   // Constructors and Assignment Operators
   //
-  // A node_hash_set supports the same overload set as `std::unordered_set`
+  // A node_hash_set supports the same overload set as `std::unordered_set` 
   // for construction and assignment:
   //
   // *  Default constructor
@@ -167,7 +167,7 @@ class node_hash_set
   // available within the `node_hash_set`.
   //
   // NOTE: this member function is particular to `absl::node_hash_set` and is
-  // not provided in the `std::unordered_set` API.
+  // not provided in the `std::unordered_set` API. 
   using Base::capacity;
 
   // node_hash_set::empty()
@@ -208,7 +208,7 @@ class node_hash_set
   //   `void`.
   //
   //   NOTE: this return behavior is different than that of STL containers in
-  //   general and `std::unordered_set` in particular.
+  //   general and `std::unordered_set` in particular. 
   //
   // iterator erase(const_iterator first, const_iterator last):
   //
@@ -314,7 +314,7 @@ class node_hash_set
 
   // node_hash_set::merge()
   //
-  // Extracts elements from a given `source` node hash set into this
+  // Extracts elements from a given `source` node hash set into this 
   // `node_hash_set`. If the destination `node_hash_set` already contains an
   // element with an equivalent key, that element is not extracted.
   using Base::merge;
@@ -322,15 +322,15 @@ class node_hash_set
   // node_hash_set::swap(node_hash_set& other)
   //
   // Exchanges the contents of this `node_hash_set` with those of the `other`
-  // node hash set, avoiding invocation of any move, copy, or swap operations on
+  // node hash set, avoiding invocation of any move, copy, or swap operations on 
   // individual elements.
   //
   // All iterators and references on the `node_hash_set` remain valid, excepting
   // for the past-the-end iterator, which is invalidated.
   //
-  // `swap()` requires that the node hash set's hashing and key equivalence
+  // `swap()` requires that the node hash set's hashing and key equivalence 
   // functions be Swappable, and are exchaged using unqualified calls to
-  // non-member `swap()`. If the set's allocator has
+  // non-member `swap()`. If the set's allocator has 
   // `std::allocator_traits<allocator_type>::propagate_on_container_swap::value`
   // set to `true`, the allocators are also exchanged using an unqualified call
   // to non-member `swap()`; otherwise, the allocators are not swapped.
@@ -385,14 +385,14 @@ class node_hash_set
   // node_hash_set::bucket_count()
   //
   // Returns the number of "buckets" within the `node_hash_set`. Note that
-  // because a node hash set contains all elements within its internal storage,
+  // because a node hash set contains all elements within its internal storage, 
   // this value simply equals the current capacity of the `node_hash_set`.
   using Base::bucket_count;
 
   // node_hash_set::load_factor()
   //
   // Returns the current load factor of the `node_hash_set` (the average number
-  // of slots occupied with a value within the hash set).
+  // of slots occupied with a value within the hash set). 
   using Base::load_factor;
 
   // node_hash_set::max_load_factor()
diff --git a/contrib/restricted/abseil-cpp/absl/debugging/failure_signal_handler.cc b/contrib/restricted/abseil-cpp/absl/debugging/failure_signal_handler.cc
index 689e5979e7..9eece4ded2 100644
--- a/contrib/restricted/abseil-cpp/absl/debugging/failure_signal_handler.cc
+++ b/contrib/restricted/abseil-cpp/absl/debugging/failure_signal_handler.cc
@@ -21,7 +21,7 @@
 #ifdef _WIN32
 #include <windows.h>
 #else
-#include <sched.h>
+#include <sched.h> 
 #include <unistd.h>
 #endif
 
@@ -136,8 +136,8 @@ static bool SetupAlternateStackOnce() {
 #else
   const size_t page_mask = sysconf(_SC_PAGESIZE) - 1;
 #endif
-  size_t stack_size =
-      (std::max<size_t>(SIGSTKSZ, 65536) + page_mask) & ~page_mask;
+  size_t stack_size = 
+      (std::max<size_t>(SIGSTKSZ, 65536) + page_mask) & ~page_mask; 
 #if defined(ABSL_HAVE_ADDRESS_SANITIZER) || \
     defined(ABSL_HAVE_MEMORY_SANITIZER) || defined(ABSL_HAVE_THREAD_SANITIZER)
   // Account for sanitizer instrumentation requiring additional stack space.
@@ -221,24 +221,24 @@ static void WriteToStderr(const char* data) {
   absl::raw_logging_internal::SafeWriteToStderr(data, strlen(data));
 }
 
-static void WriteSignalMessage(int signo, int cpu,
-                               void (*writerfn)(const char*)) {
-  char buf[96];
-  char on_cpu[32] = {0};
-  if (cpu != -1) {
-    snprintf(on_cpu, sizeof(on_cpu), " on cpu %d", cpu);
-  }
+static void WriteSignalMessage(int signo, int cpu, 
+                               void (*writerfn)(const char*)) { 
+  char buf[96]; 
+  char on_cpu[32] = {0}; 
+  if (cpu != -1) { 
+    snprintf(on_cpu, sizeof(on_cpu), " on cpu %d", cpu); 
+  } 
   const char* const signal_string =
       debugging_internal::FailureSignalToString(signo);
   if (signal_string != nullptr && signal_string[0] != '\0') {
-    snprintf(buf, sizeof(buf), "*** %s received at time=%ld%s ***\n",
+    snprintf(buf, sizeof(buf), "*** %s received at time=%ld%s ***\n", 
              signal_string,
-             static_cast<long>(time(nullptr)),   // NOLINT(runtime/int)
-             on_cpu);
+             static_cast<long>(time(nullptr)),   // NOLINT(runtime/int) 
+             on_cpu); 
   } else {
-    snprintf(buf, sizeof(buf), "*** Signal %d received at time=%ld%s ***\n",
-             signo, static_cast<long>(time(nullptr)),  // NOLINT(runtime/int)
-             on_cpu);
+    snprintf(buf, sizeof(buf), "*** Signal %d received at time=%ld%s ***\n", 
+             signo, static_cast<long>(time(nullptr)),  // NOLINT(runtime/int) 
+             on_cpu); 
   }
   writerfn(buf);
 }
@@ -278,10 +278,10 @@ ABSL_ATTRIBUTE_NOINLINE static void WriteStackTrace(
 // Called by AbslFailureSignalHandler() to write the failure info. It is
 // called once with writerfn set to WriteToStderr() and then possibly
 // with writerfn set to the user provided function.
-static void WriteFailureInfo(int signo, void* ucontext, int cpu,
+static void WriteFailureInfo(int signo, void* ucontext, int cpu, 
                              void (*writerfn)(const char*)) {
   WriterFnStruct writerfn_struct{writerfn};
-  WriteSignalMessage(signo, cpu, writerfn);
+  WriteSignalMessage(signo, cpu, writerfn); 
   WriteStackTrace(ucontext, fsh_options.symbolize_stacktrace, WriterFnWrapper,
                   &writerfn_struct);
 }
@@ -343,14 +343,14 @@ static void AbslFailureSignalHandler(int signo, siginfo_t*, void* ucontext) {
     }
   }
 
-  // Increase the chance that the CPU we report was the same CPU on which the
-  // signal was received by doing this as early as possible, i.e. after
-  // verifying that this is not a recursive signal handler invocation.
-  int my_cpu = -1;
-#ifdef ABSL_HAVE_SCHED_GETCPU
-  my_cpu = sched_getcpu();
-#endif
-
+  // Increase the chance that the CPU we report was the same CPU on which the 
+  // signal was received by doing this as early as possible, i.e. after 
+  // verifying that this is not a recursive signal handler invocation. 
+  int my_cpu = -1; 
+#ifdef ABSL_HAVE_SCHED_GETCPU 
+  my_cpu = sched_getcpu(); 
+#endif 
+ 
 #ifdef ABSL_HAVE_ALARM
   // Set an alarm to abort the program in case this code hangs or deadlocks.
   if (fsh_options.alarm_on_failure_secs > 0) {
@@ -361,12 +361,12 @@ static void AbslFailureSignalHandler(int signo, siginfo_t*, void* ucontext) {
 #endif
 
   // First write to stderr.
-  WriteFailureInfo(signo, ucontext, my_cpu, WriteToStderr);
+  WriteFailureInfo(signo, ucontext, my_cpu, WriteToStderr); 
 
   // Riskier code (because it is less likely to be async-signal-safe)
   // goes after this point.
   if (fsh_options.writerfn != nullptr) {
-    WriteFailureInfo(signo, ucontext, my_cpu, fsh_options.writerfn);
+    WriteFailureInfo(signo, ucontext, my_cpu, fsh_options.writerfn); 
     fsh_options.writerfn(nullptr);
   }
 
diff --git a/contrib/restricted/abseil-cpp/absl/debugging/failure_signal_handler/ya.make b/contrib/restricted/abseil-cpp/absl/debugging/failure_signal_handler/ya.make
index 62217bae8f..6f214ff9a7 100644
--- a/contrib/restricted/abseil-cpp/absl/debugging/failure_signal_handler/ya.make
+++ b/contrib/restricted/abseil-cpp/absl/debugging/failure_signal_handler/ya.make
@@ -1,46 +1,46 @@
-# 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/internal
     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
-)
-
-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/debugging)
-
-SRCS(
+ 
+SRCS( 
     failure_signal_handler.cc
-)
-
-END()
+) 
+ 
+END() 
diff --git a/contrib/restricted/abseil-cpp/absl/debugging/internal/address_is_readable.cc b/contrib/restricted/abseil-cpp/absl/debugging/internal/address_is_readable.cc
index 329c285f3b..e4289ee15f 100644
--- a/contrib/restricted/abseil-cpp/absl/debugging/internal/address_is_readable.cc
+++ b/contrib/restricted/abseil-cpp/absl/debugging/internal/address_is_readable.cc
@@ -68,7 +68,7 @@ static void Unpack(uint64_t x, int *pid, int *read_fd, int *write_fd) {
 // unimplemented.
 // This is a namespace-scoped variable for correct zero-initialization.
 static std::atomic<uint64_t> pid_and_fds;  // initially 0, an invalid pid.
-
+ 
 bool AddressIsReadable(const void *addr) {
   absl::base_internal::ErrnoSaver errno_saver;
   // We test whether a byte is readable by using write().  Normally, this would
@@ -87,7 +87,7 @@ bool AddressIsReadable(const void *addr) {
     int pid;
     int read_fd;
     int write_fd;
-    uint64_t local_pid_and_fds = pid_and_fds.load(std::memory_order_acquire);
+    uint64_t local_pid_and_fds = pid_and_fds.load(std::memory_order_acquire); 
     Unpack(local_pid_and_fds, &pid, &read_fd, &write_fd);
     while (current_pid != pid) {
       int p[2];
@@ -99,13 +99,13 @@ bool AddressIsReadable(const void *addr) {
       fcntl(p[1], F_SETFD, FD_CLOEXEC);
       uint64_t new_pid_and_fds = Pack(current_pid, p[0], p[1]);
       if (pid_and_fds.compare_exchange_strong(
-              local_pid_and_fds, new_pid_and_fds, std::memory_order_release,
+              local_pid_and_fds, new_pid_and_fds, std::memory_order_release, 
               std::memory_order_relaxed)) {
         local_pid_and_fds = new_pid_and_fds;  // fds exposed to other threads
       } else {  // fds not exposed to other threads; we can close them.
         close(p[0]);
         close(p[1]);
-        local_pid_and_fds = pid_and_fds.load(std::memory_order_acquire);
+        local_pid_and_fds = pid_and_fds.load(std::memory_order_acquire); 
       }
       Unpack(local_pid_and_fds, &pid, &read_fd, &write_fd);
     }
@@ -125,7 +125,7 @@ bool AddressIsReadable(const void *addr) {
       // If pid_and_fds contains the problematic file descriptors we just used,
       // this call will forget them, and the loop will try again.
       pid_and_fds.compare_exchange_strong(local_pid_and_fds, 0,
-                                          std::memory_order_release,
+                                          std::memory_order_release, 
                                           std::memory_order_relaxed);
     }
   } while (errno == EBADF);
diff --git a/contrib/restricted/abseil-cpp/absl/debugging/internal/demangle.cc b/contrib/restricted/abseil-cpp/absl/debugging/internal/demangle.cc
index 93ae32796c..a5b37f3199 100644
--- a/contrib/restricted/abseil-cpp/absl/debugging/internal/demangle.cc
+++ b/contrib/restricted/abseil-cpp/absl/debugging/internal/demangle.cc
@@ -386,27 +386,27 @@ static bool IsDigit(char c) { return c >= '0' && c <= '9'; }
 // by GCC 4.5.x and later versions (and our locally-modified version of GCC
 // 4.4.x) to indicate functions which have been cloned during optimization.
 // We treat any sequence (.<alpha>+.<digit>+)+ as a function clone suffix.
-// Additionally, '_' is allowed along with the alphanumeric sequence.
+// Additionally, '_' is allowed along with the alphanumeric sequence. 
 static bool IsFunctionCloneSuffix(const char *str) {
   size_t i = 0;
   while (str[i] != '\0') {
-    bool parsed = false;
-    // Consume a single [.<alpha> | _]*[.<digit>]* sequence.
-    if (str[i] == '.' && (IsAlpha(str[i + 1]) || str[i + 1] == '_')) {
-      parsed = true;
-      i += 2;
-      while (IsAlpha(str[i]) || str[i] == '_') {
-        ++i;
-      }
+    bool parsed = false; 
+    // Consume a single [.<alpha> | _]*[.<digit>]* sequence. 
+    if (str[i] == '.' && (IsAlpha(str[i + 1]) || str[i + 1] == '_')) { 
+      parsed = true; 
+      i += 2; 
+      while (IsAlpha(str[i]) || str[i] == '_') { 
+        ++i; 
+      } 
     }
-    if (str[i] == '.' && IsDigit(str[i + 1])) {
-      parsed = true;
-      i += 2;
-      while (IsDigit(str[i])) {
-        ++i;
-      }
+    if (str[i] == '.' && IsDigit(str[i + 1])) { 
+      parsed = true; 
+      i += 2; 
+      while (IsDigit(str[i])) { 
+        ++i; 
+      } 
     }
-    if (!parsed)
+    if (!parsed) 
       return false;
   }
   return true;  // Consumed everything in "str".
diff --git a/contrib/restricted/abseil-cpp/absl/debugging/internal/examine_stack.cc b/contrib/restricted/abseil-cpp/absl/debugging/internal/examine_stack.cc
index 589a3ef367..a6bbf1405a 100644
--- a/contrib/restricted/abseil-cpp/absl/debugging/internal/examine_stack.cc
+++ b/contrib/restricted/abseil-cpp/absl/debugging/internal/examine_stack.cc
@@ -46,42 +46,42 @@ void* GetProgramCounter(void* vuc) {
     ucontext_t* context = reinterpret_cast<ucontext_t*>(vuc);
 #if defined(__aarch64__)
     return reinterpret_cast<void*>(context->uc_mcontext.pc);
-#elif defined(__alpha__)
-    return reinterpret_cast<void*>(context->uc_mcontext.sc_pc);
+#elif defined(__alpha__) 
+    return reinterpret_cast<void*>(context->uc_mcontext.sc_pc); 
 #elif defined(__arm__)
     return reinterpret_cast<void*>(context->uc_mcontext.arm_pc);
-#elif defined(__hppa__)
-    return reinterpret_cast<void*>(context->uc_mcontext.sc_iaoq[0]);
+#elif defined(__hppa__) 
+    return reinterpret_cast<void*>(context->uc_mcontext.sc_iaoq[0]); 
 #elif defined(__i386__)
     if (14 < ABSL_ARRAYSIZE(context->uc_mcontext.gregs))
       return reinterpret_cast<void*>(context->uc_mcontext.gregs[14]);
-#elif defined(__ia64__)
-    return reinterpret_cast<void*>(context->uc_mcontext.sc_ip);
-#elif defined(__m68k__)
-    return reinterpret_cast<void*>(context->uc_mcontext.gregs[16]);
+#elif defined(__ia64__) 
+    return reinterpret_cast<void*>(context->uc_mcontext.sc_ip); 
+#elif defined(__m68k__) 
+    return reinterpret_cast<void*>(context->uc_mcontext.gregs[16]); 
 #elif defined(__mips__)
     return reinterpret_cast<void*>(context->uc_mcontext.pc);
 #elif defined(__powerpc64__)
     return reinterpret_cast<void*>(context->uc_mcontext.gp_regs[32]);
 #elif defined(__powerpc__)
-    return reinterpret_cast<void*>(context->uc_mcontext.uc_regs->gregs[32]);
+    return reinterpret_cast<void*>(context->uc_mcontext.uc_regs->gregs[32]); 
 #elif defined(__riscv)
     return reinterpret_cast<void*>(context->uc_mcontext.__gregs[REG_PC]);
 #elif defined(__s390__) && !defined(__s390x__)
     return reinterpret_cast<void*>(context->uc_mcontext.psw.addr & 0x7fffffff);
 #elif defined(__s390__) && defined(__s390x__)
     return reinterpret_cast<void*>(context->uc_mcontext.psw.addr);
-#elif defined(__sh__)
-    return reinterpret_cast<void*>(context->uc_mcontext.pc);
-#elif defined(__sparc__) && !defined(__arch64__)
-    return reinterpret_cast<void*>(context->uc_mcontext.gregs[19]);
-#elif defined(__sparc__) && defined(__arch64__)
-    return reinterpret_cast<void*>(context->uc_mcontext.mc_gregs[19]);
+#elif defined(__sh__) 
+    return reinterpret_cast<void*>(context->uc_mcontext.pc); 
+#elif defined(__sparc__) && !defined(__arch64__) 
+    return reinterpret_cast<void*>(context->uc_mcontext.gregs[19]); 
+#elif defined(__sparc__) && defined(__arch64__) 
+    return reinterpret_cast<void*>(context->uc_mcontext.mc_gregs[19]); 
 #elif defined(__x86_64__)
     if (16 < ABSL_ARRAYSIZE(context->uc_mcontext.gregs))
       return reinterpret_cast<void*>(context->uc_mcontext.gregs[16]);
-#elif defined(__e2k__)
-    return reinterpret_cast<void*>(context->uc_mcontext.cr0_hi);
+#elif defined(__e2k__) 
+    return reinterpret_cast<void*>(context->uc_mcontext.cr0_hi); 
 #else
 #error "Undefined Architecture."
 #endif
diff --git a/contrib/restricted/abseil-cpp/absl/debugging/internal/stacktrace_aarch64-inl.inc b/contrib/restricted/abseil-cpp/absl/debugging/internal/stacktrace_aarch64-inl.inc
index f4859d7c21..48689e2949 100644
--- a/contrib/restricted/abseil-cpp/absl/debugging/internal/stacktrace_aarch64-inl.inc
+++ b/contrib/restricted/abseil-cpp/absl/debugging/internal/stacktrace_aarch64-inl.inc
@@ -37,11 +37,11 @@ static const unsigned char* GetKernelRtSigreturnAddress() {
   absl::debugging_internal::VDSOSupport vdso;
   if (vdso.IsPresent()) {
     absl::debugging_internal::VDSOSupport::SymbolInfo symbol_info;
-    auto lookup = [&](int type) {
-      return vdso.LookupSymbol("__kernel_rt_sigreturn", "LINUX_2.6.39", type,
-                               &symbol_info);
-    };
-    if ((!lookup(STT_FUNC) && !lookup(STT_NOTYPE)) ||
+    auto lookup = [&](int type) { 
+      return vdso.LookupSymbol("__kernel_rt_sigreturn", "LINUX_2.6.39", type, 
+                               &symbol_info); 
+    }; 
+    if ((!lookup(STT_FUNC) && !lookup(STT_NOTYPE)) || 
         symbol_info.address == nullptr) {
       // Unexpected: VDSO is present, yet the expected symbol is missing
       // or null.
diff --git a/contrib/restricted/abseil-cpp/absl/debugging/internal/stacktrace_config.h b/contrib/restricted/abseil-cpp/absl/debugging/internal/stacktrace_config.h
index ff21b719a0..5679ae462e 100644
--- a/contrib/restricted/abseil-cpp/absl/debugging/internal/stacktrace_config.h
+++ b/contrib/restricted/abseil-cpp/absl/debugging/internal/stacktrace_config.h
@@ -21,8 +21,8 @@
 #ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_CONFIG_H_
 #define ABSL_DEBUGGING_INTERNAL_STACKTRACE_CONFIG_H_
 
-#include "absl/base/config.h"
-
+#include "absl/base/config.h" 
+ 
 #if defined(ABSL_STACKTRACE_INL_HEADER)
 #error ABSL_STACKTRACE_INL_HEADER cannot be directly set
 
@@ -31,7 +31,7 @@
     "absl/debugging/internal/stacktrace_win32-inl.inc"
 
 #elif defined(__APPLE__)
-#ifdef ABSL_HAVE_THREAD_LOCAL
+#ifdef ABSL_HAVE_THREAD_LOCAL 
 // Thread local support required for UnwindImpl.
 #define ABSL_STACKTRACE_INL_HEADER \
   "absl/debugging/internal/stacktrace_generic-inl.inc"
diff --git a/contrib/restricted/abseil-cpp/absl/debugging/internal/stacktrace_powerpc-inl.inc b/contrib/restricted/abseil-cpp/absl/debugging/internal/stacktrace_powerpc-inl.inc
index cf8c05160c..bf82026c7f 100644
--- a/contrib/restricted/abseil-cpp/absl/debugging/internal/stacktrace_powerpc-inl.inc
+++ b/contrib/restricted/abseil-cpp/absl/debugging/internal/stacktrace_powerpc-inl.inc
@@ -131,12 +131,12 @@ static void **NextStackFrame(void **old_sp, const void *uc) {
       const ucontext_t* signal_context =
           reinterpret_cast<const ucontext_t*>(uc);
       void **const sp_before_signal =
-#if defined(__PPC64__)
-          reinterpret_cast<void **>(signal_context->uc_mcontext.gp_regs[PT_R1]);
-#else
-          reinterpret_cast<void **>(
-              signal_context->uc_mcontext.uc_regs->gregs[PT_R1]);
-#endif
+#if defined(__PPC64__) 
+          reinterpret_cast<void **>(signal_context->uc_mcontext.gp_regs[PT_R1]); 
+#else 
+          reinterpret_cast<void **>( 
+              signal_context->uc_mcontext.uc_regs->gregs[PT_R1]); 
+#endif 
       // Check that alleged sp before signal is nonnull and is reasonably
       // aligned.
       if (sp_before_signal != nullptr &&
diff --git a/contrib/restricted/abseil-cpp/absl/debugging/leak_check.cc b/contrib/restricted/abseil-cpp/absl/debugging/leak_check.cc
index 764ca0ad00..771b79aec6 100644
--- a/contrib/restricted/abseil-cpp/absl/debugging/leak_check.cc
+++ b/contrib/restricted/abseil-cpp/absl/debugging/leak_check.cc
@@ -16,7 +16,7 @@
 // When lsan is not linked in, these functions are not available,
 // therefore Abseil code which depends on these functions is conditioned on the
 // definition of LEAK_SANITIZER.
-#include "absl/base/attributes.h"
+#include "absl/base/attributes.h" 
 #include "absl/debugging/leak_check.h"
 
 #ifndef LEAK_SANITIZER
@@ -24,7 +24,7 @@
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 bool HaveLeakSanitizer() { return false; }
-bool LeakCheckerIsActive() { return false; }
+bool LeakCheckerIsActive() { return false; } 
 void DoIgnoreLeak(const void*) { }
 void RegisterLivePointers(const void*, size_t) { }
 void UnRegisterLivePointers(const void*, size_t) { }
@@ -37,23 +37,23 @@ ABSL_NAMESPACE_END
 
 #include <sanitizer/lsan_interface.h>
 
-#if ABSL_HAVE_ATTRIBUTE_WEAK
-extern "C" ABSL_ATTRIBUTE_WEAK int __lsan_is_turned_off();
-#endif
-
+#if ABSL_HAVE_ATTRIBUTE_WEAK 
+extern "C" ABSL_ATTRIBUTE_WEAK int __lsan_is_turned_off(); 
+#endif 
+ 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 bool HaveLeakSanitizer() { return true; }
-
-#if ABSL_HAVE_ATTRIBUTE_WEAK
-bool LeakCheckerIsActive() {
-  return !(&__lsan_is_turned_off && __lsan_is_turned_off());
-}
-#else
-bool LeakCheckerIsActive() { return true; }
-#endif
-
-bool FindAndReportLeaks() { return __lsan_do_recoverable_leak_check(); }
+ 
+#if ABSL_HAVE_ATTRIBUTE_WEAK 
+bool LeakCheckerIsActive() { 
+  return !(&__lsan_is_turned_off && __lsan_is_turned_off()); 
+} 
+#else 
+bool LeakCheckerIsActive() { return true; } 
+#endif 
+ 
+bool FindAndReportLeaks() { return __lsan_do_recoverable_leak_check(); } 
 void DoIgnoreLeak(const void* ptr) { __lsan_ignore_object(ptr); }
 void RegisterLivePointers(const void* ptr, size_t size) {
   __lsan_register_root_region(ptr, size);
diff --git a/contrib/restricted/abseil-cpp/absl/debugging/leak_check.h b/contrib/restricted/abseil-cpp/absl/debugging/leak_check.h
index 5fc2b052e4..a177a37aec 100644
--- a/contrib/restricted/abseil-cpp/absl/debugging/leak_check.h
+++ b/contrib/restricted/abseil-cpp/absl/debugging/leak_check.h
@@ -43,12 +43,12 @@ ABSL_NAMESPACE_BEGIN
 // currently built into this target.
 bool HaveLeakSanitizer();
 
-// LeakCheckerIsActive()
-//
-// Returns true if a leak-checking sanitizer (either ASan or standalone LSan) is
-// currently built into this target and is turned on.
-bool LeakCheckerIsActive();
-
+// LeakCheckerIsActive() 
+// 
+// Returns true if a leak-checking sanitizer (either ASan or standalone LSan) is 
+// currently built into this target and is turned on. 
+bool LeakCheckerIsActive(); 
+ 
 // DoIgnoreLeak()
 //
 // Implements `IgnoreLeak()` below. This function should usually
@@ -68,8 +68,8 @@ void DoIgnoreLeak(const void* ptr);
 //
 // If the passed `ptr` does not point to an actively allocated object at the
 // time `IgnoreLeak()` is called, the call is a no-op; if it is actively
-// allocated, leak sanitizer will assume this object is referenced even if
-// there is no actual reference in user memory.
+// allocated, leak sanitizer will assume this object is referenced even if 
+// there is no actual reference in user memory. 
 //
 template <typename T>
 T* IgnoreLeak(T* ptr) {
@@ -77,19 +77,19 @@ T* IgnoreLeak(T* ptr) {
   return ptr;
 }
 
-// FindAndReportLeaks()
-//
-// If any leaks are detected, prints a leak report and returns true.  This
-// function may be called repeatedly, and does not affect end-of-process leak
-// checking.
-//
-// Example:
-// if (FindAndReportLeaks()) {
-//   ... diagnostic already printed. Exit with failure code.
-//   exit(1)
-// }
-bool FindAndReportLeaks();
-
+// FindAndReportLeaks() 
+// 
+// If any leaks are detected, prints a leak report and returns true.  This 
+// function may be called repeatedly, and does not affect end-of-process leak 
+// checking. 
+// 
+// Example: 
+// if (FindAndReportLeaks()) { 
+//   ... diagnostic already printed. Exit with failure code. 
+//   exit(1) 
+// } 
+bool FindAndReportLeaks(); 
+ 
 // LeakCheckDisabler
 //
 // This helper class indicates that any heap allocations done in the code block
diff --git a/contrib/restricted/abseil-cpp/absl/debugging/symbolize/ya.make b/contrib/restricted/abseil-cpp/absl/debugging/symbolize/ya.make
index 5c25223100..4ca1eae5c9 100644
--- a/contrib/restricted/abseil-cpp/absl/debugging/symbolize/ya.make
+++ b/contrib/restricted/abseil-cpp/absl/debugging/symbolize/ya.make
@@ -1,43 +1,43 @@
-# 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/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
-)
-
-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/debugging)
-
-SRCS(
+ 
+SRCS( 
     symbolize.cc
-)
-
-END()
+) 
+ 
+END() 
diff --git a/contrib/restricted/abseil-cpp/absl/debugging/symbolize_elf.inc b/contrib/restricted/abseil-cpp/absl/debugging/symbolize_elf.inc
index 3ff343d64f..7c88a58e4d 100644
--- a/contrib/restricted/abseil-cpp/absl/debugging/symbolize_elf.inc
+++ b/contrib/restricted/abseil-cpp/absl/debugging/symbolize_elf.inc
@@ -1295,7 +1295,7 @@ static bool MaybeInitializeObjFile(ObjFile *obj) {
     const int phnum = obj->elf_header.e_phnum;
     const int phentsize = obj->elf_header.e_phentsize;
     size_t phoff = obj->elf_header.e_phoff;
-    size_t num_executable_load_segments = 0;
+    size_t num_executable_load_segments = 0; 
     for (int j = 0; j < phnum; j++) {
       ElfW(Phdr) phdr;
       if (!ReadFromOffsetExact(obj->fd, &phdr, sizeof(phdr), phoff)) {
@@ -1356,7 +1356,7 @@ const char *Symbolizer::GetSymbol(const void *const pc) {
         // Note: some binaries have multiple "rx" LOAD segments. We must
         // find the right one.
         ElfW(Phdr) *phdr = nullptr;
-        for (size_t j = 0; j < obj->phdr.size(); j++) {
+        for (size_t j = 0; j < obj->phdr.size(); j++) { 
           ElfW(Phdr) &p = obj->phdr[j];
           if (p.p_type != PT_LOAD) {
             // We only expect PT_LOADs. This must be PT_NULL that we didn't
diff --git a/contrib/restricted/abseil-cpp/absl/flags/commandlineflag/ya.make b/contrib/restricted/abseil-cpp/absl/flags/commandlineflag/ya.make
index 4eef7c0237..71191a2d72 100644
--- a/contrib/restricted/abseil-cpp/absl/flags/commandlineflag/ya.make
+++ b/contrib/restricted/abseil-cpp/absl/flags/commandlineflag/ya.make
@@ -1,42 +1,42 @@
-# 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
-    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
+OWNER(g:cpp-contrib) 
+ 
+LICENSE(Apache-2.0) 
+ 
+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/flags/internal/commandlineflag
-    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/types/bad_optional_access
-)
-
-ADDINCL(
-    GLOBAL contrib/restricted/abseil-cpp
-)
-
-NO_COMPILER_WARNINGS()
-
-NO_UTIL()
-
-CFLAGS(
-    -DNOMINMAX
-)
-
+    contrib/restricted/abseil-cpp/absl/types/bad_optional_access 
+) 
+ 
+ADDINCL( 
+    GLOBAL contrib/restricted/abseil-cpp 
+) 
+ 
+NO_COMPILER_WARNINGS() 
+ 
+NO_UTIL() 
+ 
+CFLAGS( 
+    -DNOMINMAX 
+) 
+ 
 SRCDIR(contrib/restricted/abseil-cpp/absl/flags)
-
-SRCS(
+ 
+SRCS( 
     commandlineflag.cc
-)
-
-END()
+) 
+ 
+END() 
diff --git a/contrib/restricted/abseil-cpp/absl/flags/flag.h b/contrib/restricted/abseil-cpp/absl/flags/flag.h
index a724ccc97d..64f6013d20 100644
--- a/contrib/restricted/abseil-cpp/absl/flags/flag.h
+++ b/contrib/restricted/abseil-cpp/absl/flags/flag.h
@@ -208,15 +208,15 @@ ABSL_NAMESPACE_END
 #if ABSL_FLAGS_STRIP_NAMES
 #define ABSL_FLAG_IMPL_FLAGNAME(txt) ""
 #define ABSL_FLAG_IMPL_FILENAME() ""
-#define ABSL_FLAG_IMPL_REGISTRAR(T, flag)                                      \
-  absl::flags_internal::FlagRegistrar<T, false>(ABSL_FLAG_IMPL_FLAG_PTR(flag), \
-                                                nullptr)
+#define ABSL_FLAG_IMPL_REGISTRAR(T, flag)                                      \ 
+  absl::flags_internal::FlagRegistrar<T, false>(ABSL_FLAG_IMPL_FLAG_PTR(flag), \ 
+                                                nullptr) 
 #else
 #define ABSL_FLAG_IMPL_FLAGNAME(txt) txt
 #define ABSL_FLAG_IMPL_FILENAME() __FILE__
-#define ABSL_FLAG_IMPL_REGISTRAR(T, flag)                                     \
-  absl::flags_internal::FlagRegistrar<T, true>(ABSL_FLAG_IMPL_FLAG_PTR(flag), \
-                                               __FILE__)
+#define ABSL_FLAG_IMPL_REGISTRAR(T, flag)                                     \ 
+  absl::flags_internal::FlagRegistrar<T, true>(ABSL_FLAG_IMPL_FLAG_PTR(flag), \ 
+                                               __FILE__) 
 #endif
 
 // ABSL_FLAG_IMPL macro definition conditional on ABSL_FLAGS_STRIP_HELP
diff --git a/contrib/restricted/abseil-cpp/absl/flags/internal/commandlineflag.h b/contrib/restricted/abseil-cpp/absl/flags/internal/commandlineflag.h
index ebfe81ba1e..ddb0e9cd00 100644
--- a/contrib/restricted/abseil-cpp/absl/flags/internal/commandlineflag.h
+++ b/contrib/restricted/abseil-cpp/absl/flags/internal/commandlineflag.h
@@ -24,7 +24,7 @@ ABSL_NAMESPACE_BEGIN
 namespace flags_internal {
 
 // An alias for flag fast type id. This value identifies the flag value type
-// similarly to typeid(T), without relying on RTTI being available. In most
+// similarly to typeid(T), without relying on RTTI being available. In most 
 // cases this id is enough to uniquely identify the flag's value type. In a few
 // cases we'll have to resort to using actual RTTI implementation if it is
 // available.
diff --git a/contrib/restricted/abseil-cpp/absl/flags/internal/flag.cc b/contrib/restricted/abseil-cpp/absl/flags/internal/flag.cc
index 1515022d11..20e1e8cd71 100644
--- a/contrib/restricted/abseil-cpp/absl/flags/internal/flag.cc
+++ b/contrib/restricted/abseil-cpp/absl/flags/internal/flag.cc
@@ -96,8 +96,8 @@ class FlagState : public flags_internal::FlagStateInterface {
         counter_(counter) {}
 
   ~FlagState() override {
-    if (flag_impl_.ValueStorageKind() != FlagValueStorageKind::kAlignedBuffer &&
-        flag_impl_.ValueStorageKind() != FlagValueStorageKind::kSequenceLocked)
+    if (flag_impl_.ValueStorageKind() != FlagValueStorageKind::kAlignedBuffer && 
+        flag_impl_.ValueStorageKind() != FlagValueStorageKind::kSequenceLocked) 
       return;
     flags_internal::Delete(flag_impl_.op_, value_.heap_allocated);
   }
@@ -164,11 +164,11 @@ void FlagImpl::Init() {
                            std::memory_order_release);
       break;
     }
-    case FlagValueStorageKind::kSequenceLocked: {
+    case FlagValueStorageKind::kSequenceLocked: { 
       // For this storage kind the default_value_ always points to gen_func
       // during initialization.
       assert(def_kind == FlagDefaultKind::kGenFunc);
-      (*default_value_.gen_func)(AtomicBufferValue());
+      (*default_value_.gen_func)(AtomicBufferValue()); 
       break;
     }
     case FlagValueStorageKind::kAlignedBuffer:
@@ -178,7 +178,7 @@ void FlagImpl::Init() {
       (*default_value_.gen_func)(AlignedBufferValue());
       break;
   }
-  seq_lock_.MarkInitialized();
+  seq_lock_.MarkInitialized(); 
 }
 
 absl::Mutex* FlagImpl::DataGuard() const {
@@ -239,11 +239,11 @@ void FlagImpl::StoreValue(const void* src) {
       int64_t one_word_val = OneWordValue().load(std::memory_order_acquire);
       std::memcpy(&one_word_val, src, Sizeof(op_));
       OneWordValue().store(one_word_val, std::memory_order_release);
-      seq_lock_.IncrementModificationCount();
+      seq_lock_.IncrementModificationCount(); 
       break;
     }
-    case FlagValueStorageKind::kSequenceLocked: {
-      seq_lock_.Write(AtomicBufferValue(), src, Sizeof(op_));
+    case FlagValueStorageKind::kSequenceLocked: { 
+      seq_lock_.Write(AtomicBufferValue(), src, Sizeof(op_)); 
       break;
     }
     case FlagValueStorageKind::kAlignedBuffer:
@@ -270,10 +270,10 @@ FlagFastTypeId FlagImpl::TypeId() const {
   return flags_internal::FastTypeId(op_);
 }
 
-int64_t FlagImpl::ModificationCount() const {
-  return seq_lock_.ModificationCount();
-}
-
+int64_t FlagImpl::ModificationCount() const { 
+  return seq_lock_.ModificationCount(); 
+} 
+ 
 bool FlagImpl::IsSpecifiedOnCommandLine() const {
   absl::MutexLock l(DataGuard());
   return on_command_line_;
@@ -296,11 +296,11 @@ std::string FlagImpl::CurrentValue() const {
               OneWordValue().load(std::memory_order_acquire));
       return flags_internal::Unparse(op_, one_word_val.data());
     }
-    case FlagValueStorageKind::kSequenceLocked: {
-      std::unique_ptr<void, DynValueDeleter> cloned(flags_internal::Alloc(op_),
-                                                    DynValueDeleter{op_});
-      ReadSequenceLockedData(cloned.get());
-      return flags_internal::Unparse(op_, cloned.get());
+    case FlagValueStorageKind::kSequenceLocked: { 
+      std::unique_ptr<void, DynValueDeleter> cloned(flags_internal::Alloc(op_), 
+                                                    DynValueDeleter{op_}); 
+      ReadSequenceLockedData(cloned.get()); 
+      return flags_internal::Unparse(op_, cloned.get()); 
     }
     case FlagValueStorageKind::kAlignedBuffer: {
       absl::MutexLock l(guard);
@@ -355,17 +355,17 @@ std::unique_ptr<FlagStateInterface> FlagImpl::SaveState() {
     case FlagValueStorageKind::kOneWordAtomic: {
       return absl::make_unique<FlagState>(
           *this, OneWordValue().load(std::memory_order_acquire), modified,
-          on_command_line, ModificationCount());
+          on_command_line, ModificationCount()); 
     }
-    case FlagValueStorageKind::kSequenceLocked: {
-      void* cloned = flags_internal::Alloc(op_);
-      // Read is guaranteed to be successful because we hold the lock.
-      bool success =
-          seq_lock_.TryRead(cloned, AtomicBufferValue(), Sizeof(op_));
-      assert(success);
-      static_cast<void>(success);
-      return absl::make_unique<FlagState>(*this, cloned, modified,
-                                          on_command_line, ModificationCount());
+    case FlagValueStorageKind::kSequenceLocked: { 
+      void* cloned = flags_internal::Alloc(op_); 
+      // Read is guaranteed to be successful because we hold the lock. 
+      bool success = 
+          seq_lock_.TryRead(cloned, AtomicBufferValue(), Sizeof(op_)); 
+      assert(success); 
+      static_cast<void>(success); 
+      return absl::make_unique<FlagState>(*this, cloned, modified, 
+                                          on_command_line, ModificationCount()); 
     }
     case FlagValueStorageKind::kAlignedBuffer: {
       return absl::make_unique<FlagState>(
@@ -378,7 +378,7 @@ std::unique_ptr<FlagStateInterface> FlagImpl::SaveState() {
 
 bool FlagImpl::RestoreState(const FlagState& flag_state) {
   absl::MutexLock l(DataGuard());
-  if (flag_state.counter_ == ModificationCount()) {
+  if (flag_state.counter_ == ModificationCount()) { 
     return false;
   }
 
@@ -413,11 +413,11 @@ void* FlagImpl::AlignedBufferValue() const {
   return OffsetValue<void>();
 }
 
-std::atomic<uint64_t>* FlagImpl::AtomicBufferValue() const {
-  assert(ValueStorageKind() == FlagValueStorageKind::kSequenceLocked);
-  return OffsetValue<std::atomic<uint64_t>>();
-}
-
+std::atomic<uint64_t>* FlagImpl::AtomicBufferValue() const { 
+  assert(ValueStorageKind() == FlagValueStorageKind::kSequenceLocked); 
+  return OffsetValue<std::atomic<uint64_t>>(); 
+} 
+ 
 std::atomic<int64_t>& FlagImpl::OneWordValue() const {
   assert(ValueStorageKind() == FlagValueStorageKind::kOneWordAtomic ||
          ValueStorageKind() == FlagValueStorageKind::kValueAndInitBit);
@@ -453,8 +453,8 @@ void FlagImpl::Read(void* dst) const {
       std::memcpy(dst, &one_word_val, Sizeof(op_));
       break;
     }
-    case FlagValueStorageKind::kSequenceLocked: {
-      ReadSequenceLockedData(dst);
+    case FlagValueStorageKind::kSequenceLocked: { 
+      ReadSequenceLockedData(dst); 
       break;
     }
     case FlagValueStorageKind::kAlignedBuffer: {
@@ -482,20 +482,20 @@ bool FlagImpl::ReadOneBool() const {
       .value;
 }
 
-void FlagImpl::ReadSequenceLockedData(void* dst) const {
-  int size = Sizeof(op_);
-  // Attempt to read using the sequence lock.
-  if (ABSL_PREDICT_TRUE(seq_lock_.TryRead(dst, AtomicBufferValue(), size))) {
-    return;
-  }
-  // We failed due to contention. Acquire the lock to prevent contention
-  // and try again.
-  absl::ReaderMutexLock l(DataGuard());
-  bool success = seq_lock_.TryRead(dst, AtomicBufferValue(), size);
-  assert(success);
-  static_cast<void>(success);
-}
-
+void FlagImpl::ReadSequenceLockedData(void* dst) const { 
+  int size = Sizeof(op_); 
+  // Attempt to read using the sequence lock. 
+  if (ABSL_PREDICT_TRUE(seq_lock_.TryRead(dst, AtomicBufferValue(), size))) { 
+    return; 
+  } 
+  // We failed due to contention. Acquire the lock to prevent contention 
+  // and try again. 
+  absl::ReaderMutexLock l(DataGuard()); 
+  bool success = seq_lock_.TryRead(dst, AtomicBufferValue(), size); 
+  assert(success); 
+  static_cast<void>(success); 
+} 
+ 
 void FlagImpl::Write(const void* src) {
   absl::MutexLock l(DataGuard());
 
diff --git a/contrib/restricted/abseil-cpp/absl/flags/internal/flag.h b/contrib/restricted/abseil-cpp/absl/flags/internal/flag.h
index 124a2f1c03..9e3a204d39 100644
--- a/contrib/restricted/abseil-cpp/absl/flags/internal/flag.h
+++ b/contrib/restricted/abseil-cpp/absl/flags/internal/flag.h
@@ -37,7 +37,7 @@
 #include "absl/flags/config.h"
 #include "absl/flags/internal/commandlineflag.h"
 #include "absl/flags/internal/registry.h"
-#include "absl/flags/internal/sequence_lock.h"
+#include "absl/flags/internal/sequence_lock.h" 
 #include "absl/flags/marshalling.h"
 #include "absl/meta/type_traits.h"
 #include "absl/strings/string_view.h"
@@ -315,15 +315,15 @@ using FlagUseOneWordStorage = std::integral_constant<
     bool, absl::type_traits_internal::is_trivially_copyable<T>::value &&
               (sizeof(T) <= 8)>;
 
-template <class T>
+template <class T> 
 using FlagUseSequenceLockStorage = std::integral_constant<
     bool, absl::type_traits_internal::is_trivially_copyable<T>::value &&
-              (sizeof(T) > 8)>;
+              (sizeof(T) > 8)>; 
 
 enum class FlagValueStorageKind : uint8_t {
   kValueAndInitBit = 0,
   kOneWordAtomic = 1,
-  kSequenceLocked = 2,
+  kSequenceLocked = 2, 
   kAlignedBuffer = 3,
 };
 
@@ -334,8 +334,8 @@ static constexpr FlagValueStorageKind StorageKind() {
          : FlagUseOneWordStorage<T>::value
              ? FlagValueStorageKind::kOneWordAtomic
          : FlagUseSequenceLockStorage<T>::value
-             ? FlagValueStorageKind::kSequenceLocked
-             : FlagValueStorageKind::kAlignedBuffer;
+             ? FlagValueStorageKind::kSequenceLocked 
+             : FlagValueStorageKind::kAlignedBuffer; 
 }
 
 struct FlagOneWordValue {
@@ -371,7 +371,7 @@ struct FlagValue<T, FlagValueStorageKind::kValueAndInitBit> : FlagOneWordValue {
 template <typename T>
 struct FlagValue<T, FlagValueStorageKind::kOneWordAtomic> : FlagOneWordValue {
   constexpr FlagValue() : FlagOneWordValue(UninitializedFlagValue()) {}
-  bool Get(const SequenceLock&, T& dst) const {
+  bool Get(const SequenceLock&, T& dst) const { 
     int64_t one_word_val = value.load(std::memory_order_acquire);
     if (ABSL_PREDICT_FALSE(one_word_val == UninitializedFlagValue())) {
       return false;
@@ -382,16 +382,16 @@ struct FlagValue<T, FlagValueStorageKind::kOneWordAtomic> : FlagOneWordValue {
 };
 
 template <typename T>
-struct FlagValue<T, FlagValueStorageKind::kSequenceLocked> {
-  bool Get(const SequenceLock& lock, T& dst) const {
-    return lock.TryRead(&dst, value_words, sizeof(T));
+struct FlagValue<T, FlagValueStorageKind::kSequenceLocked> { 
+  bool Get(const SequenceLock& lock, T& dst) const { 
+    return lock.TryRead(&dst, value_words, sizeof(T)); 
   }
-
-  static constexpr int kNumWords =
-      flags_internal::AlignUp(sizeof(T), sizeof(uint64_t)) / sizeof(uint64_t);
-
-  alignas(T) alignas(
-      std::atomic<uint64_t>) std::atomic<uint64_t> value_words[kNumWords];
+ 
+  static constexpr int kNumWords = 
+      flags_internal::AlignUp(sizeof(T), sizeof(uint64_t)) / sizeof(uint64_t); 
+ 
+  alignas(T) alignas( 
+      std::atomic<uint64_t>) std::atomic<uint64_t> value_words[kNumWords]; 
 };
 
 template <typename T>
@@ -507,14 +507,14 @@ class FlagImpl final : public CommandLineFlag {
   // flag.cc, we can define it in that file as well.
   template <typename StorageT>
   StorageT* OffsetValue() const;
-  // This is an accessor for a value stored in an aligned buffer storage
-  // used for non-trivially-copyable data types.
+  // This is an accessor for a value stored in an aligned buffer storage 
+  // used for non-trivially-copyable data types. 
   // Returns a mutable pointer to the start of a buffer.
   void* AlignedBufferValue() const;
-
-  // The same as above, but used for sequencelock-protected storage.
-  std::atomic<uint64_t>* AtomicBufferValue() const;
-
+ 
+  // The same as above, but used for sequencelock-protected storage. 
+  std::atomic<uint64_t>* AtomicBufferValue() const; 
+ 
   // This is an accessor for a value stored as one word atomic. Returns a
   // mutable reference to an atomic value.
   std::atomic<int64_t>& OneWordValue() const;
@@ -527,12 +527,12 @@ class FlagImpl final : public CommandLineFlag {
   // Stores the flag value based on the pointer to the source.
   void StoreValue(const void* src) ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
 
-  // Copy the flag data, protected by `seq_lock_` into `dst`.
-  //
-  // REQUIRES: ValueStorageKind() == kSequenceLocked.
-  void ReadSequenceLockedData(void* dst) const
-      ABSL_LOCKS_EXCLUDED(*DataGuard());
-
+  // Copy the flag data, protected by `seq_lock_` into `dst`. 
+  // 
+  // REQUIRES: ValueStorageKind() == kSequenceLocked. 
+  void ReadSequenceLockedData(void* dst) const 
+      ABSL_LOCKS_EXCLUDED(*DataGuard()); 
+ 
   FlagHelpKind HelpSourceKind() const {
     return static_cast<FlagHelpKind>(help_source_kind_);
   }
@@ -558,8 +558,8 @@ class FlagImpl final : public CommandLineFlag {
   void CheckDefaultValueParsingRoundtrip() const override
       ABSL_LOCKS_EXCLUDED(*DataGuard());
 
-  int64_t ModificationCount() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
-
+  int64_t ModificationCount() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard()); 
+ 
   // Interfaces to save and restore flags to/from persistent state.
   // Returns current flag state or nullptr if flag does not support
   // saving and restoring a state.
@@ -606,9 +606,9 @@ class FlagImpl final : public CommandLineFlag {
   // Unique tag for absl::call_once call to initialize this flag.
   absl::once_flag init_control_;
 
-  // Sequence lock / mutation counter.
-  flags_internal::SequenceLock seq_lock_;
-
+  // Sequence lock / mutation counter. 
+  flags_internal::SequenceLock seq_lock_; 
+ 
   // Optional flag's callback and absl::Mutex to guard the invocations.
   FlagCallback* callback_ ABSL_GUARDED_BY(*DataGuard());
   // Either a pointer to the function generating the default value based on the
@@ -669,9 +669,9 @@ class Flag {
     impl_.AssertValidType(base_internal::FastTypeId<T>(), &GenRuntimeTypeId<T>);
 #endif
 
-    if (ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value))) {
-      impl_.Read(&u.value);
-    }
+    if (ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value))) { 
+      impl_.Read(&u.value); 
+    } 
     return std::move(u.value);
   }
   void Set(const T& v) {
@@ -772,9 +772,9 @@ struct FlagRegistrarEmpty {};
 template <typename T, bool do_register>
 class FlagRegistrar {
  public:
-  explicit FlagRegistrar(Flag<T>& flag, const char* filename) : flag_(flag) {
-    if (do_register)
-      flags_internal::RegisterCommandLineFlag(flag_.impl_, filename);
+  explicit FlagRegistrar(Flag<T>& flag, const char* filename) : flag_(flag) { 
+    if (do_register) 
+      flags_internal::RegisterCommandLineFlag(flag_.impl_, filename); 
   }
 
   FlagRegistrar OnUpdate(FlagCallbackFunc cb) && {
diff --git a/contrib/restricted/abseil-cpp/absl/flags/internal/flag/ya.make b/contrib/restricted/abseil-cpp/absl/flags/internal/flag/ya.make
index 76f47ce655..12b51ff58c 100644
--- a/contrib/restricted/abseil-cpp/absl/flags/internal/flag/ya.make
+++ b/contrib/restricted/abseil-cpp/absl/flags/internal/flag/ya.make
@@ -1,20 +1,20 @@
-# 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
@@ -24,8 +24,8 @@ PEERDIR(
     contrib/restricted/abseil-cpp/absl/flags/internal/program_name
     contrib/restricted/abseil-cpp/absl/flags/marshalling
     contrib/restricted/abseil-cpp/absl/flags/usage_config
-    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/strings/internal/str_format
     contrib/restricted/abseil-cpp/absl/synchronization
@@ -33,25 +33,25 @@ PEERDIR(
     contrib/restricted/abseil-cpp/absl/time
     contrib/restricted/abseil-cpp/absl/time/civil_time
     contrib/restricted/abseil-cpp/absl/time/time_zone
-    contrib/restricted/abseil-cpp/absl/types/bad_optional_access
-)
-
-ADDINCL(
-    GLOBAL contrib/restricted/abseil-cpp
-)
-
-NO_COMPILER_WARNINGS()
-
-NO_UTIL()
-
-CFLAGS(
-    -DNOMINMAX
-)
-
+    contrib/restricted/abseil-cpp/absl/types/bad_optional_access 
+) 
+ 
+ADDINCL( 
+    GLOBAL contrib/restricted/abseil-cpp 
+) 
+ 
+NO_COMPILER_WARNINGS() 
+ 
+NO_UTIL() 
+ 
+CFLAGS( 
+    -DNOMINMAX 
+) 
+ 
 SRCDIR(contrib/restricted/abseil-cpp/absl/flags/internal)
-
-SRCS(
+ 
+SRCS( 
     flag.cc
-)
-
-END()
+) 
+ 
+END() 
diff --git a/contrib/restricted/abseil-cpp/absl/flags/internal/registry.h b/contrib/restricted/abseil-cpp/absl/flags/internal/registry.h
index 4b68c85f5c..4848bda8a8 100644
--- a/contrib/restricted/abseil-cpp/absl/flags/internal/registry.h
+++ b/contrib/restricted/abseil-cpp/absl/flags/internal/registry.h
@@ -36,7 +36,7 @@ void ForEachFlag(std::function<void(CommandLineFlag&)> visitor);
 
 //-----------------------------------------------------------------------------
 
-bool RegisterCommandLineFlag(CommandLineFlag&, const char* filename);
+bool RegisterCommandLineFlag(CommandLineFlag&, const char* filename); 
 
 void FinalizeRegistry();
 
diff --git a/contrib/restricted/abseil-cpp/absl/flags/internal/sequence_lock.h b/contrib/restricted/abseil-cpp/absl/flags/internal/sequence_lock.h
index 36318ab9d3..caa745b42a 100644
--- a/contrib/restricted/abseil-cpp/absl/flags/internal/sequence_lock.h
+++ b/contrib/restricted/abseil-cpp/absl/flags/internal/sequence_lock.h
@@ -1,187 +1,187 @@
-//
-// 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_FLAGS_INTERNAL_SEQUENCE_LOCK_H_
-#define ABSL_FLAGS_INTERNAL_SEQUENCE_LOCK_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <atomic>
-#include <cassert>
-#include <cstring>
-
-#include "absl/base/optimization.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace flags_internal {
-
-// Align 'x' up to the nearest 'align' bytes.
-inline constexpr size_t AlignUp(size_t x, size_t align) {
-  return align * ((x + align - 1) / align);
-}
-
-// A SequenceLock implements lock-free reads. A sequence counter is incremented
-// before and after each write, and readers access the counter before and after
-// accessing the protected data. If the counter is verified to not change during
-// the access, and the sequence counter value was even, then the reader knows
-// that the read was race-free and valid. Otherwise, the reader must fall back
-// to a Mutex-based code path.
-//
-// This particular SequenceLock starts in an "uninitialized" state in which
-// TryRead() returns false. It must be enabled by calling MarkInitialized().
-// This serves as a marker that the associated flag value has not yet been
-// initialized and a slow path needs to be taken.
-//
-// The memory reads and writes protected by this lock must use the provided
-// `TryRead()` and `Write()` functions. These functions behave similarly to
-// `memcpy()`, with one oddity: the protected data must be an array of
+// 
+// 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_FLAGS_INTERNAL_SEQUENCE_LOCK_H_ 
+#define ABSL_FLAGS_INTERNAL_SEQUENCE_LOCK_H_ 
+ 
+#include <stddef.h> 
+#include <stdint.h> 
+ 
+#include <atomic> 
+#include <cassert> 
+#include <cstring> 
+ 
+#include "absl/base/optimization.h" 
+ 
+namespace absl { 
+ABSL_NAMESPACE_BEGIN 
+namespace flags_internal { 
+ 
+// Align 'x' up to the nearest 'align' bytes. 
+inline constexpr size_t AlignUp(size_t x, size_t align) { 
+  return align * ((x + align - 1) / align); 
+} 
+ 
+// A SequenceLock implements lock-free reads. A sequence counter is incremented 
+// before and after each write, and readers access the counter before and after 
+// accessing the protected data. If the counter is verified to not change during 
+// the access, and the sequence counter value was even, then the reader knows 
+// that the read was race-free and valid. Otherwise, the reader must fall back 
+// to a Mutex-based code path. 
+// 
+// This particular SequenceLock starts in an "uninitialized" state in which 
+// TryRead() returns false. It must be enabled by calling MarkInitialized(). 
+// This serves as a marker that the associated flag value has not yet been 
+// initialized and a slow path needs to be taken. 
+// 
+// The memory reads and writes protected by this lock must use the provided 
+// `TryRead()` and `Write()` functions. These functions behave similarly to 
+// `memcpy()`, with one oddity: the protected data must be an array of 
 // `std::atomic<uint64>`. This is to comply with the C++ standard, which
-// considers data races on non-atomic objects to be undefined behavior. See "Can
-// Seqlocks Get Along With Programming Language Memory Models?"[1] by Hans J.
-// Boehm for more details.
-//
-// [1] https://www.hpl.hp.com/techreports/2012/HPL-2012-68.pdf
-class SequenceLock {
- public:
-  constexpr SequenceLock() : lock_(kUninitialized) {}
-
-  // Mark that this lock is ready for use.
-  void MarkInitialized() {
-    assert(lock_.load(std::memory_order_relaxed) == kUninitialized);
-    lock_.store(0, std::memory_order_release);
-  }
-
-  // Copy "size" bytes of data from "src" to "dst", protected as a read-side
-  // critical section of the sequence lock.
-  //
-  // Unlike traditional sequence lock implementations which loop until getting a
-  // clean read, this implementation returns false in the case of concurrent
-  // calls to `Write`. In such a case, the caller should fall back to a
-  // locking-based slow path.
-  //
-  // Returns false if the sequence lock was not yet marked as initialized.
-  //
-  // NOTE: If this returns false, "dst" may be overwritten with undefined
-  // (potentially uninitialized) data.
-  bool TryRead(void* dst, const std::atomic<uint64_t>* src, size_t size) const {
-    // Acquire barrier ensures that no loads done by f() are reordered
-    // above the first load of the sequence counter.
-    int64_t seq_before = lock_.load(std::memory_order_acquire);
-    if (ABSL_PREDICT_FALSE(seq_before & 1) == 1) return false;
-    RelaxedCopyFromAtomic(dst, src, size);
-    // Another acquire fence ensures that the load of 'lock_' below is
-    // strictly ordered after the RelaxedCopyToAtomic call above.
-    std::atomic_thread_fence(std::memory_order_acquire);
-    int64_t seq_after = lock_.load(std::memory_order_relaxed);
-    return ABSL_PREDICT_TRUE(seq_before == seq_after);
-  }
-
-  // Copy "size" bytes from "src" to "dst" as a write-side critical section
-  // of the sequence lock. Any concurrent readers will be forced to retry
-  // until they get a read that does not conflict with this write.
-  //
-  // This call must be externally synchronized against other calls to Write,
-  // but may proceed concurrently with reads.
-  void Write(std::atomic<uint64_t>* dst, const void* src, size_t size) {
-    // We can use relaxed instructions to increment the counter since we
-    // are extenally synchronized. The std::atomic_thread_fence below
-    // ensures that the counter updates don't get interleaved with the
-    // copy to the data.
-    int64_t orig_seq = lock_.load(std::memory_order_relaxed);
-    assert((orig_seq & 1) == 0);  // Must be initially unlocked.
-    lock_.store(orig_seq + 1, std::memory_order_relaxed);
-
-    // We put a release fence between update to lock_ and writes to shared data.
-    // Thus all stores to shared data are effectively release operations and
-    // update to lock_ above cannot be re-ordered past any of them. Note that
-    // this barrier is not for the fetch_add above.  A release barrier for the
-    // fetch_add would be before it, not after.
-    std::atomic_thread_fence(std::memory_order_release);
-    RelaxedCopyToAtomic(dst, src, size);
-    // "Release" semantics ensure that none of the writes done by
-    // RelaxedCopyToAtomic() can be reordered after the following modification.
-    lock_.store(orig_seq + 2, std::memory_order_release);
-  }
-
-  // Return the number of times that Write() has been called.
-  //
-  // REQUIRES: This must be externally synchronized against concurrent calls to
-  // `Write()` or `IncrementModificationCount()`.
-  // REQUIRES: `MarkInitialized()` must have been previously called.
-  int64_t ModificationCount() const {
-    int64_t val = lock_.load(std::memory_order_relaxed);
-    assert(val != kUninitialized && (val & 1) == 0);
-    return val / 2;
-  }
-
-  // REQUIRES: This must be externally synchronized against concurrent calls to
-  // `Write()` or `ModificationCount()`.
-  // REQUIRES: `MarkInitialized()` must have been previously called.
-  void IncrementModificationCount() {
-    int64_t val = lock_.load(std::memory_order_relaxed);
-    assert(val != kUninitialized);
-    lock_.store(val + 2, std::memory_order_relaxed);
-  }
-
- private:
-  // Perform the equivalent of "memcpy(dst, src, size)", but using relaxed
-  // atomics.
-  static void RelaxedCopyFromAtomic(void* dst, const std::atomic<uint64_t>* src,
-                                    size_t size) {
-    char* dst_byte = static_cast<char*>(dst);
-    while (size >= sizeof(uint64_t)) {
-      uint64_t word = src->load(std::memory_order_relaxed);
-      std::memcpy(dst_byte, &word, sizeof(word));
-      dst_byte += sizeof(word);
-      src++;
-      size -= sizeof(word);
-    }
-    if (size > 0) {
-      uint64_t word = src->load(std::memory_order_relaxed);
-      std::memcpy(dst_byte, &word, size);
-    }
-  }
-
-  // Perform the equivalent of "memcpy(dst, src, size)", but using relaxed
-  // atomics.
-  static void RelaxedCopyToAtomic(std::atomic<uint64_t>* dst, const void* src,
-                                  size_t size) {
-    const char* src_byte = static_cast<const char*>(src);
-    while (size >= sizeof(uint64_t)) {
-      uint64_t word;
-      std::memcpy(&word, src_byte, sizeof(word));
-      dst->store(word, std::memory_order_relaxed);
-      src_byte += sizeof(word);
-      dst++;
-      size -= sizeof(word);
-    }
-    if (size > 0) {
-      uint64_t word = 0;
-      std::memcpy(&word, src_byte, size);
-      dst->store(word, std::memory_order_relaxed);
-    }
-  }
-
-  static constexpr int64_t kUninitialized = -1;
-  std::atomic<int64_t> lock_;
-};
-
-}  // namespace flags_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_FLAGS_INTERNAL_SEQUENCE_LOCK_H_
+// considers data races on non-atomic objects to be undefined behavior. See "Can 
+// Seqlocks Get Along With Programming Language Memory Models?"[1] by Hans J. 
+// Boehm for more details. 
+// 
+// [1] https://www.hpl.hp.com/techreports/2012/HPL-2012-68.pdf 
+class SequenceLock { 
+ public: 
+  constexpr SequenceLock() : lock_(kUninitialized) {} 
+ 
+  // Mark that this lock is ready for use. 
+  void MarkInitialized() { 
+    assert(lock_.load(std::memory_order_relaxed) == kUninitialized); 
+    lock_.store(0, std::memory_order_release); 
+  } 
+ 
+  // Copy "size" bytes of data from "src" to "dst", protected as a read-side 
+  // critical section of the sequence lock. 
+  // 
+  // Unlike traditional sequence lock implementations which loop until getting a 
+  // clean read, this implementation returns false in the case of concurrent 
+  // calls to `Write`. In such a case, the caller should fall back to a 
+  // locking-based slow path. 
+  // 
+  // Returns false if the sequence lock was not yet marked as initialized. 
+  // 
+  // NOTE: If this returns false, "dst" may be overwritten with undefined 
+  // (potentially uninitialized) data. 
+  bool TryRead(void* dst, const std::atomic<uint64_t>* src, size_t size) const { 
+    // Acquire barrier ensures that no loads done by f() are reordered 
+    // above the first load of the sequence counter. 
+    int64_t seq_before = lock_.load(std::memory_order_acquire); 
+    if (ABSL_PREDICT_FALSE(seq_before & 1) == 1) return false; 
+    RelaxedCopyFromAtomic(dst, src, size); 
+    // Another acquire fence ensures that the load of 'lock_' below is 
+    // strictly ordered after the RelaxedCopyToAtomic call above. 
+    std::atomic_thread_fence(std::memory_order_acquire); 
+    int64_t seq_after = lock_.load(std::memory_order_relaxed); 
+    return ABSL_PREDICT_TRUE(seq_before == seq_after); 
+  } 
+ 
+  // Copy "size" bytes from "src" to "dst" as a write-side critical section 
+  // of the sequence lock. Any concurrent readers will be forced to retry 
+  // until they get a read that does not conflict with this write. 
+  // 
+  // This call must be externally synchronized against other calls to Write, 
+  // but may proceed concurrently with reads. 
+  void Write(std::atomic<uint64_t>* dst, const void* src, size_t size) { 
+    // We can use relaxed instructions to increment the counter since we 
+    // are extenally synchronized. The std::atomic_thread_fence below 
+    // ensures that the counter updates don't get interleaved with the 
+    // copy to the data. 
+    int64_t orig_seq = lock_.load(std::memory_order_relaxed); 
+    assert((orig_seq & 1) == 0);  // Must be initially unlocked. 
+    lock_.store(orig_seq + 1, std::memory_order_relaxed); 
+ 
+    // We put a release fence between update to lock_ and writes to shared data. 
+    // Thus all stores to shared data are effectively release operations and 
+    // update to lock_ above cannot be re-ordered past any of them. Note that 
+    // this barrier is not for the fetch_add above.  A release barrier for the 
+    // fetch_add would be before it, not after. 
+    std::atomic_thread_fence(std::memory_order_release); 
+    RelaxedCopyToAtomic(dst, src, size); 
+    // "Release" semantics ensure that none of the writes done by 
+    // RelaxedCopyToAtomic() can be reordered after the following modification. 
+    lock_.store(orig_seq + 2, std::memory_order_release); 
+  } 
+ 
+  // Return the number of times that Write() has been called. 
+  // 
+  // REQUIRES: This must be externally synchronized against concurrent calls to 
+  // `Write()` or `IncrementModificationCount()`. 
+  // REQUIRES: `MarkInitialized()` must have been previously called. 
+  int64_t ModificationCount() const { 
+    int64_t val = lock_.load(std::memory_order_relaxed); 
+    assert(val != kUninitialized && (val & 1) == 0); 
+    return val / 2; 
+  } 
+ 
+  // REQUIRES: This must be externally synchronized against concurrent calls to 
+  // `Write()` or `ModificationCount()`. 
+  // REQUIRES: `MarkInitialized()` must have been previously called. 
+  void IncrementModificationCount() { 
+    int64_t val = lock_.load(std::memory_order_relaxed); 
+    assert(val != kUninitialized); 
+    lock_.store(val + 2, std::memory_order_relaxed); 
+  } 
+ 
+ private: 
+  // Perform the equivalent of "memcpy(dst, src, size)", but using relaxed 
+  // atomics. 
+  static void RelaxedCopyFromAtomic(void* dst, const std::atomic<uint64_t>* src, 
+                                    size_t size) { 
+    char* dst_byte = static_cast<char*>(dst); 
+    while (size >= sizeof(uint64_t)) { 
+      uint64_t word = src->load(std::memory_order_relaxed); 
+      std::memcpy(dst_byte, &word, sizeof(word)); 
+      dst_byte += sizeof(word); 
+      src++; 
+      size -= sizeof(word); 
+    } 
+    if (size > 0) { 
+      uint64_t word = src->load(std::memory_order_relaxed); 
+      std::memcpy(dst_byte, &word, size); 
+    } 
+  } 
+ 
+  // Perform the equivalent of "memcpy(dst, src, size)", but using relaxed 
+  // atomics. 
+  static void RelaxedCopyToAtomic(std::atomic<uint64_t>* dst, const void* src, 
+                                  size_t size) { 
+    const char* src_byte = static_cast<const char*>(src); 
+    while (size >= sizeof(uint64_t)) { 
+      uint64_t word; 
+      std::memcpy(&word, src_byte, sizeof(word)); 
+      dst->store(word, std::memory_order_relaxed); 
+      src_byte += sizeof(word); 
+      dst++; 
+      size -= sizeof(word); 
+    } 
+    if (size > 0) { 
+      uint64_t word = 0; 
+      std::memcpy(&word, src_byte, size); 
+      dst->store(word, std::memory_order_relaxed); 
+    } 
+  } 
+ 
+  static constexpr int64_t kUninitialized = -1; 
+  std::atomic<int64_t> lock_; 
+}; 
+ 
+}  // namespace flags_internal 
+ABSL_NAMESPACE_END 
+}  // namespace absl 
+ 
+#endif  // ABSL_FLAGS_INTERNAL_SEQUENCE_LOCK_H_ 
diff --git a/contrib/restricted/abseil-cpp/absl/flags/internal/usage.cc b/contrib/restricted/abseil-cpp/absl/flags/internal/usage.cc
index 949709e883..a3a7d5c933 100644
--- a/contrib/restricted/abseil-cpp/absl/flags/internal/usage.cc
+++ b/contrib/restricted/abseil-cpp/absl/flags/internal/usage.cc
@@ -37,26 +37,26 @@
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
 
-// Dummy global variables to prevent anyone else defining these.
-bool FLAGS_help = false;
-bool FLAGS_helpfull = false;
-bool FLAGS_helpshort = false;
-bool FLAGS_helppackage = false;
-bool FLAGS_version = false;
-bool FLAGS_only_check_args = false;
-bool FLAGS_helpon = false;
-bool FLAGS_helpmatch = false;
+// Dummy global variables to prevent anyone else defining these. 
+bool FLAGS_help = false; 
+bool FLAGS_helpfull = false; 
+bool FLAGS_helpshort = false; 
+bool FLAGS_helppackage = false; 
+bool FLAGS_version = false; 
+bool FLAGS_only_check_args = false; 
+bool FLAGS_helpon = false; 
+bool FLAGS_helpmatch = false; 
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace flags_internal {
 namespace {
 
-using PerFlagFilter = std::function<bool(const absl::CommandLineFlag&)>;
-
-// Maximum length size in a human readable format.
-constexpr size_t kHrfMaxLineLength = 80;
-
+using PerFlagFilter = std::function<bool(const absl::CommandLineFlag&)>; 
+ 
+// Maximum length size in a human readable format. 
+constexpr size_t kHrfMaxLineLength = 80; 
+ 
 // This class is used to emit an XML element with `tag` and `text`.
 // It adds opening and closing tags and escapes special characters in the text.
 // For example:
@@ -109,12 +109,12 @@ class FlagHelpPrettyPrinter {
  public:
   // Pretty printer holds on to the std::ostream& reference to direct an output
   // to that stream.
-  FlagHelpPrettyPrinter(size_t max_line_len, size_t min_line_len,
-                        size_t wrapped_line_indent, std::ostream& out)
+  FlagHelpPrettyPrinter(size_t max_line_len, size_t min_line_len, 
+                        size_t wrapped_line_indent, std::ostream& out) 
       : out_(out),
         max_line_len_(max_line_len),
-        min_line_len_(min_line_len),
-        wrapped_line_indent_(wrapped_line_indent),
+        min_line_len_(min_line_len), 
+        wrapped_line_indent_(wrapped_line_indent), 
         line_len_(0),
         first_line_(true) {}
 
@@ -168,12 +168,12 @@ class FlagHelpPrettyPrinter {
 
   void StartLine() {
     if (first_line_) {
-      line_len_ = min_line_len_;
+      line_len_ = min_line_len_; 
       first_line_ = false;
     } else {
-      line_len_ = min_line_len_ + wrapped_line_indent_;
+      line_len_ = min_line_len_ + wrapped_line_indent_; 
     }
-    out_ << std::string(line_len_, ' ');
+    out_ << std::string(line_len_, ' '); 
   }
   void EndLine() {
     out_ << '\n';
@@ -182,15 +182,15 @@ class FlagHelpPrettyPrinter {
 
  private:
   std::ostream& out_;
-  const size_t max_line_len_;
-  const size_t min_line_len_;
-  const size_t wrapped_line_indent_;
-  size_t line_len_;
+  const size_t max_line_len_; 
+  const size_t min_line_len_; 
+  const size_t wrapped_line_indent_; 
+  size_t line_len_; 
   bool first_line_;
 };
 
 void FlagHelpHumanReadable(const CommandLineFlag& flag, std::ostream& out) {
-  FlagHelpPrettyPrinter printer(kHrfMaxLineLength, 4, 2, out);
+  FlagHelpPrettyPrinter printer(kHrfMaxLineLength, 4, 2, out); 
 
   // Flag name.
   printer.Write(absl::StrCat("--", flag.Name()));
@@ -226,7 +226,7 @@ void FlagHelpHumanReadable(const CommandLineFlag& flag, std::ostream& out) {
 // If a flag's help message has been stripped (e.g. by adding '#define
 // STRIP_FLAG_HELP 1' then this flag will not be displayed by '--help'
 // and its variants.
-void FlagsHelpImpl(std::ostream& out, PerFlagFilter filter_cb,
+void FlagsHelpImpl(std::ostream& out, PerFlagFilter filter_cb, 
                    HelpFormat format, absl::string_view program_usage_message) {
   if (format == HelpFormat::kHumanReadable) {
     out << flags_internal::ShortProgramInvocationName() << ": "
@@ -261,9 +261,9 @@ void FlagsHelpImpl(std::ostream& out, PerFlagFilter filter_cb,
     // If the flag has been stripped, pretend that it doesn't exist.
     if (flag.Help() == flags_internal::kStrippedFlagHelp) return;
 
-    // Make sure flag satisfies the filter
-    if (!filter_cb(flag)) return;
-
+    // Make sure flag satisfies the filter 
+    if (!filter_cb(flag)) return; 
+ 
     std::string flag_filename = flag.Filename();
 
     matching_flags[std::string(flags_internal::Package(flag_filename))]
@@ -300,34 +300,34 @@ void FlagsHelpImpl(std::ostream& out, PerFlagFilter filter_cb,
   }
 
   if (format == HelpFormat::kHumanReadable) {
-    FlagHelpPrettyPrinter printer(kHrfMaxLineLength, 0, 0, out);
-
+    FlagHelpPrettyPrinter printer(kHrfMaxLineLength, 0, 0, out); 
+ 
     if (filter_cb && matching_flags.empty()) {
-      printer.Write("No flags matched.\n", true);
+      printer.Write("No flags matched.\n", true); 
     }
-    printer.EndLine();
-    printer.Write(
-        "Try --helpfull to get a list of all flags or --help=substring "
-        "shows help for flags which include specified substring in either "
-        "in the name, or description or path.\n",
-        true);
+    printer.EndLine(); 
+    printer.Write( 
+        "Try --helpfull to get a list of all flags or --help=substring " 
+        "shows help for flags which include specified substring in either " 
+        "in the name, or description or path.\n", 
+        true); 
   } else {
     // The end of the document.
     out << "</AllFlags>\n";
   }
 }
 
-void FlagsHelpImpl(std::ostream& out,
-                   flags_internal::FlagKindFilter filename_filter_cb,
-                   HelpFormat format, absl::string_view program_usage_message) {
-  FlagsHelpImpl(
-      out,
-      [&](const absl::CommandLineFlag& flag) {
-        return filename_filter_cb && filename_filter_cb(flag.Filename());
-      },
-      format, program_usage_message);
-}
-
+void FlagsHelpImpl(std::ostream& out, 
+                   flags_internal::FlagKindFilter filename_filter_cb, 
+                   HelpFormat format, absl::string_view program_usage_message) { 
+  FlagsHelpImpl( 
+      out, 
+      [&](const absl::CommandLineFlag& flag) { 
+        return filename_filter_cb && filename_filter_cb(flag.Filename()); 
+      }, 
+      format, program_usage_message); 
+} 
+ 
 }  // namespace
 
 // --------------------------------------------------------------------
@@ -339,7 +339,7 @@ void FlagHelp(std::ostream& out, const CommandLineFlag& flag,
 }
 
 // --------------------------------------------------------------------
-// Produces the help messages for all flags matching the filename filter.
+// Produces the help messages for all flags matching the filename filter. 
 // If filter is empty produces help messages for all flags.
 void FlagsHelp(std::ostream& out, absl::string_view filter, HelpFormat format,
                absl::string_view program_usage_message) {
@@ -354,169 +354,169 @@ void FlagsHelp(std::ostream& out, absl::string_view filter, HelpFormat format,
 // If so, handles them appropriately.
 int HandleUsageFlags(std::ostream& out,
                      absl::string_view program_usage_message) {
-  switch (GetFlagsHelpMode()) {
-    case HelpMode::kNone:
-      break;
-    case HelpMode::kImportant:
-      flags_internal::FlagsHelpImpl(
-          out, flags_internal::GetUsageConfig().contains_help_flags,
-          GetFlagsHelpFormat(), program_usage_message);
-      return 1;
-
-    case HelpMode::kShort:
-      flags_internal::FlagsHelpImpl(
-          out, flags_internal::GetUsageConfig().contains_helpshort_flags,
-          GetFlagsHelpFormat(), program_usage_message);
-      return 1;
-
-    case HelpMode::kFull:
-      flags_internal::FlagsHelp(out, "", GetFlagsHelpFormat(),
-                                program_usage_message);
-      return 1;
-
-    case HelpMode::kPackage:
-      flags_internal::FlagsHelpImpl(
-          out, flags_internal::GetUsageConfig().contains_helppackage_flags,
-          GetFlagsHelpFormat(), program_usage_message);
-
-      return 1;
-
-    case HelpMode::kMatch: {
-      std::string substr = GetFlagsHelpMatchSubstr();
-      if (substr.empty()) {
-        // show all options
-        flags_internal::FlagsHelp(out, substr, GetFlagsHelpFormat(),
-                                  program_usage_message);
-      } else {
-        auto filter_cb = [&substr](const absl::CommandLineFlag& flag) {
-          if (absl::StrContains(flag.Name(), substr)) return true;
-          if (absl::StrContains(flag.Filename(), substr)) return true;
-          if (absl::StrContains(flag.Help(), substr)) return true;
-
-          return false;
-        };
-        flags_internal::FlagsHelpImpl(
-            out, filter_cb, HelpFormat::kHumanReadable, program_usage_message);
-      }
-
-      return 1;
-    }
-    case HelpMode::kVersion:
-      if (flags_internal::GetUsageConfig().version_string)
-        out << flags_internal::GetUsageConfig().version_string();
-      // Unlike help, we may be asking for version in a script, so return 0
-      return 0;
-
-    case HelpMode::kOnlyCheckArgs:
-      return 0;
+  switch (GetFlagsHelpMode()) { 
+    case HelpMode::kNone: 
+      break; 
+    case HelpMode::kImportant: 
+      flags_internal::FlagsHelpImpl( 
+          out, flags_internal::GetUsageConfig().contains_help_flags, 
+          GetFlagsHelpFormat(), program_usage_message); 
+      return 1; 
+
+    case HelpMode::kShort: 
+      flags_internal::FlagsHelpImpl( 
+          out, flags_internal::GetUsageConfig().contains_helpshort_flags, 
+          GetFlagsHelpFormat(), program_usage_message); 
+      return 1; 
+
+    case HelpMode::kFull: 
+      flags_internal::FlagsHelp(out, "", GetFlagsHelpFormat(), 
+                                program_usage_message); 
+      return 1; 
+
+    case HelpMode::kPackage: 
+      flags_internal::FlagsHelpImpl( 
+          out, flags_internal::GetUsageConfig().contains_helppackage_flags, 
+          GetFlagsHelpFormat(), program_usage_message); 
+
+      return 1; 
+
+    case HelpMode::kMatch: { 
+      std::string substr = GetFlagsHelpMatchSubstr(); 
+      if (substr.empty()) { 
+        // show all options 
+        flags_internal::FlagsHelp(out, substr, GetFlagsHelpFormat(), 
+                                  program_usage_message); 
+      } else { 
+        auto filter_cb = [&substr](const absl::CommandLineFlag& flag) { 
+          if (absl::StrContains(flag.Name(), substr)) return true; 
+          if (absl::StrContains(flag.Filename(), substr)) return true; 
+          if (absl::StrContains(flag.Help(), substr)) return true; 
+
+          return false; 
+        }; 
+        flags_internal::FlagsHelpImpl( 
+            out, filter_cb, HelpFormat::kHumanReadable, program_usage_message); 
+      } 
+ 
+      return 1; 
+    } 
+    case HelpMode::kVersion: 
+      if (flags_internal::GetUsageConfig().version_string) 
+        out << flags_internal::GetUsageConfig().version_string(); 
+      // Unlike help, we may be asking for version in a script, so return 0 
+      return 0; 
+ 
+    case HelpMode::kOnlyCheckArgs: 
+      return 0; 
   }
 
-  return -1;
-}
-
-// --------------------------------------------------------------------
-// Globals representing usage reporting flags
-
-namespace {
-
-ABSL_CONST_INIT absl::Mutex help_attributes_guard(absl::kConstInit);
-ABSL_CONST_INIT std::string* match_substr
-    ABSL_GUARDED_BY(help_attributes_guard) = nullptr;
-ABSL_CONST_INIT HelpMode help_mode ABSL_GUARDED_BY(help_attributes_guard) =
-    HelpMode::kNone;
-ABSL_CONST_INIT HelpFormat help_format ABSL_GUARDED_BY(help_attributes_guard) =
-    HelpFormat::kHumanReadable;
-
-}  // namespace
-
-std::string GetFlagsHelpMatchSubstr() {
-  absl::MutexLock l(&help_attributes_guard);
-  if (match_substr == nullptr) return "";
-  return *match_substr;
-}
-
-void SetFlagsHelpMatchSubstr(absl::string_view substr) {
-  absl::MutexLock l(&help_attributes_guard);
-  if (match_substr == nullptr) match_substr = new std::string;
-  match_substr->assign(substr.data(), substr.size());
-}
-
-HelpMode GetFlagsHelpMode() {
-  absl::MutexLock l(&help_attributes_guard);
-  return help_mode;
-}
-
-void SetFlagsHelpMode(HelpMode mode) {
-  absl::MutexLock l(&help_attributes_guard);
-  help_mode = mode;
-}
-
-HelpFormat GetFlagsHelpFormat() {
-  absl::MutexLock l(&help_attributes_guard);
-  return help_format;
-}
-
-void SetFlagsHelpFormat(HelpFormat format) {
-  absl::MutexLock l(&help_attributes_guard);
-  help_format = format;
-}
-
-// Deduces usage flags from the input argument in a form --name=value or
-// --name. argument is already split into name and value before we call this
-// function.
-bool DeduceUsageFlags(absl::string_view name, absl::string_view value) {
-  if (absl::ConsumePrefix(&name, "help")) {
-    if (name == "") {
-      if (value.empty()) {
-        SetFlagsHelpMode(HelpMode::kImportant);
-      } else {
-        SetFlagsHelpMode(HelpMode::kMatch);
-        SetFlagsHelpMatchSubstr(value);
-      }
-      return true;
-    }
-
-    if (name == "match") {
-      SetFlagsHelpMode(HelpMode::kMatch);
-      SetFlagsHelpMatchSubstr(value);
-      return true;
-    }
-
-    if (name == "on") {
-      SetFlagsHelpMode(HelpMode::kMatch);
-      SetFlagsHelpMatchSubstr(absl::StrCat("/", value, "."));
-      return true;
-    }
-
-    if (name == "full") {
-      SetFlagsHelpMode(HelpMode::kFull);
-      return true;
-    }
-
-    if (name == "short") {
-      SetFlagsHelpMode(HelpMode::kShort);
-      return true;
-    }
-
-    if (name == "package") {
-      SetFlagsHelpMode(HelpMode::kPackage);
-      return true;
-    }
-
-    return false;
+  return -1; 
+} 
+
+// -------------------------------------------------------------------- 
+// Globals representing usage reporting flags 
+
+namespace { 
+ 
+ABSL_CONST_INIT absl::Mutex help_attributes_guard(absl::kConstInit); 
+ABSL_CONST_INIT std::string* match_substr 
+    ABSL_GUARDED_BY(help_attributes_guard) = nullptr; 
+ABSL_CONST_INIT HelpMode help_mode ABSL_GUARDED_BY(help_attributes_guard) = 
+    HelpMode::kNone; 
+ABSL_CONST_INIT HelpFormat help_format ABSL_GUARDED_BY(help_attributes_guard) = 
+    HelpFormat::kHumanReadable; 
+ 
+}  // namespace 
+ 
+std::string GetFlagsHelpMatchSubstr() { 
+  absl::MutexLock l(&help_attributes_guard); 
+  if (match_substr == nullptr) return ""; 
+  return *match_substr; 
+} 
+ 
+void SetFlagsHelpMatchSubstr(absl::string_view substr) { 
+  absl::MutexLock l(&help_attributes_guard); 
+  if (match_substr == nullptr) match_substr = new std::string; 
+  match_substr->assign(substr.data(), substr.size()); 
+} 
+ 
+HelpMode GetFlagsHelpMode() { 
+  absl::MutexLock l(&help_attributes_guard); 
+  return help_mode; 
+} 
+ 
+void SetFlagsHelpMode(HelpMode mode) { 
+  absl::MutexLock l(&help_attributes_guard); 
+  help_mode = mode; 
+} 
+ 
+HelpFormat GetFlagsHelpFormat() { 
+  absl::MutexLock l(&help_attributes_guard); 
+  return help_format; 
+} 
+ 
+void SetFlagsHelpFormat(HelpFormat format) { 
+  absl::MutexLock l(&help_attributes_guard); 
+  help_format = format; 
+} 
+ 
+// Deduces usage flags from the input argument in a form --name=value or 
+// --name. argument is already split into name and value before we call this 
+// function. 
+bool DeduceUsageFlags(absl::string_view name, absl::string_view value) { 
+  if (absl::ConsumePrefix(&name, "help")) { 
+    if (name == "") { 
+      if (value.empty()) { 
+        SetFlagsHelpMode(HelpMode::kImportant); 
+      } else { 
+        SetFlagsHelpMode(HelpMode::kMatch); 
+        SetFlagsHelpMatchSubstr(value); 
+      } 
+      return true; 
+    } 
+ 
+    if (name == "match") { 
+      SetFlagsHelpMode(HelpMode::kMatch); 
+      SetFlagsHelpMatchSubstr(value); 
+      return true; 
+    } 
+ 
+    if (name == "on") { 
+      SetFlagsHelpMode(HelpMode::kMatch); 
+      SetFlagsHelpMatchSubstr(absl::StrCat("/", value, ".")); 
+      return true; 
+    } 
+ 
+    if (name == "full") { 
+      SetFlagsHelpMode(HelpMode::kFull); 
+      return true; 
+    } 
+ 
+    if (name == "short") { 
+      SetFlagsHelpMode(HelpMode::kShort); 
+      return true; 
+    } 
+ 
+    if (name == "package") { 
+      SetFlagsHelpMode(HelpMode::kPackage); 
+      return true; 
+    } 
+ 
+    return false; 
   }
 
-  if (name == "version") {
-    SetFlagsHelpMode(HelpMode::kVersion);
-    return true;
+  if (name == "version") { 
+    SetFlagsHelpMode(HelpMode::kVersion); 
+    return true; 
   }
 
-  if (name == "only_check_args") {
-    SetFlagsHelpMode(HelpMode::kOnlyCheckArgs);
-    return true;
+  if (name == "only_check_args") { 
+    SetFlagsHelpMode(HelpMode::kOnlyCheckArgs); 
+    return true; 
   }
 
-  return false;
+  return false; 
 }
 
 }  // namespace flags_internal
diff --git a/contrib/restricted/abseil-cpp/absl/flags/internal/usage.h b/contrib/restricted/abseil-cpp/absl/flags/internal/usage.h
index c0bcac5762..5198d75225 100644
--- a/contrib/restricted/abseil-cpp/absl/flags/internal/usage.h
+++ b/contrib/restricted/abseil-cpp/absl/flags/internal/usage.h
@@ -66,37 +66,37 @@ void FlagsHelp(std::ostream& out, absl::string_view filter,
 int HandleUsageFlags(std::ostream& out,
                      absl::string_view program_usage_message);
 
-// --------------------------------------------------------------------
-// Globals representing usage reporting flags
-
-enum class HelpMode {
-  kNone,
-  kImportant,
-  kShort,
-  kFull,
-  kPackage,
-  kMatch,
-  kVersion,
-  kOnlyCheckArgs
-};
-
-// Returns substring to filter help output (--help=substr argument)
-std::string GetFlagsHelpMatchSubstr();
-// Returns the requested help mode.
-HelpMode GetFlagsHelpMode();
-// Returns the requested help format.
-HelpFormat GetFlagsHelpFormat();
-
-// These are corresponding setters to the attributes above.
-void SetFlagsHelpMatchSubstr(absl::string_view);
-void SetFlagsHelpMode(HelpMode);
-void SetFlagsHelpFormat(HelpFormat);
-
-// Deduces usage flags from the input argument in a form --name=value or
-// --name. argument is already split into name and value before we call this
-// function.
-bool DeduceUsageFlags(absl::string_view name, absl::string_view value);
-
+// -------------------------------------------------------------------- 
+// Globals representing usage reporting flags 
+ 
+enum class HelpMode { 
+  kNone, 
+  kImportant, 
+  kShort, 
+  kFull, 
+  kPackage, 
+  kMatch, 
+  kVersion, 
+  kOnlyCheckArgs 
+}; 
+ 
+// Returns substring to filter help output (--help=substr argument) 
+std::string GetFlagsHelpMatchSubstr(); 
+// Returns the requested help mode. 
+HelpMode GetFlagsHelpMode(); 
+// Returns the requested help format. 
+HelpFormat GetFlagsHelpFormat(); 
+ 
+// These are corresponding setters to the attributes above. 
+void SetFlagsHelpMatchSubstr(absl::string_view); 
+void SetFlagsHelpMode(HelpMode); 
+void SetFlagsHelpFormat(HelpFormat); 
+ 
+// Deduces usage flags from the input argument in a form --name=value or 
+// --name. argument is already split into name and value before we call this 
+// function. 
+bool DeduceUsageFlags(absl::string_view name, absl::string_view value); 
+ 
 }  // namespace flags_internal
 ABSL_NAMESPACE_END
 }  // namespace absl
diff --git a/contrib/restricted/abseil-cpp/absl/flags/internal/usage/ya.make b/contrib/restricted/abseil-cpp/absl/flags/internal/usage/ya.make
index 358744df59..3973999aa3 100644
--- a/contrib/restricted/abseil-cpp/absl/flags/internal/usage/ya.make
+++ b/contrib/restricted/abseil-cpp/absl/flags/internal/usage/ya.make
@@ -10,7 +10,7 @@ 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/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
@@ -18,10 +18,10 @@ PEERDIR(
     contrib/restricted/abseil-cpp/absl/city
     contrib/restricted/abseil-cpp/absl/container/internal/absl_hashtablez_sampler
     contrib/restricted/abseil-cpp/absl/container/internal/raw_hash_set
-    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/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/flags
     contrib/restricted/abseil-cpp/absl/flags/commandlineflag
     contrib/restricted/abseil-cpp/absl/flags/internal/commandlineflag
@@ -42,13 +42,13 @@ PEERDIR(
     contrib/restricted/abseil-cpp/absl/strings/internal/cordz_functions
     contrib/restricted/abseil-cpp/absl/strings/internal/cordz_handle
     contrib/restricted/abseil-cpp/absl/strings/internal/cordz_info
-    contrib/restricted/abseil-cpp/absl/strings/internal/str_format
+    contrib/restricted/abseil-cpp/absl/strings/internal/str_format 
     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
-    contrib/restricted/abseil-cpp/absl/types/bad_optional_access
+    contrib/restricted/abseil-cpp/absl/types/bad_optional_access 
     contrib/restricted/abseil-cpp/absl/types/bad_variant_access
 )
 
diff --git a/contrib/restricted/abseil-cpp/absl/flags/marshalling.h b/contrib/restricted/abseil-cpp/absl/flags/marshalling.h
index 7cbc136d57..00704d1ea3 100644
--- a/contrib/restricted/abseil-cpp/absl/flags/marshalling.h
+++ b/contrib/restricted/abseil-cpp/absl/flags/marshalling.h
@@ -83,7 +83,7 @@
 //   // AbslParseFlag converts from a string to OutputMode.
 //   // Must be in same namespace as OutputMode.
 //
-//   // Parses an OutputMode from the command line flag value `text`. Returns
+//   // Parses an OutputMode from the command line flag value `text`. Returns 
 //   // `true` and sets `*mode` on success; returns `false` and sets `*error`
 //   // on failure.
 //   bool AbslParseFlag(absl::string_view text,
@@ -139,7 +139,7 @@
 //
 //   // Within the implementation, `AbslParseFlag()` will, in turn invoke
 //   // `absl::ParseFlag()` on its constituent `int` and `std::string` types
-//   // (which have built-in Abseil flag support).
+//   // (which have built-in Abseil flag support). 
 //
 //   bool AbslParseFlag(absl::string_view text, MyFlagType* flag,
 //                      std::string* err) {
diff --git a/contrib/restricted/abseil-cpp/absl/flags/marshalling/ya.make b/contrib/restricted/abseil-cpp/absl/flags/marshalling/ya.make
index 1b02b87173..102f239809 100644
--- a/contrib/restricted/abseil-cpp/absl/flags/marshalling/ya.make
+++ b/contrib/restricted/abseil-cpp/absl/flags/marshalling/ya.make
@@ -1,41 +1,41 @@
-# 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
-    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
+OWNER(g:cpp-contrib) 
+ 
+LICENSE(Apache-2.0) 
+ 
+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
     contrib/restricted/abseil-cpp/absl/strings/internal/str_format
-)
-
-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/flags)
-
-SRCS(
+ 
+SRCS( 
     marshalling.cc
-)
-
-END()
+) 
+ 
+END() 
diff --git a/contrib/restricted/abseil-cpp/absl/flags/parse.cc b/contrib/restricted/abseil-cpp/absl/flags/parse.cc
index dd1a6796ca..5c8738309d 100644
--- a/contrib/restricted/abseil-cpp/absl/flags/parse.cc
+++ b/contrib/restricted/abseil-cpp/absl/flags/parse.cc
@@ -713,11 +713,11 @@ std::vector<char*> ParseCommandLineImpl(int argc, char* argv[],
     std::tie(flag, is_negative) = LocateFlag(flag_name);
 
     if (flag == nullptr) {
-      // Usage flags are not modeled as Abseil flags. Locate them separately.
-      if (flags_internal::DeduceUsageFlags(flag_name, value)) {
-        continue;
-      }
-
+      // Usage flags are not modeled as Abseil flags. Locate them separately. 
+      if (flags_internal::DeduceUsageFlags(flag_name, value)) { 
+        continue; 
+      } 
+ 
       if (on_undef_flag != OnUndefinedFlag::kIgnoreUndefined) {
         undefined_flag_names.emplace_back(arg_from_argv,
                                           std::string(flag_name));
diff --git a/contrib/restricted/abseil-cpp/absl/flags/reflection.cc b/contrib/restricted/abseil-cpp/absl/flags/reflection.cc
index dbce4032ab..5dde972b1b 100644
--- a/contrib/restricted/abseil-cpp/absl/flags/reflection.cc
+++ b/contrib/restricted/abseil-cpp/absl/flags/reflection.cc
@@ -50,7 +50,7 @@ class FlagRegistry {
   ~FlagRegistry() = default;
 
   // Store a flag in this registry. Takes ownership of *flag.
-  void RegisterFlag(CommandLineFlag& flag, const char* filename);
+  void RegisterFlag(CommandLineFlag& flag, const char* filename); 
 
   void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION(lock_) { lock_.Lock(); }
   void Unlock() ABSL_UNLOCK_FUNCTION(lock_) { lock_.Unlock(); }
@@ -110,20 +110,20 @@ CommandLineFlag* FlagRegistry::FindFlag(absl::string_view name) {
   return it != flags_.end() ? it->second : nullptr;
 }
 
-void FlagRegistry::RegisterFlag(CommandLineFlag& flag, const char* filename) {
-  if (filename != nullptr &&
-      flag.Filename() != GetUsageConfig().normalize_filename(filename)) {
-    flags_internal::ReportUsageError(
-        absl::StrCat(
-            "Inconsistency between flag object and registration for flag '",
-            flag.Name(),
-            "', likely due to duplicate flags or an ODR violation. Relevant "
-            "files: ",
-            flag.Filename(), " and ", filename),
-        true);
-    std::exit(1);
-  }
-
+void FlagRegistry::RegisterFlag(CommandLineFlag& flag, const char* filename) { 
+  if (filename != nullptr && 
+      flag.Filename() != GetUsageConfig().normalize_filename(filename)) { 
+    flags_internal::ReportUsageError( 
+        absl::StrCat( 
+            "Inconsistency between flag object and registration for flag '", 
+            flag.Name(), 
+            "', likely due to duplicate flags or an ODR violation. Relevant " 
+            "files: ", 
+            flag.Filename(), " and ", filename), 
+        true); 
+    std::exit(1); 
+  } 
+ 
   FlagRegistryLock registry_lock(*this);
 
   std::pair<FlagIterator, bool> ins =
@@ -188,8 +188,8 @@ void ForEachFlag(std::function<void(CommandLineFlag&)> visitor) {
 
 // --------------------------------------------------------------------
 
-bool RegisterCommandLineFlag(CommandLineFlag& flag, const char* filename) {
-  FlagRegistry::GlobalRegistry().RegisterFlag(flag, filename);
+bool RegisterCommandLineFlag(CommandLineFlag& flag, const char* filename) { 
+  FlagRegistry::GlobalRegistry().RegisterFlag(flag, filename); 
   return true;
 }
 
@@ -283,7 +283,7 @@ void Retire(const char* name, FlagFastTypeId type_id, char* buf) {
   static_assert(alignof(RetiredFlagObj) == kRetiredFlagObjAlignment, "");
   auto* flag = ::new (static_cast<void*>(buf))
       flags_internal::RetiredFlagObj(name, type_id);
-  FlagRegistry::GlobalRegistry().RegisterFlag(*flag, nullptr);
+  FlagRegistry::GlobalRegistry().RegisterFlag(*flag, nullptr); 
 }
 
 // --------------------------------------------------------------------
@@ -345,7 +345,7 @@ CommandLineFlag* FindCommandLineFlag(absl::string_view name) {
 absl::flat_hash_map<absl::string_view, absl::CommandLineFlag*> GetAllFlags() {
   absl::flat_hash_map<absl::string_view, absl::CommandLineFlag*> res;
   flags_internal::ForEachFlag([&](CommandLineFlag& flag) {
-    if (!flag.IsRetired()) res.insert({flag.Name(), &flag});
+    if (!flag.IsRetired()) res.insert({flag.Name(), &flag}); 
   });
   return res;
 }
diff --git a/contrib/restricted/abseil-cpp/absl/flags/reflection.h b/contrib/restricted/abseil-cpp/absl/flags/reflection.h
index e6baf5de4b..f38292b8db 100644
--- a/contrib/restricted/abseil-cpp/absl/flags/reflection.h
+++ b/contrib/restricted/abseil-cpp/absl/flags/reflection.h
@@ -64,7 +64,7 @@ absl::flat_hash_map<absl::string_view, absl::CommandLineFlag*> GetAllFlags();
 //   void MyFunc() {
 //    absl::FlagSaver fs;
 //    ...
-//    absl::SetFlag(&FLAGS_myFlag, otherValue);
+//    absl::SetFlag(&FLAGS_myFlag, otherValue); 
 //    ...
 //  } // scope of FlagSaver left, flags return to previous state
 //
diff --git a/contrib/restricted/abseil-cpp/absl/flags/reflection/ya.make b/contrib/restricted/abseil-cpp/absl/flags/reflection/ya.make
index f75bc1c67d..0936f25e48 100644
--- a/contrib/restricted/abseil-cpp/absl/flags/reflection/ya.make
+++ b/contrib/restricted/abseil-cpp/absl/flags/reflection/ya.make
@@ -10,7 +10,7 @@ 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/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
@@ -18,10 +18,10 @@ PEERDIR(
     contrib/restricted/abseil-cpp/absl/city
     contrib/restricted/abseil-cpp/absl/container/internal/absl_hashtablez_sampler
     contrib/restricted/abseil-cpp/absl/container/internal/raw_hash_set
-    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/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/flags/commandlineflag
     contrib/restricted/abseil-cpp/absl/flags/internal/commandlineflag
     contrib/restricted/abseil-cpp/absl/flags/internal/private_handle_accessor
@@ -43,7 +43,7 @@ PEERDIR(
     contrib/restricted/abseil-cpp/absl/time
     contrib/restricted/abseil-cpp/absl/time/civil_time
     contrib/restricted/abseil-cpp/absl/time/time_zone
-    contrib/restricted/abseil-cpp/absl/types/bad_optional_access
+    contrib/restricted/abseil-cpp/absl/types/bad_optional_access 
     contrib/restricted/abseil-cpp/absl/types/bad_variant_access
 )
 
diff --git a/contrib/restricted/abseil-cpp/absl/flags/usage/ya.make b/contrib/restricted/abseil-cpp/absl/flags/usage/ya.make
index f6b243c84c..b5879008eb 100644
--- a/contrib/restricted/abseil-cpp/absl/flags/usage/ya.make
+++ b/contrib/restricted/abseil-cpp/absl/flags/usage/ya.make
@@ -33,7 +33,7 @@ PEERDIR(
     contrib/restricted/abseil-cpp/absl/flags/reflection
     contrib/restricted/abseil-cpp/absl/flags/usage_config
     contrib/restricted/abseil-cpp/absl/hash
-    contrib/restricted/abseil-cpp/absl/hash/internal
+    contrib/restricted/abseil-cpp/absl/hash/internal 
     contrib/restricted/abseil-cpp/absl/numeric
     contrib/restricted/abseil-cpp/absl/profiling/internal/exponential_biased
     contrib/restricted/abseil-cpp/absl/strings
diff --git a/contrib/restricted/abseil-cpp/absl/flags/usage_config.cc b/contrib/restricted/abseil-cpp/absl/flags/usage_config.cc
index 5d7426db31..acf437a90c 100644
--- a/contrib/restricted/abseil-cpp/absl/flags/usage_config.cc
+++ b/contrib/restricted/abseil-cpp/absl/flags/usage_config.cc
@@ -34,8 +34,8 @@ extern "C" {
 
 // Additional report of fatal usage error message before we std::exit. Error is
 // fatal if is_fatal argument to ReportUsageError is true.
-ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(
-    AbslInternalReportFatalUsageError)(absl::string_view) {}
+ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL( 
+    AbslInternalReportFatalUsageError)(absl::string_view) {} 
 
 }  // extern "C"
 
@@ -129,7 +129,7 @@ void ReportUsageError(absl::string_view msg, bool is_fatal) {
   std::cerr << "ERROR: " << msg << std::endl;
 
   if (is_fatal) {
-    ABSL_INTERNAL_C_SYMBOL(AbslInternalReportFatalUsageError)(msg);
+    ABSL_INTERNAL_C_SYMBOL(AbslInternalReportFatalUsageError)(msg); 
   }
 }
 
diff --git a/contrib/restricted/abseil-cpp/absl/flags/usage_config.h b/contrib/restricted/abseil-cpp/absl/flags/usage_config.h
index ded70300f0..5a1acaf9be 100644
--- a/contrib/restricted/abseil-cpp/absl/flags/usage_config.h
+++ b/contrib/restricted/abseil-cpp/absl/flags/usage_config.h
@@ -127,8 +127,8 @@ extern "C" {
 
 // Additional report of fatal usage error message before we std::exit. Error is
 // fatal if is_fatal argument to ReportUsageError is true.
-void ABSL_INTERNAL_C_SYMBOL(AbslInternalReportFatalUsageError)(
-    absl::string_view);
+void ABSL_INTERNAL_C_SYMBOL(AbslInternalReportFatalUsageError)( 
+    absl::string_view); 
 
 }  // extern "C"
 
diff --git a/contrib/restricted/abseil-cpp/absl/flags/ya.make b/contrib/restricted/abseil-cpp/absl/flags/ya.make
index 983809b80c..ec1b324e17 100644
--- a/contrib/restricted/abseil-cpp/absl/flags/ya.make
+++ b/contrib/restricted/abseil-cpp/absl/flags/ya.make
@@ -1,20 +1,20 @@
-# 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
+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/city
     contrib/restricted/abseil-cpp/absl/container/internal/absl_hashtablez_sampler
     contrib/restricted/abseil-cpp/absl/container/internal/raw_hash_set
@@ -32,9 +32,9 @@ PEERDIR(
     contrib/restricted/abseil-cpp/absl/flags/usage_config
     contrib/restricted/abseil-cpp/absl/hash
     contrib/restricted/abseil-cpp/absl/hash/internal
-    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/cord
     contrib/restricted/abseil-cpp/absl/strings/internal/absl_cord_internal
     contrib/restricted/abseil-cpp/absl/strings/internal/absl_strings_internal
@@ -47,24 +47,24 @@ PEERDIR(
     contrib/restricted/abseil-cpp/absl/time
     contrib/restricted/abseil-cpp/absl/time/civil_time
     contrib/restricted/abseil-cpp/absl/time/time_zone
-    contrib/restricted/abseil-cpp/absl/types/bad_optional_access
+    contrib/restricted/abseil-cpp/absl/types/bad_optional_access 
     contrib/restricted/abseil-cpp/absl/types/bad_variant_access
-)
-
-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( 
     flag.cc
-)
-
-END()
+) 
+ 
+END() 
diff --git a/contrib/restricted/abseil-cpp/absl/hash/internal/city.cc b/contrib/restricted/abseil-cpp/absl/hash/internal/city.cc
index 5460134e57..01bd850482 100644
--- a/contrib/restricted/abseil-cpp/absl/hash/internal/city.cc
+++ b/contrib/restricted/abseil-cpp/absl/hash/internal/city.cc
@@ -210,11 +210,11 @@ static uint64_t HashLen16(uint64_t u, uint64_t v, uint64_t mul) {
   return b;
 }
 
-static uint64_t HashLen16(uint64_t u, uint64_t v) {
-  const uint64_t kMul = 0x9ddfea08eb382d69ULL;
-  return HashLen16(u, v, kMul);
-}
-
+static uint64_t HashLen16(uint64_t u, uint64_t v) { 
+  const uint64_t kMul = 0x9ddfea08eb382d69ULL; 
+  return HashLen16(u, v, kMul); 
+} 
+ 
 static uint64_t HashLen0to16(const char *s, size_t len) {
   if (len >= 8) {
     uint64_t mul = k2 + len * 2;
diff --git a/contrib/restricted/abseil-cpp/absl/hash/internal/hash.cc b/contrib/restricted/abseil-cpp/absl/hash/internal/hash.cc
index 11451e575c..f8cb56df18 100644
--- a/contrib/restricted/abseil-cpp/absl/hash/internal/hash.cc
+++ b/contrib/restricted/abseil-cpp/absl/hash/internal/hash.cc
@@ -35,7 +35,7 @@ uint64_t MixingHashState::CombineLargeContiguousImpl32(
 uint64_t MixingHashState::CombineLargeContiguousImpl64(
     uint64_t state, const unsigned char* first, size_t len) {
   while (len >= PiecewiseChunkSize()) {
-    state = Mix(state, Hash64(first, PiecewiseChunkSize()));
+    state = Mix(state, Hash64(first, PiecewiseChunkSize())); 
     len -= PiecewiseChunkSize();
     first += PiecewiseChunkSize();
   }
@@ -49,21 +49,21 @@ ABSL_CONST_INIT const void* const MixingHashState::kSeed = &kSeed;
 // The salt array used by LowLevelHash. This array is NOT the mechanism used to
 // make absl::Hash non-deterministic between program invocations.  See `Seed()`
 // for that mechanism.
-//
-// Any random values are fine. These values are just digits from the decimal
-// part of pi.
-// https://en.wikipedia.org/wiki/Nothing-up-my-sleeve_number
+// 
+// Any random values are fine. These values are just digits from the decimal 
+// part of pi. 
+// https://en.wikipedia.org/wiki/Nothing-up-my-sleeve_number 
 constexpr uint64_t kHashSalt[5] = {
-    uint64_t{0x243F6A8885A308D3}, uint64_t{0x13198A2E03707344},
-    uint64_t{0xA4093822299F31D0}, uint64_t{0x082EFA98EC4E6C89},
-    uint64_t{0x452821E638D01377},
-};
-
+    uint64_t{0x243F6A8885A308D3}, uint64_t{0x13198A2E03707344}, 
+    uint64_t{0xA4093822299F31D0}, uint64_t{0x082EFA98EC4E6C89}, 
+    uint64_t{0x452821E638D01377}, 
+}; 
+ 
 uint64_t MixingHashState::LowLevelHashImpl(const unsigned char* data,
                                            size_t len) {
   return LowLevelHash(data, len, Seed(), kHashSalt);
-}
-
+} 
+ 
 }  // namespace hash_internal
 ABSL_NAMESPACE_END
 }  // namespace absl
diff --git a/contrib/restricted/abseil-cpp/absl/hash/internal/hash.h b/contrib/restricted/abseil-cpp/absl/hash/internal/hash.h
index b1e33caf4c..f6c4a148b8 100644
--- a/contrib/restricted/abseil-cpp/absl/hash/internal/hash.h
+++ b/contrib/restricted/abseil-cpp/absl/hash/internal/hash.h
@@ -39,8 +39,8 @@
 #include <utility>
 #include <vector>
 
-#include "absl/base/config.h"
-#include "absl/base/internal/unaligned_access.h"
+#include "absl/base/config.h" 
+#include "absl/base/internal/unaligned_access.h" 
 #include "absl/base/port.h"
 #include "absl/container/fixed_array.h"
 #include "absl/hash/internal/city.h"
@@ -834,7 +834,7 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
   static uint64_t CombineContiguousImpl(uint64_t state,
                                         const unsigned char* first, size_t len,
                                         std::integral_constant<int, 8>
-                                        /* sizeof_size_t */);
+                                        /* sizeof_size_t */); 
 
   // Slow dispatch path for calls to CombineContiguousImpl with a size argument
   // larger than PiecewiseChunkSize().  Has the same effect as calling
@@ -847,54 +847,54 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
                                                size_t len);
 
   // Reads 9 to 16 bytes from p.
-  // The least significant 8 bytes are in .first, the rest (zero padded) bytes
-  // are in .second.
+  // The least significant 8 bytes are in .first, the rest (zero padded) bytes 
+  // are in .second. 
   static std::pair<uint64_t, uint64_t> Read9To16(const unsigned char* p,
                                                  size_t len) {
-    uint64_t low_mem = absl::base_internal::UnalignedLoad64(p);
-    uint64_t high_mem = absl::base_internal::UnalignedLoad64(p + len - 8);
-#ifdef ABSL_IS_LITTLE_ENDIAN
-    uint64_t most_significant = high_mem;
-    uint64_t least_significant = low_mem;
-#else
-    uint64_t most_significant = low_mem;
-    uint64_t least_significant = high_mem;
-#endif
-    return {least_significant, most_significant >> (128 - len * 8)};
+    uint64_t low_mem = absl::base_internal::UnalignedLoad64(p); 
+    uint64_t high_mem = absl::base_internal::UnalignedLoad64(p + len - 8); 
+#ifdef ABSL_IS_LITTLE_ENDIAN 
+    uint64_t most_significant = high_mem; 
+    uint64_t least_significant = low_mem; 
+#else 
+    uint64_t most_significant = low_mem; 
+    uint64_t least_significant = high_mem; 
+#endif 
+    return {least_significant, most_significant >> (128 - len * 8)}; 
   }
 
   // Reads 4 to 8 bytes from p. Zero pads to fill uint64_t.
   static uint64_t Read4To8(const unsigned char* p, size_t len) {
-    uint32_t low_mem = absl::base_internal::UnalignedLoad32(p);
-    uint32_t high_mem = absl::base_internal::UnalignedLoad32(p + len - 4);
-#ifdef ABSL_IS_LITTLE_ENDIAN
-    uint32_t most_significant = high_mem;
-    uint32_t least_significant = low_mem;
-#else
-    uint32_t most_significant = low_mem;
-    uint32_t least_significant = high_mem;
-#endif
-    return (static_cast<uint64_t>(most_significant) << (len - 4) * 8) |
-           least_significant;
+    uint32_t low_mem = absl::base_internal::UnalignedLoad32(p); 
+    uint32_t high_mem = absl::base_internal::UnalignedLoad32(p + len - 4); 
+#ifdef ABSL_IS_LITTLE_ENDIAN 
+    uint32_t most_significant = high_mem; 
+    uint32_t least_significant = low_mem; 
+#else 
+    uint32_t most_significant = low_mem; 
+    uint32_t least_significant = high_mem; 
+#endif 
+    return (static_cast<uint64_t>(most_significant) << (len - 4) * 8) | 
+           least_significant; 
   }
 
   // Reads 1 to 3 bytes from p. Zero pads to fill uint32_t.
   static uint32_t Read1To3(const unsigned char* p, size_t len) {
-    unsigned char mem0 = p[0];
-    unsigned char mem1 = p[len / 2];
-    unsigned char mem2 = p[len - 1];
-#ifdef ABSL_IS_LITTLE_ENDIAN
-    unsigned char significant2 = mem2;
-    unsigned char significant1 = mem1;
-    unsigned char significant0 = mem0;
-#else
-    unsigned char significant2 = mem0;
-    unsigned char significant1 = mem1;
-    unsigned char significant0 = mem2;
-#endif
-    return static_cast<uint32_t>(significant0 |                     //
-                                 (significant1 << (len / 2 * 8)) |  //
-                                 (significant2 << ((len - 1) * 8)));
+    unsigned char mem0 = p[0]; 
+    unsigned char mem1 = p[len / 2]; 
+    unsigned char mem2 = p[len - 1]; 
+#ifdef ABSL_IS_LITTLE_ENDIAN 
+    unsigned char significant2 = mem2; 
+    unsigned char significant1 = mem1; 
+    unsigned char significant0 = mem0; 
+#else 
+    unsigned char significant2 = mem0; 
+    unsigned char significant1 = mem1; 
+    unsigned char significant0 = mem2; 
+#endif 
+    return static_cast<uint32_t>(significant0 |                     // 
+                                 (significant1 << (len / 2 * 8)) |  // 
+                                 (significant2 << ((len - 1) * 8))); 
   }
 
   ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Mix(uint64_t state, uint64_t v) {
@@ -919,16 +919,16 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
   // An extern to avoid bloat on a direct call to LowLevelHash() with fixed
   // values for both the seed and salt parameters.
   static uint64_t LowLevelHashImpl(const unsigned char* data, size_t len);
-
-  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Hash64(const unsigned char* data,
-                                                      size_t len) {
-#ifdef ABSL_HAVE_INTRINSIC_INT128
+ 
+  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Hash64(const unsigned char* data, 
+                                                      size_t len) { 
+#ifdef ABSL_HAVE_INTRINSIC_INT128 
     return LowLevelHashImpl(data, len);
-#else
+#else 
     return hash_internal::CityHash64(reinterpret_cast<const char*>(data), len);
-#endif
-  }
-
+#endif 
+  } 
+ 
   // Seed()
   //
   // A non-deterministic seed.
@@ -946,14 +946,14 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
   // On other platforms this is still going to be non-deterministic but most
   // probably per-build and not per-process.
   ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Seed() {
-#if (!defined(__clang__) || __clang_major__ > 11) && \
-    !defined(__apple_build_version__)
-    return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(&kSeed));
-#else
-    // Workaround the absence of
-    // https://github.com/llvm/llvm-project/commit/bc15bf66dcca76cc06fe71fca35b74dc4d521021.
+#if (!defined(__clang__) || __clang_major__ > 11) && \ 
+    !defined(__apple_build_version__) 
+    return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(&kSeed)); 
+#else 
+    // Workaround the absence of 
+    // https://github.com/llvm/llvm-project/commit/bc15bf66dcca76cc06fe71fca35b74dc4d521021. 
     return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(kSeed));
-#endif
+#endif 
   }
   static const void* const kSeed;
 
@@ -994,7 +994,7 @@ inline uint64_t MixingHashState::CombineContiguousImpl(
     if (ABSL_PREDICT_FALSE(len > PiecewiseChunkSize())) {
       return CombineLargeContiguousImpl64(state, first, len);
     }
-    v = Hash64(first, len);
+    v = Hash64(first, len); 
   } else if (len > 8) {
     auto p = Read9To16(first, len);
     state = Mix(state, p.first);
diff --git a/contrib/restricted/abseil-cpp/absl/hash/internal/low_level_hash.cc b/contrib/restricted/abseil-cpp/absl/hash/internal/low_level_hash.cc
index 6f9cb9c7bf..865f5901c8 100644
--- a/contrib/restricted/abseil-cpp/absl/hash/internal/low_level_hash.cc
+++ b/contrib/restricted/abseil-cpp/absl/hash/internal/low_level_hash.cc
@@ -1,33 +1,33 @@
-// 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.
-
+// 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/hash/internal/low_level_hash.h"
-
-#include "absl/base/internal/unaligned_access.h"
+ 
+#include "absl/base/internal/unaligned_access.h" 
 #include "absl/numeric/bits.h"
-#include "absl/numeric/int128.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace hash_internal {
-
+#include "absl/numeric/int128.h" 
+ 
+namespace absl { 
+ABSL_NAMESPACE_BEGIN 
+namespace hash_internal { 
+ 
 static uint64_t Mix(uint64_t v0, uint64_t v1) {
 #if !defined(__aarch64__)
   // The default bit-mixer uses 64x64->128-bit multiplication.
-  absl::uint128 p = v0;
-  p *= v1;
-  return absl::Uint128Low64(p) ^ absl::Uint128High64(p);
+  absl::uint128 p = v0; 
+  p *= v1; 
+  return absl::Uint128Low64(p) ^ absl::Uint128High64(p); 
 #else
   // The default bit-mixer above would perform poorly on some ARM microarchs,
   // where calculating a 128-bit product requires a sequence of two
@@ -37,87 +37,87 @@ static uint64_t Mix(uint64_t v0, uint64_t v1) {
   p *= v1 ^ absl::rotl(v0, 39);
   return p ^ (p >> 11);
 #endif
-}
-
+} 
+ 
 uint64_t LowLevelHash(const void* data, size_t len, uint64_t seed,
                       const uint64_t salt[]) {
-  const uint8_t* ptr = static_cast<const uint8_t*>(data);
-  uint64_t starting_length = static_cast<uint64_t>(len);
-  uint64_t current_state = seed ^ salt[0];
-
-  if (len > 64) {
-    // If we have more than 64 bytes, we're going to handle chunks of 64
-    // bytes at a time. We're going to build up two separate hash states
-    // which we will then hash together.
-    uint64_t duplicated_state = current_state;
-
-    do {
-      uint64_t a = absl::base_internal::UnalignedLoad64(ptr);
-      uint64_t b = absl::base_internal::UnalignedLoad64(ptr + 8);
-      uint64_t c = absl::base_internal::UnalignedLoad64(ptr + 16);
-      uint64_t d = absl::base_internal::UnalignedLoad64(ptr + 24);
-      uint64_t e = absl::base_internal::UnalignedLoad64(ptr + 32);
-      uint64_t f = absl::base_internal::UnalignedLoad64(ptr + 40);
-      uint64_t g = absl::base_internal::UnalignedLoad64(ptr + 48);
-      uint64_t h = absl::base_internal::UnalignedLoad64(ptr + 56);
-
+  const uint8_t* ptr = static_cast<const uint8_t*>(data); 
+  uint64_t starting_length = static_cast<uint64_t>(len); 
+  uint64_t current_state = seed ^ salt[0]; 
+ 
+  if (len > 64) { 
+    // If we have more than 64 bytes, we're going to handle chunks of 64 
+    // bytes at a time. We're going to build up two separate hash states 
+    // which we will then hash together. 
+    uint64_t duplicated_state = current_state; 
+ 
+    do { 
+      uint64_t a = absl::base_internal::UnalignedLoad64(ptr); 
+      uint64_t b = absl::base_internal::UnalignedLoad64(ptr + 8); 
+      uint64_t c = absl::base_internal::UnalignedLoad64(ptr + 16); 
+      uint64_t d = absl::base_internal::UnalignedLoad64(ptr + 24); 
+      uint64_t e = absl::base_internal::UnalignedLoad64(ptr + 32); 
+      uint64_t f = absl::base_internal::UnalignedLoad64(ptr + 40); 
+      uint64_t g = absl::base_internal::UnalignedLoad64(ptr + 48); 
+      uint64_t h = absl::base_internal::UnalignedLoad64(ptr + 56); 
+ 
       uint64_t cs0 = Mix(a ^ salt[1], b ^ current_state);
       uint64_t cs1 = Mix(c ^ salt[2], d ^ current_state);
-      current_state = (cs0 ^ cs1);
-
+      current_state = (cs0 ^ cs1); 
+ 
       uint64_t ds0 = Mix(e ^ salt[3], f ^ duplicated_state);
       uint64_t ds1 = Mix(g ^ salt[4], h ^ duplicated_state);
-      duplicated_state = (ds0 ^ ds1);
-
-      ptr += 64;
-      len -= 64;
-    } while (len > 64);
-
-    current_state = current_state ^ duplicated_state;
-  }
-
-  // We now have a data `ptr` with at most 64 bytes and the current state
-  // of the hashing state machine stored in current_state.
-  while (len > 16) {
-    uint64_t a = absl::base_internal::UnalignedLoad64(ptr);
-    uint64_t b = absl::base_internal::UnalignedLoad64(ptr + 8);
-
+      duplicated_state = (ds0 ^ ds1); 
+ 
+      ptr += 64; 
+      len -= 64; 
+    } while (len > 64); 
+ 
+    current_state = current_state ^ duplicated_state; 
+  } 
+ 
+  // We now have a data `ptr` with at most 64 bytes and the current state 
+  // of the hashing state machine stored in current_state. 
+  while (len > 16) { 
+    uint64_t a = absl::base_internal::UnalignedLoad64(ptr); 
+    uint64_t b = absl::base_internal::UnalignedLoad64(ptr + 8); 
+ 
     current_state = Mix(a ^ salt[1], b ^ current_state);
-
-    ptr += 16;
-    len -= 16;
-  }
-
-  // We now have a data `ptr` with at most 16 bytes.
-  uint64_t a = 0;
-  uint64_t b = 0;
-  if (len > 8) {
-    // When we have at least 9 and at most 16 bytes, set A to the first 64
-    // bits of the input and B to the last 64 bits of the input. Yes, they will
-    // overlap in the middle if we are working with less than the full 16
-    // bytes.
-    a = absl::base_internal::UnalignedLoad64(ptr);
-    b = absl::base_internal::UnalignedLoad64(ptr + len - 8);
-  } else if (len > 3) {
-    // If we have at least 4 and at most 8 bytes, set A to the first 32
-    // bits and B to the last 32 bits.
-    a = absl::base_internal::UnalignedLoad32(ptr);
-    b = absl::base_internal::UnalignedLoad32(ptr + len - 4);
-  } else if (len > 0) {
-    // If we have at least 1 and at most 3 bytes, read all of the provided
-    // bits into A, with some adjustments.
-    a = ((ptr[0] << 16) | (ptr[len >> 1] << 8) | ptr[len - 1]);
-    b = 0;
-  } else {
-    a = 0;
-    b = 0;
-  }
-
+ 
+    ptr += 16; 
+    len -= 16; 
+  } 
+ 
+  // We now have a data `ptr` with at most 16 bytes. 
+  uint64_t a = 0; 
+  uint64_t b = 0; 
+  if (len > 8) { 
+    // When we have at least 9 and at most 16 bytes, set A to the first 64 
+    // bits of the input and B to the last 64 bits of the input. Yes, they will 
+    // overlap in the middle if we are working with less than the full 16 
+    // bytes. 
+    a = absl::base_internal::UnalignedLoad64(ptr); 
+    b = absl::base_internal::UnalignedLoad64(ptr + len - 8); 
+  } else if (len > 3) { 
+    // If we have at least 4 and at most 8 bytes, set A to the first 32 
+    // bits and B to the last 32 bits. 
+    a = absl::base_internal::UnalignedLoad32(ptr); 
+    b = absl::base_internal::UnalignedLoad32(ptr + len - 4); 
+  } else if (len > 0) { 
+    // If we have at least 1 and at most 3 bytes, read all of the provided 
+    // bits into A, with some adjustments. 
+    a = ((ptr[0] << 16) | (ptr[len >> 1] << 8) | ptr[len - 1]); 
+    b = 0; 
+  } else { 
+    a = 0; 
+    b = 0; 
+  } 
+ 
   uint64_t w = Mix(a ^ salt[1], b ^ current_state);
-  uint64_t z = salt[1] ^ starting_length;
+  uint64_t z = salt[1] ^ starting_length; 
   return Mix(w, z);
-}
-
-}  // namespace hash_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
+} 
+ 
+}  // namespace hash_internal 
+ABSL_NAMESPACE_END 
+}  // namespace absl 
diff --git a/contrib/restricted/abseil-cpp/absl/hash/internal/low_level_hash.h b/contrib/restricted/abseil-cpp/absl/hash/internal/low_level_hash.h
index 439968aa98..3409f41b61 100644
--- a/contrib/restricted/abseil-cpp/absl/hash/internal/low_level_hash.h
+++ b/contrib/restricted/abseil-cpp/absl/hash/internal/low_level_hash.h
@@ -1,19 +1,19 @@
-// 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.
-//
+// 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. 
+// 
 // This file provides the Google-internal implementation of LowLevelHash.
-//
+// 
 // LowLevelHash is a fast hash function for hash tables, the fastest we've
 // currently (late 2020) found that passes the SMHasher tests. The algorithm
 // relies on intrinsic 128-bit multiplication for speed. This is not meant to be
@@ -21,30 +21,30 @@
 //
 // It is closely based on a version of wyhash, but does not maintain or
 // guarantee future compatibility with it.
-
+ 
 #ifndef ABSL_HASH_INTERNAL_LOW_LEVEL_HASH_H_
 #define ABSL_HASH_INTERNAL_LOW_LEVEL_HASH_H_
-
-#include <stdint.h>
-#include <stdlib.h>
-
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace hash_internal {
-
-// Hash function for a byte array. A 64-bit seed and a set of five 64-bit
-// integers are hashed into the result.
-//
-// To allow all hashable types (including string_view and Span) to depend on
+ 
+#include <stdint.h> 
+#include <stdlib.h> 
+ 
+#include "absl/base/config.h" 
+ 
+namespace absl { 
+ABSL_NAMESPACE_BEGIN 
+namespace hash_internal { 
+ 
+// Hash function for a byte array. A 64-bit seed and a set of five 64-bit 
+// integers are hashed into the result. 
+// 
+// To allow all hashable types (including string_view and Span) to depend on 
 // this algorithm, we keep the API low-level, with as few dependencies as
-// possible.
+// possible. 
 uint64_t LowLevelHash(const void* data, size_t len, uint64_t seed,
                       const uint64_t salt[5]);
-
-}  // namespace hash_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
+ 
+}  // namespace hash_internal 
+ABSL_NAMESPACE_END 
+}  // namespace absl 
+ 
 #endif  // ABSL_HASH_INTERNAL_LOW_LEVEL_HASH_H_
diff --git a/contrib/restricted/abseil-cpp/absl/hash/ya.make b/contrib/restricted/abseil-cpp/absl/hash/ya.make
index f71202900a..12ce2b67fe 100644
--- a/contrib/restricted/abseil-cpp/absl/hash/ya.make
+++ b/contrib/restricted/abseil-cpp/absl/hash/ya.make
@@ -1,44 +1,44 @@
-# 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
+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/city
     contrib/restricted/abseil-cpp/absl/hash/internal
-    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/types
-    contrib/restricted/abseil-cpp/absl/types/bad_optional_access
+    contrib/restricted/abseil-cpp/absl/types/bad_optional_access 
     contrib/restricted/abseil-cpp/absl/types/bad_variant_access
     contrib/restricted/abseil-cpp/absl/types/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( 
     internal/hash.cc
-)
-
-END()
+) 
+ 
+END() 
diff --git a/contrib/restricted/abseil-cpp/absl/meta/type_traits.h b/contrib/restricted/abseil-cpp/absl/meta/type_traits.h
index d886cb30a8..6368cfff3f 100644
--- a/contrib/restricted/abseil-cpp/absl/meta/type_traits.h
+++ b/contrib/restricted/abseil-cpp/absl/meta/type_traits.h
@@ -641,23 +641,23 @@ using underlying_type_t = typename std::underlying_type<T>::type;
 
 
 namespace type_traits_internal {
-
+ 
 #if (defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703L) || \
     (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
-// std::result_of is deprecated (C++17) or removed (C++20)
-template<typename> struct result_of;
-template<typename F, typename... Args>
-struct result_of<F(Args...)> : std::invoke_result<F, Args...> {};
-#else
-template<typename F> using result_of = std::result_of<F>;
-#endif
-
-}  // namespace type_traits_internal
-
-template<typename F>
-using result_of_t = typename type_traits_internal::result_of<F>::type;
-
-namespace type_traits_internal {
+// std::result_of is deprecated (C++17) or removed (C++20) 
+template<typename> struct result_of; 
+template<typename F, typename... Args> 
+struct result_of<F(Args...)> : std::invoke_result<F, Args...> {}; 
+#else 
+template<typename F> using result_of = std::result_of<F>; 
+#endif 
+ 
+}  // namespace type_traits_internal 
+ 
+template<typename F> 
+using result_of_t = typename type_traits_internal::result_of<F>::type; 
+ 
+namespace type_traits_internal { 
 // In MSVC we can't probe std::hash or stdext::hash because it triggers a
 // static_assert instead of failing substitution. Libc++ prior to 4.0
 // also used a static_assert.
diff --git a/contrib/restricted/abseil-cpp/absl/numeric/bits.h b/contrib/restricted/abseil-cpp/absl/numeric/bits.h
index 52013ad49b..f5381d8f94 100644
--- a/contrib/restricted/abseil-cpp/absl/numeric/bits.h
+++ b/contrib/restricted/abseil-cpp/absl/numeric/bits.h
@@ -1,177 +1,177 @@
-// 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.
-//
-// -----------------------------------------------------------------------------
-// File: bits.h
-// -----------------------------------------------------------------------------
-//
-// This file contains implementations of C++20's bitwise math functions, as
-// defined by:
-//
-// P0553R4:
-//  http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0553r4.html
-// P0556R3:
-//  http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0556r3.html
-// P1355R2:
-//  http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1355r2.html
-// P1956R1:
-//  http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p1956r1.pdf
-//
-// When using a standard library that implements these functions, we use the
-// standard library's implementation.
-
-#ifndef ABSL_NUMERIC_BITS_H_
-#define ABSL_NUMERIC_BITS_H_
-
-#include <cstdint>
-#include <limits>
-#include <type_traits>
-
-#if (defined(__cpp_lib_int_pow2) && __cpp_lib_int_pow2 >= 202002L) || \
-    (defined(__cpp_lib_bitops) && __cpp_lib_bitops >= 201907L)
-#include <bit>
-#endif
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-#include "absl/numeric/internal/bits.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-#if !(defined(__cpp_lib_bitops) && __cpp_lib_bitops >= 201907L)
-// rotating
-template <class T>
-ABSL_MUST_USE_RESULT constexpr
-    typename std::enable_if<std::is_unsigned<T>::value, T>::type
-    rotl(T x, int s) noexcept {
-  return numeric_internal::RotateLeft(x, s);
-}
-
-template <class T>
-ABSL_MUST_USE_RESULT constexpr
-    typename std::enable_if<std::is_unsigned<T>::value, T>::type
-    rotr(T x, int s) noexcept {
-  return numeric_internal::RotateRight(x, s);
-}
-
-// Counting functions
-//
-// While these functions are typically constexpr, on some platforms, they may
-// not be marked as constexpr due to constraints of the compiler/available
-// intrinsics.
-template <class T>
-ABSL_INTERNAL_CONSTEXPR_CLZ inline
-    typename std::enable_if<std::is_unsigned<T>::value, int>::type
-    countl_zero(T x) noexcept {
-  return numeric_internal::CountLeadingZeroes(x);
-}
-
-template <class T>
-ABSL_INTERNAL_CONSTEXPR_CLZ inline
-    typename std::enable_if<std::is_unsigned<T>::value, int>::type
-    countl_one(T x) noexcept {
-  // Avoid integer promotion to a wider type
-  return countl_zero(static_cast<T>(~x));
-}
-
-template <class T>
-ABSL_INTERNAL_CONSTEXPR_CTZ inline
-    typename std::enable_if<std::is_unsigned<T>::value, int>::type
-    countr_zero(T x) noexcept {
-  return numeric_internal::CountTrailingZeroes(x);
-}
-
-template <class T>
-ABSL_INTERNAL_CONSTEXPR_CTZ inline
-    typename std::enable_if<std::is_unsigned<T>::value, int>::type
-    countr_one(T x) noexcept {
-  // Avoid integer promotion to a wider type
-  return countr_zero(static_cast<T>(~x));
-}
-
-template <class T>
-ABSL_INTERNAL_CONSTEXPR_POPCOUNT inline
-    typename std::enable_if<std::is_unsigned<T>::value, int>::type
-    popcount(T x) noexcept {
-  return numeric_internal::Popcount(x);
-}
-#else  // defined(__cpp_lib_bitops) && __cpp_lib_bitops >= 201907L
-
-using std::countl_one;
-using std::countl_zero;
-using std::countr_one;
-using std::countr_zero;
-using std::popcount;
-using std::rotl;
-using std::rotr;
-
-#endif
-
-#if !(defined(__cpp_lib_int_pow2) && __cpp_lib_int_pow2 >= 202002L)
-// Returns: true if x is an integral power of two; false otherwise.
-template <class T>
-constexpr inline typename std::enable_if<std::is_unsigned<T>::value, bool>::type
-has_single_bit(T x) noexcept {
-  return x != 0 && (x & (x - 1)) == 0;
-}
-
-// Returns: If x == 0, 0; otherwise one plus the base-2 logarithm of x, with any
-// fractional part discarded.
-template <class T>
-ABSL_INTERNAL_CONSTEXPR_CLZ inline
-    typename std::enable_if<std::is_unsigned<T>::value, T>::type
-    bit_width(T x) noexcept {
-  return std::numeric_limits<T>::digits - countl_zero(x);
-}
-
-// Returns: If x == 0, 0; otherwise the maximal value y such that
-// has_single_bit(y) is true and y <= x.
-template <class T>
-ABSL_INTERNAL_CONSTEXPR_CLZ inline
-    typename std::enable_if<std::is_unsigned<T>::value, T>::type
-    bit_floor(T x) noexcept {
-  return x == 0 ? 0 : T{1} << (bit_width(x) - 1);
-}
-
-// Returns: N, where N is the smallest power of 2 greater than or equal to x.
-//
-// Preconditions: N is representable as a value of type T.
-template <class T>
-ABSL_INTERNAL_CONSTEXPR_CLZ inline
-    typename std::enable_if<std::is_unsigned<T>::value, T>::type
-    bit_ceil(T x) {
-  // If T is narrower than unsigned, T{1} << bit_width will be promoted.  We
-  // want to force it to wraparound so that bit_ceil of an invalid value are not
-  // core constant expressions.
-  //
-  // BitCeilNonPowerOf2 triggers an overflow in constexpr contexts if we would
-  // undergo promotion to unsigned but not fit the result into T without
-  // truncation.
-  return has_single_bit(x) ? T{1} << (bit_width(x) - 1)
-                           : numeric_internal::BitCeilNonPowerOf2(x);
-}
-#else  // defined(__cpp_lib_int_pow2) && __cpp_lib_int_pow2 >= 202002L
-
-using std::bit_ceil;
-using std::bit_floor;
-using std::bit_width;
-using std::has_single_bit;
-
-#endif
-
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_NUMERIC_BITS_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. 
+// 
+// ----------------------------------------------------------------------------- 
+// File: bits.h 
+// ----------------------------------------------------------------------------- 
+// 
+// This file contains implementations of C++20's bitwise math functions, as 
+// defined by: 
+// 
+// P0553R4: 
+//  http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0553r4.html 
+// P0556R3: 
+//  http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0556r3.html 
+// P1355R2: 
+//  http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1355r2.html 
+// P1956R1: 
+//  http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p1956r1.pdf 
+// 
+// When using a standard library that implements these functions, we use the 
+// standard library's implementation. 
+ 
+#ifndef ABSL_NUMERIC_BITS_H_ 
+#define ABSL_NUMERIC_BITS_H_ 
+ 
+#include <cstdint> 
+#include <limits> 
+#include <type_traits> 
+ 
+#if (defined(__cpp_lib_int_pow2) && __cpp_lib_int_pow2 >= 202002L) || \ 
+    (defined(__cpp_lib_bitops) && __cpp_lib_bitops >= 201907L) 
+#include <bit> 
+#endif 
+ 
+#include "absl/base/attributes.h" 
+#include "absl/base/config.h" 
+#include "absl/numeric/internal/bits.h" 
+ 
+namespace absl { 
+ABSL_NAMESPACE_BEGIN 
+ 
+#if !(defined(__cpp_lib_bitops) && __cpp_lib_bitops >= 201907L) 
+// rotating 
+template <class T> 
+ABSL_MUST_USE_RESULT constexpr 
+    typename std::enable_if<std::is_unsigned<T>::value, T>::type 
+    rotl(T x, int s) noexcept { 
+  return numeric_internal::RotateLeft(x, s); 
+} 
+ 
+template <class T> 
+ABSL_MUST_USE_RESULT constexpr 
+    typename std::enable_if<std::is_unsigned<T>::value, T>::type 
+    rotr(T x, int s) noexcept { 
+  return numeric_internal::RotateRight(x, s); 
+} 
+ 
+// Counting functions 
+// 
+// While these functions are typically constexpr, on some platforms, they may 
+// not be marked as constexpr due to constraints of the compiler/available 
+// intrinsics. 
+template <class T> 
+ABSL_INTERNAL_CONSTEXPR_CLZ inline 
+    typename std::enable_if<std::is_unsigned<T>::value, int>::type 
+    countl_zero(T x) noexcept { 
+  return numeric_internal::CountLeadingZeroes(x); 
+} 
+ 
+template <class T> 
+ABSL_INTERNAL_CONSTEXPR_CLZ inline 
+    typename std::enable_if<std::is_unsigned<T>::value, int>::type 
+    countl_one(T x) noexcept { 
+  // Avoid integer promotion to a wider type 
+  return countl_zero(static_cast<T>(~x)); 
+} 
+ 
+template <class T> 
+ABSL_INTERNAL_CONSTEXPR_CTZ inline 
+    typename std::enable_if<std::is_unsigned<T>::value, int>::type 
+    countr_zero(T x) noexcept { 
+  return numeric_internal::CountTrailingZeroes(x); 
+} 
+ 
+template <class T> 
+ABSL_INTERNAL_CONSTEXPR_CTZ inline 
+    typename std::enable_if<std::is_unsigned<T>::value, int>::type 
+    countr_one(T x) noexcept { 
+  // Avoid integer promotion to a wider type 
+  return countr_zero(static_cast<T>(~x)); 
+} 
+ 
+template <class T> 
+ABSL_INTERNAL_CONSTEXPR_POPCOUNT inline 
+    typename std::enable_if<std::is_unsigned<T>::value, int>::type 
+    popcount(T x) noexcept { 
+  return numeric_internal::Popcount(x); 
+} 
+#else  // defined(__cpp_lib_bitops) && __cpp_lib_bitops >= 201907L 
+ 
+using std::countl_one; 
+using std::countl_zero; 
+using std::countr_one; 
+using std::countr_zero; 
+using std::popcount; 
+using std::rotl; 
+using std::rotr; 
+ 
+#endif 
+ 
+#if !(defined(__cpp_lib_int_pow2) && __cpp_lib_int_pow2 >= 202002L) 
+// Returns: true if x is an integral power of two; false otherwise. 
+template <class T> 
+constexpr inline typename std::enable_if<std::is_unsigned<T>::value, bool>::type 
+has_single_bit(T x) noexcept { 
+  return x != 0 && (x & (x - 1)) == 0; 
+} 
+ 
+// Returns: If x == 0, 0; otherwise one plus the base-2 logarithm of x, with any 
+// fractional part discarded. 
+template <class T> 
+ABSL_INTERNAL_CONSTEXPR_CLZ inline 
+    typename std::enable_if<std::is_unsigned<T>::value, T>::type 
+    bit_width(T x) noexcept { 
+  return std::numeric_limits<T>::digits - countl_zero(x); 
+} 
+ 
+// Returns: If x == 0, 0; otherwise the maximal value y such that 
+// has_single_bit(y) is true and y <= x. 
+template <class T> 
+ABSL_INTERNAL_CONSTEXPR_CLZ inline 
+    typename std::enable_if<std::is_unsigned<T>::value, T>::type 
+    bit_floor(T x) noexcept { 
+  return x == 0 ? 0 : T{1} << (bit_width(x) - 1); 
+} 
+ 
+// Returns: N, where N is the smallest power of 2 greater than or equal to x. 
+// 
+// Preconditions: N is representable as a value of type T. 
+template <class T> 
+ABSL_INTERNAL_CONSTEXPR_CLZ inline 
+    typename std::enable_if<std::is_unsigned<T>::value, T>::type 
+    bit_ceil(T x) { 
+  // If T is narrower than unsigned, T{1} << bit_width will be promoted.  We 
+  // want to force it to wraparound so that bit_ceil of an invalid value are not 
+  // core constant expressions. 
+  // 
+  // BitCeilNonPowerOf2 triggers an overflow in constexpr contexts if we would 
+  // undergo promotion to unsigned but not fit the result into T without 
+  // truncation. 
+  return has_single_bit(x) ? T{1} << (bit_width(x) - 1) 
+                           : numeric_internal::BitCeilNonPowerOf2(x); 
+} 
+#else  // defined(__cpp_lib_int_pow2) && __cpp_lib_int_pow2 >= 202002L 
+ 
+using std::bit_ceil; 
+using std::bit_floor; 
+using std::bit_width; 
+using std::has_single_bit; 
+ 
+#endif 
+ 
+ABSL_NAMESPACE_END 
+}  // namespace absl 
+ 
+#endif  // ABSL_NUMERIC_BITS_H_ 
diff --git a/contrib/restricted/abseil-cpp/absl/numeric/int128.cc b/contrib/restricted/abseil-cpp/absl/numeric/int128.cc
index 4f91e48463..07bfbc593f 100644
--- a/contrib/restricted/abseil-cpp/absl/numeric/int128.cc
+++ b/contrib/restricted/abseil-cpp/absl/numeric/int128.cc
@@ -24,7 +24,7 @@
 #include <type_traits>
 
 #include "absl/base/optimization.h"
-#include "absl/numeric/bits.h"
+#include "absl/numeric/bits.h" 
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
@@ -43,11 +43,11 @@ namespace {
 inline ABSL_ATTRIBUTE_ALWAYS_INLINE int Fls128(uint128 n) {
   if (uint64_t hi = Uint128High64(n)) {
     ABSL_INTERNAL_ASSUME(hi != 0);
-    return 127 - countl_zero(hi);
+    return 127 - countl_zero(hi); 
   }
   const uint64_t low = Uint128Low64(n);
   ABSL_INTERNAL_ASSUME(low != 0);
-  return 63 - countl_zero(low);
+  return 63 - countl_zero(low); 
 }
 
 // Long division/modulo for uint128 implemented using the shift-subtract
diff --git a/contrib/restricted/abseil-cpp/absl/numeric/internal/bits.h b/contrib/restricted/abseil-cpp/absl/numeric/internal/bits.h
index bfef06bce1..087ac613cd 100644
--- a/contrib/restricted/abseil-cpp/absl/numeric/internal/bits.h
+++ b/contrib/restricted/abseil-cpp/absl/numeric/internal/bits.h
@@ -1,358 +1,358 @@
-// 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_NUMERIC_INTERNAL_BITS_H_
-#define ABSL_NUMERIC_INTERNAL_BITS_H_
-
-#include <cstdint>
-#include <limits>
-#include <type_traits>
-
-// Clang on Windows has __builtin_clzll; otherwise we need to use the
-// windows intrinsic functions.
-#if defined(_MSC_VER) && !defined(__clang__)
-#include <intrin.h>
-#endif
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-
-#if defined(__GNUC__) && !defined(__clang__)
-// GCC
-#define ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(x) 1
-#else
-#define ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(x) ABSL_HAVE_BUILTIN(x)
-#endif
-
-#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_popcountl) && \
-    ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_popcountll)
-#define ABSL_INTERNAL_CONSTEXPR_POPCOUNT constexpr
-#define ABSL_INTERNAL_HAS_CONSTEXPR_POPCOUNT 1
-#else
-#define ABSL_INTERNAL_CONSTEXPR_POPCOUNT
-#define ABSL_INTERNAL_HAS_CONSTEXPR_POPCOUNT 0
-#endif
-
-#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_clz) && \
-    ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_clzll)
-#define ABSL_INTERNAL_CONSTEXPR_CLZ constexpr
-#define ABSL_INTERNAL_HAS_CONSTEXPR_CLZ 1
-#else
-#define ABSL_INTERNAL_CONSTEXPR_CLZ
-#define ABSL_INTERNAL_HAS_CONSTEXPR_CLZ 0
-#endif
-
-#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctz) && \
-    ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctzll)
-#define ABSL_INTERNAL_CONSTEXPR_CTZ constexpr
-#define ABSL_INTERNAL_HAS_CONSTEXPR_CTZ 1
-#else
-#define ABSL_INTERNAL_CONSTEXPR_CTZ
-#define ABSL_INTERNAL_HAS_CONSTEXPR_CTZ 0
-#endif
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace numeric_internal {
-
-constexpr bool IsPowerOf2(unsigned int x) noexcept {
-  return x != 0 && (x & (x - 1)) == 0;
-}
-
-template <class T>
-ABSL_MUST_USE_RESULT ABSL_ATTRIBUTE_ALWAYS_INLINE constexpr T RotateRight(
-    T x, int s) noexcept {
-  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
-  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
-                "T must have a power-of-2 size");
-
-  return static_cast<T>(x >> (s & (std::numeric_limits<T>::digits - 1))) |
-         static_cast<T>(x << ((-s) & (std::numeric_limits<T>::digits - 1)));
-}
-
-template <class T>
-ABSL_MUST_USE_RESULT ABSL_ATTRIBUTE_ALWAYS_INLINE constexpr T RotateLeft(
-    T x, int s) noexcept {
-  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
-  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
-                "T must have a power-of-2 size");
-
-  return static_cast<T>(x << (s & (std::numeric_limits<T>::digits - 1))) |
-         static_cast<T>(x >> ((-s) & (std::numeric_limits<T>::digits - 1)));
-}
-
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_POPCOUNT inline int
-Popcount32(uint32_t x) noexcept {
-#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_popcount)
-  static_assert(sizeof(unsigned int) == sizeof(x),
-                "__builtin_popcount does not take 32-bit arg");
-  return __builtin_popcount(x);
-#else
-  x -= ((x >> 1) & 0x55555555);
-  x = ((x >> 2) & 0x33333333) + (x & 0x33333333);
-  return static_cast<int>((((x + (x >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24);
-#endif
-}
-
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_POPCOUNT inline int
-Popcount64(uint64_t x) noexcept {
-#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_popcountll)
-  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
-                "__builtin_popcount does not take 64-bit arg");
-  return __builtin_popcountll(x);
-#else
-  x -= (x >> 1) & 0x5555555555555555ULL;
-  x = ((x >> 2) & 0x3333333333333333ULL) + (x & 0x3333333333333333ULL);
-  return static_cast<int>(
-      (((x + (x >> 4)) & 0xF0F0F0F0F0F0F0FULL) * 0x101010101010101ULL) >> 56);
-#endif
-}
-
-template <class T>
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_POPCOUNT inline int
-Popcount(T x) noexcept {
-  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
-  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
-                "T must have a power-of-2 size");
-  static_assert(sizeof(x) <= sizeof(uint64_t), "T is too large");
-  return sizeof(x) <= sizeof(uint32_t) ? Popcount32(x) : Popcount64(x);
-}
-
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline int
-CountLeadingZeroes32(uint32_t x) {
-#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_clz)
-  // Use __builtin_clz, which uses the following instructions:
-  //  x86: bsr, lzcnt
-  //  ARM64: clz
-  //  PPC: cntlzd
-
-  static_assert(sizeof(unsigned int) == sizeof(x),
-                "__builtin_clz does not take 32-bit arg");
-  // Handle 0 as a special case because __builtin_clz(0) is undefined.
-  return x == 0 ? 32 : __builtin_clz(x);
-#elif defined(_MSC_VER) && !defined(__clang__)
-  unsigned long result = 0;  // NOLINT(runtime/int)
-  if (_BitScanReverse(&result, x)) {
-    return 31 - result;
-  }
-  return 32;
-#else
-  int zeroes = 28;
-  if (x >> 16) {
-    zeroes -= 16;
-    x >>= 16;
-  }
-  if (x >> 8) {
-    zeroes -= 8;
-    x >>= 8;
-  }
-  if (x >> 4) {
-    zeroes -= 4;
-    x >>= 4;
-  }
-  return "\4\3\2\2\1\1\1\1\0\0\0\0\0\0\0"[x] + zeroes;
-#endif
-}
-
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline int
-CountLeadingZeroes16(uint16_t x) {
-#if ABSL_HAVE_BUILTIN(__builtin_clzs)
-  static_assert(sizeof(unsigned short) == sizeof(x),  // NOLINT(runtime/int)
-                "__builtin_clzs does not take 16-bit arg");
-  return x == 0 ? 16 : __builtin_clzs(x);
-#else
-  return CountLeadingZeroes32(x) - 16;
-#endif
-}
-
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline int
-CountLeadingZeroes64(uint64_t x) {
-#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_clzll)
-  // Use __builtin_clzll, which uses the following instructions:
-  //  x86: bsr, lzcnt
-  //  ARM64: clz
-  //  PPC: cntlzd
-  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
-                "__builtin_clzll does not take 64-bit arg");
-
-  // Handle 0 as a special case because __builtin_clzll(0) is undefined.
-  return x == 0 ? 64 : __builtin_clzll(x);
-#elif defined(_MSC_VER) && !defined(__clang__) && \
-    (defined(_M_X64) || defined(_M_ARM64))
-  // MSVC does not have __buitin_clzll. Use _BitScanReverse64.
-  unsigned long result = 0;  // NOLINT(runtime/int)
-  if (_BitScanReverse64(&result, x)) {
-    return 63 - result;
-  }
-  return 64;
-#elif defined(_MSC_VER) && !defined(__clang__)
-  // MSVC does not have __buitin_clzll. Compose two calls to _BitScanReverse
-  unsigned long result = 0;  // NOLINT(runtime/int)
-  if ((x >> 32) &&
-      _BitScanReverse(&result, static_cast<unsigned long>(x >> 32))) {
-    return 31 - result;
-  }
-  if (_BitScanReverse(&result, static_cast<unsigned long>(x))) {
-    return 63 - result;
-  }
-  return 64;
-#else
-  int zeroes = 60;
-  if (x >> 32) {
-    zeroes -= 32;
-    x >>= 32;
-  }
-  if (x >> 16) {
-    zeroes -= 16;
-    x >>= 16;
-  }
-  if (x >> 8) {
-    zeroes -= 8;
-    x >>= 8;
-  }
-  if (x >> 4) {
-    zeroes -= 4;
-    x >>= 4;
-  }
-  return "\4\3\2\2\1\1\1\1\0\0\0\0\0\0\0"[x] + zeroes;
-#endif
-}
-
-template <typename T>
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline int
-CountLeadingZeroes(T x) {
-  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
-  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
-                "T must have a power-of-2 size");
-  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
-  return sizeof(T) <= sizeof(uint16_t)
-             ? CountLeadingZeroes16(static_cast<uint16_t>(x)) -
-                   (std::numeric_limits<uint16_t>::digits -
-                    std::numeric_limits<T>::digits)
-             : (sizeof(T) <= sizeof(uint32_t)
-                    ? CountLeadingZeroes32(static_cast<uint32_t>(x)) -
-                          (std::numeric_limits<uint32_t>::digits -
-                           std::numeric_limits<T>::digits)
-                    : CountLeadingZeroes64(x));
-}
-
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CTZ inline int
-CountTrailingZeroesNonzero32(uint32_t x) {
-#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctz)
-  static_assert(sizeof(unsigned int) == sizeof(x),
-                "__builtin_ctz does not take 32-bit arg");
-  return __builtin_ctz(x);
-#elif defined(_MSC_VER) && !defined(__clang__)
-  unsigned long result = 0;  // NOLINT(runtime/int)
-  _BitScanForward(&result, x);
-  return result;
-#else
-  int c = 31;
-  x &= ~x + 1;
-  if (x & 0x0000FFFF) c -= 16;
-  if (x & 0x00FF00FF) c -= 8;
-  if (x & 0x0F0F0F0F) c -= 4;
-  if (x & 0x33333333) c -= 2;
-  if (x & 0x55555555) c -= 1;
-  return c;
-#endif
-}
-
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CTZ inline int
-CountTrailingZeroesNonzero64(uint64_t x) {
-#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctzll)
-  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
-                "__builtin_ctzll does not take 64-bit arg");
-  return __builtin_ctzll(x);
-#elif defined(_MSC_VER) && !defined(__clang__) && \
-    (defined(_M_X64) || defined(_M_ARM64))
-  unsigned long result = 0;  // NOLINT(runtime/int)
-  _BitScanForward64(&result, x);
-  return result;
-#elif defined(_MSC_VER) && !defined(__clang__)
-  unsigned long result = 0;  // NOLINT(runtime/int)
-  if (static_cast<uint32_t>(x) == 0) {
-    _BitScanForward(&result, static_cast<unsigned long>(x >> 32));
-    return result + 32;
-  }
-  _BitScanForward(&result, static_cast<unsigned long>(x));
-  return result;
-#else
-  int c = 63;
-  x &= ~x + 1;
-  if (x & 0x00000000FFFFFFFF) c -= 32;
-  if (x & 0x0000FFFF0000FFFF) c -= 16;
-  if (x & 0x00FF00FF00FF00FF) c -= 8;
-  if (x & 0x0F0F0F0F0F0F0F0F) c -= 4;
-  if (x & 0x3333333333333333) c -= 2;
-  if (x & 0x5555555555555555) c -= 1;
-  return c;
-#endif
-}
-
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CTZ inline int
-CountTrailingZeroesNonzero16(uint16_t x) {
-#if ABSL_HAVE_BUILTIN(__builtin_ctzs)
-  static_assert(sizeof(unsigned short) == sizeof(x),  // NOLINT(runtime/int)
-                "__builtin_ctzs does not take 16-bit arg");
-  return __builtin_ctzs(x);
-#else
-  return CountTrailingZeroesNonzero32(x);
-#endif
-}
-
-template <class T>
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CTZ inline int
-CountTrailingZeroes(T x) noexcept {
-  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
-  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
-                "T must have a power-of-2 size");
-  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
-  return x == 0 ? std::numeric_limits<T>::digits
-                : (sizeof(T) <= sizeof(uint16_t)
-                       ? CountTrailingZeroesNonzero16(static_cast<uint16_t>(x))
-                       : (sizeof(T) <= sizeof(uint32_t)
-                              ? CountTrailingZeroesNonzero32(
-                                    static_cast<uint32_t>(x))
-                              : CountTrailingZeroesNonzero64(x)));
-}
-
-// If T is narrower than unsigned, T{1} << bit_width will be promoted.  We
-// want to force it to wraparound so that bit_ceil of an invalid value are not
-// core constant expressions.
-template <class T>
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline
-    typename std::enable_if<std::is_unsigned<T>::value, T>::type
-    BitCeilPromotionHelper(T x, T promotion) {
-  return (T{1} << (x + promotion)) >> promotion;
-}
-
-template <class T>
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline
-    typename std::enable_if<std::is_unsigned<T>::value, T>::type
-    BitCeilNonPowerOf2(T x) {
-  // If T is narrower than unsigned, it undergoes promotion to unsigned when we
-  // shift.  We calculate the number of bits added by the wider type.
-  return BitCeilPromotionHelper(
-      static_cast<T>(std::numeric_limits<T>::digits - CountLeadingZeroes(x)),
-      T{sizeof(T) >= sizeof(unsigned) ? 0
-                                      : std::numeric_limits<unsigned>::digits -
-                                            std::numeric_limits<T>::digits});
-}
-
-}  // namespace numeric_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_NUMERIC_INTERNAL_BITS_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_NUMERIC_INTERNAL_BITS_H_ 
+#define ABSL_NUMERIC_INTERNAL_BITS_H_ 
+ 
+#include <cstdint> 
+#include <limits> 
+#include <type_traits> 
+ 
+// Clang on Windows has __builtin_clzll; otherwise we need to use the 
+// windows intrinsic functions. 
+#if defined(_MSC_VER) && !defined(__clang__) 
+#include <intrin.h> 
+#endif 
+ 
+#include "absl/base/attributes.h" 
+#include "absl/base/config.h" 
+ 
+#if defined(__GNUC__) && !defined(__clang__) 
+// GCC 
+#define ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(x) 1 
+#else 
+#define ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(x) ABSL_HAVE_BUILTIN(x) 
+#endif 
+ 
+#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_popcountl) && \ 
+    ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_popcountll) 
+#define ABSL_INTERNAL_CONSTEXPR_POPCOUNT constexpr 
+#define ABSL_INTERNAL_HAS_CONSTEXPR_POPCOUNT 1 
+#else 
+#define ABSL_INTERNAL_CONSTEXPR_POPCOUNT 
+#define ABSL_INTERNAL_HAS_CONSTEXPR_POPCOUNT 0 
+#endif 
+ 
+#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_clz) && \ 
+    ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_clzll) 
+#define ABSL_INTERNAL_CONSTEXPR_CLZ constexpr 
+#define ABSL_INTERNAL_HAS_CONSTEXPR_CLZ 1 
+#else 
+#define ABSL_INTERNAL_CONSTEXPR_CLZ 
+#define ABSL_INTERNAL_HAS_CONSTEXPR_CLZ 0 
+#endif 
+ 
+#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctz) && \ 
+    ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctzll) 
+#define ABSL_INTERNAL_CONSTEXPR_CTZ constexpr 
+#define ABSL_INTERNAL_HAS_CONSTEXPR_CTZ 1 
+#else 
+#define ABSL_INTERNAL_CONSTEXPR_CTZ 
+#define ABSL_INTERNAL_HAS_CONSTEXPR_CTZ 0 
+#endif 
+ 
+namespace absl { 
+ABSL_NAMESPACE_BEGIN 
+namespace numeric_internal { 
+ 
+constexpr bool IsPowerOf2(unsigned int x) noexcept { 
+  return x != 0 && (x & (x - 1)) == 0; 
+} 
+ 
+template <class T> 
+ABSL_MUST_USE_RESULT ABSL_ATTRIBUTE_ALWAYS_INLINE constexpr T RotateRight( 
+    T x, int s) noexcept { 
+  static_assert(std::is_unsigned<T>::value, "T must be unsigned"); 
+  static_assert(IsPowerOf2(std::numeric_limits<T>::digits), 
+                "T must have a power-of-2 size"); 
+ 
+  return static_cast<T>(x >> (s & (std::numeric_limits<T>::digits - 1))) | 
+         static_cast<T>(x << ((-s) & (std::numeric_limits<T>::digits - 1))); 
+} 
+ 
+template <class T> 
+ABSL_MUST_USE_RESULT ABSL_ATTRIBUTE_ALWAYS_INLINE constexpr T RotateLeft( 
+    T x, int s) noexcept { 
+  static_assert(std::is_unsigned<T>::value, "T must be unsigned"); 
+  static_assert(IsPowerOf2(std::numeric_limits<T>::digits), 
+                "T must have a power-of-2 size"); 
+ 
+  return static_cast<T>(x << (s & (std::numeric_limits<T>::digits - 1))) | 
+         static_cast<T>(x >> ((-s) & (std::numeric_limits<T>::digits - 1))); 
+} 
+ 
+ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_POPCOUNT inline int 
+Popcount32(uint32_t x) noexcept { 
+#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_popcount) 
+  static_assert(sizeof(unsigned int) == sizeof(x), 
+                "__builtin_popcount does not take 32-bit arg"); 
+  return __builtin_popcount(x); 
+#else 
+  x -= ((x >> 1) & 0x55555555); 
+  x = ((x >> 2) & 0x33333333) + (x & 0x33333333); 
+  return static_cast<int>((((x + (x >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24); 
+#endif 
+} 
+ 
+ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_POPCOUNT inline int 
+Popcount64(uint64_t x) noexcept { 
+#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_popcountll) 
+  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int) 
+                "__builtin_popcount does not take 64-bit arg"); 
+  return __builtin_popcountll(x); 
+#else 
+  x -= (x >> 1) & 0x5555555555555555ULL; 
+  x = ((x >> 2) & 0x3333333333333333ULL) + (x & 0x3333333333333333ULL); 
+  return static_cast<int>( 
+      (((x + (x >> 4)) & 0xF0F0F0F0F0F0F0FULL) * 0x101010101010101ULL) >> 56); 
+#endif 
+} 
+ 
+template <class T> 
+ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_POPCOUNT inline int 
+Popcount(T x) noexcept { 
+  static_assert(std::is_unsigned<T>::value, "T must be unsigned"); 
+  static_assert(IsPowerOf2(std::numeric_limits<T>::digits), 
+                "T must have a power-of-2 size"); 
+  static_assert(sizeof(x) <= sizeof(uint64_t), "T is too large"); 
+  return sizeof(x) <= sizeof(uint32_t) ? Popcount32(x) : Popcount64(x); 
+} 
+ 
+ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline int 
+CountLeadingZeroes32(uint32_t x) { 
+#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_clz) 
+  // Use __builtin_clz, which uses the following instructions: 
+  //  x86: bsr, lzcnt 
+  //  ARM64: clz 
+  //  PPC: cntlzd 
+ 
+  static_assert(sizeof(unsigned int) == sizeof(x), 
+                "__builtin_clz does not take 32-bit arg"); 
+  // Handle 0 as a special case because __builtin_clz(0) is undefined. 
+  return x == 0 ? 32 : __builtin_clz(x); 
+#elif defined(_MSC_VER) && !defined(__clang__) 
+  unsigned long result = 0;  // NOLINT(runtime/int) 
+  if (_BitScanReverse(&result, x)) { 
+    return 31 - result; 
+  } 
+  return 32; 
+#else 
+  int zeroes = 28; 
+  if (x >> 16) { 
+    zeroes -= 16; 
+    x >>= 16; 
+  } 
+  if (x >> 8) { 
+    zeroes -= 8; 
+    x >>= 8; 
+  } 
+  if (x >> 4) { 
+    zeroes -= 4; 
+    x >>= 4; 
+  } 
+  return "\4\3\2\2\1\1\1\1\0\0\0\0\0\0\0"[x] + zeroes; 
+#endif 
+} 
+ 
+ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline int 
+CountLeadingZeroes16(uint16_t x) { 
+#if ABSL_HAVE_BUILTIN(__builtin_clzs) 
+  static_assert(sizeof(unsigned short) == sizeof(x),  // NOLINT(runtime/int) 
+                "__builtin_clzs does not take 16-bit arg"); 
+  return x == 0 ? 16 : __builtin_clzs(x); 
+#else 
+  return CountLeadingZeroes32(x) - 16; 
+#endif 
+} 
+ 
+ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline int 
+CountLeadingZeroes64(uint64_t x) { 
+#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_clzll) 
+  // Use __builtin_clzll, which uses the following instructions: 
+  //  x86: bsr, lzcnt 
+  //  ARM64: clz 
+  //  PPC: cntlzd 
+  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int) 
+                "__builtin_clzll does not take 64-bit arg"); 
+ 
+  // Handle 0 as a special case because __builtin_clzll(0) is undefined. 
+  return x == 0 ? 64 : __builtin_clzll(x); 
+#elif defined(_MSC_VER) && !defined(__clang__) && \ 
+    (defined(_M_X64) || defined(_M_ARM64)) 
+  // MSVC does not have __buitin_clzll. Use _BitScanReverse64. 
+  unsigned long result = 0;  // NOLINT(runtime/int) 
+  if (_BitScanReverse64(&result, x)) { 
+    return 63 - result; 
+  } 
+  return 64; 
+#elif defined(_MSC_VER) && !defined(__clang__) 
+  // MSVC does not have __buitin_clzll. Compose two calls to _BitScanReverse 
+  unsigned long result = 0;  // NOLINT(runtime/int) 
+  if ((x >> 32) && 
+      _BitScanReverse(&result, static_cast<unsigned long>(x >> 32))) { 
+    return 31 - result; 
+  } 
+  if (_BitScanReverse(&result, static_cast<unsigned long>(x))) { 
+    return 63 - result; 
+  } 
+  return 64; 
+#else 
+  int zeroes = 60; 
+  if (x >> 32) { 
+    zeroes -= 32; 
+    x >>= 32; 
+  } 
+  if (x >> 16) { 
+    zeroes -= 16; 
+    x >>= 16; 
+  } 
+  if (x >> 8) { 
+    zeroes -= 8; 
+    x >>= 8; 
+  } 
+  if (x >> 4) { 
+    zeroes -= 4; 
+    x >>= 4; 
+  } 
+  return "\4\3\2\2\1\1\1\1\0\0\0\0\0\0\0"[x] + zeroes; 
+#endif 
+} 
+ 
+template <typename T> 
+ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline int 
+CountLeadingZeroes(T x) { 
+  static_assert(std::is_unsigned<T>::value, "T must be unsigned"); 
+  static_assert(IsPowerOf2(std::numeric_limits<T>::digits), 
+                "T must have a power-of-2 size"); 
+  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large"); 
+  return sizeof(T) <= sizeof(uint16_t) 
+             ? CountLeadingZeroes16(static_cast<uint16_t>(x)) - 
+                   (std::numeric_limits<uint16_t>::digits - 
+                    std::numeric_limits<T>::digits) 
+             : (sizeof(T) <= sizeof(uint32_t) 
+                    ? CountLeadingZeroes32(static_cast<uint32_t>(x)) - 
+                          (std::numeric_limits<uint32_t>::digits - 
+                           std::numeric_limits<T>::digits) 
+                    : CountLeadingZeroes64(x)); 
+} 
+ 
+ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CTZ inline int 
+CountTrailingZeroesNonzero32(uint32_t x) { 
+#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctz) 
+  static_assert(sizeof(unsigned int) == sizeof(x), 
+                "__builtin_ctz does not take 32-bit arg"); 
+  return __builtin_ctz(x); 
+#elif defined(_MSC_VER) && !defined(__clang__) 
+  unsigned long result = 0;  // NOLINT(runtime/int) 
+  _BitScanForward(&result, x); 
+  return result; 
+#else 
+  int c = 31; 
+  x &= ~x + 1; 
+  if (x & 0x0000FFFF) c -= 16; 
+  if (x & 0x00FF00FF) c -= 8; 
+  if (x & 0x0F0F0F0F) c -= 4; 
+  if (x & 0x33333333) c -= 2; 
+  if (x & 0x55555555) c -= 1; 
+  return c; 
+#endif 
+} 
+ 
+ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CTZ inline int 
+CountTrailingZeroesNonzero64(uint64_t x) { 
+#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctzll) 
+  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int) 
+                "__builtin_ctzll does not take 64-bit arg"); 
+  return __builtin_ctzll(x); 
+#elif defined(_MSC_VER) && !defined(__clang__) && \ 
+    (defined(_M_X64) || defined(_M_ARM64)) 
+  unsigned long result = 0;  // NOLINT(runtime/int) 
+  _BitScanForward64(&result, x); 
+  return result; 
+#elif defined(_MSC_VER) && !defined(__clang__) 
+  unsigned long result = 0;  // NOLINT(runtime/int) 
+  if (static_cast<uint32_t>(x) == 0) { 
+    _BitScanForward(&result, static_cast<unsigned long>(x >> 32)); 
+    return result + 32; 
+  } 
+  _BitScanForward(&result, static_cast<unsigned long>(x)); 
+  return result; 
+#else 
+  int c = 63; 
+  x &= ~x + 1; 
+  if (x & 0x00000000FFFFFFFF) c -= 32; 
+  if (x & 0x0000FFFF0000FFFF) c -= 16; 
+  if (x & 0x00FF00FF00FF00FF) c -= 8; 
+  if (x & 0x0F0F0F0F0F0F0F0F) c -= 4; 
+  if (x & 0x3333333333333333) c -= 2; 
+  if (x & 0x5555555555555555) c -= 1; 
+  return c; 
+#endif 
+} 
+ 
+ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CTZ inline int 
+CountTrailingZeroesNonzero16(uint16_t x) { 
+#if ABSL_HAVE_BUILTIN(__builtin_ctzs) 
+  static_assert(sizeof(unsigned short) == sizeof(x),  // NOLINT(runtime/int) 
+                "__builtin_ctzs does not take 16-bit arg"); 
+  return __builtin_ctzs(x); 
+#else 
+  return CountTrailingZeroesNonzero32(x); 
+#endif 
+} 
+ 
+template <class T> 
+ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CTZ inline int 
+CountTrailingZeroes(T x) noexcept { 
+  static_assert(std::is_unsigned<T>::value, "T must be unsigned"); 
+  static_assert(IsPowerOf2(std::numeric_limits<T>::digits), 
+                "T must have a power-of-2 size"); 
+  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large"); 
+  return x == 0 ? std::numeric_limits<T>::digits 
+                : (sizeof(T) <= sizeof(uint16_t) 
+                       ? CountTrailingZeroesNonzero16(static_cast<uint16_t>(x)) 
+                       : (sizeof(T) <= sizeof(uint32_t) 
+                              ? CountTrailingZeroesNonzero32( 
+                                    static_cast<uint32_t>(x)) 
+                              : CountTrailingZeroesNonzero64(x))); 
+} 
+ 
+// If T is narrower than unsigned, T{1} << bit_width will be promoted.  We 
+// want to force it to wraparound so that bit_ceil of an invalid value are not 
+// core constant expressions. 
+template <class T> 
+ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline 
+    typename std::enable_if<std::is_unsigned<T>::value, T>::type 
+    BitCeilPromotionHelper(T x, T promotion) { 
+  return (T{1} << (x + promotion)) >> promotion; 
+} 
+ 
+template <class T> 
+ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline 
+    typename std::enable_if<std::is_unsigned<T>::value, T>::type 
+    BitCeilNonPowerOf2(T x) { 
+  // If T is narrower than unsigned, it undergoes promotion to unsigned when we 
+  // shift.  We calculate the number of bits added by the wider type. 
+  return BitCeilPromotionHelper( 
+      static_cast<T>(std::numeric_limits<T>::digits - CountLeadingZeroes(x)), 
+      T{sizeof(T) >= sizeof(unsigned) ? 0 
+                                      : std::numeric_limits<unsigned>::digits - 
+                                            std::numeric_limits<T>::digits}); 
+} 
+ 
+}  // namespace numeric_internal 
+ABSL_NAMESPACE_END 
+}  // namespace absl 
+ 
+#endif  // ABSL_NUMERIC_INTERNAL_BITS_H_ 
diff --git a/contrib/restricted/abseil-cpp/absl/numeric/internal/representation.h b/contrib/restricted/abseil-cpp/absl/numeric/internal/representation.h
index 82d332fdde..4651292487 100644
--- a/contrib/restricted/abseil-cpp/absl/numeric/internal/representation.h
+++ b/contrib/restricted/abseil-cpp/absl/numeric/internal/representation.h
@@ -1,55 +1,55 @@
-// 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_NUMERIC_INTERNAL_REPRESENTATION_H_
-#define ABSL_NUMERIC_INTERNAL_REPRESENTATION_H_
-
-#include <limits>
-
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace numeric_internal {
-
-// Returns true iff long double is represented as a pair of doubles added
-// together.
-inline constexpr bool IsDoubleDouble() {
-  // A double-double value always has exactly twice the precision of a double
-  // value--one double carries the high digits and one double carries the low
-  // digits. This property is not shared with any other common floating-point
-  // representation, so this test won't trigger false positives. For reference,
-  // this table gives the number of bits of precision of each common
-  // floating-point representation:
-  //
-  //                type     precision
-  //         IEEE single          24 b
-  //         IEEE double          53
-  //     x86 long double          64
-  //       double-double         106
-  //      IEEE quadruple         113
-  //
-  // Note in particular that a quadruple-precision float has greater precision
-  // than a double-double float despite taking up the same amount of memory; the
-  // quad has more of its bits allocated to the mantissa than the double-double
-  // has.
-  return std::numeric_limits<long double>::digits ==
-         2 * std::numeric_limits<double>::digits;
-}
-
-}  // namespace numeric_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_NUMERIC_INTERNAL_REPRESENTATION_H_
+// 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_NUMERIC_INTERNAL_REPRESENTATION_H_ 
+#define ABSL_NUMERIC_INTERNAL_REPRESENTATION_H_ 
+ 
+#include <limits> 
+ 
+#include "absl/base/config.h" 
+ 
+namespace absl { 
+ABSL_NAMESPACE_BEGIN 
+namespace numeric_internal { 
+ 
+// Returns true iff long double is represented as a pair of doubles added 
+// together. 
+inline constexpr bool IsDoubleDouble() { 
+  // A double-double value always has exactly twice the precision of a double 
+  // value--one double carries the high digits and one double carries the low 
+  // digits. This property is not shared with any other common floating-point 
+  // representation, so this test won't trigger false positives. For reference, 
+  // this table gives the number of bits of precision of each common 
+  // floating-point representation: 
+  // 
+  //                type     precision 
+  //         IEEE single          24 b 
+  //         IEEE double          53 
+  //     x86 long double          64 
+  //       double-double         106 
+  //      IEEE quadruple         113 
+  // 
+  // Note in particular that a quadruple-precision float has greater precision 
+  // than a double-double float despite taking up the same amount of memory; the 
+  // quad has more of its bits allocated to the mantissa than the double-double 
+  // has. 
+  return std::numeric_limits<long double>::digits == 
+         2 * std::numeric_limits<double>::digits; 
+} 
+ 
+}  // namespace numeric_internal 
+ABSL_NAMESPACE_END 
+}  // namespace absl 
+ 
+#endif  // ABSL_NUMERIC_INTERNAL_REPRESENTATION_H_ 
diff --git a/contrib/restricted/abseil-cpp/absl/random/internal/explicit_seed_seq.h b/contrib/restricted/abseil-cpp/absl/random/internal/explicit_seed_seq.h
index 25f791535f..f405c562d4 100644
--- a/contrib/restricted/abseil-cpp/absl/random/internal/explicit_seed_seq.h
+++ b/contrib/restricted/abseil-cpp/absl/random/internal/explicit_seed_seq.h
@@ -23,7 +23,7 @@
 #include <vector>
 
 #include "absl/base/config.h"
-#include "absl/base/internal/endian.h"
+#include "absl/base/internal/endian.h" 
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
diff --git a/contrib/restricted/abseil-cpp/absl/random/internal/fastmath.h b/contrib/restricted/abseil-cpp/absl/random/internal/fastmath.h
index 963b7690f1..615ed41ce5 100644
--- a/contrib/restricted/abseil-cpp/absl/random/internal/fastmath.h
+++ b/contrib/restricted/abseil-cpp/absl/random/internal/fastmath.h
@@ -22,7 +22,7 @@
 #include <cmath>
 #include <cstdint>
 
-#include "absl/numeric/bits.h"
+#include "absl/numeric/bits.h" 
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
@@ -34,10 +34,10 @@ namespace random_internal {
 // for instance--std::log2 rounds up rather than down, which introduces
 // definite skew in the results.
 inline int IntLog2Floor(uint64_t n) {
-  return (n <= 1) ? 0 : (63 - countl_zero(n));
+  return (n <= 1) ? 0 : (63 - countl_zero(n)); 
 }
 inline int IntLog2Ceil(uint64_t n) {
-  return (n <= 1) ? 0 : (64 - countl_zero(n - 1));
+  return (n <= 1) ? 0 : (64 - countl_zero(n - 1)); 
 }
 
 inline double StirlingLogFactorial(double n) {
diff --git a/contrib/restricted/abseil-cpp/absl/random/internal/generate_real.h b/contrib/restricted/abseil-cpp/absl/random/internal/generate_real.h
index d5fbb44c24..6c08de7834 100644
--- a/contrib/restricted/abseil-cpp/absl/random/internal/generate_real.h
+++ b/contrib/restricted/abseil-cpp/absl/random/internal/generate_real.h
@@ -24,7 +24,7 @@
 #include <type_traits>
 
 #include "absl/meta/type_traits.h"
-#include "absl/numeric/bits.h"
+#include "absl/numeric/bits.h" 
 #include "absl/random/internal/fastmath.h"
 #include "absl/random/internal/traits.h"
 
@@ -120,7 +120,7 @@ inline RealType GenerateRealFromBits(uint64_t bits, int exp_bias = 0) {
 
   // Number of leading zeros is mapped to the exponent: 2^-clz
   // bits is 0..01xxxxxx. After shifting, we're left with 1xxx...0..0
-  int clz = countl_zero(bits);
+  int clz = countl_zero(bits); 
   bits <<= (IncludeZero ? clz : (clz & 63));  // remove 0-bits.
   exp -= clz;                                 // set the exponent.
   bits >>= (63 - kExp);
diff --git a/contrib/restricted/abseil-cpp/absl/random/internal/mock_helpers.h b/contrib/restricted/abseil-cpp/absl/random/internal/mock_helpers.h
index 9d6ab21ef5..0b1180d708 100644
--- a/contrib/restricted/abseil-cpp/absl/random/internal/mock_helpers.h
+++ b/contrib/restricted/abseil-cpp/absl/random/internal/mock_helpers.h
@@ -80,13 +80,13 @@ class MockHelpers {
   }
 
  public:
-  // InvokeMock is private; this provides access for some specialized use cases.
-  template <typename URBG>
-  static inline bool PrivateInvokeMock(URBG* urbg, IdType type,
-                                       void* args_tuple, void* result) {
-    return urbg->InvokeMock(type, args_tuple, result);
-  }
-
+  // InvokeMock is private; this provides access for some specialized use cases. 
+  template <typename URBG> 
+  static inline bool PrivateInvokeMock(URBG* urbg, IdType type, 
+                                       void* args_tuple, void* result) { 
+    return urbg->InvokeMock(type, args_tuple, result); 
+  } 
+ 
   // Invoke a mock for the KeyT (may or may not be a signature).
   //
   // KeyT is used to generate a typeid-based lookup key for the mock.
@@ -116,14 +116,14 @@ class MockHelpers {
   // The mocked function signature will be composed from KeyT as:
   //   result_type(args...)
   template <typename KeyT, typename MockURBG>
-  static auto MockFor(MockURBG& m)
-      -> decltype(m.template RegisterMock<
-                  typename KeySignature<KeyT>::result_type,
-                  typename KeySignature<KeyT>::arg_tuple_type>(
-          m, std::declval<IdType>())) {
+  static auto MockFor(MockURBG& m) 
+      -> decltype(m.template RegisterMock< 
+                  typename KeySignature<KeyT>::result_type, 
+                  typename KeySignature<KeyT>::arg_tuple_type>( 
+          m, std::declval<IdType>())) { 
     return m.template RegisterMock<typename KeySignature<KeyT>::result_type,
                                    typename KeySignature<KeyT>::arg_tuple_type>(
-        m, ::absl::base_internal::FastTypeId<KeyT>());
+        m, ::absl::base_internal::FastTypeId<KeyT>()); 
   }
 };
 
diff --git a/contrib/restricted/abseil-cpp/absl/random/internal/mock_overload_set.h b/contrib/restricted/abseil-cpp/absl/random/internal/mock_overload_set.h
index 0d9c6c120c..6f3d33d917 100644
--- a/contrib/restricted/abseil-cpp/absl/random/internal/mock_overload_set.h
+++ b/contrib/restricted/abseil-cpp/absl/random/internal/mock_overload_set.h
@@ -44,12 +44,12 @@ struct MockSingleOverload<DistrT, Ret(MockingBitGen&, Args...)> {
                 "Overload signature must have return type matching the "
                 "distribution result_type.");
   using KeyT = Ret(DistrT, std::tuple<Args...>);
-
-  template <typename MockURBG>
-  auto gmock_Call(MockURBG& gen, const ::testing::Matcher<Args>&... matchers)
+ 
+  template <typename MockURBG> 
+  auto gmock_Call(MockURBG& gen, const ::testing::Matcher<Args>&... matchers) 
       -> decltype(MockHelpers::MockFor<KeyT>(gen).gmock_Call(matchers...)) {
-    static_assert(std::is_base_of<MockingBitGen, MockURBG>::value,
-                  "Mocking requires an absl::MockingBitGen");
+    static_assert(std::is_base_of<MockingBitGen, MockURBG>::value, 
+                  "Mocking requires an absl::MockingBitGen"); 
     return MockHelpers::MockFor<KeyT>(gen).gmock_Call(matchers...);
   }
 };
@@ -60,14 +60,14 @@ struct MockSingleOverload<DistrT, Ret(Arg, MockingBitGen&, Args...)> {
                 "Overload signature must have return type matching the "
                 "distribution result_type.");
   using KeyT = Ret(DistrT, std::tuple<Arg, Args...>);
-
-  template <typename MockURBG>
-  auto gmock_Call(const ::testing::Matcher<Arg>& matcher, MockURBG& gen,
-                  const ::testing::Matcher<Args>&... matchers)
+ 
+  template <typename MockURBG> 
+  auto gmock_Call(const ::testing::Matcher<Arg>& matcher, MockURBG& gen, 
+                  const ::testing::Matcher<Args>&... matchers) 
       -> decltype(MockHelpers::MockFor<KeyT>(gen).gmock_Call(matcher,
                                                              matchers...)) {
-    static_assert(std::is_base_of<MockingBitGen, MockURBG>::value,
-                  "Mocking requires an absl::MockingBitGen");
+    static_assert(std::is_base_of<MockingBitGen, MockURBG>::value, 
+                  "Mocking requires an absl::MockingBitGen"); 
     return MockHelpers::MockFor<KeyT>(gen).gmock_Call(matcher, matchers...);
   }
 };
diff --git a/contrib/restricted/abseil-cpp/absl/random/internal/pcg_engine.h b/contrib/restricted/abseil-cpp/absl/random/internal/pcg_engine.h
index 8efaf2e09a..0b07417aeb 100644
--- a/contrib/restricted/abseil-cpp/absl/random/internal/pcg_engine.h
+++ b/contrib/restricted/abseil-cpp/absl/random/internal/pcg_engine.h
@@ -19,7 +19,7 @@
 
 #include "absl/base/config.h"
 #include "absl/meta/type_traits.h"
-#include "absl/numeric/bits.h"
+#include "absl/numeric/bits.h" 
 #include "absl/numeric/int128.h"
 #include "absl/random/internal/fastmath.h"
 #include "absl/random/internal/iostream_state_saver.h"
@@ -262,7 +262,7 @@ struct pcg_xsl_rr_128_64 {
     uint64_t rotate = h >> 58u;
     uint64_t s = Uint128Low64(state) ^ h;
 #endif
-    return rotr(s, rotate);
+    return rotr(s, rotate); 
   }
 };
 
@@ -282,8 +282,8 @@ struct pcg_xsh_rr_64_32 {
   using state_type = uint64_t;
   using result_type = uint32_t;
   inline uint32_t operator()(uint64_t state) {
-    return rotr(static_cast<uint32_t>(((state >> 18) ^ state) >> 27),
-                state >> 59);
+    return rotr(static_cast<uint32_t>(((state >> 18) ^ state) >> 27), 
+                state >> 59); 
   }
 };
 
diff --git a/contrib/restricted/abseil-cpp/absl/random/internal/randen.cc b/contrib/restricted/abseil-cpp/absl/random/internal/randen.cc
index c1bc044435..ad8ac3bb6d 100644
--- a/contrib/restricted/abseil-cpp/absl/random/internal/randen.cc
+++ b/contrib/restricted/abseil-cpp/absl/random/internal/randen.cc
@@ -17,7 +17,7 @@
 #include "absl/base/internal/raw_logging.h"
 #include "absl/random/internal/randen_detect.h"
 
-// RANDen = RANDom generator or beetroots in Swiss High German.
+// RANDen = RANDom generator or beetroots in Swiss High German. 
 // 'Strong' (well-distributed, unpredictable, backtracking-resistant) random
 // generator, faster in some benchmarks than std::mt19937_64 and pcg64_c32.
 //
diff --git a/contrib/restricted/abseil-cpp/absl/random/internal/randen.h b/contrib/restricted/abseil-cpp/absl/random/internal/randen.h
index 9a3840b8f1..acb34f3908 100644
--- a/contrib/restricted/abseil-cpp/absl/random/internal/randen.h
+++ b/contrib/restricted/abseil-cpp/absl/random/internal/randen.h
@@ -26,7 +26,7 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace random_internal {
 
-// RANDen = RANDom generator or beetroots in Swiss High German.
+// RANDen = RANDom generator or beetroots in Swiss High German. 
 // 'Strong' (well-distributed, unpredictable, backtracking-resistant) random
 // generator, faster in some benchmarks than std::mt19937_64 and pcg64_c32.
 //
diff --git a/contrib/restricted/abseil-cpp/absl/random/internal/randen_detect.cc b/contrib/restricted/abseil-cpp/absl/random/internal/randen_detect.cc
index bbe7b96532..c8de07ac7f 100644
--- a/contrib/restricted/abseil-cpp/absl/random/internal/randen_detect.cc
+++ b/contrib/restricted/abseil-cpp/absl/random/internal/randen_detect.cc
@@ -1,13 +1,13 @@
 // Copyright 2017 The Abseil Authors.
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
+// 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,
+// 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.
diff --git a/contrib/restricted/abseil-cpp/absl/random/internal/randen_engine.h b/contrib/restricted/abseil-cpp/absl/random/internal/randen_engine.h
index 372c3ac2bd..870ee2caf4 100644
--- a/contrib/restricted/abseil-cpp/absl/random/internal/randen_engine.h
+++ b/contrib/restricted/abseil-cpp/absl/random/internal/randen_engine.h
@@ -23,7 +23,7 @@
 #include <limits>
 #include <type_traits>
 
-#include "absl/base/internal/endian.h"
+#include "absl/base/internal/endian.h" 
 #include "absl/meta/type_traits.h"
 #include "absl/random/internal/iostream_state_saver.h"
 #include "absl/random/internal/randen.h"
@@ -77,7 +77,7 @@ class alignas(16) randen_engine {
       impl_.Generate(state_);
     }
 
-    return little_endian::ToHost(state_[next_++]);
+    return little_endian::ToHost(state_[next_++]); 
   }
 
   template <class SeedSequence>
@@ -189,8 +189,8 @@ class alignas(16) randen_engine {
       // In the case that `elem` is `uint8_t`, it must be cast to something
       // larger so that it prints as an integer rather than a character. For
       // simplicity, apply the cast all circumstances.
-      os << static_cast<numeric_type>(little_endian::FromHost(elem))
-         << os.fill();
+      os << static_cast<numeric_type>(little_endian::FromHost(elem)) 
+         << os.fill(); 
     }
     os << engine.next_;
     return os;
@@ -209,7 +209,7 @@ class alignas(16) randen_engine {
       // necessary to read a wider type and then cast it to uint8_t.
       numeric_type value;
       is >> value;
-      elem = little_endian::ToHost(static_cast<result_type>(value));
+      elem = little_endian::ToHost(static_cast<result_type>(value)); 
     }
     is >> next;
     if (is.fail()) {
diff --git a/contrib/restricted/abseil-cpp/absl/random/internal/randen_hwaes.h b/contrib/restricted/abseil-cpp/absl/random/internal/randen_hwaes.h
index 71a7f69f25..4c241dc743 100644
--- a/contrib/restricted/abseil-cpp/absl/random/internal/randen_hwaes.h
+++ b/contrib/restricted/abseil-cpp/absl/random/internal/randen_hwaes.h
@@ -26,7 +26,7 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace random_internal {
 
-// RANDen = RANDom generator or beetroots in Swiss High German.
+// RANDen = RANDom generator or beetroots in Swiss High German. 
 // 'Strong' (well-distributed, unpredictable, backtracking-resistant) random
 // generator, faster in some benchmarks than std::mt19937_64 and pcg64_c32.
 //
diff --git a/contrib/restricted/abseil-cpp/absl/random/internal/randen_slow.h b/contrib/restricted/abseil-cpp/absl/random/internal/randen_slow.h
index 532c3a8991..abc23ce6b0 100644
--- a/contrib/restricted/abseil-cpp/absl/random/internal/randen_slow.h
+++ b/contrib/restricted/abseil-cpp/absl/random/internal/randen_slow.h
@@ -23,7 +23,7 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace random_internal {
 
-// RANDen = RANDom generator or beetroots in Swiss High German.
+// RANDen = RANDom generator or beetroots in Swiss High German. 
 // RandenSlow implements the basic state manipulation methods for
 // architectures lacking AES hardware acceleration intrinsics.
 class RandenSlow {
diff --git a/contrib/restricted/abseil-cpp/absl/random/internal/randen_traits.h b/contrib/restricted/abseil-cpp/absl/random/internal/randen_traits.h
index 120022c9fb..18e6d38d14 100644
--- a/contrib/restricted/abseil-cpp/absl/random/internal/randen_traits.h
+++ b/contrib/restricted/abseil-cpp/absl/random/internal/randen_traits.h
@@ -28,7 +28,7 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace random_internal {
 
-// RANDen = RANDom generator or beetroots in Swiss High German.
+// RANDen = RANDom generator or beetroots in Swiss High German. 
 // 'Strong' (well-distributed, unpredictable, backtracking-resistant) random
 // generator, faster in some benchmarks than std::mt19937_64 and pcg64_c32.
 //
diff --git a/contrib/restricted/abseil-cpp/absl/random/internal/wide_multiply.h b/contrib/restricted/abseil-cpp/absl/random/internal/wide_multiply.h
index b6e6c4b6aa..609d411f73 100644
--- a/contrib/restricted/abseil-cpp/absl/random/internal/wide_multiply.h
+++ b/contrib/restricted/abseil-cpp/absl/random/internal/wide_multiply.h
@@ -26,7 +26,7 @@
 #endif
 
 #include "absl/base/config.h"
-#include "absl/numeric/bits.h"
+#include "absl/numeric/bits.h" 
 #include "absl/numeric/int128.h"
 #include "absl/random/internal/traits.h"
 
diff --git a/contrib/restricted/abseil-cpp/absl/random/log_uniform_int_distribution.h b/contrib/restricted/abseil-cpp/absl/random/log_uniform_int_distribution.h
index 43e101169c..6c52d34d26 100644
--- a/contrib/restricted/abseil-cpp/absl/random/log_uniform_int_distribution.h
+++ b/contrib/restricted/abseil-cpp/absl/random/log_uniform_int_distribution.h
@@ -23,7 +23,7 @@
 #include <ostream>
 #include <type_traits>
 
-#include "absl/numeric/bits.h"
+#include "absl/numeric/bits.h" 
 #include "absl/random/internal/fastmath.h"
 #include "absl/random/internal/generate_real.h"
 #include "absl/random/internal/iostream_state_saver.h"
@@ -69,10 +69,10 @@ class log_uniform_int_distribution {
       if (base_ == 2) {
         // Determine where the first set bit is on range(), giving a log2(range)
         // value which can be used to construct bounds.
-        log_range_ =
-            (std::min)(bit_width(range()),
-                       static_cast<unsigned_type>(
-                           std::numeric_limits<unsigned_type>::digits));
+        log_range_ = 
+            (std::min)(bit_width(range()), 
+                       static_cast<unsigned_type>( 
+                           std::numeric_limits<unsigned_type>::digits)); 
       } else {
         // NOTE: Computing the logN(x) introduces error from 2 sources:
         // 1. Conversion of int to double loses precision for values >=
diff --git a/contrib/restricted/abseil-cpp/absl/random/mocking_bit_gen.h b/contrib/restricted/abseil-cpp/absl/random/mocking_bit_gen.h
index 7b2b80eb35..89d7a2ec12 100644
--- a/contrib/restricted/abseil-cpp/absl/random/mocking_bit_gen.h
+++ b/contrib/restricted/abseil-cpp/absl/random/mocking_bit_gen.h
@@ -104,7 +104,7 @@ class BitGenRef;
 class MockingBitGen {
  public:
   MockingBitGen() = default;
-  ~MockingBitGen() = default;
+  ~MockingBitGen() = default; 
 
   // URBG interface
   using result_type = absl::BitGen::result_type;
@@ -125,46 +125,46 @@ class MockingBitGen {
   // NOTE: MockFnCaller is essentially equivalent to the lambda:
   // [fn](auto... args) { return fn->Call(std::move(args)...)}
   // however that fails to build on some supported platforms.
-  template <typename MockFnType, typename ResultT, typename Tuple>
+  template <typename MockFnType, typename ResultT, typename Tuple> 
   struct MockFnCaller;
-
+ 
   // specialization for std::tuple.
-  template <typename MockFnType, typename ResultT, typename... Args>
-  struct MockFnCaller<MockFnType, ResultT, std::tuple<Args...>> {
+  template <typename MockFnType, typename ResultT, typename... Args> 
+  struct MockFnCaller<MockFnType, ResultT, std::tuple<Args...>> { 
     MockFnType* fn;
     inline ResultT operator()(Args... args) {
       return fn->Call(std::move(args)...);
     }
   };
 
-  // FunctionHolder owns a particular ::testing::MockFunction associated with
-  // a mocked type signature, and implement the type-erased Apply call, which
-  // applies type-erased arguments to the mock.
-  class FunctionHolder {
-   public:
-    virtual ~FunctionHolder() = default;
-
-    // Call is a dispatch function which converts the
-    // generic type-erased parameters into a specific mock invocation call.
-    virtual void Apply(/*ArgTupleT*/ void* args_tuple,
-                       /*ResultT*/ void* result) = 0;
-  };
-
-  template <typename MockFnType, typename ResultT, typename ArgTupleT>
-  class FunctionHolderImpl final : public FunctionHolder {
-   public:
-    void Apply(void* args_tuple, void* result) override {
-      // Requires tuple_args to point to a ArgTupleT, which is a
-      // std::tuple<Args...> used to invoke the mock function. Requires result
-      // to point to a ResultT, which is the result of the call.
-      *static_cast<ResultT*>(result) =
-          absl::apply(MockFnCaller<MockFnType, ResultT, ArgTupleT>{&mock_fn_},
-                      *static_cast<ArgTupleT*>(args_tuple));
-    }
-
-    MockFnType mock_fn_;
-  };
-
+  // FunctionHolder owns a particular ::testing::MockFunction associated with 
+  // a mocked type signature, and implement the type-erased Apply call, which 
+  // applies type-erased arguments to the mock. 
+  class FunctionHolder { 
+   public: 
+    virtual ~FunctionHolder() = default; 
+ 
+    // Call is a dispatch function which converts the 
+    // generic type-erased parameters into a specific mock invocation call. 
+    virtual void Apply(/*ArgTupleT*/ void* args_tuple, 
+                       /*ResultT*/ void* result) = 0; 
+  }; 
+ 
+  template <typename MockFnType, typename ResultT, typename ArgTupleT> 
+  class FunctionHolderImpl final : public FunctionHolder { 
+   public: 
+    void Apply(void* args_tuple, void* result) override { 
+      // Requires tuple_args to point to a ArgTupleT, which is a 
+      // std::tuple<Args...> used to invoke the mock function. Requires result 
+      // to point to a ResultT, which is the result of the call. 
+      *static_cast<ResultT*>(result) = 
+          absl::apply(MockFnCaller<MockFnType, ResultT, ArgTupleT>{&mock_fn_}, 
+                      *static_cast<ArgTupleT*>(args_tuple)); 
+    } 
+ 
+    MockFnType mock_fn_; 
+  }; 
+ 
   // MockingBitGen::RegisterMock
   //
   // RegisterMock<ResultT, ArgTupleT>(FastTypeIdType) is the main extension
@@ -175,31 +175,31 @@ class MockingBitGen {
   //
   // The returned MockFunction<...> type can be used to setup additional
   // distribution parameters of the expectation.
-  template <typename ResultT, typename ArgTupleT, typename SelfT>
-  auto RegisterMock(SelfT&, base_internal::FastTypeIdType type)
+  template <typename ResultT, typename ArgTupleT, typename SelfT> 
+  auto RegisterMock(SelfT&, base_internal::FastTypeIdType type) 
       -> decltype(GetMockFnType(std::declval<ResultT>(),
                                 std::declval<ArgTupleT>()))& {
-    using MockFnType = decltype(GetMockFnType(std::declval<ResultT>(),
-                                              std::declval<ArgTupleT>()));
-
-    using WrappedFnType = absl::conditional_t<
-        std::is_same<SelfT, ::testing::NiceMock<absl::MockingBitGen>>::value,
-        ::testing::NiceMock<MockFnType>,
-        absl::conditional_t<
-            std::is_same<SelfT,
-                         ::testing::NaggyMock<absl::MockingBitGen>>::value,
-            ::testing::NaggyMock<MockFnType>,
-            absl::conditional_t<
-                std::is_same<SelfT,
-                             ::testing::StrictMock<absl::MockingBitGen>>::value,
-                ::testing::StrictMock<MockFnType>, MockFnType>>>;
-
-    using ImplT = FunctionHolderImpl<WrappedFnType, ResultT, ArgTupleT>;
+    using MockFnType = decltype(GetMockFnType(std::declval<ResultT>(), 
+                                              std::declval<ArgTupleT>())); 
+ 
+    using WrappedFnType = absl::conditional_t< 
+        std::is_same<SelfT, ::testing::NiceMock<absl::MockingBitGen>>::value, 
+        ::testing::NiceMock<MockFnType>, 
+        absl::conditional_t< 
+            std::is_same<SelfT, 
+                         ::testing::NaggyMock<absl::MockingBitGen>>::value, 
+            ::testing::NaggyMock<MockFnType>, 
+            absl::conditional_t< 
+                std::is_same<SelfT, 
+                             ::testing::StrictMock<absl::MockingBitGen>>::value, 
+                ::testing::StrictMock<MockFnType>, MockFnType>>>; 
+ 
+    using ImplT = FunctionHolderImpl<WrappedFnType, ResultT, ArgTupleT>; 
     auto& mock = mocks_[type];
-    if (!mock) {
-      mock = absl::make_unique<ImplT>();
+    if (!mock) { 
+      mock = absl::make_unique<ImplT>(); 
     }
-    return static_cast<ImplT*>(mock.get())->mock_fn_;
+    return static_cast<ImplT*>(mock.get())->mock_fn_; 
   }
 
   // MockingBitGen::InvokeMock
@@ -218,13 +218,13 @@ class MockingBitGen {
     // Trigger a mock, if there exists one that matches `param`.
     auto it = mocks_.find(type);
     if (it == mocks_.end()) return false;
-    it->second->Apply(args_tuple, result);
+    it->second->Apply(args_tuple, result); 
     return true;
   }
 
-  absl::flat_hash_map<base_internal::FastTypeIdType,
-                      std::unique_ptr<FunctionHolder>>
-      mocks_;
+  absl::flat_hash_map<base_internal::FastTypeIdType, 
+                      std::unique_ptr<FunctionHolder>> 
+      mocks_; 
   absl::BitGen gen_;
 
   template <typename>
diff --git a/contrib/restricted/abseil-cpp/absl/random/uniform_int_distribution.h b/contrib/restricted/abseil-cpp/absl/random/uniform_int_distribution.h
index c1f54ccebc..e71b2bcbe6 100644
--- a/contrib/restricted/abseil-cpp/absl/random/uniform_int_distribution.h
+++ b/contrib/restricted/abseil-cpp/absl/random/uniform_int_distribution.h
@@ -196,7 +196,7 @@ typename random_internal::make_unsigned_bits<IntType>::type
 uniform_int_distribution<IntType>::Generate(
     URBG& g,  // NOLINT(runtime/references)
     typename random_internal::make_unsigned_bits<IntType>::type R) {
-  random_internal::FastUniformBits<unsigned_type> fast_bits;
+  random_internal::FastUniformBits<unsigned_type> fast_bits; 
   unsigned_type bits = fast_bits(g);
   const unsigned_type Lim = R + 1;
   if ((R & Lim) == 0) {
diff --git a/contrib/restricted/abseil-cpp/absl/status/internal/status_internal.h b/contrib/restricted/abseil-cpp/absl/status/internal/status_internal.h
index ac12940a6d..9a3a8df838 100644
--- a/contrib/restricted/abseil-cpp/absl/status/internal/status_internal.h
+++ b/contrib/restricted/abseil-cpp/absl/status/internal/status_internal.h
@@ -19,20 +19,20 @@
 #include "absl/container/inlined_vector.h"
 #include "absl/strings/cord.h"
 
-#ifndef SWIG
-// Disabled for SWIG as it doesn't parse attributes correctly.
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-// Returned Status objects may not be ignored. Codesearch doesn't handle ifdefs
-// as part of a class definitions (b/6995610), so we use a forward declaration.
-class ABSL_MUST_USE_RESULT Status;
-ABSL_NAMESPACE_END
-}  // namespace absl
-#endif  // !SWIG
-
+#ifndef SWIG 
+// Disabled for SWIG as it doesn't parse attributes correctly. 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
+// Returned Status objects may not be ignored. Codesearch doesn't handle ifdefs 
+// as part of a class definitions (b/6995610), so we use a forward declaration. 
+class ABSL_MUST_USE_RESULT Status; 
+ABSL_NAMESPACE_END 
+}  // namespace absl 
+#endif  // !SWIG 
 
+namespace absl { 
+ABSL_NAMESPACE_BEGIN 
+ 
 enum class StatusCode : int;
 
 namespace status_internal {
@@ -49,11 +49,11 @@ using Payloads = absl::InlinedVector<Payload, 1>;
 struct StatusRep {
   StatusRep(absl::StatusCode code_arg, absl::string_view message_arg,
             std::unique_ptr<status_internal::Payloads> payloads_arg)
-      : ref(int32_t{1}),
+      : ref(int32_t{1}), 
         code(code_arg),
         message(message_arg),
         payloads(std::move(payloads_arg)) {}
-
+ 
   std::atomic<int32_t> ref;
   absl::StatusCode code;
   std::string message;
diff --git a/contrib/restricted/abseil-cpp/absl/status/internal/statusor_internal.h b/contrib/restricted/abseil-cpp/absl/status/internal/statusor_internal.h
index eaac2c0b14..668c1b00ed 100644
--- a/contrib/restricted/abseil-cpp/absl/status/internal/statusor_internal.h
+++ b/contrib/restricted/abseil-cpp/absl/status/internal/statusor_internal.h
@@ -17,7 +17,7 @@
 #include <type_traits>
 #include <utility>
 
-#include "absl/base/attributes.h"
+#include "absl/base/attributes.h" 
 #include "absl/meta/type_traits.h"
 #include "absl/status/status.h"
 #include "absl/utility/utility.h"
@@ -136,14 +136,14 @@ class Helper {
  public:
   // Move type-agnostic error handling to the .cc.
   static void HandleInvalidStatusCtorArg(Status*);
-  ABSL_ATTRIBUTE_NORETURN static void Crash(const absl::Status& status);
+  ABSL_ATTRIBUTE_NORETURN static void Crash(const absl::Status& status); 
 };
 
 // Construct an instance of T in `p` through placement new, passing Args... to
 // the constructor.
 // This abstraction is here mostly for the gcc performance fix.
 template <typename T, typename... Args>
-ABSL_ATTRIBUTE_NONNULL(1) void PlacementNew(void* p, Args&&... args) {
+ABSL_ATTRIBUTE_NONNULL(1) void PlacementNew(void* p, Args&&... args) { 
   new (p) T(std::forward<Args>(args)...);
 }
 
diff --git a/contrib/restricted/abseil-cpp/absl/status/status.cc b/contrib/restricted/abseil-cpp/absl/status/status.cc
index bcf3413e5f..04aeefb216 100644
--- a/contrib/restricted/abseil-cpp/absl/status/status.cc
+++ b/contrib/restricted/abseil-cpp/absl/status/status.cc
@@ -283,27 +283,27 @@ bool Status::EqualsSlow(const absl::Status& a, const absl::Status& b) {
   return true;
 }
 
-std::string Status::ToStringSlow(StatusToStringMode mode) const {
+std::string Status::ToStringSlow(StatusToStringMode mode) const { 
   std::string text;
   absl::StrAppend(&text, absl::StatusCodeToString(code()), ": ", message());
 
-  const bool with_payload = (mode & StatusToStringMode::kWithPayload) ==
-                      StatusToStringMode::kWithPayload;
-
-  if (with_payload) {
-    status_internal::StatusPayloadPrinter printer =
-        status_internal::GetStatusPayloadPrinter();
-    this->ForEachPayload([&](absl::string_view type_url,
-                             const absl::Cord& payload) {
-      absl::optional<std::string> result;
-      if (printer) result = printer(type_url, payload);
-      absl::StrAppend(
-          &text, " [", type_url, "='",
-          result.has_value() ? *result : absl::CHexEscape(std::string(payload)),
-          "']");
-    });
-  }
-
+  const bool with_payload = (mode & StatusToStringMode::kWithPayload) == 
+                      StatusToStringMode::kWithPayload; 
+ 
+  if (with_payload) { 
+    status_internal::StatusPayloadPrinter printer = 
+        status_internal::GetStatusPayloadPrinter(); 
+    this->ForEachPayload([&](absl::string_view type_url, 
+                             const absl::Cord& payload) { 
+      absl::optional<std::string> result; 
+      if (printer) result = printer(type_url, payload); 
+      absl::StrAppend( 
+          &text, " [", type_url, "='", 
+          result.has_value() ? *result : absl::CHexEscape(std::string(payload)), 
+          "']"); 
+    }); 
+  } 
+ 
   return text;
 }
 
diff --git a/contrib/restricted/abseil-cpp/absl/status/status.h b/contrib/restricted/abseil-cpp/absl/status/status.h
index 39071e5f4a..d43f526336 100644
--- a/contrib/restricted/abseil-cpp/absl/status/status.h
+++ b/contrib/restricted/abseil-cpp/absl/status/status.h
@@ -58,7 +58,7 @@
 #include "absl/functional/function_ref.h"
 #include "absl/status/internal/status_internal.h"
 #include "absl/strings/cord.h"
-#include "absl/strings/string_view.h"
+#include "absl/strings/string_view.h" 
 #include "absl/types/optional.h"
 
 namespace absl {
@@ -282,59 +282,59 @@ std::string StatusCodeToString(StatusCode code);
 // Streams StatusCodeToString(code) to `os`.
 std::ostream& operator<<(std::ostream& os, StatusCode code);
 
-// absl::StatusToStringMode
-//
-// An `absl::StatusToStringMode` is an enumerated type indicating how
+// absl::StatusToStringMode 
+// 
+// An `absl::StatusToStringMode` is an enumerated type indicating how 
 // `absl::Status::ToString()` should construct the output string for a non-ok
-// status.
-enum class StatusToStringMode : int {
-  // ToString will not contain any extra data (such as payloads). It will only
-  // contain the error code and message, if any.
-  kWithNoExtraData = 0,
-  // ToString will contain the payloads.
-  kWithPayload = 1 << 0,
-  // ToString will include all the extra data this Status has.
-  kWithEverything = ~kWithNoExtraData,
+// status. 
+enum class StatusToStringMode : int { 
+  // ToString will not contain any extra data (such as payloads). It will only 
+  // contain the error code and message, if any. 
+  kWithNoExtraData = 0, 
+  // ToString will contain the payloads. 
+  kWithPayload = 1 << 0, 
+  // ToString will include all the extra data this Status has. 
+  kWithEverything = ~kWithNoExtraData, 
   // Default mode used by ToString. Its exact value might change in the future.
   kDefault = kWithPayload,
-};
-
-// absl::StatusToStringMode is specified as a bitmask type, which means the
-// following operations must be provided:
-inline constexpr StatusToStringMode operator&(StatusToStringMode lhs,
-                                              StatusToStringMode rhs) {
-  return static_cast<StatusToStringMode>(static_cast<int>(lhs) &
-                                         static_cast<int>(rhs));
-}
-inline constexpr StatusToStringMode operator|(StatusToStringMode lhs,
-                                              StatusToStringMode rhs) {
-  return static_cast<StatusToStringMode>(static_cast<int>(lhs) |
-                                         static_cast<int>(rhs));
-}
-inline constexpr StatusToStringMode operator^(StatusToStringMode lhs,
-                                              StatusToStringMode rhs) {
-  return static_cast<StatusToStringMode>(static_cast<int>(lhs) ^
-                                         static_cast<int>(rhs));
-}
-inline constexpr StatusToStringMode operator~(StatusToStringMode arg) {
-  return static_cast<StatusToStringMode>(~static_cast<int>(arg));
-}
-inline StatusToStringMode& operator&=(StatusToStringMode& lhs,
-                                      StatusToStringMode rhs) {
-  lhs = lhs & rhs;
-  return lhs;
-}
-inline StatusToStringMode& operator|=(StatusToStringMode& lhs,
-                                      StatusToStringMode rhs) {
-  lhs = lhs | rhs;
-  return lhs;
-}
-inline StatusToStringMode& operator^=(StatusToStringMode& lhs,
-                                      StatusToStringMode rhs) {
-  lhs = lhs ^ rhs;
-  return lhs;
-}
-
+}; 
+ 
+// absl::StatusToStringMode is specified as a bitmask type, which means the 
+// following operations must be provided: 
+inline constexpr StatusToStringMode operator&(StatusToStringMode lhs, 
+                                              StatusToStringMode rhs) { 
+  return static_cast<StatusToStringMode>(static_cast<int>(lhs) & 
+                                         static_cast<int>(rhs)); 
+} 
+inline constexpr StatusToStringMode operator|(StatusToStringMode lhs, 
+                                              StatusToStringMode rhs) { 
+  return static_cast<StatusToStringMode>(static_cast<int>(lhs) | 
+                                         static_cast<int>(rhs)); 
+} 
+inline constexpr StatusToStringMode operator^(StatusToStringMode lhs, 
+                                              StatusToStringMode rhs) { 
+  return static_cast<StatusToStringMode>(static_cast<int>(lhs) ^ 
+                                         static_cast<int>(rhs)); 
+} 
+inline constexpr StatusToStringMode operator~(StatusToStringMode arg) { 
+  return static_cast<StatusToStringMode>(~static_cast<int>(arg)); 
+} 
+inline StatusToStringMode& operator&=(StatusToStringMode& lhs, 
+                                      StatusToStringMode rhs) { 
+  lhs = lhs & rhs; 
+  return lhs; 
+} 
+inline StatusToStringMode& operator|=(StatusToStringMode& lhs, 
+                                      StatusToStringMode rhs) { 
+  lhs = lhs | rhs; 
+  return lhs; 
+} 
+inline StatusToStringMode& operator^=(StatusToStringMode& lhs, 
+                                      StatusToStringMode rhs) { 
+  lhs = lhs ^ rhs; 
+  return lhs; 
+} 
+ 
 // absl::Status
 //
 // The `absl::Status` class is generally used to gracefully handle errors
@@ -416,12 +416,12 @@ inline StatusToStringMode& operator^=(StatusToStringMode& lhs,
 //     return result;
 //   }
 //
-// For documentation see https://abseil.io/docs/cpp/guides/status.
-//
-// Returned Status objects may not be ignored. status_internal.h has a forward
-// declaration of the form
-// class ABSL_MUST_USE_RESULT Status;
-class Status final {
+// For documentation see https://abseil.io/docs/cpp/guides/status. 
+// 
+// Returned Status objects may not be ignored. status_internal.h has a forward 
+// declaration of the form 
+// class ABSL_MUST_USE_RESULT Status; 
+class Status final { 
  public:
   // Constructors
 
@@ -431,10 +431,10 @@ class Status final {
   Status();
 
   // Creates a status in the canonical error space with the specified
-  // `absl::StatusCode` and error message.  If `code == absl::StatusCode::kOk`,  // NOLINT
+  // `absl::StatusCode` and error message.  If `code == absl::StatusCode::kOk`,  // NOLINT 
   // `msg` is ignored and an object identical to an OK status is constructed.
   //
-  // The `msg` string must be in UTF-8. The implementation may complain (e.g.,  // NOLINT
+  // The `msg` string must be in UTF-8. The implementation may complain (e.g.,  // NOLINT 
   // by printing a warning) if it is not.
   Status(absl::StatusCode code, absl::string_view msg);
 
@@ -503,16 +503,16 @@ class Status final {
 
   // Status::ToString()
   //
-  // Returns a string based on the `mode`. By default, it returns combination of
-  // the error code name, the message and any associated payload messages. This
-  // string is designed simply to be human readable and its exact format should
-  // not be load bearing. Do not depend on the exact format of the result of
-  // `ToString()` which is subject to change.
+  // Returns a string based on the `mode`. By default, it returns combination of 
+  // the error code name, the message and any associated payload messages. This 
+  // string is designed simply to be human readable and its exact format should 
+  // not be load bearing. Do not depend on the exact format of the result of 
+  // `ToString()` which is subject to change. 
   //
   // The printed code name and the message are generally substrings of the
   // result, and the payloads to be printed use the status payload printer
   // mechanism (which is internal).
-  std::string ToString(
+  std::string ToString( 
       StatusToStringMode mode = StatusToStringMode::kDefault) const;
 
   // Status::IgnoreError()
@@ -613,9 +613,9 @@ class Status final {
   status_internal::Payloads* GetPayloads();
 
   // Takes ownership of payload.
-  static uintptr_t NewRep(
-      absl::StatusCode code, absl::string_view msg,
-      std::unique_ptr<status_internal::Payloads> payload);
+  static uintptr_t NewRep( 
+      absl::StatusCode code, absl::string_view msg, 
+      std::unique_ptr<status_internal::Payloads> payload); 
   static bool EqualsSlow(const absl::Status& a, const absl::Status& b);
 
   // MSVC 14.0 limitation requires the const.
@@ -644,7 +644,7 @@ class Status final {
   static uintptr_t PointerToRep(status_internal::StatusRep* r);
   static status_internal::StatusRep* RepToPointer(uintptr_t r);
 
-  std::string ToStringSlow(StatusToStringMode mode) const;
+  std::string ToStringSlow(StatusToStringMode mode) const; 
 
   // Status supports two different representations.
   //  - When the low bit is off it is an inlined representation.
@@ -767,11 +767,11 @@ inline Status::Status(Status&& x) noexcept : rep_(x.rep_) {
 
 inline Status& Status::operator=(Status&& x) {
   uintptr_t old_rep = rep_;
-  if (x.rep_ != old_rep) {
-    rep_ = x.rep_;
-    x.rep_ = MovedFromRep();
-    Unref(old_rep);
-  }
+  if (x.rep_ != old_rep) { 
+    rep_ = x.rep_; 
+    x.rep_ = MovedFromRep(); 
+    Unref(old_rep); 
+  } 
   return *this;
 }
 
@@ -808,8 +808,8 @@ inline bool operator!=(const Status& lhs, const Status& rhs) {
   return !(lhs == rhs);
 }
 
-inline std::string Status::ToString(StatusToStringMode mode) const {
-  return ok() ? "OK" : ToStringSlow(mode);
+inline std::string Status::ToString(StatusToStringMode mode) const { 
+  return ok() ? "OK" : ToStringSlow(mode); 
 }
 
 inline void Status::IgnoreError() const {
diff --git a/contrib/restricted/abseil-cpp/absl/status/statusor.h b/contrib/restricted/abseil-cpp/absl/status/statusor.h
index c051fbb3aa..f6eaf41703 100644
--- a/contrib/restricted/abseil-cpp/absl/status/statusor.h
+++ b/contrib/restricted/abseil-cpp/absl/status/statusor.h
@@ -145,7 +145,7 @@ class ABSL_MUST_USE_RESULT StatusOr;
 //
 // NOTE: using `absl::StatusOr<T>::value()` when no valid value is present will
 // throw an exception if exceptions are enabled or terminate the process when
-// exceptions are not enabled.
+// exceptions are not enabled. 
 //
 // Example:
 //
@@ -550,7 +550,7 @@ class StatusOr : private internal_statusor::StatusOrData<T>,
 
   // StatusOr<T>::value_or()
   //
-  // Returns the current value if `this->ok() == true`. Otherwise constructs a
+  // Returns the current value if `this->ok() == true`. Otherwise constructs a 
   // value using the provided `default_value`.
   //
   // Unlike `value`, this function returns by value, copying the current value
diff --git a/contrib/restricted/abseil-cpp/absl/status/statusor/ya.make b/contrib/restricted/abseil-cpp/absl/status/statusor/ya.make
index 9628fcdffb..5c4e185687 100644
--- a/contrib/restricted/abseil-cpp/absl/status/statusor/ya.make
+++ b/contrib/restricted/abseil-cpp/absl/status/statusor/ya.make
@@ -1,28 +1,28 @@
-# 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/status
-    contrib/restricted/abseil-cpp/absl/strings
+    contrib/restricted/abseil-cpp/absl/strings 
     contrib/restricted/abseil-cpp/absl/strings/cord
     contrib/restricted/abseil-cpp/absl/strings/internal/absl_cord_internal
     contrib/restricted/abseil-cpp/absl/strings/internal/absl_strings_internal
@@ -35,26 +35,26 @@ PEERDIR(
     contrib/restricted/abseil-cpp/absl/time
     contrib/restricted/abseil-cpp/absl/time/civil_time
     contrib/restricted/abseil-cpp/absl/time/time_zone
-    contrib/restricted/abseil-cpp/absl/types/bad_optional_access
+    contrib/restricted/abseil-cpp/absl/types/bad_optional_access 
     contrib/restricted/abseil-cpp/absl/types/bad_variant_access
-)
-
-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/status)
-
-SRCS(
+ 
+SRCS( 
     statusor.cc
-)
-
-END()
+) 
+ 
+END() 
diff --git a/contrib/restricted/abseil-cpp/absl/strings/charconv.cc b/contrib/restricted/abseil-cpp/absl/strings/charconv.cc
index fefcfc90a5..e9e2446602 100644
--- a/contrib/restricted/abseil-cpp/absl/strings/charconv.cc
+++ b/contrib/restricted/abseil-cpp/absl/strings/charconv.cc
@@ -20,7 +20,7 @@
 #include <cstring>
 
 #include "absl/base/casts.h"
-#include "absl/numeric/bits.h"
+#include "absl/numeric/bits.h" 
 #include "absl/numeric/int128.h"
 #include "absl/strings/internal/charconv_bigint.h"
 #include "absl/strings/internal/charconv_parse.h"
@@ -242,11 +242,11 @@ struct CalculatedFloat {
 
 // Returns the bit width of the given uint128.  (Equivalently, returns 128
 // minus the number of leading zero bits.)
-unsigned BitWidth(uint128 value) {
+unsigned BitWidth(uint128 value) { 
   if (Uint128High64(value) == 0) {
-    return static_cast<unsigned>(bit_width(Uint128Low64(value)));
+    return static_cast<unsigned>(bit_width(Uint128Low64(value))); 
   }
-  return 128 - countl_zero(Uint128High64(value));
+  return 128 - countl_zero(Uint128High64(value)); 
 }
 
 // Calculates how far to the right a mantissa needs to be shifted to create a
@@ -519,7 +519,7 @@ CalculatedFloat CalculateFromParsedHexadecimal(
     const strings_internal::ParsedFloat& parsed_hex) {
   uint64_t mantissa = parsed_hex.mantissa;
   int exponent = parsed_hex.exponent;
-  auto mantissa_width = static_cast<unsigned>(bit_width(mantissa));
+  auto mantissa_width = static_cast<unsigned>(bit_width(mantissa)); 
   const int shift = NormalizedShiftSize<FloatType>(mantissa_width, exponent);
   bool result_exact;
   exponent += shift;
diff --git a/contrib/restricted/abseil-cpp/absl/strings/cord.cc b/contrib/restricted/abseil-cpp/absl/strings/cord.cc
index 854047ca98..db0659b584 100644
--- a/contrib/restricted/abseil-cpp/absl/strings/cord.cc
+++ b/contrib/restricted/abseil-cpp/absl/strings/cord.cc
@@ -37,7 +37,7 @@
 #include "absl/strings/escaping.h"
 #include "absl/strings/internal/cord_internal.h"
 #include "absl/strings/internal/cord_rep_btree.h"
-#include "absl/strings/internal/cord_rep_flat.h"
+#include "absl/strings/internal/cord_rep_flat.h" 
 #include "absl/strings/internal/cordz_statistics.h"
 #include "absl/strings/internal/cordz_update_scope.h"
 #include "absl/strings/internal/cordz_update_tracker.h"
@@ -54,15 +54,15 @@ using ::absl::cord_internal::CordRep;
 using ::absl::cord_internal::CordRepBtree;
 using ::absl::cord_internal::CordRepConcat;
 using ::absl::cord_internal::CordRepExternal;
-using ::absl::cord_internal::CordRepFlat;
+using ::absl::cord_internal::CordRepFlat; 
 using ::absl::cord_internal::CordRepSubstring;
 using ::absl::cord_internal::CordzUpdateTracker;
 using ::absl::cord_internal::InlineData;
 using ::absl::cord_internal::kMaxFlatLength;
-using ::absl::cord_internal::kMinFlatLength;
+using ::absl::cord_internal::kMinFlatLength; 
 
-using ::absl::cord_internal::kInlinedVectorSize;
-using ::absl::cord_internal::kMaxBytesToCopy;
+using ::absl::cord_internal::kInlinedVectorSize; 
+using ::absl::cord_internal::kMaxBytesToCopy; 
 
 constexpr uint64_t Fibonacci(unsigned char n, uint64_t a = 0, uint64_t b = 1) {
   return n == 0 ? a : Fibonacci(n - 1, b, a + b);
@@ -96,8 +96,8 @@ static const int kMinLengthSize = ABSL_ARRAYSIZE(min_length);
 
 static inline bool btree_enabled() {
   return cord_internal::cord_btree_enabled.load(
-      std::memory_order_relaxed);
-}
+      std::memory_order_relaxed); 
+} 
 
 static inline bool IsRootBalanced(CordRep* node) {
   if (!node->IsConcat()) {
@@ -114,8 +114,8 @@ static inline bool IsRootBalanced(CordRep* node) {
 }
 
 static CordRep* Rebalance(CordRep* node);
-static void DumpNode(CordRep* rep, bool include_data, std::ostream* os,
-                     int indent = 0);
+static void DumpNode(CordRep* rep, bool include_data, std::ostream* os, 
+                     int indent = 0); 
 static bool VerifyNode(CordRep* root, CordRep* start_node,
                        bool full_validation);
 
@@ -158,14 +158,14 @@ static void SetConcatChildren(CordRepConcat* concat, CordRep* left,
 // The returned node has a refcount of 1.
 static CordRep* RawConcat(CordRep* left, CordRep* right) {
   // Avoid making degenerate concat nodes (one child is empty)
-  if (left == nullptr) return right;
-  if (right == nullptr) return left;
-  if (left->length == 0) {
-    CordRep::Unref(left);
+  if (left == nullptr) return right; 
+  if (right == nullptr) return left; 
+  if (left->length == 0) { 
+    CordRep::Unref(left); 
     return right;
   }
-  if (right->length == 0) {
-    CordRep::Unref(right);
+  if (right->length == 0) { 
+    CordRep::Unref(right); 
     return left;
   }
 
@@ -204,23 +204,23 @@ static CordRep* MakeBalancedTree(CordRep** reps, size_t n) {
   return reps[0];
 }
 
-static CordRepFlat* CreateFlat(const char* data, size_t length,
+static CordRepFlat* CreateFlat(const char* data, size_t length, 
                                size_t alloc_hint) {
-  CordRepFlat* flat = CordRepFlat::New(length + alloc_hint);
-  flat->length = length;
-  memcpy(flat->Data(), data, length);
-  return flat;
-}
-
+  CordRepFlat* flat = CordRepFlat::New(length + alloc_hint); 
+  flat->length = length; 
+  memcpy(flat->Data(), data, length); 
+  return flat; 
+} 
+ 
 // Creates a new flat or Btree out of the specified array.
-// The returned node has a refcount of 1.
+// The returned node has a refcount of 1. 
 static CordRep* NewBtree(const char* data, size_t length, size_t alloc_hint) {
-  if (length <= kMaxFlatLength) {
-    return CreateFlat(data, length, alloc_hint);
+  if (length <= kMaxFlatLength) { 
+    return CreateFlat(data, length, alloc_hint); 
   }
-  CordRepFlat* flat = CreateFlat(data, kMaxFlatLength, 0);
-  data += kMaxFlatLength;
-  length -= kMaxFlatLength;
+  CordRepFlat* flat = CreateFlat(data, kMaxFlatLength, 0); 
+  data += kMaxFlatLength; 
+  length -= kMaxFlatLength; 
   auto* root = CordRepBtree::Create(flat);
   return CordRepBtree::Append(root, {data, length}, alloc_hint);
 }
@@ -231,14 +231,14 @@ static CordRep* NewTree(const char* data, size_t length, size_t alloc_hint) {
   if (length == 0) return nullptr;
   if (btree_enabled()) {
     return NewBtree(data, length, alloc_hint);
-  }
+  } 
   absl::FixedArray<CordRep*> reps((length - 1) / kMaxFlatLength + 1);
   size_t n = 0;
   do {
     const size_t len = std::min(length, kMaxFlatLength);
-    CordRepFlat* rep = CordRepFlat::New(len + alloc_hint);
+    CordRepFlat* rep = CordRepFlat::New(len + alloc_hint); 
     rep->length = len;
-    memcpy(rep->Data(), data, len);
+    memcpy(rep->Data(), data, len); 
     reps[n++] = VerifyTree(rep);
     data += len;
     length -= len;
@@ -261,7 +261,7 @@ void InitializeCordRepExternal(absl::string_view data, CordRepExternal* rep) {
 static CordRep* NewSubstring(CordRep* child, size_t offset, size_t length) {
   // Never create empty substring nodes
   if (length == 0) {
-    CordRep::Unref(child);
+    CordRep::Unref(child); 
     return nullptr;
   } else {
     CordRepSubstring* rep = new CordRepSubstring();
@@ -312,29 +312,29 @@ inline void Cord::InlineRep::set_data(const char* data, size_t n,
                                       bool nullify_tail) {
   static_assert(kMaxInline == 15, "set_data is hard-coded for a length of 15");
 
-  cord_internal::SmallMemmove(data_.as_chars(), data, n, nullify_tail);
-  set_inline_size(n);
+  cord_internal::SmallMemmove(data_.as_chars(), data, n, nullify_tail); 
+  set_inline_size(n); 
 }
 
 inline char* Cord::InlineRep::set_data(size_t n) {
   assert(n <= kMaxInline);
   ResetToEmpty();
-  set_inline_size(n);
-  return data_.as_chars();
+  set_inline_size(n); 
+  return data_.as_chars(); 
 }
 
 inline void Cord::InlineRep::reduce_size(size_t n) {
-  size_t tag = inline_size();
+  size_t tag = inline_size(); 
   assert(tag <= kMaxInline);
   assert(tag >= n);
   tag -= n;
-  memset(data_.as_chars() + tag, 0, n);
-  set_inline_size(static_cast<char>(tag));
+  memset(data_.as_chars() + tag, 0, n); 
+  set_inline_size(static_cast<char>(tag)); 
 }
 
 inline void Cord::InlineRep::remove_prefix(size_t n) {
-  cord_internal::SmallMemmove(data_.as_chars(), data_.as_chars() + n,
-                              inline_size() - n);
+  cord_internal::SmallMemmove(data_.as_chars(), data_.as_chars() + n, 
+                              inline_size() - n); 
   reduce_size(n);
 }
 
@@ -342,8 +342,8 @@ inline void Cord::InlineRep::remove_prefix(size_t n) {
 // Directly returns `rep` if `rep` is already a CordRepBtree.
 static CordRepBtree* ForceBtree(CordRep* rep) {
   return rep->IsBtree() ? rep->btree() : CordRepBtree::Create(rep);
-}
-
+} 
+ 
 void Cord::InlineRep::AppendTreeToInlined(CordRep* tree,
                                           MethodIdentifier method) {
   assert(!is_tree());
@@ -421,13 +421,13 @@ static inline bool PrepareAppendRegion(CordRep* root, char** region,
                                        size_t* size, size_t max_length) {
   if (root->IsBtree() && root->refcount.IsMutable()) {
     Span<char> span = root->btree()->GetAppendBuffer(max_length);
-    if (!span.empty()) {
-      *region = span.data();
-      *size = span.size();
-      return true;
-    }
-  }
-
+    if (!span.empty()) { 
+      *region = span.data(); 
+      *size = span.size(); 
+      return true; 
+    } 
+  } 
+ 
   // Search down the right-hand path for a non-full FLAT node.
   CordRep* dst = root;
   while (dst->IsConcat() && dst->refcount.IsMutable()) {
@@ -441,7 +441,7 @@ static inline bool PrepareAppendRegion(CordRep* root, char** region,
   }
 
   const size_t in_use = dst->length;
-  const size_t capacity = dst->flat()->Capacity();
+  const size_t capacity = dst->flat()->Capacity(); 
   if (in_use == capacity) {
     *region = nullptr;
     *size = 0;
@@ -456,7 +456,7 @@ static inline bool PrepareAppendRegion(CordRep* root, char** region,
   }
   dst->length += size_increase;
 
-  *region = dst->flat()->Data() + in_use;
+  *region = dst->flat()->Data() + in_use; 
   *size = size_increase;
   return true;
 }
@@ -474,8 +474,8 @@ void Cord::InlineRep::GetAppendRegion(char** region, size_t* size,
       *region = data_.as_chars() + sz;
       *size = has_length ? length : available;
       set_inline_size(has_length ? sz + length : kMaxInline);
-      return;
-    }
+      return; 
+    } 
   }
 
   size_t extra = has_length ? length : (std::max)(sz, kMinFlatLength);
@@ -489,14 +489,14 @@ void Cord::InlineRep::GetAppendRegion(char** region, size_t* size,
   // Allocate new node.
   CordRepFlat* new_node = CordRepFlat::New(extra);
   new_node->length = std::min(new_node->Capacity(), length);
-  *region = new_node->Data();
+  *region = new_node->Data(); 
   *size = new_node->length;
-
+ 
   if (btree_enabled()) {
     rep = CordRepBtree::Append(ForceBtree(rep), new_node);
   } else {
     rep = Concat(rep, new_node);
-  }
+  } 
   CommitTree(root, rep, scope, method);
 }
 
@@ -522,7 +522,7 @@ static bool RepMemoryUsageDataEdge(const CordRep* rep,
                         sizeof(cord_internal::CordRepExternalImpl<intptr_t>) +
                         rep->length;
     return true;
-  }
+  } 
   return false;
 }
 
@@ -530,7 +530,7 @@ static bool RepMemoryUsageDataEdge(const CordRep* rep,
 // will return true.
 static bool RepMemoryUsageLeaf(const CordRep* rep, size_t* total_mem_usage) {
   if (rep->IsFlat()) {
-    *total_mem_usage += rep->flat()->AllocatedSize();
+    *total_mem_usage += rep->flat()->AllocatedSize(); 
     return true;
   }
   if (rep->IsExternal()) {
@@ -570,7 +570,7 @@ void Cord::InlineRep::AssignSlow(const Cord::InlineRep& src) {
 void Cord::InlineRep::UnrefTree() {
   if (is_tree()) {
     CordzInfo::MaybeUntrackCord(data_.cordz_info());
-    CordRep::Unref(tree());
+    CordRep::Unref(tree()); 
   }
 }
 
@@ -612,9 +612,9 @@ void Cord::DestroyCordSlow() {
 // Mutators
 
 void Cord::Clear() {
-  if (CordRep* tree = contents_.clear()) {
-    CordRep::Unref(tree);
-  }
+  if (CordRep* tree = contents_.clear()) { 
+    CordRep::Unref(tree); 
+  } 
 }
 
 Cord& Cord::AssignLargeString(std::string&& src) {
@@ -680,15 +680,15 @@ void Cord::InlineRep::AppendArray(absl::string_view src,
       memcpy(region, src.data(), appended);
     }
   } else {
-    // Try to fit in the inline buffer if possible.
-    size_t inline_length = inline_size();
+    // Try to fit in the inline buffer if possible. 
+    size_t inline_length = inline_size(); 
     if (src.size() <= kMaxInline - inline_length) {
-      // Append new data to embedded array
+      // Append new data to embedded array 
       memcpy(data_.as_chars() + inline_length, src.data(), src.size());
       set_inline_size(inline_length + src.size());
-      return;
-    }
-
+      return; 
+    } 
+ 
     // Allocate flat to be a perfect fit on first append exceeding inlined size.
     // Subsequent growth will use amortized growth until we reach maximum flat
     // size.
@@ -725,12 +725,12 @@ void Cord::InlineRep::AppendArray(absl::string_view src,
       length = std::max<size_t>(rep->length / 10, src.size());
     }
     rep = Concat(rep, NewTree(src.data(), src.size(), length - src.size()));
-  }
+  } 
   CommitTree(root, rep, scope, method);
 }
 
 inline CordRep* Cord::TakeRep() const& {
-  return CordRep::Ref(contents_.tree());
+  return CordRep::Ref(contents_.tree()); 
 }
 
 inline CordRep* Cord::TakeRep() && {
@@ -781,7 +781,7 @@ inline void Cord::AppendImpl(C&& src) {
     return;
   }
 
-  // Guaranteed to be a tree (kMaxBytesToCopy > kInlinedSize)
+  // Guaranteed to be a tree (kMaxBytesToCopy > kInlinedSize) 
   CordRep* rep = std::forward<C>(src).TakeRep();
   contents_.AppendTree(rep, CordzUpdateTracker::kAppendCord);
 }
@@ -809,7 +809,7 @@ template void Cord::Append(std::string&& src);
 void Cord::Prepend(const Cord& src) {
   CordRep* src_tree = src.contents_.tree();
   if (src_tree != nullptr) {
-    CordRep::Ref(src_tree);
+    CordRep::Ref(src_tree); 
     contents_.PrependTree(src_tree, CordzUpdateTracker::kPrependCord);
     return;
   }
@@ -821,17 +821,17 @@ void Cord::Prepend(const Cord& src) {
 
 void Cord::PrependArray(absl::string_view src, MethodIdentifier method) {
   if (src.empty()) return;  // memcpy(_, nullptr, 0) is undefined.
-  if (!contents_.is_tree()) {
-    size_t cur_size = contents_.inline_size();
-    if (cur_size + src.size() <= InlineRep::kMaxInline) {
-      // Use embedded storage.
-      char data[InlineRep::kMaxInline + 1] = {0};
-      memcpy(data, src.data(), src.size());
-      memcpy(data + src.size(), contents_.data(), cur_size);
-      memcpy(contents_.data_.as_chars(), data, InlineRep::kMaxInline + 1);
-      contents_.set_inline_size(cur_size + src.size());
-      return;
-    }
+  if (!contents_.is_tree()) { 
+    size_t cur_size = contents_.inline_size(); 
+    if (cur_size + src.size() <= InlineRep::kMaxInline) { 
+      // Use embedded storage. 
+      char data[InlineRep::kMaxInline + 1] = {0}; 
+      memcpy(data, src.data(), src.size()); 
+      memcpy(data + src.size(), contents_.data(), cur_size); 
+      memcpy(contents_.data_.as_chars(), data, InlineRep::kMaxInline + 1); 
+      contents_.set_inline_size(cur_size + src.size()); 
+      return; 
+    } 
   }
   CordRep* rep = NewTree(src.data(), src.size(), 0);
   contents_.PrependTree(rep, method);
@@ -851,7 +851,7 @@ template void Cord::Prepend(std::string&& src);
 
 static CordRep* RemovePrefixFrom(CordRep* node, size_t n) {
   if (n >= node->length) return nullptr;
-  if (n == 0) return CordRep::Ref(node);
+  if (n == 0) return CordRep::Ref(node); 
   absl::InlinedVector<CordRep*, kInlinedVectorSize> rhs_stack;
 
   while (node->IsConcat()) {
@@ -869,7 +869,7 @@ static CordRep* RemovePrefixFrom(CordRep* node, size_t n) {
   assert(n <= node->length);
 
   if (n == 0) {
-    CordRep::Ref(node);
+    CordRep::Ref(node); 
   } else {
     size_t start = n;
     size_t len = node->length - n;
@@ -878,10 +878,10 @@ static CordRep* RemovePrefixFrom(CordRep* node, size_t n) {
       start += node->substring()->start;
       node = node->substring()->child;
     }
-    node = NewSubstring(CordRep::Ref(node), start, len);
+    node = NewSubstring(CordRep::Ref(node), start, len); 
   }
   while (!rhs_stack.empty()) {
-    node = Concat(node, CordRep::Ref(rhs_stack.back()));
+    node = Concat(node, CordRep::Ref(rhs_stack.back())); 
     rhs_stack.pop_back();
   }
   return node;
@@ -892,7 +892,7 @@ static CordRep* RemovePrefixFrom(CordRep* node, size_t n) {
 // edited in place iff that node and all its ancestors have a refcount of 1.
 static CordRep* RemoveSuffixFrom(CordRep* node, size_t n) {
   if (n >= node->length) return nullptr;
-  if (n == 0) return CordRep::Ref(node);
+  if (n == 0) return CordRep::Ref(node); 
   absl::InlinedVector<CordRep*, kInlinedVectorSize> lhs_stack;
   bool inplace_ok = node->refcount.IsMutable();
 
@@ -912,11 +912,11 @@ static CordRep* RemoveSuffixFrom(CordRep* node, size_t n) {
   assert(n <= node->length);
 
   if (n == 0) {
-    CordRep::Ref(node);
+    CordRep::Ref(node); 
   } else if (inplace_ok && !node->IsExternal()) {
     // Consider making a new buffer if the current node capacity is much
     // larger than the new length.
-    CordRep::Ref(node);
+    CordRep::Ref(node); 
     node->length -= n;
   } else {
     size_t start = 0;
@@ -925,10 +925,10 @@ static CordRep* RemoveSuffixFrom(CordRep* node, size_t n) {
       start = node->substring()->start;
       node = node->substring()->child;
     }
-    node = NewSubstring(CordRep::Ref(node), start, len);
+    node = NewSubstring(CordRep::Ref(node), start, len); 
   }
   while (!lhs_stack.empty()) {
-    node = Concat(CordRep::Ref(lhs_stack.back()), node);
+    node = Concat(CordRep::Ref(lhs_stack.back()), node); 
     lhs_stack.pop_back();
   }
   return node;
@@ -1006,13 +1006,13 @@ static CordRep* NewSubRange(CordRep* node, size_t pos, size_t n) {
       results.pop_back();
       results.push_back(Concat(left, right));
     } else if (pos == 0 && n == node->length) {
-      results.push_back(CordRep::Ref(node));
+      results.push_back(CordRep::Ref(node)); 
     } else if (!node->IsConcat()) {
       if (node->IsSubstring()) {
         pos += node->substring()->start;
         node = node->substring()->child;
       }
-      results.push_back(NewSubstring(CordRep::Ref(node), pos, n));
+      results.push_back(NewSubstring(CordRep::Ref(node), pos, n)); 
     } else if (pos + n <= node->concat()->left->length) {
       todo.push_back(SubRange(node->concat()->left, pos, n));
     } else if (pos >= node->concat()->left->length) {
@@ -1056,7 +1056,7 @@ Cord Cord::Subcord(size_t pos, size_t new_size) const {
       ++it;
     }
     cord_internal::SmallMemmove(dest, it->data(), remaining_size);
-    sub_cord.contents_.set_inline_size(new_size);
+    sub_cord.contents_.set_inline_size(new_size); 
     return sub_cord;
   }
 
@@ -1100,9 +1100,9 @@ class CordForest {
           concat_node->left = concat_freelist_;
           concat_freelist_ = concat_node;
         } else {
-          CordRep::Ref(concat_node->right);
-          CordRep::Ref(concat_node->left);
-          CordRep::Unref(concat_node);
+          CordRep::Ref(concat_node->right); 
+          CordRep::Ref(concat_node->left); 
+          CordRep::Unref(concat_node); 
         }
       } else {
         AddNode(node);
@@ -1252,13 +1252,13 @@ bool ComputeCompareResult<bool>(int memcmp_res) {
 // Helper routine. Locates the first flat or external chunk of the Cord without
 // initializing the iterator, and returns a string_view referencing the data.
 inline absl::string_view Cord::InlineRep::FindFlatStartPiece() const {
-  if (!is_tree()) {
-    return absl::string_view(data_.as_chars(), data_.inline_size());
+  if (!is_tree()) { 
+    return absl::string_view(data_.as_chars(), data_.inline_size()); 
   }
 
   CordRep* node = tree();
   if (node->IsFlat()) {
-    return absl::string_view(node->flat()->Data(), node->length);
+    return absl::string_view(node->flat()->Data(), node->length); 
   }
 
   if (node->IsExternal()) {
@@ -1272,8 +1272,8 @@ inline absl::string_view Cord::InlineRep::FindFlatStartPiece() const {
       tree = tree->Edge(CordRepBtree::kFront)->btree();
     }
     return tree->Data(tree->begin());
-  }
-
+  } 
+ 
   // Walk down the left branches until we hit a non-CONCAT node.
   while (node->IsConcat()) {
     node = node->concat()->left;
@@ -1290,7 +1290,7 @@ inline absl::string_view Cord::InlineRep::FindFlatStartPiece() const {
   }
 
   if (node->IsFlat()) {
-    return absl::string_view(node->flat()->Data() + offset, length);
+    return absl::string_view(node->flat()->Data() + offset, length); 
   }
 
   assert(node->IsExternal() && "Expect FLAT or EXTERNAL node here");
@@ -1473,22 +1473,22 @@ void Cord::CopyToArraySlowPath(char* dst) const {
   }
 }
 
-Cord::ChunkIterator& Cord::ChunkIterator::AdvanceStack() {
-  auto& stack_of_right_children = stack_of_right_children_;
-  if (stack_of_right_children.empty()) {
+Cord::ChunkIterator& Cord::ChunkIterator::AdvanceStack() { 
+  auto& stack_of_right_children = stack_of_right_children_; 
+  if (stack_of_right_children.empty()) { 
     assert(!current_chunk_.empty());  // Called on invalid iterator.
     // We have reached the end of the Cord.
     return *this;
   }
 
   // Process the next node on the stack.
-  CordRep* node = stack_of_right_children.back();
-  stack_of_right_children.pop_back();
+  CordRep* node = stack_of_right_children.back(); 
+  stack_of_right_children.pop_back(); 
 
   // Walk down the left branches until we hit a non-CONCAT node. Save the
   // right children to the stack for subsequent traversal.
   while (node->IsConcat()) {
-    stack_of_right_children.push_back(node->concat()->right);
+    stack_of_right_children.push_back(node->concat()->right); 
     node = node->concat()->left;
   }
 
@@ -1532,30 +1532,30 @@ Cord Cord::ChunkIterator::AdvanceAndReadBytes(size_t n) {
     }
     return subcord;
   }
-
+ 
   if (btree_reader_) {
-    size_t chunk_size = current_chunk_.size();
-    if (n <= chunk_size && n <= kMaxBytesToCopy) {
+    size_t chunk_size = current_chunk_.size(); 
+    if (n <= chunk_size && n <= kMaxBytesToCopy) { 
       subcord = Cord(current_chunk_.substr(0, n), method);
       if (n < chunk_size) {
         current_chunk_.remove_prefix(n);
       } else {
         current_chunk_ = btree_reader_.Next();
       }
-    } else {
+    } else { 
       CordRep* rep;
       current_chunk_ = btree_reader_.Read(n, chunk_size, rep);
       subcord.contents_.EmplaceTree(rep, method);
-    }
+    } 
     bytes_remaining_ -= n;
-    return subcord;
-  }
-
-  auto& stack_of_right_children = stack_of_right_children_;
+    return subcord; 
+  } 
+ 
+  auto& stack_of_right_children = stack_of_right_children_; 
   if (n < current_chunk_.size()) {
     // Range to read is a proper subrange of the current chunk.
     assert(current_leaf_ != nullptr);
-    CordRep* subnode = CordRep::Ref(current_leaf_);
+    CordRep* subnode = CordRep::Ref(current_leaf_); 
     const char* data = subnode->IsExternal() ? subnode->external()->base
                                              : subnode->flat()->Data();
     subnode = NewSubstring(subnode, current_chunk_.data() - data, n);
@@ -1567,7 +1567,7 @@ Cord Cord::ChunkIterator::AdvanceAndReadBytes(size_t n) {
   // Range to read begins with a proper subrange of the current chunk.
   assert(!current_chunk_.empty());
   assert(current_leaf_ != nullptr);
-  CordRep* subnode = CordRep::Ref(current_leaf_);
+  CordRep* subnode = CordRep::Ref(current_leaf_); 
   if (current_chunk_.size() < subnode->length) {
     const char* data = subnode->IsExternal() ? subnode->external()->base
                                              : subnode->flat()->Data();
@@ -1580,20 +1580,20 @@ Cord Cord::ChunkIterator::AdvanceAndReadBytes(size_t n) {
   // Process the next node(s) on the stack, reading whole subtrees depending on
   // their length and how many bytes we are advancing.
   CordRep* node = nullptr;
-  while (!stack_of_right_children.empty()) {
-    node = stack_of_right_children.back();
-    stack_of_right_children.pop_back();
+  while (!stack_of_right_children.empty()) { 
+    node = stack_of_right_children.back(); 
+    stack_of_right_children.pop_back(); 
     if (node->length > n) break;
     // TODO(qrczak): This might unnecessarily recreate existing concat nodes.
     // Avoiding that would need pretty complicated logic (instead of
-    // current_leaf, keep current_subtree_ which points to the highest node
+    // current_leaf, keep current_subtree_ which points to the highest node 
     // such that the current leaf can be found on the path of left children
     // starting from current_subtree_; delay creating subnode while node is
     // below current_subtree_; find the proper node along the path of left
     // children starting from current_subtree_ if this loop exits while staying
     // below current_subtree_; etc.; alternatively, push parents instead of
     // right children on the stack).
-    subnode = Concat(subnode, CordRep::Ref(node));
+    subnode = Concat(subnode, CordRep::Ref(node)); 
     n -= node->length;
     bytes_remaining_ -= node->length;
     node = nullptr;
@@ -1611,11 +1611,11 @@ Cord Cord::ChunkIterator::AdvanceAndReadBytes(size_t n) {
   while (node->IsConcat()) {
     if (node->concat()->left->length > n) {
       // Push right, descend left.
-      stack_of_right_children.push_back(node->concat()->right);
+      stack_of_right_children.push_back(node->concat()->right); 
       node = node->concat()->left;
     } else {
       // Read left, descend right.
-      subnode = Concat(subnode, CordRep::Ref(node->concat()->left));
+      subnode = Concat(subnode, CordRep::Ref(node->concat()->left)); 
       n -= node->concat()->left->length;
       bytes_remaining_ -= node->concat()->left->length;
       node = node->concat()->right;
@@ -1634,9 +1634,9 @@ Cord Cord::ChunkIterator::AdvanceAndReadBytes(size_t n) {
   // chunk.
   assert(node->IsExternal() || node->IsFlat());
   assert(length > n);
-  if (n > 0) {
-    subnode = Concat(subnode, NewSubstring(CordRep::Ref(node), offset, n));
-  }
+  if (n > 0) { 
+    subnode = Concat(subnode, NewSubstring(CordRep::Ref(node), offset, n)); 
+  } 
   const char* data =
       node->IsExternal() ? node->external()->base : node->flat()->Data();
   current_chunk_ = absl::string_view(data + offset + n, length - n);
@@ -1654,19 +1654,19 @@ void Cord::ChunkIterator::AdvanceBytesSlowPath(size_t n) {
   n -= current_chunk_.size();
   bytes_remaining_ -= current_chunk_.size();
 
-  if (stack_of_right_children_.empty()) {
-    // We have reached the end of the Cord.
-    assert(bytes_remaining_ == 0);
-    return;
-  }
-
+  if (stack_of_right_children_.empty()) { 
+    // We have reached the end of the Cord. 
+    assert(bytes_remaining_ == 0); 
+    return; 
+  } 
+ 
   // Process the next node(s) on the stack, skipping whole subtrees depending on
   // their length and how many bytes we are advancing.
   CordRep* node = nullptr;
-  auto& stack_of_right_children = stack_of_right_children_;
-  while (!stack_of_right_children.empty()) {
-    node = stack_of_right_children.back();
-    stack_of_right_children.pop_back();
+  auto& stack_of_right_children = stack_of_right_children_; 
+  while (!stack_of_right_children.empty()) { 
+    node = stack_of_right_children.back(); 
+    stack_of_right_children.pop_back(); 
     if (node->length > n) break;
     n -= node->length;
     bytes_remaining_ -= node->length;
@@ -1684,7 +1684,7 @@ void Cord::ChunkIterator::AdvanceBytesSlowPath(size_t n) {
   while (node->IsConcat()) {
     if (node->concat()->left->length > n) {
       // Push right, descend left.
-      stack_of_right_children.push_back(node->concat()->right);
+      stack_of_right_children.push_back(node->concat()->right); 
       node = node->concat()->left;
     } else {
       // Skip left, descend right.
@@ -1723,7 +1723,7 @@ char Cord::operator[](size_t i) const {
     assert(offset < rep->length);
     if (rep->IsFlat()) {
       // Get the "i"th character directly from the flat array.
-      return rep->flat()->Data()[offset];
+      return rep->flat()->Data()[offset]; 
     } else if (rep->IsBtree()) {
       return rep->btree()->GetCharacter(offset);
     } else if (rep->IsExternal()) {
@@ -1757,9 +1757,9 @@ absl::string_view Cord::FlattenSlowPath() {
   // Try to put the contents into a new flat rep. If they won't fit in the
   // biggest possible flat node, use an external rep instead.
   if (total_size <= kMaxFlatLength) {
-    new_rep = CordRepFlat::New(total_size);
+    new_rep = CordRepFlat::New(total_size); 
     new_rep->length = total_size;
-    new_buffer = new_rep->flat()->Data();
+    new_buffer = new_rep->flat()->Data(); 
     CopyToArraySlowPath(new_buffer);
   } else {
     new_buffer = std::allocator<char>().allocate(total_size);
@@ -1779,7 +1779,7 @@ absl::string_view Cord::FlattenSlowPath() {
 /* static */ bool Cord::GetFlatAux(CordRep* rep, absl::string_view* fragment) {
   assert(rep != nullptr);
   if (rep->IsFlat()) {
-    *fragment = absl::string_view(rep->flat()->Data(), rep->length);
+    *fragment = absl::string_view(rep->flat()->Data(), rep->length); 
     return true;
   } else if (rep->IsExternal()) {
     *fragment = absl::string_view(rep->external()->base, rep->length);
@@ -1789,8 +1789,8 @@ absl::string_view Cord::FlattenSlowPath() {
   } else if (rep->IsSubstring()) {
     CordRep* child = rep->substring()->child;
     if (child->IsFlat()) {
-      *fragment = absl::string_view(
-          child->flat()->Data() + rep->substring()->start, rep->length);
+      *fragment = absl::string_view( 
+          child->flat()->Data() + rep->substring()->start, rep->length); 
       return true;
     } else if (child->IsExternal()) {
       *fragment = absl::string_view(
@@ -1808,14 +1808,14 @@ absl::string_view Cord::FlattenSlowPath() {
     absl::cord_internal::CordRep* rep,
     absl::FunctionRef<void(absl::string_view)> callback) {
   if (rep->IsBtree()) {
-    ChunkIterator it(rep), end;
-    while (it != end) {
-      callback(*it);
-      ++it;
-    }
-    return;
-  }
-
+    ChunkIterator it(rep), end; 
+    while (it != end) { 
+      callback(*it); 
+      ++it; 
+    } 
+    return; 
+  } 
+ 
   assert(rep != nullptr);
   int stack_pos = 0;
   constexpr int stack_max = 128;
@@ -1857,8 +1857,8 @@ absl::string_view Cord::FlattenSlowPath() {
   }
 }
 
-static void DumpNode(CordRep* rep, bool include_data, std::ostream* os,
-                     int indent) {
+static void DumpNode(CordRep* rep, bool include_data, std::ostream* os, 
+                     int indent) { 
   const int kIndentStep = 1;
   absl::InlinedVector<CordRep*, kInlinedVectorSize> stack;
   absl::InlinedVector<int, kInlinedVectorSize> indents;
@@ -1880,7 +1880,7 @@ static void DumpNode(CordRep* rep, bool include_data, std::ostream* os,
       *os << "SUBSTRING @ " << rep->substring()->start << "\n";
       indent += kIndentStep;
       rep = rep->substring()->child;
-    } else {  // Leaf or ring
+    } else {  // Leaf or ring 
       if (rep->IsExternal()) {
         *os << "EXTERNAL [";
         if (include_data)
@@ -1889,9 +1889,9 @@ static void DumpNode(CordRep* rep, bool include_data, std::ostream* os,
       } else if (rep->IsFlat()) {
         *os << "FLAT cap=" << rep->flat()->Capacity() << " [";
         if (include_data)
-          *os << absl::CEscape(std::string(rep->flat()->Data(), rep->length));
+          *os << absl::CEscape(std::string(rep->flat()->Data(), rep->length)); 
         *os << "]\n";
-      } else {
+      } else { 
         CordRepBtree::Dump(rep, /*label=*/ "", include_data, *os);
       }
       if (stack.empty()) break;
@@ -2026,14 +2026,14 @@ std::ostream& operator<<(std::ostream& out, const Cord& cord) {
 }
 
 namespace strings_internal {
-size_t CordTestAccess::FlatOverhead() { return cord_internal::kFlatOverhead; }
-size_t CordTestAccess::MaxFlatLength() { return cord_internal::kMaxFlatLength; }
+size_t CordTestAccess::FlatOverhead() { return cord_internal::kFlatOverhead; } 
+size_t CordTestAccess::MaxFlatLength() { return cord_internal::kMaxFlatLength; } 
 size_t CordTestAccess::FlatTagToLength(uint8_t tag) {
-  return cord_internal::TagToLength(tag);
+  return cord_internal::TagToLength(tag); 
 }
 uint8_t CordTestAccess::LengthToTag(size_t s) {
   ABSL_INTERNAL_CHECK(s <= kMaxFlatLength, absl::StrCat("Invalid length ", s));
-  return cord_internal::AllocatedSizeToTag(s + cord_internal::kFlatOverhead);
+  return cord_internal::AllocatedSizeToTag(s + cord_internal::kFlatOverhead); 
 }
 size_t CordTestAccess::SizeofCordRepConcat() { return sizeof(CordRepConcat); }
 size_t CordTestAccess::SizeofCordRepExternal() {
diff --git a/contrib/restricted/abseil-cpp/absl/strings/cord.h b/contrib/restricted/abseil-cpp/absl/strings/cord.h
index f0a1991471..b0589b54ab 100644
--- a/contrib/restricted/abseil-cpp/absl/strings/cord.h
+++ b/contrib/restricted/abseil-cpp/absl/strings/cord.h
@@ -25,7 +25,7 @@
 //
 // Because a Cord consists of these chunks, data can be added to or removed from
 // a Cord during its lifetime. Chunks may also be shared between Cords. Unlike a
-// `std::string`, a Cord can therefore accommodate data that changes over its
+// `std::string`, a Cord can therefore accommodate data that changes over its 
 // lifetime, though it's not quite "mutable"; it can change only in the
 // attachment, detachment, or rearrangement of chunks of its constituent data.
 //
@@ -81,14 +81,14 @@
 #include "absl/strings/internal/cord_internal.h"
 #include "absl/strings/internal/cord_rep_btree.h"
 #include "absl/strings/internal/cord_rep_btree_reader.h"
-#include "absl/strings/internal/cord_rep_ring.h"
+#include "absl/strings/internal/cord_rep_ring.h" 
 #include "absl/strings/internal/cordz_functions.h"
 #include "absl/strings/internal/cordz_info.h"
 #include "absl/strings/internal/cordz_statistics.h"
 #include "absl/strings/internal/cordz_update_scope.h"
 #include "absl/strings/internal/cordz_update_tracker.h"
 #include "absl/strings/internal/resize_uninitialized.h"
-#include "absl/strings/internal/string_constant.h"
+#include "absl/strings/internal/string_constant.h" 
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
@@ -294,7 +294,7 @@ class Cord {
   bool StartsWith(const Cord& rhs) const;
   bool StartsWith(absl::string_view rhs) const;
 
-  // Cord::EndsWith()
+  // Cord::EndsWith() 
   //
   // Determines whether the Cord ends with the passed string data `rhs`.
   bool EndsWith(absl::string_view rhs) const;
@@ -368,38 +368,38 @@ class Cord {
     friend class CharIterator;
 
    private:
-    using CordRep = absl::cord_internal::CordRep;
+    using CordRep = absl::cord_internal::CordRep; 
     using CordRepBtree = absl::cord_internal::CordRepBtree;
     using CordRepBtreeReader = absl::cord_internal::CordRepBtreeReader;
-
-    // Stack of right children of concat nodes that we have to visit.
-    // Keep this at the end of the structure to avoid cache-thrashing.
-    // TODO(jgm): Benchmark to see if there's a more optimal value than 47 for
-    // the inlined vector size (47 exists for backward compatibility).
-    using Stack = absl::InlinedVector<absl::cord_internal::CordRep*, 47>;
-
-    // Constructs a `begin()` iterator from `tree`. `tree` must not be null.
-    explicit ChunkIterator(cord_internal::CordRep* tree);
-
+ 
+    // Stack of right children of concat nodes that we have to visit. 
+    // Keep this at the end of the structure to avoid cache-thrashing. 
+    // TODO(jgm): Benchmark to see if there's a more optimal value than 47 for 
+    // the inlined vector size (47 exists for backward compatibility). 
+    using Stack = absl::InlinedVector<absl::cord_internal::CordRep*, 47>; 
+ 
+    // Constructs a `begin()` iterator from `tree`. `tree` must not be null. 
+    explicit ChunkIterator(cord_internal::CordRep* tree); 
+ 
     // Constructs a `begin()` iterator from `cord`.
     explicit ChunkIterator(const Cord* cord);
 
-    // Initializes this instance from a tree. Invoked by constructors.
-    void InitTree(cord_internal::CordRep* tree);
-
+    // Initializes this instance from a tree. Invoked by constructors. 
+    void InitTree(cord_internal::CordRep* tree); 
+ 
     // Removes `n` bytes from `current_chunk_`. Expects `n` to be smaller than
     // `current_chunk_.size()`.
     void RemoveChunkPrefix(size_t n);
     Cord AdvanceAndReadBytes(size_t n);
     void AdvanceBytes(size_t n);
-
-    // Stack specific operator++
-    ChunkIterator& AdvanceStack();
-
+ 
+    // Stack specific operator++ 
+    ChunkIterator& AdvanceStack(); 
+ 
     // Btree specific operator++
     ChunkIterator& AdvanceBtree();
     void AdvanceBytesBtree(size_t n);
-
+ 
     // Iterates `n` bytes, where `n` is expected to be greater than or equal to
     // `current_chunk_.size()`.
     void AdvanceBytesSlowPath(size_t n);
@@ -413,12 +413,12 @@ class Cord {
     absl::cord_internal::CordRep* current_leaf_ = nullptr;
     // The number of bytes left in the `Cord` over which we are iterating.
     size_t bytes_remaining_ = 0;
-
+ 
     // Cord reader for cord btrees. Empty if not traversing a btree.
     CordRepBtreeReader btree_reader_;
-
-    // See 'Stack' alias definition.
-    Stack stack_of_right_children_;
+ 
+    // See 'Stack' alias definition. 
+    Stack stack_of_right_children_; 
   };
 
   // Cord::ChunkIterator::chunk_begin()
@@ -680,14 +680,14 @@ class Cord {
     return c.HashFragmented(std::move(hash_state));
   }
 
-  // Create a Cord with the contents of StringConstant<T>::value.
-  // No allocations will be done and no data will be copied.
-  // This is an INTERNAL API and subject to change or removal. This API can only
-  // be used by spelling absl::strings_internal::MakeStringConstant, which is
-  // also an internal API.
-  template <typename T>
-  explicit constexpr Cord(strings_internal::StringConstant<T>);
-
+  // Create a Cord with the contents of StringConstant<T>::value. 
+  // No allocations will be done and no data will be copied. 
+  // This is an INTERNAL API and subject to change or removal. This API can only 
+  // be used by spelling absl::strings_internal::MakeStringConstant, which is 
+  // also an internal API. 
+  template <typename T> 
+  explicit constexpr Cord(strings_internal::StringConstant<T>); 
+ 
  private:
   using CordRep = absl::cord_internal::CordRep;
   using CordRepFlat = absl::cord_internal::CordRepFlat;
@@ -732,8 +732,8 @@ class Cord {
     InlineRep& operator=(const InlineRep& src);
     InlineRep& operator=(InlineRep&& src) noexcept;
 
-    explicit constexpr InlineRep(cord_internal::InlineData data);
-
+    explicit constexpr InlineRep(cord_internal::InlineData data); 
+ 
     void Swap(InlineRep* rhs);
     bool empty() const;
     size_t size() const;
@@ -743,7 +743,7 @@ class Cord {
     char* set_data(size_t n);          // Write data to the result
     // Returns nullptr if holding bytes
     absl::cord_internal::CordRep* tree() const;
-    absl::cord_internal::CordRep* as_tree() const;
+    absl::cord_internal::CordRep* as_tree() const; 
     // Returns non-null iff was holding a pointer
     absl::cord_internal::CordRep* clear();
     // Converts to pointer if necessary.
@@ -820,31 +820,31 @@ class Cord {
       memcpy(&(*dst)[0], &data_, sizeof(data_) - 1);
       // erase is faster than resize because the logic for memory allocation is
       // not needed.
-      dst->erase(inline_size());
+      dst->erase(inline_size()); 
     }
 
     // Copies the inline contents into `dst`. Assumes the cord is not empty.
     void CopyToArray(char* dst) const;
 
-    bool is_tree() const { return data_.is_tree(); }
-
-    // Returns true if the Cord is being profiled by cordz.
-    bool is_profiled() const { return data_.is_tree() && data_.is_profiled(); }
-
-    // Returns the profiled CordzInfo, or nullptr if not sampled.
-    absl::cord_internal::CordzInfo* cordz_info() const {
-      return data_.cordz_info();
-    }
-
-    // Sets the profiled CordzInfo. `cordz_info` must not be null.
-    void set_cordz_info(cord_internal::CordzInfo* cordz_info) {
-      assert(cordz_info != nullptr);
-      data_.set_cordz_info(cordz_info);
-    }
-
-    // Resets the current cordz_info to null / empty.
-    void clear_cordz_info() { data_.clear_cordz_info(); }
-
+    bool is_tree() const { return data_.is_tree(); } 
+
+    // Returns true if the Cord is being profiled by cordz. 
+    bool is_profiled() const { return data_.is_tree() && data_.is_profiled(); } 
+ 
+    // Returns the profiled CordzInfo, or nullptr if not sampled. 
+    absl::cord_internal::CordzInfo* cordz_info() const { 
+      return data_.cordz_info(); 
+    } 
+ 
+    // Sets the profiled CordzInfo. `cordz_info` must not be null. 
+    void set_cordz_info(cord_internal::CordzInfo* cordz_info) { 
+      assert(cordz_info != nullptr); 
+      data_.set_cordz_info(cordz_info); 
+    } 
+ 
+    // Resets the current cordz_info to null / empty. 
+    void clear_cordz_info() { data_.clear_cordz_info(); } 
+ 
    private:
     friend class Cord;
 
@@ -854,8 +854,8 @@ class Cord {
 
     void ResetToEmpty() { data_ = {}; }
 
-    void set_inline_size(size_t size) { data_.set_inline_size(size); }
-    size_t inline_size() const { return data_.inline_size(); }
+    void set_inline_size(size_t size) { data_.set_inline_size(size); } 
+    size_t inline_size() const { return data_.inline_size(); } 
 
     cord_internal::InlineData data_;
   };
@@ -1019,17 +1019,17 @@ Cord MakeCordFromExternal(absl::string_view data, Releaser&& releaser) {
   return cord;
 }
 
-constexpr Cord::InlineRep::InlineRep(cord_internal::InlineData data)
-    : data_(data) {}
-
-inline Cord::InlineRep::InlineRep(const Cord::InlineRep& src)
+constexpr Cord::InlineRep::InlineRep(cord_internal::InlineData data) 
+    : data_(data) {} 
+ 
+inline Cord::InlineRep::InlineRep(const Cord::InlineRep& src) 
     : data_(InlineData::kDefaultInit) {
   if (CordRep* tree = src.tree()) {
     EmplaceTree(CordRep::Ref(tree), src.data_,
                 CordzUpdateTracker::kConstructorCord);
   } else {
     data_ = src.data_;
-  }
+  } 
 }
 
 inline Cord::InlineRep::InlineRep(Cord::InlineRep&& src) : data_(src.data_) {
@@ -1066,26 +1066,26 @@ inline void Cord::InlineRep::Swap(Cord::InlineRep* rhs) {
 }
 
 inline const char* Cord::InlineRep::data() const {
-  return is_tree() ? nullptr : data_.as_chars();
-}
-
-inline absl::cord_internal::CordRep* Cord::InlineRep::as_tree() const {
-  assert(data_.is_tree());
-  return data_.as_tree();
+  return is_tree() ? nullptr : data_.as_chars(); 
 }
 
+inline absl::cord_internal::CordRep* Cord::InlineRep::as_tree() const { 
+  assert(data_.is_tree()); 
+  return data_.as_tree(); 
+} 
+ 
 inline absl::cord_internal::CordRep* Cord::InlineRep::tree() const {
   if (is_tree()) {
-    return as_tree();
+    return as_tree(); 
   } else {
     return nullptr;
   }
 }
 
-inline bool Cord::InlineRep::empty() const { return data_.is_empty(); }
+inline bool Cord::InlineRep::empty() const { return data_.is_empty(); } 
 
 inline size_t Cord::InlineRep::size() const {
-  return is_tree() ? as_tree()->length : inline_size();
+  return is_tree() ? as_tree()->length : inline_size(); 
 }
 
 inline cord_internal::CordRepFlat* Cord::InlineRep::MakeFlatWithExtraCapacity(
@@ -1151,9 +1151,9 @@ inline absl::cord_internal::CordRep* Cord::InlineRep::clear() {
 
 inline void Cord::InlineRep::CopyToArray(char* dst) const {
   assert(!is_tree());
-  size_t n = inline_size();
+  size_t n = inline_size(); 
   assert(n != 0);
-  cord_internal::SmallMemmove(dst, data_.as_chars(), n);
+  cord_internal::SmallMemmove(dst, data_.as_chars(), n); 
 }
 
 constexpr inline Cord::Cord() noexcept {}
@@ -1161,16 +1161,16 @@ constexpr inline Cord::Cord() noexcept {}
 inline Cord::Cord(absl::string_view src)
     : Cord(src, CordzUpdateTracker::kConstructorString) {}
 
-template <typename T>
-constexpr Cord::Cord(strings_internal::StringConstant<T>)
-    : contents_(strings_internal::StringConstant<T>::value.size() <=
-                        cord_internal::kMaxInline
-                    ? cord_internal::InlineData(
-                          strings_internal::StringConstant<T>::value)
-                    : cord_internal::InlineData(
-                          &cord_internal::ConstInitExternalStorage<
-                              strings_internal::StringConstant<T>>::value)) {}
-
+template <typename T> 
+constexpr Cord::Cord(strings_internal::StringConstant<T>) 
+    : contents_(strings_internal::StringConstant<T>::value.size() <= 
+                        cord_internal::kMaxInline 
+                    ? cord_internal::InlineData( 
+                          strings_internal::StringConstant<T>::value) 
+                    : cord_internal::InlineData( 
+                          &cord_internal::ConstInitExternalStorage< 
+                              strings_internal::StringConstant<T>>::value)) {} 
+ 
 inline Cord& Cord::operator=(const Cord& x) {
   contents_ = x.contents_;
   return *this;
@@ -1185,8 +1185,8 @@ Cord& Cord::operator=(T&& src) {
   }
 }
 
-inline Cord::Cord(const Cord& src) : contents_(src.contents_) {}
-
+inline Cord::Cord(const Cord& src) : contents_(src.contents_) {} 
+ 
 inline Cord::Cord(Cord&& src) noexcept : contents_(std::move(src.contents_)) {}
 
 inline void Cord::swap(Cord& other) noexcept {
@@ -1273,64 +1273,64 @@ inline bool Cord::StartsWith(absl::string_view rhs) const {
   return EqualsImpl(rhs, rhs_size);
 }
 
-inline void Cord::ChunkIterator::InitTree(cord_internal::CordRep* tree) {
+inline void Cord::ChunkIterator::InitTree(cord_internal::CordRep* tree) { 
   if (tree->tag == cord_internal::BTREE) {
     current_chunk_ = btree_reader_.Init(tree->btree());
-    return;
-  }
-
-  stack_of_right_children_.push_back(tree);
-  operator++();
-}
-
-inline Cord::ChunkIterator::ChunkIterator(cord_internal::CordRep* tree)
-    : bytes_remaining_(tree->length) {
-  InitTree(tree);
-}
-
+    return; 
+  } 
+ 
+  stack_of_right_children_.push_back(tree); 
+  operator++(); 
+} 
+ 
+inline Cord::ChunkIterator::ChunkIterator(cord_internal::CordRep* tree) 
+    : bytes_remaining_(tree->length) { 
+  InitTree(tree); 
+} 
+ 
 inline Cord::ChunkIterator::ChunkIterator(const Cord* cord)
     : bytes_remaining_(cord->size()) {
   if (cord->contents_.is_tree()) {
-    InitTree(cord->contents_.as_tree());
+    InitTree(cord->contents_.as_tree()); 
   } else {
-    current_chunk_ =
-        absl::string_view(cord->contents_.data(), bytes_remaining_);
+    current_chunk_ = 
+        absl::string_view(cord->contents_.data(), bytes_remaining_); 
   }
 }
 
 inline Cord::ChunkIterator& Cord::ChunkIterator::AdvanceBtree() {
   current_chunk_ = btree_reader_.Next();
-  return *this;
-}
-
+  return *this; 
+} 
+ 
 inline void Cord::ChunkIterator::AdvanceBytesBtree(size_t n) {
-  assert(n >= current_chunk_.size());
-  bytes_remaining_ -= n;
-  if (bytes_remaining_) {
-    if (n == current_chunk_.size()) {
+  assert(n >= current_chunk_.size()); 
+  bytes_remaining_ -= n; 
+  if (bytes_remaining_) { 
+    if (n == current_chunk_.size()) { 
       current_chunk_ = btree_reader_.Next();
-    } else {
+    } else { 
       size_t offset = btree_reader_.length() - bytes_remaining_;
       current_chunk_ = btree_reader_.Seek(offset);
-    }
-  } else {
-    current_chunk_ = {};
-  }
-}
-
-inline Cord::ChunkIterator& Cord::ChunkIterator::operator++() {
-  ABSL_HARDENING_ASSERT(bytes_remaining_ > 0 &&
-                        "Attempted to iterate past `end()`");
-  assert(bytes_remaining_ >= current_chunk_.size());
-  bytes_remaining_ -= current_chunk_.size();
-  if (bytes_remaining_ > 0) {
+    } 
+  } else { 
+    current_chunk_ = {}; 
+  } 
+} 
+ 
+inline Cord::ChunkIterator& Cord::ChunkIterator::operator++() { 
+  ABSL_HARDENING_ASSERT(bytes_remaining_ > 0 && 
+                        "Attempted to iterate past `end()`"); 
+  assert(bytes_remaining_ >= current_chunk_.size()); 
+  bytes_remaining_ -= current_chunk_.size(); 
+  if (bytes_remaining_ > 0) { 
     return btree_reader_ ? AdvanceBtree() : AdvanceStack();
-  } else {
-    current_chunk_ = {};
-  }
-  return *this;
-}
-
+  } else { 
+    current_chunk_ = {}; 
+  } 
+  return *this; 
+} 
+ 
 inline Cord::ChunkIterator Cord::ChunkIterator::operator++(int) {
   ChunkIterator tmp(*this);
   operator++();
@@ -1362,7 +1362,7 @@ inline void Cord::ChunkIterator::RemoveChunkPrefix(size_t n) {
 }
 
 inline void Cord::ChunkIterator::AdvanceBytes(size_t n) {
-  assert(bytes_remaining_ >= n);
+  assert(bytes_remaining_ >= n); 
   if (ABSL_PREDICT_TRUE(n < current_chunk_.size())) {
     RemoveChunkPrefix(n);
   } else if (n != 0) {
diff --git a/contrib/restricted/abseil-cpp/absl/strings/cord/ya.make b/contrib/restricted/abseil-cpp/absl/strings/cord/ya.make
index b3654c86d0..df2c3b8c5a 100644
--- a/contrib/restricted/abseil-cpp/absl/strings/cord/ya.make
+++ b/contrib/restricted/abseil-cpp/absl/strings/cord/ya.make
@@ -1,30 +1,30 @@
-# Generated by devtools/yamaker.
-
-LIBRARY()
-
+# Generated by devtools/yamaker. 
+ 
+LIBRARY() 
+ 
 WITHOUT_LICENSE_TEXTS()
 
-OWNER(g:cpp-contrib)
-
-LICENSE(Apache-2.0)
-
-PEERDIR(
+OWNER(g:cpp-contrib) 
+ 
+LICENSE(Apache-2.0) 
+ 
+PEERDIR( 
     contrib/restricted/abseil-cpp/absl/algorithm
-    contrib/restricted/abseil-cpp/absl/base
+    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/container
     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/functional
-    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
@@ -36,26 +36,26 @@ PEERDIR(
     contrib/restricted/abseil-cpp/absl/time/civil_time
     contrib/restricted/abseil-cpp/absl/time/time_zone
     contrib/restricted/abseil-cpp/absl/types
-    contrib/restricted/abseil-cpp/absl/types/bad_optional_access
+    contrib/restricted/abseil-cpp/absl/types/bad_optional_access 
     contrib/restricted/abseil-cpp/absl/utility
-)
-
-ADDINCL(
-    GLOBAL contrib/restricted/abseil-cpp
-)
-
-NO_COMPILER_WARNINGS()
-
-NO_UTIL()
-
-CFLAGS(
-    -DNOMINMAX
-)
-
-SRCDIR(contrib/restricted/abseil-cpp/absl/strings)
-
-SRCS(
-    cord.cc
-)
-
-END()
+) 
+ 
+ADDINCL( 
+    GLOBAL contrib/restricted/abseil-cpp 
+) 
+ 
+NO_COMPILER_WARNINGS() 
+ 
+NO_UTIL() 
+ 
+CFLAGS( 
+    -DNOMINMAX 
+) 
+ 
+SRCDIR(contrib/restricted/abseil-cpp/absl/strings) 
+ 
+SRCS( 
+    cord.cc 
+) 
+ 
+END() 
diff --git a/contrib/restricted/abseil-cpp/absl/strings/escaping.cc b/contrib/restricted/abseil-cpp/absl/strings/escaping.cc
index 18b20b83fd..b7a6525a49 100644
--- a/contrib/restricted/abseil-cpp/absl/strings/escaping.cc
+++ b/contrib/restricted/abseil-cpp/absl/strings/escaping.cc
@@ -137,7 +137,7 @@ bool CUnescapeInternal(absl::string_view source, bool leave_nulls_escaped,
             // Copy the escape sequence for the null character
             const ptrdiff_t octal_size = p + 1 - octal_start;
             *d++ = '\\';
-            memmove(d, octal_start, octal_size);
+            memmove(d, octal_start, octal_size); 
             d += octal_size;
             break;
           }
@@ -170,7 +170,7 @@ bool CUnescapeInternal(absl::string_view source, bool leave_nulls_escaped,
             // Copy the escape sequence for the null character
             const ptrdiff_t hex_size = p + 1 - hex_start;
             *d++ = '\\';
-            memmove(d, hex_start, hex_size);
+            memmove(d, hex_start, hex_size); 
             d += hex_size;
             break;
           }
@@ -203,7 +203,7 @@ bool CUnescapeInternal(absl::string_view source, bool leave_nulls_escaped,
           if ((rune == 0) && leave_nulls_escaped) {
             // Copy the escape sequence for the null character
             *d++ = '\\';
-            memmove(d, hex_start, 5);  // u0000
+            memmove(d, hex_start, 5);  // u0000 
             d += 5;
             break;
           }
@@ -251,7 +251,7 @@ bool CUnescapeInternal(absl::string_view source, bool leave_nulls_escaped,
           if ((rune == 0) && leave_nulls_escaped) {
             // Copy the escape sequence for the null character
             *d++ = '\\';
-            memmove(d, hex_start, 9);  // U00000000
+            memmove(d, hex_start, 9);  // U00000000 
             d += 9;
             break;
           }
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 2c62f6421a..a1c2096292 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 d29acaf462..a476cd262c 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 1767e6fcc5..2fdbd88583 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 bfe5564e46..6aaad5021a 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 4d0f988697..c9249798a1 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 07c77eb3e5..2635fe1558 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 2000e21ea0..f9b57a8bbf 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 7ceeaa000e..9578154b12 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 47e1c6006c..b18d14d614 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 56243dd401..e571f5dcf6 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 1ad95a8a05..3765399311 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 c988ba8fd2..9f5e8aae3d 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 b26cff6648..bbca0fdcfb 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 b1c4068475..73381fb0a4 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 1f07f02b2e..ae934819e5 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 e766421617..bc503bc9a9 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 a11336b7f0..ade2a38ff5 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_ 
diff --git a/contrib/restricted/abseil-cpp/absl/strings/match.cc b/contrib/restricted/abseil-cpp/absl/strings/match.cc
index 2d67250970..50f1fba32b 100644
--- a/contrib/restricted/abseil-cpp/absl/strings/match.cc
+++ b/contrib/restricted/abseil-cpp/absl/strings/match.cc
@@ -19,22 +19,22 @@
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 
-bool EqualsIgnoreCase(absl::string_view piece1,
-                      absl::string_view piece2) noexcept {
+bool EqualsIgnoreCase(absl::string_view piece1, 
+                      absl::string_view piece2) noexcept { 
   return (piece1.size() == piece2.size() &&
           0 == absl::strings_internal::memcasecmp(piece1.data(), piece2.data(),
                                                   piece1.size()));
   // memcasecmp uses absl::ascii_tolower().
 }
 
-bool StartsWithIgnoreCase(absl::string_view text,
-                          absl::string_view prefix) noexcept {
+bool StartsWithIgnoreCase(absl::string_view text, 
+                          absl::string_view prefix) noexcept { 
   return (text.size() >= prefix.size()) &&
          EqualsIgnoreCase(text.substr(0, prefix.size()), prefix);
 }
 
-bool EndsWithIgnoreCase(absl::string_view text,
-                        absl::string_view suffix) noexcept {
+bool EndsWithIgnoreCase(absl::string_view text, 
+                        absl::string_view suffix) noexcept { 
   return (text.size() >= suffix.size()) &&
          EqualsIgnoreCase(text.substr(text.size() - suffix.size()), suffix);
 }
diff --git a/contrib/restricted/abseil-cpp/absl/strings/match.h b/contrib/restricted/abseil-cpp/absl/strings/match.h
index 038cbb3fa8..c79ed7edd4 100644
--- a/contrib/restricted/abseil-cpp/absl/strings/match.h
+++ b/contrib/restricted/abseil-cpp/absl/strings/match.h
@@ -43,20 +43,20 @@ ABSL_NAMESPACE_BEGIN
 // StrContains()
 //
 // Returns whether a given string `haystack` contains the substring `needle`.
-inline bool StrContains(absl::string_view haystack,
-                        absl::string_view needle) noexcept {
+inline bool StrContains(absl::string_view haystack, 
+                        absl::string_view needle) noexcept { 
   return haystack.find(needle, 0) != haystack.npos;
 }
 
-inline bool StrContains(absl::string_view haystack, char needle) noexcept {
-  return haystack.find(needle) != haystack.npos;
-}
-
+inline bool StrContains(absl::string_view haystack, char needle) noexcept { 
+  return haystack.find(needle) != haystack.npos; 
+} 
+ 
 // StartsWith()
 //
 // Returns whether a given string `text` begins with `prefix`.
-inline bool StartsWith(absl::string_view text,
-                       absl::string_view prefix) noexcept {
+inline bool StartsWith(absl::string_view text, 
+                       absl::string_view prefix) noexcept { 
   return prefix.empty() ||
          (text.size() >= prefix.size() &&
           memcmp(text.data(), prefix.data(), prefix.size()) == 0);
@@ -65,8 +65,8 @@ inline bool StartsWith(absl::string_view text,
 // EndsWith()
 //
 // Returns whether a given string `text` ends with `suffix`.
-inline bool EndsWith(absl::string_view text,
-                     absl::string_view suffix) noexcept {
+inline bool EndsWith(absl::string_view text, 
+                     absl::string_view suffix) noexcept { 
   return suffix.empty() ||
          (text.size() >= suffix.size() &&
           memcmp(text.data() + (text.size() - suffix.size()), suffix.data(),
@@ -77,22 +77,22 @@ inline bool EndsWith(absl::string_view text,
 //
 // Returns whether given ASCII strings `piece1` and `piece2` are equal, ignoring
 // case in the comparison.
-bool EqualsIgnoreCase(absl::string_view piece1,
-                      absl::string_view piece2) noexcept;
+bool EqualsIgnoreCase(absl::string_view piece1, 
+                      absl::string_view piece2) noexcept; 
 
 // StartsWithIgnoreCase()
 //
 // Returns whether a given ASCII string `text` starts with `prefix`,
 // ignoring case in the comparison.
-bool StartsWithIgnoreCase(absl::string_view text,
-                          absl::string_view prefix) noexcept;
+bool StartsWithIgnoreCase(absl::string_view text, 
+                          absl::string_view prefix) noexcept; 
 
 // EndsWithIgnoreCase()
 //
 // Returns whether a given ASCII string `text` ends with `suffix`, ignoring
 // case in the comparison.
-bool EndsWithIgnoreCase(absl::string_view text,
-                        absl::string_view suffix) noexcept;
+bool EndsWithIgnoreCase(absl::string_view text, 
+                        absl::string_view suffix) noexcept; 
 
 ABSL_NAMESPACE_END
 }  // namespace absl
diff --git a/contrib/restricted/abseil-cpp/absl/strings/numbers.cc b/contrib/restricted/abseil-cpp/absl/strings/numbers.cc
index cbd84c918b..24f6bcfcb8 100644
--- a/contrib/restricted/abseil-cpp/absl/strings/numbers.cc
+++ b/contrib/restricted/abseil-cpp/absl/strings/numbers.cc
@@ -32,7 +32,7 @@
 
 #include "absl/base/attributes.h"
 #include "absl/base/internal/raw_logging.h"
-#include "absl/numeric/bits.h"
+#include "absl/numeric/bits.h" 
 #include "absl/strings/ascii.h"
 #include "absl/strings/charconv.h"
 #include "absl/strings/escaping.h"
@@ -46,13 +46,13 @@ ABSL_NAMESPACE_BEGIN
 bool SimpleAtof(absl::string_view str, float* out) {
   *out = 0.0;
   str = StripAsciiWhitespace(str);
-  // std::from_chars doesn't accept an initial +, but SimpleAtof does, so if one
-  // is present, skip it, while avoiding accepting "+-0" as valid.
+  // std::from_chars doesn't accept an initial +, but SimpleAtof does, so if one 
+  // is present, skip it, while avoiding accepting "+-0" as valid. 
   if (!str.empty() && str[0] == '+') {
     str.remove_prefix(1);
-    if (!str.empty() && str[0] == '-') {
-      return false;
-    }
+    if (!str.empty() && str[0] == '-') { 
+      return false; 
+    } 
   }
   auto result = absl::from_chars(str.data(), str.data() + str.size(), *out);
   if (result.ec == std::errc::invalid_argument) {
@@ -77,13 +77,13 @@ bool SimpleAtof(absl::string_view str, float* out) {
 bool SimpleAtod(absl::string_view str, double* out) {
   *out = 0.0;
   str = StripAsciiWhitespace(str);
-  // std::from_chars doesn't accept an initial +, but SimpleAtod does, so if one
-  // is present, skip it, while avoiding accepting "+-0" as valid.
+  // std::from_chars doesn't accept an initial +, but SimpleAtod does, so if one 
+  // is present, skip it, while avoiding accepting "+-0" as valid. 
   if (!str.empty() && str[0] == '+') {
     str.remove_prefix(1);
-    if (!str.empty() && str[0] == '-') {
-      return false;
-    }
+    if (!str.empty() && str[0] == '-') { 
+      return false; 
+    } 
   }
   auto result = absl::from_chars(str.data(), str.data() + str.size(), *out);
   if (result.ec == std::errc::invalid_argument) {
@@ -313,7 +313,7 @@ static std::pair<uint64_t, uint64_t> Mul32(std::pair<uint64_t, uint64_t> num,
   uint64_t bits128_up = (bits96_127 >> 32) + (bits64_127 < bits64_95);
   if (bits128_up == 0) return {bits64_127, bits0_63};
 
-  auto shift = static_cast<unsigned>(bit_width(bits128_up));
+  auto shift = static_cast<unsigned>(bit_width(bits128_up)); 
   uint64_t lo = (bits0_63 >> shift) + (bits64_127 << (64 - shift));
   uint64_t hi = (bits64_127 >> shift) + (bits128_up << (64 - shift));
   return {hi, lo};
@@ -344,7 +344,7 @@ static std::pair<uint64_t, uint64_t> PowFive(uint64_t num, int expfive) {
       5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
       5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5};
   result = Mul32(result, powers_of_five[expfive & 15]);
-  int shift = countl_zero(result.first);
+  int shift = countl_zero(result.first); 
   if (shift != 0) {
     result.first = (result.first << shift) + (result.second >> (64 - shift));
     result.second = (result.second << shift);
@@ -746,18 +746,18 @@ struct LookupTables {
         X / 35, X / 36,                                                   \
   }
 
-// This kVmaxOverBase is generated with
-//  for (int base = 2; base < 37; ++base) {
-//    absl::uint128 max = std::numeric_limits<absl::uint128>::max();
-//    auto result = max / base;
-//    std::cout << "    MakeUint128(" << absl::Uint128High64(result) << "u, "
-//              << absl::Uint128Low64(result) << "u),\n";
-//  }
-// See https://godbolt.org/z/aneYsb
-//
+// This kVmaxOverBase is generated with 
+//  for (int base = 2; base < 37; ++base) { 
+//    absl::uint128 max = std::numeric_limits<absl::uint128>::max(); 
+//    auto result = max / base; 
+//    std::cout << "    MakeUint128(" << absl::Uint128High64(result) << "u, " 
+//              << absl::Uint128Low64(result) << "u),\n"; 
+//  } 
+// See https://godbolt.org/z/aneYsb 
+// 
 // uint128& operator/=(uint128) is not constexpr, so hardcode the resulting
 // array to avoid a static initializer.
-template<>
+template<> 
 const uint128 LookupTables<uint128>::kVmaxOverBase[] = {
     0,
     0,
@@ -798,111 +798,111 @@ const uint128 LookupTables<uint128>::kVmaxOverBase[] = {
     MakeUint128(512409557603043100u, 8198552921648689607u),
 };
 
-// This kVmaxOverBase generated with
-//   for (int base = 2; base < 37; ++base) {
-//    absl::int128 max = std::numeric_limits<absl::int128>::max();
-//    auto result = max / base;
-//    std::cout << "\tMakeInt128(" << absl::Int128High64(result) << ", "
-//              << absl::Int128Low64(result) << "u),\n";
-//  }
-// See https://godbolt.org/z/7djYWz
-//
-// int128& operator/=(int128) is not constexpr, so hardcode the resulting array
-// to avoid a static initializer.
-template<>
-const int128 LookupTables<int128>::kVmaxOverBase[] = {
-    0,
-    0,
-    MakeInt128(4611686018427387903, 18446744073709551615u),
-    MakeInt128(3074457345618258602, 12297829382473034410u),
-    MakeInt128(2305843009213693951, 18446744073709551615u),
-    MakeInt128(1844674407370955161, 11068046444225730969u),
-    MakeInt128(1537228672809129301, 6148914691236517205u),
-    MakeInt128(1317624576693539401, 2635249153387078802u),
-    MakeInt128(1152921504606846975, 18446744073709551615u),
-    MakeInt128(1024819115206086200, 16397105843297379214u),
-    MakeInt128(922337203685477580, 14757395258967641292u),
-    MakeInt128(838488366986797800, 13415813871788764811u),
-    MakeInt128(768614336404564650, 12297829382473034410u),
-    MakeInt128(709490156681136600, 11351842506898185609u),
-    MakeInt128(658812288346769700, 10540996613548315209u),
-    MakeInt128(614891469123651720, 9838263505978427528u),
-    MakeInt128(576460752303423487, 18446744073709551615u),
-    MakeInt128(542551296285575047, 9765923333140350855u),
-    MakeInt128(512409557603043100, 8198552921648689607u),
-    MakeInt128(485440633518672410, 17475862806672206794u),
-    MakeInt128(461168601842738790, 7378697629483820646u),
-    MakeInt128(439208192231179800, 7027331075698876806u),
-    MakeInt128(419244183493398900, 6707906935894382405u),
-    MakeInt128(401016175515425035, 2406097053092550210u),
-    MakeInt128(384307168202282325, 6148914691236517205u),
-    MakeInt128(368934881474191032, 5902958103587056517u),
-    MakeInt128(354745078340568300, 5675921253449092804u),
-    MakeInt128(341606371735362066, 17763531330238827482u),
-    MakeInt128(329406144173384850, 5270498306774157604u),
-    MakeInt128(318047311615681924, 7633135478776366185u),
-    MakeInt128(307445734561825860, 4919131752989213764u),
-    MakeInt128(297528130221121800, 4760450083537948804u),
-    MakeInt128(288230376151711743, 18446744073709551615u),
-    MakeInt128(279496122328932600, 4471937957262921603u),
-    MakeInt128(271275648142787523, 14106333703424951235u),
-    MakeInt128(263524915338707880, 4216398645419326083u),
-    MakeInt128(256204778801521550, 4099276460824344803u),
-};
-
-// This kVminOverBase generated with
-//  for (int base = 2; base < 37; ++base) {
-//    absl::int128 min = std::numeric_limits<absl::int128>::min();
-//    auto result = min / base;
-//    std::cout << "\tMakeInt128(" << absl::Int128High64(result) << ", "
-//              << absl::Int128Low64(result) << "u),\n";
-//  }
-//
-// See https://godbolt.org/z/7djYWz
-//
-// int128& operator/=(int128) is not constexpr, so hardcode the resulting array
-// to avoid a static initializer.
-template<>
-const int128 LookupTables<int128>::kVminOverBase[] = {
-    0,
-    0,
-    MakeInt128(-4611686018427387904, 0u),
-    MakeInt128(-3074457345618258603, 6148914691236517206u),
-    MakeInt128(-2305843009213693952, 0u),
-    MakeInt128(-1844674407370955162, 7378697629483820647u),
-    MakeInt128(-1537228672809129302, 12297829382473034411u),
-    MakeInt128(-1317624576693539402, 15811494920322472814u),
-    MakeInt128(-1152921504606846976, 0u),
-    MakeInt128(-1024819115206086201, 2049638230412172402u),
-    MakeInt128(-922337203685477581, 3689348814741910324u),
-    MakeInt128(-838488366986797801, 5030930201920786805u),
-    MakeInt128(-768614336404564651, 6148914691236517206u),
-    MakeInt128(-709490156681136601, 7094901566811366007u),
-    MakeInt128(-658812288346769701, 7905747460161236407u),
-    MakeInt128(-614891469123651721, 8608480567731124088u),
-    MakeInt128(-576460752303423488, 0u),
-    MakeInt128(-542551296285575048, 8680820740569200761u),
-    MakeInt128(-512409557603043101, 10248191152060862009u),
-    MakeInt128(-485440633518672411, 970881267037344822u),
-    MakeInt128(-461168601842738791, 11068046444225730970u),
-    MakeInt128(-439208192231179801, 11419412998010674810u),
-    MakeInt128(-419244183493398901, 11738837137815169211u),
-    MakeInt128(-401016175515425036, 16040647020617001406u),
-    MakeInt128(-384307168202282326, 12297829382473034411u),
-    MakeInt128(-368934881474191033, 12543785970122495099u),
-    MakeInt128(-354745078340568301, 12770822820260458812u),
-    MakeInt128(-341606371735362067, 683212743470724134u),
-    MakeInt128(-329406144173384851, 13176245766935394012u),
-    MakeInt128(-318047311615681925, 10813608594933185431u),
-    MakeInt128(-307445734561825861, 13527612320720337852u),
-    MakeInt128(-297528130221121801, 13686293990171602812u),
-    MakeInt128(-288230376151711744, 0u),
-    MakeInt128(-279496122328932601, 13974806116446630013u),
-    MakeInt128(-271275648142787524, 4340410370284600381u),
-    MakeInt128(-263524915338707881, 14230345428290225533u),
-    MakeInt128(-256204778801521551, 14347467612885206813u),
-};
-
+// This kVmaxOverBase generated with 
+//   for (int base = 2; base < 37; ++base) { 
+//    absl::int128 max = std::numeric_limits<absl::int128>::max(); 
+//    auto result = max / base; 
+//    std::cout << "\tMakeInt128(" << absl::Int128High64(result) << ", " 
+//              << absl::Int128Low64(result) << "u),\n"; 
+//  } 
+// See https://godbolt.org/z/7djYWz 
+// 
+// int128& operator/=(int128) is not constexpr, so hardcode the resulting array 
+// to avoid a static initializer. 
+template<> 
+const int128 LookupTables<int128>::kVmaxOverBase[] = { 
+    0, 
+    0, 
+    MakeInt128(4611686018427387903, 18446744073709551615u), 
+    MakeInt128(3074457345618258602, 12297829382473034410u), 
+    MakeInt128(2305843009213693951, 18446744073709551615u), 
+    MakeInt128(1844674407370955161, 11068046444225730969u), 
+    MakeInt128(1537228672809129301, 6148914691236517205u), 
+    MakeInt128(1317624576693539401, 2635249153387078802u), 
+    MakeInt128(1152921504606846975, 18446744073709551615u), 
+    MakeInt128(1024819115206086200, 16397105843297379214u), 
+    MakeInt128(922337203685477580, 14757395258967641292u), 
+    MakeInt128(838488366986797800, 13415813871788764811u), 
+    MakeInt128(768614336404564650, 12297829382473034410u), 
+    MakeInt128(709490156681136600, 11351842506898185609u), 
+    MakeInt128(658812288346769700, 10540996613548315209u), 
+    MakeInt128(614891469123651720, 9838263505978427528u), 
+    MakeInt128(576460752303423487, 18446744073709551615u), 
+    MakeInt128(542551296285575047, 9765923333140350855u), 
+    MakeInt128(512409557603043100, 8198552921648689607u), 
+    MakeInt128(485440633518672410, 17475862806672206794u), 
+    MakeInt128(461168601842738790, 7378697629483820646u), 
+    MakeInt128(439208192231179800, 7027331075698876806u), 
+    MakeInt128(419244183493398900, 6707906935894382405u), 
+    MakeInt128(401016175515425035, 2406097053092550210u), 
+    MakeInt128(384307168202282325, 6148914691236517205u), 
+    MakeInt128(368934881474191032, 5902958103587056517u), 
+    MakeInt128(354745078340568300, 5675921253449092804u), 
+    MakeInt128(341606371735362066, 17763531330238827482u), 
+    MakeInt128(329406144173384850, 5270498306774157604u), 
+    MakeInt128(318047311615681924, 7633135478776366185u), 
+    MakeInt128(307445734561825860, 4919131752989213764u), 
+    MakeInt128(297528130221121800, 4760450083537948804u), 
+    MakeInt128(288230376151711743, 18446744073709551615u), 
+    MakeInt128(279496122328932600, 4471937957262921603u), 
+    MakeInt128(271275648142787523, 14106333703424951235u), 
+    MakeInt128(263524915338707880, 4216398645419326083u), 
+    MakeInt128(256204778801521550, 4099276460824344803u), 
+}; 
+ 
+// This kVminOverBase generated with 
+//  for (int base = 2; base < 37; ++base) { 
+//    absl::int128 min = std::numeric_limits<absl::int128>::min(); 
+//    auto result = min / base; 
+//    std::cout << "\tMakeInt128(" << absl::Int128High64(result) << ", " 
+//              << absl::Int128Low64(result) << "u),\n"; 
+//  } 
+// 
+// See https://godbolt.org/z/7djYWz 
+// 
+// int128& operator/=(int128) is not constexpr, so hardcode the resulting array 
+// to avoid a static initializer. 
+template<> 
+const int128 LookupTables<int128>::kVminOverBase[] = { 
+    0, 
+    0, 
+    MakeInt128(-4611686018427387904, 0u), 
+    MakeInt128(-3074457345618258603, 6148914691236517206u), 
+    MakeInt128(-2305843009213693952, 0u), 
+    MakeInt128(-1844674407370955162, 7378697629483820647u), 
+    MakeInt128(-1537228672809129302, 12297829382473034411u), 
+    MakeInt128(-1317624576693539402, 15811494920322472814u), 
+    MakeInt128(-1152921504606846976, 0u), 
+    MakeInt128(-1024819115206086201, 2049638230412172402u), 
+    MakeInt128(-922337203685477581, 3689348814741910324u), 
+    MakeInt128(-838488366986797801, 5030930201920786805u), 
+    MakeInt128(-768614336404564651, 6148914691236517206u), 
+    MakeInt128(-709490156681136601, 7094901566811366007u), 
+    MakeInt128(-658812288346769701, 7905747460161236407u), 
+    MakeInt128(-614891469123651721, 8608480567731124088u), 
+    MakeInt128(-576460752303423488, 0u), 
+    MakeInt128(-542551296285575048, 8680820740569200761u), 
+    MakeInt128(-512409557603043101, 10248191152060862009u), 
+    MakeInt128(-485440633518672411, 970881267037344822u), 
+    MakeInt128(-461168601842738791, 11068046444225730970u), 
+    MakeInt128(-439208192231179801, 11419412998010674810u), 
+    MakeInt128(-419244183493398901, 11738837137815169211u), 
+    MakeInt128(-401016175515425036, 16040647020617001406u), 
+    MakeInt128(-384307168202282326, 12297829382473034411u), 
+    MakeInt128(-368934881474191033, 12543785970122495099u), 
+    MakeInt128(-354745078340568301, 12770822820260458812u), 
+    MakeInt128(-341606371735362067, 683212743470724134u), 
+    MakeInt128(-329406144173384851, 13176245766935394012u), 
+    MakeInt128(-318047311615681925, 10813608594933185431u), 
+    MakeInt128(-307445734561825861, 13527612320720337852u), 
+    MakeInt128(-297528130221121801, 13686293990171602812u), 
+    MakeInt128(-288230376151711744, 0u), 
+    MakeInt128(-279496122328932601, 13974806116446630013u), 
+    MakeInt128(-271275648142787524, 4340410370284600381u), 
+    MakeInt128(-263524915338707881, 14230345428290225533u), 
+    MakeInt128(-256204778801521551, 14347467612885206813u), 
+}; 
+ 
 template <typename IntType>
 const IntType LookupTables<IntType>::kVmaxOverBase[] =
     X_OVER_BASE_INITIALIZER(std::numeric_limits<IntType>::max());
@@ -1072,10 +1072,10 @@ bool safe_strto64_base(absl::string_view text, int64_t* value, int base) {
   return safe_int_internal<int64_t>(text, value, base);
 }
 
-bool safe_strto128_base(absl::string_view text, int128* value, int base) {
-  return safe_int_internal<absl::int128>(text, value, base);
-}
-
+bool safe_strto128_base(absl::string_view text, int128* value, int base) { 
+  return safe_int_internal<absl::int128>(text, value, base); 
+} 
+ 
 bool safe_strtou32_base(absl::string_view text, uint32_t* value, int base) {
   return safe_uint_internal<uint32_t>(text, value, base);
 }
diff --git a/contrib/restricted/abseil-cpp/absl/strings/numbers.h b/contrib/restricted/abseil-cpp/absl/strings/numbers.h
index 899e623c8c..6952facbb2 100644
--- a/contrib/restricted/abseil-cpp/absl/strings/numbers.h
+++ b/contrib/restricted/abseil-cpp/absl/strings/numbers.h
@@ -50,7 +50,7 @@
 #endif
 #include "absl/base/macros.h"
 #include "absl/base/port.h"
-#include "absl/numeric/bits.h"
+#include "absl/numeric/bits.h" 
 #include "absl/numeric/int128.h"
 #include "absl/strings/string_view.h"
 
@@ -147,11 +147,11 @@ inline void PutTwoDigits(size_t i, char* buf) {
 }
 
 // safe_strto?() functions for implementing SimpleAtoi()
-
+ 
 bool safe_strto32_base(absl::string_view text, int32_t* value, int base);
 bool safe_strto64_base(absl::string_view text, int64_t* value, int base);
-bool safe_strto128_base(absl::string_view text, absl::int128* value,
-                         int base);
+bool safe_strto128_base(absl::string_view text, absl::int128* value, 
+                         int base); 
 bool safe_strtou32_base(absl::string_view text, uint32_t* value, int base);
 bool safe_strtou64_base(absl::string_view text, uint64_t* value, int base);
 bool safe_strtou128_base(absl::string_view text, absl::uint128* value,
@@ -263,7 +263,7 @@ inline size_t FastHexToBufferZeroPad16(uint64_t val, char* out) {
   }
 #endif
   // | 0x1 so that even 0 has 1 digit.
-  return 16 - countl_zero(val | 0x1) / 4;
+  return 16 - countl_zero(val | 0x1) / 4; 
 }
 
 }  // namespace numbers_internal
@@ -274,11 +274,11 @@ ABSL_MUST_USE_RESULT bool SimpleAtoi(absl::string_view str, int_type* out) {
 }
 
 ABSL_MUST_USE_RESULT inline bool SimpleAtoi(absl::string_view str,
-                                            absl::int128* out) {
-  return numbers_internal::safe_strto128_base(str, out, 10);
-}
-
-ABSL_MUST_USE_RESULT inline bool SimpleAtoi(absl::string_view str,
+                                            absl::int128* out) { 
+  return numbers_internal::safe_strto128_base(str, out, 10); 
+} 
+ 
+ABSL_MUST_USE_RESULT inline bool SimpleAtoi(absl::string_view str, 
                                             absl::uint128* out) {
   return numbers_internal::safe_strtou128_base(str, out, 10);
 }
diff --git a/contrib/restricted/abseil-cpp/absl/strings/str_join.h b/contrib/restricted/abseil-cpp/absl/strings/str_join.h
index 33534536cf..96eb8725ad 100644
--- a/contrib/restricted/abseil-cpp/absl/strings/str_join.h
+++ b/contrib/restricted/abseil-cpp/absl/strings/str_join.h
@@ -144,7 +144,7 @@ strings_internal::DereferenceFormatterImpl<Formatter> DereferenceFormatter(
       std::forward<Formatter>(f));
 }
 
-// Function overload of `DereferenceFormatter()` for using a default
+// Function overload of `DereferenceFormatter()` for using a default 
 // `AlphaNumFormatter()`.
 inline strings_internal::DereferenceFormatterImpl<
     strings_internal::AlphaNumFormatterImpl>
diff --git a/contrib/restricted/abseil-cpp/absl/strings/str_split.h b/contrib/restricted/abseil-cpp/absl/strings/str_split.h
index bfbca422a8..c896bcbf83 100644
--- a/contrib/restricted/abseil-cpp/absl/strings/str_split.h
+++ b/contrib/restricted/abseil-cpp/absl/strings/str_split.h
@@ -369,12 +369,12 @@ struct SkipWhitespace {
   }
 };
 
-template <typename T>
-using EnableSplitIfString =
-    typename std::enable_if<std::is_same<T, std::string>::value ||
-                            std::is_same<T, const std::string>::value,
-                            int>::type;
-
+template <typename T> 
+using EnableSplitIfString = 
+    typename std::enable_if<std::is_same<T, std::string>::value || 
+                            std::is_same<T, const std::string>::value, 
+                            int>::type; 
+ 
 //------------------------------------------------------------------------------
 //                                  StrSplit()
 //------------------------------------------------------------------------------
@@ -495,50 +495,50 @@ using EnableSplitIfString =
 // Try not to depend on this distinction because the bug may one day be fixed.
 template <typename Delimiter>
 strings_internal::Splitter<
-    typename strings_internal::SelectDelimiter<Delimiter>::type, AllowEmpty,
-    absl::string_view>
+    typename strings_internal::SelectDelimiter<Delimiter>::type, AllowEmpty, 
+    absl::string_view> 
 StrSplit(strings_internal::ConvertibleToStringView text, Delimiter d) {
   using DelimiterType =
       typename strings_internal::SelectDelimiter<Delimiter>::type;
-  return strings_internal::Splitter<DelimiterType, AllowEmpty,
-                                    absl::string_view>(
-      text.value(), DelimiterType(d), AllowEmpty());
-}
-
-template <typename Delimiter, typename StringType,
-          EnableSplitIfString<StringType> = 0>
-strings_internal::Splitter<
-    typename strings_internal::SelectDelimiter<Delimiter>::type, AllowEmpty,
-    std::string>
-StrSplit(StringType&& text, Delimiter d) {
-  using DelimiterType =
-      typename strings_internal::SelectDelimiter<Delimiter>::type;
-  return strings_internal::Splitter<DelimiterType, AllowEmpty, std::string>(
+  return strings_internal::Splitter<DelimiterType, AllowEmpty, 
+                                    absl::string_view>( 
+      text.value(), DelimiterType(d), AllowEmpty()); 
+} 
+ 
+template <typename Delimiter, typename StringType, 
+          EnableSplitIfString<StringType> = 0> 
+strings_internal::Splitter< 
+    typename strings_internal::SelectDelimiter<Delimiter>::type, AllowEmpty, 
+    std::string> 
+StrSplit(StringType&& text, Delimiter d) { 
+  using DelimiterType = 
+      typename strings_internal::SelectDelimiter<Delimiter>::type; 
+  return strings_internal::Splitter<DelimiterType, AllowEmpty, std::string>( 
       std::move(text), DelimiterType(d), AllowEmpty());
 }
 
 template <typename Delimiter, typename Predicate>
 strings_internal::Splitter<
-    typename strings_internal::SelectDelimiter<Delimiter>::type, Predicate,
-    absl::string_view>
+    typename strings_internal::SelectDelimiter<Delimiter>::type, Predicate, 
+    absl::string_view> 
 StrSplit(strings_internal::ConvertibleToStringView text, Delimiter d,
          Predicate p) {
   using DelimiterType =
       typename strings_internal::SelectDelimiter<Delimiter>::type;
-  return strings_internal::Splitter<DelimiterType, Predicate,
-                                    absl::string_view>(
-      text.value(), DelimiterType(d), std::move(p));
-}
-
-template <typename Delimiter, typename Predicate, typename StringType,
-          EnableSplitIfString<StringType> = 0>
-strings_internal::Splitter<
-    typename strings_internal::SelectDelimiter<Delimiter>::type, Predicate,
-    std::string>
-StrSplit(StringType&& text, Delimiter d, Predicate p) {
-  using DelimiterType =
-      typename strings_internal::SelectDelimiter<Delimiter>::type;
-  return strings_internal::Splitter<DelimiterType, Predicate, std::string>(
+  return strings_internal::Splitter<DelimiterType, Predicate, 
+                                    absl::string_view>( 
+      text.value(), DelimiterType(d), std::move(p)); 
+} 
+ 
+template <typename Delimiter, typename Predicate, typename StringType, 
+          EnableSplitIfString<StringType> = 0> 
+strings_internal::Splitter< 
+    typename strings_internal::SelectDelimiter<Delimiter>::type, Predicate, 
+    std::string> 
+StrSplit(StringType&& text, Delimiter d, Predicate p) { 
+  using DelimiterType = 
+      typename strings_internal::SelectDelimiter<Delimiter>::type; 
+  return strings_internal::Splitter<DelimiterType, Predicate, std::string>( 
       std::move(text), DelimiterType(d), std::move(p));
 }
 
diff --git a/contrib/restricted/abseil-cpp/absl/strings/ya.make b/contrib/restricted/abseil-cpp/absl/strings/ya.make
index bc11193f12..278e4f8cf7 100644
--- a/contrib/restricted/abseil-cpp/absl/strings/ya.make
+++ b/contrib/restricted/abseil-cpp/absl/strings/ya.make
@@ -9,9 +9,9 @@ LICENSE(Apache-2.0)
 LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
 
 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/internal/throw_delegate
     contrib/restricted/abseil-cpp/absl/base/log_severity
     contrib/restricted/abseil-cpp/absl/numeric
diff --git a/contrib/restricted/abseil-cpp/absl/synchronization/internal/futex.h b/contrib/restricted/abseil-cpp/absl/synchronization/internal/futex.h
index 06fbd6d072..8503a65aa7 100644
--- a/contrib/restricted/abseil-cpp/absl/synchronization/internal/futex.h
+++ b/contrib/restricted/abseil-cpp/absl/synchronization/internal/futex.h
@@ -38,19 +38,19 @@
 #include "absl/base/optimization.h"
 #include "absl/synchronization/internal/kernel_timeout.h"
 
-#ifdef ABSL_INTERNAL_HAVE_FUTEX
-#error ABSL_INTERNAL_HAVE_FUTEX may not be set on the command line
-#elif defined(__BIONIC__)
-// Bionic supports all the futex operations we need even when some of the futex
-// definitions are missing.
-#define ABSL_INTERNAL_HAVE_FUTEX
-#elif defined(__linux__) && defined(FUTEX_CLOCK_REALTIME)
-// FUTEX_CLOCK_REALTIME requires Linux >= 2.6.28.
-#define ABSL_INTERNAL_HAVE_FUTEX
-#endif
-
-#ifdef ABSL_INTERNAL_HAVE_FUTEX
-
+#ifdef ABSL_INTERNAL_HAVE_FUTEX 
+#error ABSL_INTERNAL_HAVE_FUTEX may not be set on the command line 
+#elif defined(__BIONIC__) 
+// Bionic supports all the futex operations we need even when some of the futex 
+// definitions are missing. 
+#define ABSL_INTERNAL_HAVE_FUTEX 
+#elif defined(__linux__) && defined(FUTEX_CLOCK_REALTIME) 
+// FUTEX_CLOCK_REALTIME requires Linux >= 2.6.28. 
+#define ABSL_INTERNAL_HAVE_FUTEX 
+#endif 
+ 
+#ifdef ABSL_INTERNAL_HAVE_FUTEX 
+ 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace synchronization_internal {
@@ -149,6 +149,6 @@ class Futex : public FutexImpl {};
 ABSL_NAMESPACE_END
 }  // namespace absl
 
-#endif  // ABSL_INTERNAL_HAVE_FUTEX
-
+#endif  // ABSL_INTERNAL_HAVE_FUTEX 
+ 
 #endif  // ABSL_SYNCHRONIZATION_INTERNAL_FUTEX_H_
diff --git a/contrib/restricted/abseil-cpp/absl/synchronization/internal/graphcycles.cc b/contrib/restricted/abseil-cpp/absl/synchronization/internal/graphcycles.cc
index 27fec21681..3ed6c7ba14 100644
--- a/contrib/restricted/abseil-cpp/absl/synchronization/internal/graphcycles.cc
+++ b/contrib/restricted/abseil-cpp/absl/synchronization/internal/graphcycles.cc
@@ -37,7 +37,7 @@
 
 #include <algorithm>
 #include <array>
-#include <limits>
+#include <limits> 
 #include "absl/base/internal/hide_ptr.h"
 #include "absl/base/internal/raw_logging.h"
 #include "absl/base/internal/spinlock.h"
diff --git a/contrib/restricted/abseil-cpp/absl/synchronization/internal/per_thread_sem.cc b/contrib/restricted/abseil-cpp/absl/synchronization/internal/per_thread_sem.cc
index a6031787e0..30b4336dd1 100644
--- a/contrib/restricted/abseil-cpp/absl/synchronization/internal/per_thread_sem.cc
+++ b/contrib/restricted/abseil-cpp/absl/synchronization/internal/per_thread_sem.cc
@@ -68,12 +68,12 @@ ABSL_NAMESPACE_END
 
 extern "C" {
 
-ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemPost)(
+ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemPost)( 
     absl::base_internal::ThreadIdentity *identity) {
   absl::synchronization_internal::Waiter::GetWaiter(identity)->Post();
 }
 
-ABSL_ATTRIBUTE_WEAK bool ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemWait)(
+ABSL_ATTRIBUTE_WEAK bool ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemWait)( 
     absl::synchronization_internal::KernelTimeout t) {
   bool timeout = false;
   absl::base_internal::ThreadIdentity *identity;
diff --git a/contrib/restricted/abseil-cpp/absl/synchronization/internal/per_thread_sem.h b/contrib/restricted/abseil-cpp/absl/synchronization/internal/per_thread_sem.h
index 7beae8ef1d..ef450b953a 100644
--- a/contrib/restricted/abseil-cpp/absl/synchronization/internal/per_thread_sem.h
+++ b/contrib/restricted/abseil-cpp/absl/synchronization/internal/per_thread_sem.h
@@ -96,20 +96,20 @@ ABSL_NAMESPACE_END
 // By changing our extension points to be extern "C", we dodge this
 // check.
 extern "C" {
-void ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemPost)(
+void ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemPost)( 
     absl::base_internal::ThreadIdentity* identity);
-bool ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemWait)(
+bool ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemWait)( 
     absl::synchronization_internal::KernelTimeout t);
 }  // extern "C"
 
 void absl::synchronization_internal::PerThreadSem::Post(
     absl::base_internal::ThreadIdentity* identity) {
-  ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemPost)(identity);
+  ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemPost)(identity); 
 }
 
 bool absl::synchronization_internal::PerThreadSem::Wait(
     absl::synchronization_internal::KernelTimeout t) {
-  return ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemWait)(t);
+  return ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemWait)(t); 
 }
 
 #endif  // ABSL_SYNCHRONIZATION_INTERNAL_PER_THREAD_SEM_H_
diff --git a/contrib/restricted/abseil-cpp/absl/synchronization/internal/waiter.h b/contrib/restricted/abseil-cpp/absl/synchronization/internal/waiter.h
index be3df180d4..638490367b 100644
--- a/contrib/restricted/abseil-cpp/absl/synchronization/internal/waiter.h
+++ b/contrib/restricted/abseil-cpp/absl/synchronization/internal/waiter.h
@@ -36,7 +36,7 @@
 #include <cstdint>
 
 #include "absl/base/internal/thread_identity.h"
-#include "absl/synchronization/internal/futex.h"
+#include "absl/synchronization/internal/futex.h" 
 #include "absl/synchronization/internal/kernel_timeout.h"
 
 // May be chosen at compile time via -DABSL_FORCE_WAITER_MODE=<index>
@@ -49,7 +49,7 @@
 #define ABSL_WAITER_MODE ABSL_FORCE_WAITER_MODE
 #elif defined(_WIN32) && _WIN32_WINNT >= _WIN32_WINNT_VISTA
 #define ABSL_WAITER_MODE ABSL_WAITER_MODE_WIN32
-#elif defined(ABSL_INTERNAL_HAVE_FUTEX)
+#elif defined(ABSL_INTERNAL_HAVE_FUTEX) 
 #define ABSL_WAITER_MODE ABSL_WAITER_MODE_FUTEX
 #elif defined(ABSL_HAVE_SEMAPHORE_H)
 #define ABSL_WAITER_MODE ABSL_WAITER_MODE_SEM
diff --git a/contrib/restricted/abseil-cpp/absl/synchronization/mutex.cc b/contrib/restricted/abseil-cpp/absl/synchronization/mutex.cc
index 76ad41fe16..a68691f3a2 100644
--- a/contrib/restricted/abseil-cpp/absl/synchronization/mutex.cc
+++ b/contrib/restricted/abseil-cpp/absl/synchronization/mutex.cc
@@ -50,7 +50,7 @@
 #include "absl/base/internal/spinlock.h"
 #include "absl/base/internal/sysinfo.h"
 #include "absl/base/internal/thread_identity.h"
-#include "absl/base/internal/tsan_mutex_interface.h"
+#include "absl/base/internal/tsan_mutex_interface.h" 
 #include "absl/base/port.h"
 #include "absl/debugging/stacktrace.h"
 #include "absl/debugging/symbolize.h"
@@ -70,9 +70,9 @@ using absl::synchronization_internal::KernelTimeout;
 using absl::synchronization_internal::PerThreadSem;
 
 extern "C" {
-ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalMutexYield)() {
-  std::this_thread::yield();
-}
+ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalMutexYield)() { 
+  std::this_thread::yield(); 
+} 
 }  // extern "C"
 
 namespace absl {
@@ -126,44 +126,44 @@ void RegisterSymbolizer(bool (*fn)(const void *pc, char *out, int out_size)) {
   symbolizer.Store(fn);
 }
 
-namespace {
-// Represents the strategy for spin and yield.
-// See the comment in GetMutexGlobals() for more information.
-enum DelayMode { AGGRESSIVE, GENTLE };
-
+namespace { 
+// Represents the strategy for spin and yield. 
+// See the comment in GetMutexGlobals() for more information. 
+enum DelayMode { AGGRESSIVE, GENTLE }; 
+ 
 struct ABSL_CACHELINE_ALIGNED MutexGlobals {
   absl::once_flag once;
   int spinloop_iterations = 0;
-  int32_t mutex_sleep_limit[2] = {};
+  int32_t mutex_sleep_limit[2] = {}; 
 };
 
-const MutexGlobals &GetMutexGlobals() {
+const MutexGlobals &GetMutexGlobals() { 
   ABSL_CONST_INIT static MutexGlobals data;
   absl::base_internal::LowLevelCallOnce(&data.once, [&]() {
-    const int num_cpus = absl::base_internal::NumCPUs();
-    data.spinloop_iterations = num_cpus > 1 ? 1500 : 0;
-    // If this a uniprocessor, only yield/sleep.  Otherwise, if the mode is
-    // aggressive then spin many times before yielding.  If the mode is
-    // gentle then spin only a few times before yielding.  Aggressive spinning
-    // is used to ensure that an Unlock() call, which must get the spin lock
-    // for any thread to make progress gets it without undue delay.
-    if (num_cpus > 1) {
-      data.mutex_sleep_limit[AGGRESSIVE] = 5000;
-      data.mutex_sleep_limit[GENTLE] = 250;
-    } else {
-      data.mutex_sleep_limit[AGGRESSIVE] = 0;
-      data.mutex_sleep_limit[GENTLE] = 0;
-    }
+    const int num_cpus = absl::base_internal::NumCPUs(); 
+    data.spinloop_iterations = num_cpus > 1 ? 1500 : 0; 
+    // If this a uniprocessor, only yield/sleep.  Otherwise, if the mode is 
+    // aggressive then spin many times before yielding.  If the mode is 
+    // gentle then spin only a few times before yielding.  Aggressive spinning 
+    // is used to ensure that an Unlock() call, which must get the spin lock 
+    // for any thread to make progress gets it without undue delay. 
+    if (num_cpus > 1) { 
+      data.mutex_sleep_limit[AGGRESSIVE] = 5000; 
+      data.mutex_sleep_limit[GENTLE] = 250; 
+    } else { 
+      data.mutex_sleep_limit[AGGRESSIVE] = 0; 
+      data.mutex_sleep_limit[GENTLE] = 0; 
+    } 
   });
   return data;
 }
-}  // namespace
+}  // namespace 
 
 namespace synchronization_internal {
-// Returns the Mutex delay on iteration `c` depending on the given `mode`.
-// The returned value should be used as `c` for the next call to `MutexDelay`.
+// Returns the Mutex delay on iteration `c` depending on the given `mode`. 
+// The returned value should be used as `c` for the next call to `MutexDelay`. 
 int MutexDelay(int32_t c, int mode) {
-  const int32_t limit = GetMutexGlobals().mutex_sleep_limit[mode];
+  const int32_t limit = GetMutexGlobals().mutex_sleep_limit[mode]; 
   if (c < limit) {
     // Spin.
     c++;
@@ -172,7 +172,7 @@ int MutexDelay(int32_t c, int mode) {
     ABSL_TSAN_MUTEX_PRE_DIVERT(nullptr, 0);
     if (c == limit) {
       // Yield once.
-      ABSL_INTERNAL_C_SYMBOL(AbslInternalMutexYield)();
+      ABSL_INTERNAL_C_SYMBOL(AbslInternalMutexYield)(); 
       c++;
     } else {
       // Then wait.
@@ -559,7 +559,7 @@ static SynchLocksHeld *Synch_GetAllLocks() {
 }
 
 // Post on "w"'s associated PerThreadSem.
-void Mutex::IncrementSynchSem(Mutex *mu, PerThreadSynch *w) {
+void Mutex::IncrementSynchSem(Mutex *mu, PerThreadSynch *w) { 
   if (mu) {
     ABSL_TSAN_MUTEX_PRE_DIVERT(mu, 0);
   }
@@ -717,7 +717,7 @@ static constexpr bool kDebugMode = false;
 static constexpr bool kDebugMode = true;
 #endif
 
-#ifdef ABSL_INTERNAL_HAVE_TSAN_INTERFACE
+#ifdef ABSL_INTERNAL_HAVE_TSAN_INTERFACE 
 static unsigned TsanFlags(Mutex::MuHow how) {
   return how == kShared ? __tsan_mutex_read_lock : 0;
 }
@@ -763,13 +763,13 @@ void SetMutexDeadlockDetectionMode(OnDeadlockCycle mode) {
   synch_deadlock_detection.store(mode, std::memory_order_release);
 }
 
-// Return true iff threads x and y are part of the same equivalence
-// class of waiters. An equivalence class is defined as the set of
-// waiters with the same condition, type of lock, and thread priority.
-//
-// Requires that x and y be waiting on the same Mutex queue.
-static bool MuEquivalentWaiter(PerThreadSynch *x, PerThreadSynch *y) {
-  return x->waitp->how == y->waitp->how && x->priority == y->priority &&
+// Return true iff threads x and y are part of the same equivalence 
+// class of waiters. An equivalence class is defined as the set of 
+// waiters with the same condition, type of lock, and thread priority. 
+// 
+// Requires that x and y be waiting on the same Mutex queue. 
+static bool MuEquivalentWaiter(PerThreadSynch *x, PerThreadSynch *y) { 
+  return x->waitp->how == y->waitp->how && x->priority == y->priority && 
          Condition::GuaranteedEqual(x->waitp->cond, y->waitp->cond);
 }
 
@@ -788,19 +788,19 @@ static inline PerThreadSynch *GetPerThreadSynch(intptr_t v) {
 //     - invalid (iff x is not in a Mutex wait queue),
 //     - null, or
 //     - a pointer to a distinct thread waiting later in the same Mutex queue
-//       such that all threads in [x, x->skip] have the same condition, priority
-//       and lock type (MuEquivalentWaiter() is true for all pairs in [x,
-//       x->skip]).
+//       such that all threads in [x, x->skip] have the same condition, priority 
+//       and lock type (MuEquivalentWaiter() is true for all pairs in [x, 
+//       x->skip]). 
 // In addition, if x->skip is  valid, (x->may_skip || x->skip == null)
 //
-// By the spec of MuEquivalentWaiter(), it is not necessary when removing the
+// By the spec of MuEquivalentWaiter(), it is not necessary when removing the 
 // first runnable thread y from the front a Mutex queue to adjust the skip
 // field of another thread x because if x->skip==y, x->skip must (have) become
 // invalid before y is removed.  The function TryRemove can remove a specified
 // thread from an arbitrary position in the queue whether runnable or not, so
 // it fixes up skip fields that would otherwise be left dangling.
 // The statement
-//     if (x->may_skip && MuEquivalentWaiter(x, x->next)) { x->skip = x->next; }
+//     if (x->may_skip && MuEquivalentWaiter(x, x->next)) { x->skip = x->next; } 
 // maintains the invariant provided x is not the last waiter in a Mutex queue
 // The statement
 //          if (x->skip != null) { x->skip = x->skip->skip; }
@@ -934,17 +934,17 @@ static PerThreadSynch *Enqueue(PerThreadSynch *head,
     if (s->priority > head->priority) {  // s's priority is above head's
       // try to put s in priority-fifo order, or failing that at the front.
       if (!head->maybe_unlocking) {
-        // No unlocker can be scanning the queue, so we can insert into the
-        // middle of the queue.
-        //
-        // Within a skip chain, all waiters have the same priority, so we can
-        // skip forward through the chains until we find one with a lower
-        // priority than the waiter to be enqueued.
+        // No unlocker can be scanning the queue, so we can insert into the 
+        // middle of the queue. 
+        // 
+        // Within a skip chain, all waiters have the same priority, so we can 
+        // skip forward through the chains until we find one with a lower 
+        // priority than the waiter to be enqueued. 
         PerThreadSynch *advance_to = head;    // next value of enqueue_after
         do {
           enqueue_after = advance_to;
-          // (side-effect: optimizes skip chain)
-          advance_to = Skip(enqueue_after->next);
+          // (side-effect: optimizes skip chain) 
+          advance_to = Skip(enqueue_after->next); 
         } while (s->priority <= advance_to->priority);
               // termination guaranteed because s->priority > head->priority
               // and head is the end of a skip chain
@@ -963,21 +963,21 @@ static PerThreadSynch *Enqueue(PerThreadSynch *head,
 
       // enqueue_after can be: head, Skip(...), or cur.
       // The first two imply enqueue_after->skip == nullptr, and
-      // the last is used only if MuEquivalentWaiter(s, cur).
+      // the last is used only if MuEquivalentWaiter(s, cur). 
       // We require this because clearing enqueue_after->skip
       // is impossible; enqueue_after's predecessors might also
       // incorrectly skip over s if we were to allow other
       // insertion points.
-      ABSL_RAW_CHECK(enqueue_after->skip == nullptr ||
-                         MuEquivalentWaiter(enqueue_after, s),
-                     "Mutex Enqueue failure");
+      ABSL_RAW_CHECK(enqueue_after->skip == nullptr || 
+                         MuEquivalentWaiter(enqueue_after, s), 
+                     "Mutex Enqueue failure"); 
 
       if (enqueue_after != head && enqueue_after->may_skip &&
-          MuEquivalentWaiter(enqueue_after, enqueue_after->next)) {
+          MuEquivalentWaiter(enqueue_after, enqueue_after->next)) { 
         // enqueue_after can skip to its new successor, s
         enqueue_after->skip = enqueue_after->next;
       }
-      if (MuEquivalentWaiter(s, s->next)) {  // s->may_skip is known to be true
+      if (MuEquivalentWaiter(s, s->next)) {  // s->may_skip is known to be true 
         s->skip = s->next;                // s may skip to its successor
       }
     } else {   // enqueue not done any other way, so
@@ -987,7 +987,7 @@ static PerThreadSynch *Enqueue(PerThreadSynch *head,
       head->next = s;
       s->readers = head->readers;  // reader count is from previous head
       s->maybe_unlocking = head->maybe_unlocking;  // same for unlock hint
-      if (head->may_skip && MuEquivalentWaiter(head, s)) {
+      if (head->may_skip && MuEquivalentWaiter(head, s)) { 
         // head now has successor; may skip
         head->skip = s;
       }
@@ -1007,7 +1007,7 @@ static PerThreadSynch *Dequeue(PerThreadSynch *head, PerThreadSynch *pw) {
   pw->next = w->next;         // snip w out of list
   if (head == w) {            // we removed the head
     head = (pw == w) ? nullptr : pw;  // either emptied list, or pw is new head
-  } else if (pw != head && MuEquivalentWaiter(pw, pw->next)) {
+  } else if (pw != head && MuEquivalentWaiter(pw, pw->next)) { 
     // pw can skip to its new successor
     if (pw->next->skip !=
         nullptr) {  // either skip to its successors skip target
@@ -1077,13 +1077,13 @@ void Mutex::TryRemove(PerThreadSynch *s) {
       PerThreadSynch *w;
       if ((w = pw->next) != s) {  // search for thread,
         do {                      // processing at least one element
-          // If the current element isn't equivalent to the waiter to be
-          // removed, we can skip the entire chain.
-          if (!MuEquivalentWaiter(s, w)) {
+          // If the current element isn't equivalent to the waiter to be 
+          // removed, we can skip the entire chain. 
+          if (!MuEquivalentWaiter(s, w)) { 
             pw = Skip(w);                // so skip all that won't match
             // we don't have to worry about dangling skip fields
             // in the threads we skipped; none can point to s
-            // because they are in a different equivalence class.
+            // because they are in a different equivalence class. 
           } else {          // seeking same condition
             FixSkip(w, s);  // fix up any skip pointer from w to s
             pw = w;
@@ -1374,9 +1374,9 @@ static GraphId DeadlockCheck(Mutex *mu) {
           len += static_cast<int>(strlen(&b->buf[len]));
         }
       }
-      ABSL_RAW_LOG(ERROR,
-                   "Acquiring absl::Mutex %p while holding %s; a cycle in the "
-                   "historical lock ordering graph has been observed",
+      ABSL_RAW_LOG(ERROR, 
+                   "Acquiring absl::Mutex %p while holding %s; a cycle in the " 
+                   "historical lock ordering graph has been observed", 
                    static_cast<void *>(mu), b->buf);
       ABSL_RAW_LOG(ERROR, "Cycle: ");
       int path_len = deadlock_graph->FindPath(
@@ -1779,7 +1779,7 @@ static inline bool EvalConditionAnnotated(const Condition *cond, Mutex *mu,
   // All memory accesses are ignored inside of mutex operations + for unlock
   // operation tsan considers that we've already released the mutex.
   bool res = false;
-#ifdef ABSL_INTERNAL_HAVE_TSAN_INTERFACE
+#ifdef ABSL_INTERNAL_HAVE_TSAN_INTERFACE 
   const int flags = read_lock ? __tsan_mutex_read_lock : 0;
   const int tryflags = flags | (trylock ? __tsan_mutex_try_lock : 0);
 #endif
@@ -2150,7 +2150,7 @@ ABSL_ATTRIBUTE_NOINLINE void Mutex::UnlockSlow(SynchWaitParams *waitp) {
           !old_h->may_skip) {                  // we used old_h as a terminator
         old_h->may_skip = true;                // allow old_h to skip once more
         ABSL_RAW_CHECK(old_h->skip == nullptr, "illegal skip from head");
-        if (h != old_h && MuEquivalentWaiter(old_h, old_h->next)) {
+        if (h != old_h && MuEquivalentWaiter(old_h, old_h->next)) { 
           old_h->skip = old_h->next;  // old_h not head & can skip to successor
         }
       }
diff --git a/contrib/restricted/abseil-cpp/absl/synchronization/mutex.h b/contrib/restricted/abseil-cpp/absl/synchronization/mutex.h
index 38338f24df..d8bf58c871 100644
--- a/contrib/restricted/abseil-cpp/absl/synchronization/mutex.h
+++ b/contrib/restricted/abseil-cpp/absl/synchronization/mutex.h
@@ -31,23 +31,23 @@
 //
 //  MutexLock - An RAII wrapper to acquire and release a `Mutex` for exclusive/
 //              write access within the current scope.
-//
+// 
 //  ReaderMutexLock
 //            - An RAII wrapper to acquire and release a `Mutex` for shared/read
 //              access within the current scope.
 //
 //  WriterMutexLock
-//            - Effectively an alias for `MutexLock` above, designed for use in
-//              distinguishing reader and writer locks within code.
+//            - Effectively an alias for `MutexLock` above, designed for use in 
+//              distinguishing reader and writer locks within code. 
 //
 // In addition to simple mutex locks, this file also defines ways to perform
 // locking under certain conditions.
 //
-//  Condition - (Preferred) Used to wait for a particular predicate that
-//              depends on state protected by the `Mutex` to become true.
-//  CondVar   - A lower-level variant of `Condition` that relies on
-//              application code to explicitly signal the `CondVar` when
-//              a condition has been met.
+//  Condition - (Preferred) Used to wait for a particular predicate that 
+//              depends on state protected by the `Mutex` to become true. 
+//  CondVar   - A lower-level variant of `Condition` that relies on 
+//              application code to explicitly signal the `CondVar` when 
+//              a condition has been met. 
 //
 // See below for more information on using `Condition` or `CondVar`.
 //
@@ -147,7 +147,7 @@ class ABSL_LOCKABLE Mutex {
   //
   // Example usage:
   //   namespace foo {
-  //   ABSL_CONST_INIT absl::Mutex mu(absl::kConstInit);
+  //   ABSL_CONST_INIT absl::Mutex mu(absl::kConstInit); 
   //   }
   explicit constexpr Mutex(absl::ConstInitType);
 
@@ -162,7 +162,7 @@ class ABSL_LOCKABLE Mutex {
   // Mutex::Unlock()
   //
   // Releases this `Mutex` and returns it from the exclusive/write state to the
-  // free state. Calling thread must hold the `Mutex` exclusively.
+  // free state. Calling thread must hold the `Mutex` exclusively. 
   void Unlock() ABSL_UNLOCK_FUNCTION();
 
   // Mutex::TryLock()
@@ -457,9 +457,9 @@ class ABSL_LOCKABLE Mutex {
 
   // Post()/Wait() versus associated PerThreadSem; in class for required
   // friendship with PerThreadSem.
-  static void IncrementSynchSem(Mutex *mu, base_internal::PerThreadSynch *w);
-  static bool DecrementSynchSem(Mutex *mu, base_internal::PerThreadSynch *w,
-                                synchronization_internal::KernelTimeout t);
+  static void IncrementSynchSem(Mutex *mu, base_internal::PerThreadSynch *w); 
+  static bool DecrementSynchSem(Mutex *mu, base_internal::PerThreadSynch *w, 
+                                synchronization_internal::KernelTimeout t); 
 
   // slow path acquire
   void LockSlowLoop(SynchWaitParams *waitp, int flags);
@@ -505,36 +505,36 @@ class ABSL_LOCKABLE Mutex {
 // Example:
 //
 // Class Foo {
-//  public:
+//  public: 
 //   Foo::Bar* Baz() {
-//     MutexLock lock(&mu_);
+//     MutexLock lock(&mu_); 
 //     ...
 //     return bar;
 //   }
 //
 // private:
-//   Mutex mu_;
+//   Mutex mu_; 
 // };
 class ABSL_SCOPED_LOCKABLE MutexLock {
  public:
-  // Constructors
-
-  // Calls `mu->Lock()` and returns when that call returns. That is, `*mu` is
-  // guaranteed to be locked when this object is constructed. Requires that
-  // `mu` be dereferenceable.
+  // Constructors 
+ 
+  // Calls `mu->Lock()` and returns when that call returns. That is, `*mu` is 
+  // guaranteed to be locked when this object is constructed. Requires that 
+  // `mu` be dereferenceable. 
   explicit MutexLock(Mutex *mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) : mu_(mu) {
     this->mu_->Lock();
   }
 
-  // Like above, but calls `mu->LockWhen(cond)` instead. That is, in addition to
-  // the above, the condition given by `cond` is also guaranteed to hold when
-  // this object is constructed.
-  explicit MutexLock(Mutex *mu, const Condition &cond)
-      ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
-      : mu_(mu) {
-    this->mu_->LockWhen(cond);
-  }
-
+  // Like above, but calls `mu->LockWhen(cond)` instead. That is, in addition to 
+  // the above, the condition given by `cond` is also guaranteed to hold when 
+  // this object is constructed. 
+  explicit MutexLock(Mutex *mu, const Condition &cond) 
+      ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) 
+      : mu_(mu) { 
+    this->mu_->LockWhen(cond); 
+  } 
+ 
   MutexLock(const MutexLock &) = delete;  // NOLINT(runtime/mutex)
   MutexLock(MutexLock&&) = delete;  // NOLINT(runtime/mutex)
   MutexLock& operator=(const MutexLock&) = delete;
@@ -556,12 +556,12 @@ class ABSL_SCOPED_LOCKABLE ReaderMutexLock {
     mu->ReaderLock();
   }
 
-  explicit ReaderMutexLock(Mutex *mu, const Condition &cond)
-      ABSL_SHARED_LOCK_FUNCTION(mu)
-      : mu_(mu) {
-    mu->ReaderLockWhen(cond);
-  }
-
+  explicit ReaderMutexLock(Mutex *mu, const Condition &cond) 
+      ABSL_SHARED_LOCK_FUNCTION(mu) 
+      : mu_(mu) { 
+    mu->ReaderLockWhen(cond); 
+  } 
+ 
   ReaderMutexLock(const ReaderMutexLock&) = delete;
   ReaderMutexLock(ReaderMutexLock&&) = delete;
   ReaderMutexLock& operator=(const ReaderMutexLock&) = delete;
@@ -584,12 +584,12 @@ class ABSL_SCOPED_LOCKABLE WriterMutexLock {
     mu->WriterLock();
   }
 
-  explicit WriterMutexLock(Mutex *mu, const Condition &cond)
-      ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
-      : mu_(mu) {
-    mu->WriterLockWhen(cond);
-  }
-
+  explicit WriterMutexLock(Mutex *mu, const Condition &cond) 
+      ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) 
+      : mu_(mu) { 
+    mu->WriterLockWhen(cond); 
+  } 
+ 
   WriterMutexLock(const WriterMutexLock&) = delete;
   WriterMutexLock(WriterMutexLock&&) = delete;
   WriterMutexLock& operator=(const WriterMutexLock&) = delete;
@@ -628,27 +628,27 @@ class ABSL_SCOPED_LOCKABLE WriterMutexLock {
 // `noexcept`; until then this requirement cannot be enforced in the
 // type system.)
 //
-// Note: to use a `Condition`, you need only construct it and pass it to a
-// suitable `Mutex' member function, such as `Mutex::Await()`, or to the
-// constructor of one of the scope guard classes.
+// Note: to use a `Condition`, you need only construct it and pass it to a 
+// suitable `Mutex' member function, such as `Mutex::Await()`, or to the 
+// constructor of one of the scope guard classes. 
 //
-// Example using LockWhen/Unlock:
+// Example using LockWhen/Unlock: 
 //
 //   // assume count_ is not internal reference count
 //   int count_ ABSL_GUARDED_BY(mu_);
-//   Condition count_is_zero(+[](int *count) { return *count == 0; }, &count_);
-//
-//   mu_.LockWhen(count_is_zero);
-//   // ...
-//   mu_.Unlock();
-//
-// Example using a scope guard:
-//
-//   {
-//     MutexLock lock(&mu_, count_is_zero);
-//     // ...
-//   }
-//
+//   Condition count_is_zero(+[](int *count) { return *count == 0; }, &count_); 
+//
+//   mu_.LockWhen(count_is_zero); 
+//   // ... 
+//   mu_.Unlock(); 
+//
+// Example using a scope guard: 
+// 
+//   { 
+//     MutexLock lock(&mu_, count_is_zero); 
+//     // ... 
+//   } 
+// 
 // When multiple threads are waiting on exactly the same condition, make sure
 // that they are constructed with the same parameters (same pointer to function
 // + arg, or same pointer to object + method), so that the mutex implementation
@@ -879,15 +879,15 @@ class ABSL_SCOPED_LOCKABLE MutexLockMaybe {
       this->mu_->Lock();
     }
   }
-
-  explicit MutexLockMaybe(Mutex *mu, const Condition &cond)
-      ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
-      : mu_(mu) {
-    if (this->mu_ != nullptr) {
-      this->mu_->LockWhen(cond);
-    }
-  }
-
+ 
+  explicit MutexLockMaybe(Mutex *mu, const Condition &cond) 
+      ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) 
+      : mu_(mu) { 
+    if (this->mu_ != nullptr) { 
+      this->mu_->LockWhen(cond); 
+    } 
+  } 
+ 
   ~MutexLockMaybe() ABSL_UNLOCK_FUNCTION() {
     if (this->mu_ != nullptr) { this->mu_->Unlock(); }
   }
@@ -910,13 +910,13 @@ class ABSL_SCOPED_LOCKABLE ReleasableMutexLock {
       : mu_(mu) {
     this->mu_->Lock();
   }
-
-  explicit ReleasableMutexLock(Mutex *mu, const Condition &cond)
-      ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
-      : mu_(mu) {
-    this->mu_->LockWhen(cond);
-  }
-
+ 
+  explicit ReleasableMutexLock(Mutex *mu, const Condition &cond) 
+      ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) 
+      : mu_(mu) { 
+    this->mu_->LockWhen(cond); 
+  } 
+ 
   ~ReleasableMutexLock() ABSL_UNLOCK_FUNCTION() {
     if (this->mu_ != nullptr) { this->mu_->Unlock(); }
   }
@@ -1076,7 +1076,7 @@ ABSL_NAMESPACE_END
 // By changing our extension points to be extern "C", we dodge this
 // check.
 extern "C" {
-void ABSL_INTERNAL_C_SYMBOL(AbslInternalMutexYield)();
+void ABSL_INTERNAL_C_SYMBOL(AbslInternalMutexYield)(); 
 }  // extern "C"
 
 #endif  // ABSL_SYNCHRONIZATION_MUTEX_H_
diff --git a/contrib/restricted/abseil-cpp/absl/time/clock.cc b/contrib/restricted/abseil-cpp/absl/time/clock.cc
index 7b204c4ee0..bce60d53d6 100644
--- a/contrib/restricted/abseil-cpp/absl/time/clock.cc
+++ b/contrib/restricted/abseil-cpp/absl/time/clock.cc
@@ -15,7 +15,7 @@
 #include "absl/time/clock.h"
 
 #include "absl/base/attributes.h"
-#include "absl/base/optimization.h"
+#include "absl/base/optimization.h" 
 
 #ifdef _WIN32
 #include <windows.h>
@@ -152,109 +152,109 @@ static_assert(((kMinNSBetweenSamples << (kScale + 1)) >> (kScale + 1)) ==
 
 // data from a sample of the kernel's time value
 struct TimeSampleAtomic {
-  std::atomic<uint64_t> raw_ns{0};              // raw kernel time
-  std::atomic<uint64_t> base_ns{0};             // our estimate of time
-  std::atomic<uint64_t> base_cycles{0};         // cycle counter reading
-  std::atomic<uint64_t> nsscaled_per_cycle{0};  // cycle period
+  std::atomic<uint64_t> raw_ns{0};              // raw kernel time 
+  std::atomic<uint64_t> base_ns{0};             // our estimate of time 
+  std::atomic<uint64_t> base_cycles{0};         // cycle counter reading 
+  std::atomic<uint64_t> nsscaled_per_cycle{0};  // cycle period 
   // cycles before we'll sample again (a scaled reciprocal of the period,
   // to avoid a division on the fast path).
-  std::atomic<uint64_t> min_cycles_per_sample{0};
+  std::atomic<uint64_t> min_cycles_per_sample{0}; 
 };
 // Same again, but with non-atomic types
 struct TimeSample {
-  uint64_t raw_ns = 0;                 // raw kernel time
-  uint64_t base_ns = 0;                // our estimate of time
-  uint64_t base_cycles = 0;            // cycle counter reading
-  uint64_t nsscaled_per_cycle = 0;     // cycle period
-  uint64_t min_cycles_per_sample = 0;  // approx cycles before next sample
+  uint64_t raw_ns = 0;                 // raw kernel time 
+  uint64_t base_ns = 0;                // our estimate of time 
+  uint64_t base_cycles = 0;            // cycle counter reading 
+  uint64_t nsscaled_per_cycle = 0;     // cycle period 
+  uint64_t min_cycles_per_sample = 0;  // approx cycles before next sample 
 };
 
-struct ABSL_CACHELINE_ALIGNED TimeState {
-  std::atomic<uint64_t> seq{0};
-  TimeSampleAtomic last_sample;  // the last sample; under seq
-
-  // The following counters are used only by the test code.
-  int64_t stats_initializations{0};
-  int64_t stats_reinitializations{0};
-  int64_t stats_calibrations{0};
-  int64_t stats_slow_paths{0};
-  int64_t stats_fast_slow_paths{0};
-
-  uint64_t last_now_cycles ABSL_GUARDED_BY(lock){0};
-
-  // Used by GetCurrentTimeNanosFromKernel().
-  // We try to read clock values at about the same time as the kernel clock.
-  // This value gets adjusted up or down as estimate of how long that should
-  // take, so we can reject attempts that take unusually long.
-  std::atomic<uint64_t> approx_syscall_time_in_cycles{10 * 1000};
-  // Number of times in a row we've seen a kernel time call take substantially
-  // less than approx_syscall_time_in_cycles.
-  std::atomic<uint32_t> kernel_time_seen_smaller{0};
-
-  // A reader-writer lock protecting the static locations below.
-  // See SeqAcquire() and SeqRelease() above.
-  absl::base_internal::SpinLock lock{absl::kConstInit,
-                                     base_internal::SCHEDULE_KERNEL_ONLY};
-};
-ABSL_CONST_INIT static TimeState time_state{};
-
-// Return the time in ns as told by the kernel interface.  Place in *cycleclock
-// the value of the cycleclock at about the time of the syscall.
-// This call represents the time base that this module synchronizes to.
-// Ensures that *cycleclock does not step back by up to (1 << 16) from
-// last_cycleclock, to discard small backward counter steps.  (Larger steps are
-// assumed to be complete resyncs, which shouldn't happen.  If they do, a full
-// reinitialization of the outer algorithm should occur.)
-static int64_t GetCurrentTimeNanosFromKernel(uint64_t last_cycleclock,
-                                             uint64_t *cycleclock)
-    ABSL_EXCLUSIVE_LOCKS_REQUIRED(time_state.lock) {
-  uint64_t local_approx_syscall_time_in_cycles =  // local copy
-      time_state.approx_syscall_time_in_cycles.load(std::memory_order_relaxed);
-
-  int64_t current_time_nanos_from_system;
-  uint64_t before_cycles;
-  uint64_t after_cycles;
-  uint64_t elapsed_cycles;
-  int loops = 0;
-  do {
-    before_cycles = GET_CURRENT_TIME_NANOS_CYCLECLOCK_NOW();
-    current_time_nanos_from_system = GET_CURRENT_TIME_NANOS_FROM_SYSTEM();
-    after_cycles = GET_CURRENT_TIME_NANOS_CYCLECLOCK_NOW();
-    // elapsed_cycles is unsigned, so is large on overflow
-    elapsed_cycles = after_cycles - before_cycles;
-    if (elapsed_cycles >= local_approx_syscall_time_in_cycles &&
-        ++loops == 20) {  // clock changed frequencies?  Back off.
-      loops = 0;
-      if (local_approx_syscall_time_in_cycles < 1000 * 1000) {
-        local_approx_syscall_time_in_cycles =
-            (local_approx_syscall_time_in_cycles + 1) << 1;
-      }
-      time_state.approx_syscall_time_in_cycles.store(
-          local_approx_syscall_time_in_cycles, std::memory_order_relaxed);
-    }
-  } while (elapsed_cycles >= local_approx_syscall_time_in_cycles ||
-           last_cycleclock - after_cycles < (static_cast<uint64_t>(1) << 16));
-
-  // Adjust approx_syscall_time_in_cycles to be within a factor of 2
-  // of the typical time to execute one iteration of the loop above.
-  if ((local_approx_syscall_time_in_cycles >> 1) < elapsed_cycles) {
-    // measured time is no smaller than half current approximation
-    time_state.kernel_time_seen_smaller.store(0, std::memory_order_relaxed);
-  } else if (time_state.kernel_time_seen_smaller.fetch_add(
-                 1, std::memory_order_relaxed) >= 3) {
-    // smaller delays several times in a row; reduce approximation by 12.5%
-    const uint64_t new_approximation =
-        local_approx_syscall_time_in_cycles -
-        (local_approx_syscall_time_in_cycles >> 3);
-    time_state.approx_syscall_time_in_cycles.store(new_approximation,
-                                                   std::memory_order_relaxed);
-    time_state.kernel_time_seen_smaller.store(0, std::memory_order_relaxed);
-  }
-
-  *cycleclock = after_cycles;
-  return current_time_nanos_from_system;
-}
-
+struct ABSL_CACHELINE_ALIGNED TimeState { 
+  std::atomic<uint64_t> seq{0}; 
+  TimeSampleAtomic last_sample;  // the last sample; under seq 
+
+  // The following counters are used only by the test code. 
+  int64_t stats_initializations{0}; 
+  int64_t stats_reinitializations{0}; 
+  int64_t stats_calibrations{0}; 
+  int64_t stats_slow_paths{0}; 
+  int64_t stats_fast_slow_paths{0}; 
+ 
+  uint64_t last_now_cycles ABSL_GUARDED_BY(lock){0}; 
+ 
+  // Used by GetCurrentTimeNanosFromKernel(). 
+  // We try to read clock values at about the same time as the kernel clock. 
+  // This value gets adjusted up or down as estimate of how long that should 
+  // take, so we can reject attempts that take unusually long. 
+  std::atomic<uint64_t> approx_syscall_time_in_cycles{10 * 1000}; 
+  // Number of times in a row we've seen a kernel time call take substantially 
+  // less than approx_syscall_time_in_cycles. 
+  std::atomic<uint32_t> kernel_time_seen_smaller{0}; 
+ 
+  // A reader-writer lock protecting the static locations below. 
+  // See SeqAcquire() and SeqRelease() above. 
+  absl::base_internal::SpinLock lock{absl::kConstInit, 
+                                     base_internal::SCHEDULE_KERNEL_ONLY}; 
+}; 
+ABSL_CONST_INIT static TimeState time_state{}; 
+ 
+// Return the time in ns as told by the kernel interface.  Place in *cycleclock 
+// the value of the cycleclock at about the time of the syscall. 
+// This call represents the time base that this module synchronizes to. 
+// Ensures that *cycleclock does not step back by up to (1 << 16) from 
+// last_cycleclock, to discard small backward counter steps.  (Larger steps are 
+// assumed to be complete resyncs, which shouldn't happen.  If they do, a full 
+// reinitialization of the outer algorithm should occur.) 
+static int64_t GetCurrentTimeNanosFromKernel(uint64_t last_cycleclock, 
+                                             uint64_t *cycleclock) 
+    ABSL_EXCLUSIVE_LOCKS_REQUIRED(time_state.lock) { 
+  uint64_t local_approx_syscall_time_in_cycles =  // local copy 
+      time_state.approx_syscall_time_in_cycles.load(std::memory_order_relaxed); 
+ 
+  int64_t current_time_nanos_from_system; 
+  uint64_t before_cycles; 
+  uint64_t after_cycles; 
+  uint64_t elapsed_cycles; 
+  int loops = 0; 
+  do { 
+    before_cycles = GET_CURRENT_TIME_NANOS_CYCLECLOCK_NOW(); 
+    current_time_nanos_from_system = GET_CURRENT_TIME_NANOS_FROM_SYSTEM(); 
+    after_cycles = GET_CURRENT_TIME_NANOS_CYCLECLOCK_NOW(); 
+    // elapsed_cycles is unsigned, so is large on overflow 
+    elapsed_cycles = after_cycles - before_cycles; 
+    if (elapsed_cycles >= local_approx_syscall_time_in_cycles && 
+        ++loops == 20) {  // clock changed frequencies?  Back off. 
+      loops = 0; 
+      if (local_approx_syscall_time_in_cycles < 1000 * 1000) { 
+        local_approx_syscall_time_in_cycles = 
+            (local_approx_syscall_time_in_cycles + 1) << 1; 
+      } 
+      time_state.approx_syscall_time_in_cycles.store( 
+          local_approx_syscall_time_in_cycles, std::memory_order_relaxed); 
+    } 
+  } while (elapsed_cycles >= local_approx_syscall_time_in_cycles || 
+           last_cycleclock - after_cycles < (static_cast<uint64_t>(1) << 16)); 
+ 
+  // Adjust approx_syscall_time_in_cycles to be within a factor of 2 
+  // of the typical time to execute one iteration of the loop above. 
+  if ((local_approx_syscall_time_in_cycles >> 1) < elapsed_cycles) { 
+    // measured time is no smaller than half current approximation 
+    time_state.kernel_time_seen_smaller.store(0, std::memory_order_relaxed); 
+  } else if (time_state.kernel_time_seen_smaller.fetch_add( 
+                 1, std::memory_order_relaxed) >= 3) { 
+    // smaller delays several times in a row; reduce approximation by 12.5% 
+    const uint64_t new_approximation = 
+        local_approx_syscall_time_in_cycles - 
+        (local_approx_syscall_time_in_cycles >> 3); 
+    time_state.approx_syscall_time_in_cycles.store(new_approximation, 
+                                                   std::memory_order_relaxed); 
+    time_state.kernel_time_seen_smaller.store(0, std::memory_order_relaxed); 
+  } 
+ 
+  *cycleclock = after_cycles; 
+  return current_time_nanos_from_system; 
+} 
+ 
 static int64_t GetCurrentTimeNanosSlowPath() ABSL_ATTRIBUTE_COLD;
 
 // Read the contents of *atomic into *sample.
@@ -321,15 +321,15 @@ int64_t GetCurrentTimeNanos() {
   // Acquire pairs with the barrier in SeqRelease - if this load sees that
   // store, the shared-data reads necessarily see that SeqRelease's updates
   // to the same shared data.
-  seq_read0 = time_state.seq.load(std::memory_order_acquire);
+  seq_read0 = time_state.seq.load(std::memory_order_acquire); 
 
-  base_ns = time_state.last_sample.base_ns.load(std::memory_order_relaxed);
-  base_cycles =
-      time_state.last_sample.base_cycles.load(std::memory_order_relaxed);
+  base_ns = time_state.last_sample.base_ns.load(std::memory_order_relaxed); 
+  base_cycles = 
+      time_state.last_sample.base_cycles.load(std::memory_order_relaxed); 
   nsscaled_per_cycle =
-      time_state.last_sample.nsscaled_per_cycle.load(std::memory_order_relaxed);
-  min_cycles_per_sample = time_state.last_sample.min_cycles_per_sample.load(
-      std::memory_order_relaxed);
+      time_state.last_sample.nsscaled_per_cycle.load(std::memory_order_relaxed); 
+  min_cycles_per_sample = time_state.last_sample.min_cycles_per_sample.load( 
+      std::memory_order_relaxed); 
 
   // This acquire fence pairs with the release fence in SeqAcquire.  Since it
   // is sequenced between reads of shared data and seq_read1, the reads of
@@ -340,7 +340,7 @@ int64_t GetCurrentTimeNanos() {
   // shared-data writes are effectively release ordered. Therefore if our
   // shared-data reads see any of a particular update's shared-data writes,
   // seq_read1 is guaranteed to see that update's SeqAcquire.
-  seq_read1 = time_state.seq.load(std::memory_order_relaxed);
+  seq_read1 = time_state.seq.load(std::memory_order_relaxed); 
 
   // Fast path.  Return if min_cycles_per_sample has not yet elapsed since the
   // last sample, and we read a consistent sample.  The fast path activates
@@ -353,9 +353,9 @@ int64_t GetCurrentTimeNanos() {
   // last_sample was updated). This is harmless, because delta_cycles will wrap
   // and report a time much much bigger than min_cycles_per_sample. In that case
   // we will take the slow path.
-  uint64_t delta_cycles;
+  uint64_t delta_cycles; 
   if (seq_read0 == seq_read1 && (seq_read0 & 1) == 0 &&
-      (delta_cycles = now_cycles - base_cycles) < min_cycles_per_sample) {
+      (delta_cycles = now_cycles - base_cycles) < min_cycles_per_sample) { 
     return base_ns + ((delta_cycles * nsscaled_per_cycle) >> kScale);
   }
   return GetCurrentTimeNanosSlowPath();
@@ -395,25 +395,25 @@ static uint64_t UpdateLastSample(
 // TODO(absl-team): Remove this attribute when our compiler is smart enough
 // to do the right thing.
 ABSL_ATTRIBUTE_NOINLINE
-static int64_t GetCurrentTimeNanosSlowPath()
-    ABSL_LOCKS_EXCLUDED(time_state.lock) {
+static int64_t GetCurrentTimeNanosSlowPath() 
+    ABSL_LOCKS_EXCLUDED(time_state.lock) { 
   // Serialize access to slow-path.  Fast-path readers are not blocked yet, and
   // code below must not modify last_sample until the seqlock is acquired.
-  time_state.lock.Lock();
+  time_state.lock.Lock(); 
 
   // Sample the kernel time base.  This is the definition of
   // "now" if we take the slow path.
   uint64_t now_cycles;
-  uint64_t now_ns =
-      GetCurrentTimeNanosFromKernel(time_state.last_now_cycles, &now_cycles);
-  time_state.last_now_cycles = now_cycles;
+  uint64_t now_ns = 
+      GetCurrentTimeNanosFromKernel(time_state.last_now_cycles, &now_cycles); 
+  time_state.last_now_cycles = now_cycles; 
 
   uint64_t estimated_base_ns;
 
   // ----------
   // Read the "last_sample" values again; this time holding the write lock.
   struct TimeSample sample;
-  ReadTimeSampleAtomic(&time_state.last_sample, &sample);
+  ReadTimeSampleAtomic(&time_state.last_sample, &sample); 
 
   // ----------
   // Try running the fast path again; another thread may have updated the
@@ -424,13 +424,13 @@ static int64_t GetCurrentTimeNanosSlowPath()
     // so that blocked readers can make progress without blocking new readers.
     estimated_base_ns = sample.base_ns +
         ((delta_cycles * sample.nsscaled_per_cycle) >> kScale);
-    time_state.stats_fast_slow_paths++;
+    time_state.stats_fast_slow_paths++; 
   } else {
     estimated_base_ns =
         UpdateLastSample(now_cycles, now_ns, delta_cycles, &sample);
   }
 
-  time_state.lock.Unlock();
+  time_state.lock.Unlock(); 
 
   return estimated_base_ns;
 }
@@ -441,10 +441,10 @@ static int64_t GetCurrentTimeNanosSlowPath()
 static uint64_t UpdateLastSample(uint64_t now_cycles, uint64_t now_ns,
                                  uint64_t delta_cycles,
                                  const struct TimeSample *sample)
-    ABSL_EXCLUSIVE_LOCKS_REQUIRED(time_state.lock) {
+    ABSL_EXCLUSIVE_LOCKS_REQUIRED(time_state.lock) { 
   uint64_t estimated_base_ns = now_ns;
-  uint64_t lock_value =
-      SeqAcquire(&time_state.seq);  // acquire seqlock to block readers
+  uint64_t lock_value = 
+      SeqAcquire(&time_state.seq);  // acquire seqlock to block readers 
 
   // The 5s in the next if-statement limits the time for which we will trust
   // the cycle counter and our last sample to give a reasonable result.
@@ -454,16 +454,16 @@ static uint64_t UpdateLastSample(uint64_t now_cycles, uint64_t now_ns,
       sample->raw_ns + static_cast<uint64_t>(5) * 1000 * 1000 * 1000 < now_ns ||
       now_ns < sample->raw_ns || now_cycles < sample->base_cycles) {
     // record this sample, and forget any previously known slope.
-    time_state.last_sample.raw_ns.store(now_ns, std::memory_order_relaxed);
-    time_state.last_sample.base_ns.store(estimated_base_ns,
-                                         std::memory_order_relaxed);
-    time_state.last_sample.base_cycles.store(now_cycles,
-                                             std::memory_order_relaxed);
-    time_state.last_sample.nsscaled_per_cycle.store(0,
-                                                    std::memory_order_relaxed);
-    time_state.last_sample.min_cycles_per_sample.store(
-        0, std::memory_order_relaxed);
-    time_state.stats_initializations++;
+    time_state.last_sample.raw_ns.store(now_ns, std::memory_order_relaxed); 
+    time_state.last_sample.base_ns.store(estimated_base_ns, 
+                                         std::memory_order_relaxed); 
+    time_state.last_sample.base_cycles.store(now_cycles, 
+                                             std::memory_order_relaxed); 
+    time_state.last_sample.nsscaled_per_cycle.store(0, 
+                                                    std::memory_order_relaxed); 
+    time_state.last_sample.min_cycles_per_sample.store( 
+        0, std::memory_order_relaxed); 
+    time_state.stats_initializations++; 
   } else if (sample->raw_ns + 500 * 1000 * 1000 < now_ns &&
              sample->base_cycles + 50 < now_cycles) {
     // Enough time has passed to compute the cycle time.
@@ -506,32 +506,32 @@ static uint64_t UpdateLastSample(uint64_t now_cycles, uint64_t now_ns,
     if (new_nsscaled_per_cycle != 0 &&
         diff_ns < 100 * 1000 * 1000 && -diff_ns < 100 * 1000 * 1000) {
       // record the cycle time measurement
-      time_state.last_sample.nsscaled_per_cycle.store(
+      time_state.last_sample.nsscaled_per_cycle.store( 
           new_nsscaled_per_cycle, std::memory_order_relaxed);
       uint64_t new_min_cycles_per_sample =
           SafeDivideAndScale(kMinNSBetweenSamples, new_nsscaled_per_cycle);
-      time_state.last_sample.min_cycles_per_sample.store(
+      time_state.last_sample.min_cycles_per_sample.store( 
           new_min_cycles_per_sample, std::memory_order_relaxed);
-      time_state.stats_calibrations++;
+      time_state.stats_calibrations++; 
     } else {  // something went wrong; forget the slope
-      time_state.last_sample.nsscaled_per_cycle.store(
-          0, std::memory_order_relaxed);
-      time_state.last_sample.min_cycles_per_sample.store(
-          0, std::memory_order_relaxed);
+      time_state.last_sample.nsscaled_per_cycle.store( 
+          0, std::memory_order_relaxed); 
+      time_state.last_sample.min_cycles_per_sample.store( 
+          0, std::memory_order_relaxed); 
       estimated_base_ns = now_ns;
-      time_state.stats_reinitializations++;
+      time_state.stats_reinitializations++; 
     }
-    time_state.last_sample.raw_ns.store(now_ns, std::memory_order_relaxed);
-    time_state.last_sample.base_ns.store(estimated_base_ns,
-                                         std::memory_order_relaxed);
-    time_state.last_sample.base_cycles.store(now_cycles,
-                                             std::memory_order_relaxed);
+    time_state.last_sample.raw_ns.store(now_ns, std::memory_order_relaxed); 
+    time_state.last_sample.base_ns.store(estimated_base_ns, 
+                                         std::memory_order_relaxed); 
+    time_state.last_sample.base_cycles.store(now_cycles, 
+                                             std::memory_order_relaxed); 
   } else {
     // have a sample, but no slope; waiting for enough time for a calibration
-    time_state.stats_slow_paths++;
+    time_state.stats_slow_paths++; 
   }
 
-  SeqRelease(&time_state.seq, lock_value);  // release the readers
+  SeqRelease(&time_state.seq, lock_value);  // release the readers 
 
   return estimated_base_ns;
 }
@@ -573,8 +573,8 @@ ABSL_NAMESPACE_END
 
 extern "C" {
 
-ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSleepFor)(
-    absl::Duration duration) {
+ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSleepFor)( 
+    absl::Duration duration) { 
   while (duration > absl::ZeroDuration()) {
     absl::Duration to_sleep = std::min(duration, absl::MaxSleep());
     absl::SleepOnce(to_sleep);
diff --git a/contrib/restricted/abseil-cpp/absl/time/clock.h b/contrib/restricted/abseil-cpp/absl/time/clock.h
index 5fe244d638..1cf616ff16 100644
--- a/contrib/restricted/abseil-cpp/absl/time/clock.h
+++ b/contrib/restricted/abseil-cpp/absl/time/clock.h
@@ -64,11 +64,11 @@ ABSL_NAMESPACE_END
 // By changing our extension points to be extern "C", we dodge this
 // check.
 extern "C" {
-void ABSL_INTERNAL_C_SYMBOL(AbslInternalSleepFor)(absl::Duration duration);
+void ABSL_INTERNAL_C_SYMBOL(AbslInternalSleepFor)(absl::Duration duration); 
 }  // extern "C"
 
 inline void absl::SleepFor(absl::Duration duration) {
-  ABSL_INTERNAL_C_SYMBOL(AbslInternalSleepFor)(duration);
+  ABSL_INTERNAL_C_SYMBOL(AbslInternalSleepFor)(duration); 
 }
 
 #endif  // ABSL_TIME_CLOCK_H_
diff --git a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/include/cctz/civil_time_detail.h b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/include/cctz/civil_time_detail.h
index 8aadde57ca..a0be43ae1f 100644
--- a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/include/cctz/civil_time_detail.h
+++ b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/include/cctz/civil_time_detail.h
@@ -416,10 +416,10 @@ class civil_time {
 
   // Assigning arithmetic.
   CONSTEXPR_M civil_time& operator+=(diff_t n) noexcept {
-    return *this = *this + n;
+    return *this = *this + n; 
   }
   CONSTEXPR_M civil_time& operator-=(diff_t n) noexcept {
-    return *this = *this - n;
+    return *this = *this - n; 
   }
   CONSTEXPR_M civil_time& operator++() noexcept { return *this += 1; }
   CONSTEXPR_M civil_time operator++(int) noexcept {
@@ -436,15 +436,15 @@ class civil_time {
 
   // Binary arithmetic operators.
   friend CONSTEXPR_F civil_time operator+(civil_time a, diff_t n) noexcept {
-    return civil_time(step(T{}, a.f_, n));
+    return civil_time(step(T{}, a.f_, n)); 
   }
   friend CONSTEXPR_F civil_time operator+(diff_t n, civil_time a) noexcept {
-    return a + n;
+    return a + n; 
   }
   friend CONSTEXPR_F civil_time operator-(civil_time a, diff_t n) noexcept {
-    return n != (std::numeric_limits<diff_t>::min)()
-               ? civil_time(step(T{}, a.f_, -n))
-               : civil_time(step(T{}, step(T{}, a.f_, -(n + 1)), 1));
+    return n != (std::numeric_limits<diff_t>::min)() 
+               ? civil_time(step(T{}, a.f_, -n)) 
+               : civil_time(step(T{}, step(T{}, a.f_, -(n + 1)), 1)); 
   }
   friend CONSTEXPR_F diff_t operator-(civil_time lhs, civil_time rhs) noexcept {
     return difference(T{}, lhs.f_, rhs.f_);
diff --git a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_libc.cc b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_libc.cc
index 887dd097c6..fdd6ab25fd 100644
--- a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_libc.cc
+++ b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/time_zone_libc.cc
@@ -27,12 +27,12 @@
 #include "absl/time/internal/cctz/include/cctz/civil_time.h"
 #include "absl/time/internal/cctz/include/cctz/time_zone.h"
 
-#if defined(_AIX)
-extern "C" {
-extern long altzone;
-}
-#endif
-
+#if defined(_AIX) 
+extern "C" { 
+extern long altzone; 
+} 
+#endif 
+ 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace time_internal {
@@ -50,7 +50,7 @@ auto tm_zone(const std::tm& tm) -> decltype(_tzname[0]) {
   const bool is_dst = tm.tm_isdst > 0;
   return _tzname[is_dst];
 }
-#elif defined(__sun) || defined(_AIX)
+#elif defined(__sun) || defined(_AIX) 
 // Uses the globals: 'timezone', 'altzone' and 'tzname'.
 auto tm_gmtoff(const std::tm& tm) -> decltype(timezone) {
   const bool is_dst = tm.tm_isdst > 0;
diff --git a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/tzfile.h b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/tzfile.h
index 31e8598257..4c49ecf1ca 100644
--- a/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/tzfile.h
+++ b/contrib/restricted/abseil-cpp/absl/time/internal/cctz/src/tzfile.h
@@ -108,15 +108,15 @@ struct tzhead {
 #ifndef TZ_MAX_TYPES
 /* This must be at least 17 for Europe/Samara and Europe/Vilnius.  */
 #define TZ_MAX_TYPES 256 /* Limited by what (unsigned char)'s can hold */
-#endif                   /* !defined TZ_MAX_TYPES */
+#endif                   /* !defined TZ_MAX_TYPES */ 
 
 #ifndef TZ_MAX_CHARS
 #define TZ_MAX_CHARS 50 /* Maximum number of abbreviation characters */
-                        /* (limited by what unsigned chars can hold) */
-#endif                  /* !defined TZ_MAX_CHARS */
+                        /* (limited by what unsigned chars can hold) */ 
+#endif                  /* !defined TZ_MAX_CHARS */ 
 
 #ifndef TZ_MAX_LEAPS
 #define TZ_MAX_LEAPS 50 /* Maximum number of leap second corrections */
-#endif                  /* !defined TZ_MAX_LEAPS */
+#endif                  /* !defined TZ_MAX_LEAPS */ 
 
 #endif /* !defined TZFILE_H */
diff --git a/contrib/restricted/abseil-cpp/absl/time/time.h b/contrib/restricted/abseil-cpp/absl/time/time.h
index 5abd815a79..1acb83aed0 100644
--- a/contrib/restricted/abseil-cpp/absl/time/time.h
+++ b/contrib/restricted/abseil-cpp/absl/time/time.h
@@ -488,12 +488,12 @@ Duration Hours(T n) {
 //
 //   absl::Duration d = absl::Milliseconds(1500);
 //   int64_t isec = absl::ToInt64Seconds(d);  // isec == 1
-ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Nanoseconds(Duration d);
-ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Microseconds(Duration d);
-ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Milliseconds(Duration d);
-ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Seconds(Duration d);
-ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Minutes(Duration d);
-ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Hours(Duration d);
+ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Nanoseconds(Duration d); 
+ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Microseconds(Duration d); 
+ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Milliseconds(Duration d); 
+ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Seconds(Duration d); 
+ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Minutes(Duration d); 
+ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Hours(Duration d); 
 
 // ToDoubleNanoSeconds()
 // ToDoubleMicroseconds()
@@ -510,12 +510,12 @@ ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Hours(Duration d);
 //
 //   absl::Duration d = absl::Milliseconds(1500);
 //   double dsec = absl::ToDoubleSeconds(d);  // dsec == 1.5
-ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleNanoseconds(Duration d);
-ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleMicroseconds(Duration d);
-ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleMilliseconds(Duration d);
-ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleSeconds(Duration d);
-ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleMinutes(Duration d);
-ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleHours(Duration d);
+ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleNanoseconds(Duration d); 
+ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleMicroseconds(Duration d); 
+ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleMilliseconds(Duration d); 
+ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleSeconds(Duration d); 
+ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleMinutes(Duration d); 
+ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleHours(Duration d); 
 
 // FromChrono()
 //
@@ -1230,15 +1230,15 @@ inline Time FromDateTime(int64_t year, int mon, int day, int hour,
 //
 // Converts the `tm_year`, `tm_mon`, `tm_mday`, `tm_hour`, `tm_min`, and
 // `tm_sec` fields to an `absl::Time` using the given time zone. See ctime(3)
-// for a description of the expected values of the tm fields. If the civil time
-// is unique (see `absl::TimeZone::At(absl::CivilSecond)` above), the matching
-// time instant is returned.  Otherwise, the `tm_isdst` field is consulted to
-// choose between the possible results.  For a repeated civil time, `tm_isdst !=
-// 0` returns the matching DST instant, while `tm_isdst == 0` returns the
-// matching non-DST instant.  For a skipped civil time there is no matching
-// instant, so `tm_isdst != 0` returns the DST instant, and `tm_isdst == 0`
-// returns the non-DST instant, that would have matched if the transition never
-// happened.
+// for a description of the expected values of the tm fields. If the civil time 
+// is unique (see `absl::TimeZone::At(absl::CivilSecond)` above), the matching 
+// time instant is returned.  Otherwise, the `tm_isdst` field is consulted to 
+// choose between the possible results.  For a repeated civil time, `tm_isdst != 
+// 0` returns the matching DST instant, while `tm_isdst == 0` returns the 
+// matching non-DST instant.  For a skipped civil time there is no matching 
+// instant, so `tm_isdst != 0` returns the DST instant, and `tm_isdst == 0` 
+// returns the non-DST instant, that would have matched if the transition never 
+// happened. 
 Time FromTM(const struct tm& tm, TimeZone tz);
 
 // ToTM()
diff --git a/contrib/restricted/abseil-cpp/absl/types/variant.h b/contrib/restricted/abseil-cpp/absl/types/variant.h
index ac93464bf8..5284dcb166 100644
--- a/contrib/restricted/abseil-cpp/absl/types/variant.h
+++ b/contrib/restricted/abseil-cpp/absl/types/variant.h
@@ -604,10 +604,10 @@ class variant<T0, Tn...> : private variant_internal::VariantBase<T0, Tn...> {
 
   // emplace() Functions
 
-  // Constructs a value of the given alternative type T within the variant. The
-  // existing value of the variant is destroyed first (provided that
-  // `absl::valueless_by_exception()` is false). Requires that T is unambiguous
-  // in the variant.
+  // Constructs a value of the given alternative type T within the variant. The 
+  // existing value of the variant is destroyed first (provided that 
+  // `absl::valueless_by_exception()` is false). Requires that T is unambiguous 
+  // in the variant. 
   //
   // Example:
   //
@@ -627,9 +627,9 @@ class variant<T0, Tn...> : private variant_internal::VariantBase<T0, Tn...> {
   }
 
   // Constructs a value of the given alternative type T within the variant using
-  // an initializer list. The existing value of the variant is destroyed first
-  // (provided that `absl::valueless_by_exception()` is false). Requires that T
-  // is unambiguous in the variant.
+  // an initializer list. The existing value of the variant is destroyed first 
+  // (provided that `absl::valueless_by_exception()` is false). Requires that T 
+  // is unambiguous in the variant. 
   //
   // Example:
   //
@@ -648,7 +648,7 @@ class variant<T0, Tn...> : private variant_internal::VariantBase<T0, Tn...> {
   }
 
   // Destroys the current value of the variant (provided that
-  // `absl::valueless_by_exception()` is false) and constructs a new value at
+  // `absl::valueless_by_exception()` is false) and constructs a new value at 
   // the given index.
   //
   // Example:
@@ -667,7 +667,7 @@ class variant<T0, Tn...> : private variant_internal::VariantBase<T0, Tn...> {
   }
 
   // Destroys the current value of the variant (provided that
-  // `absl::valueless_by_exception()` is false) and constructs a new value at
+  // `absl::valueless_by_exception()` is false) and constructs a new value at 
   // the given index using an initializer list and the provided arguments.
   //
   // Example: