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

252 files changed, 16735 insertions, 16735 deletions

diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/algorithm/.yandex_meta/licenses.list.txt b/contrib/restricted/abseil-cpp-tstring/y_absl/algorithm/.yandex_meta/licenses.list.txt
index 7be6b42848..4335862815 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/algorithm/.yandex_meta/licenses.list.txt
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/algorithm/.yandex_meta/licenses.list.txt
@@ -1,16 +1,16 @@
-====================Apache-2.0====================
-// 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====================
-// Copyright 2017 The Abseil Authors.
+====================Apache-2.0==================== 
+// 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==================== 
+// Copyright 2017 The Abseil Authors. 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/algorithm/container.h b/contrib/restricted/abseil-cpp-tstring/y_absl/algorithm/container.h
index d6bf385964..8081bfa9d1 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/algorithm/container.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/algorithm/container.h
@@ -90,10 +90,10 @@ using ContainerPointerType =
 // lookup of std::begin and std::end, i.e.
 //   using std::begin;
 //   using std::end;
-//   std::foo(begin(c), end(c));
+//   std::foo(begin(c), end(c)); 
 // becomes
 //   std::foo(container_algorithm_internal::begin(c),
-//            container_algorithm_internal::end(c));
+//            container_algorithm_internal::end(c)); 
 // These are meant for internal use only.
 
 template <typename C>
@@ -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),
@@ -340,45 +340,45 @@ container_algorithm_internal::ContainerDifferenceType<const C> c_count_if(
 // c_mismatch()
 //
 // Container-based version of the <algorithm> `std::mismatch()` function to
-// return the first element where two ordered containers differ. Applies `==` to
-// the first N elements of `c1` and `c2`, where N = min(size(c1), size(c2)).
+// return the first element where two ordered containers differ. Applies `==` to 
+// the first N elements of `c1` and `c2`, where N = min(size(c1), size(c2)). 
 template <typename C1, typename C2>
 container_algorithm_internal::ContainerIterPairType<C1, C2>
 c_mismatch(C1& c1, C2& c2) {
-  auto first1 = container_algorithm_internal::c_begin(c1);
-  auto last1 = container_algorithm_internal::c_end(c1);
-  auto first2 = container_algorithm_internal::c_begin(c2);
-  auto last2 = container_algorithm_internal::c_end(c2);
-
-  for (; first1 != last1 && first2 != last2; ++first1, (void)++first2) {
-    // Negates equality because Cpp17EqualityComparable doesn't require clients
-    // to overload both `operator==` and `operator!=`.
-    if (!(*first1 == *first2)) {
-      break;
-    }
-  }
-
-  return std::make_pair(first1, first2);
+  auto first1 = container_algorithm_internal::c_begin(c1); 
+  auto last1 = container_algorithm_internal::c_end(c1); 
+  auto first2 = container_algorithm_internal::c_begin(c2); 
+  auto last2 = container_algorithm_internal::c_end(c2); 
+ 
+  for (; first1 != last1 && first2 != last2; ++first1, (void)++first2) { 
+    // Negates equality because Cpp17EqualityComparable doesn't require clients 
+    // to overload both `operator==` and `operator!=`. 
+    if (!(*first1 == *first2)) { 
+      break; 
+    } 
+  } 
+ 
+  return std::make_pair(first1, first2); 
 }
 
 // Overload of c_mismatch() for using a predicate evaluation other than `==` as
-// the function's test condition. Applies `pred`to the first N elements of `c1`
-// and `c2`, where N = min(size(c1), size(c2)).
+// the function's test condition. Applies `pred`to the first N elements of `c1` 
+// and `c2`, where N = min(size(c1), size(c2)). 
 template <typename C1, typename C2, typename BinaryPredicate>
 container_algorithm_internal::ContainerIterPairType<C1, C2>
-c_mismatch(C1& c1, C2& c2, BinaryPredicate pred) {
-  auto first1 = container_algorithm_internal::c_begin(c1);
-  auto last1 = container_algorithm_internal::c_end(c1);
-  auto first2 = container_algorithm_internal::c_begin(c2);
-  auto last2 = container_algorithm_internal::c_end(c2);
-
-  for (; first1 != last1 && first2 != last2; ++first1, (void)++first2) {
-    if (!pred(*first1, *first2)) {
-      break;
-    }
-  }
-
-  return std::make_pair(first1, first2);
+c_mismatch(C1& c1, C2& c2, BinaryPredicate pred) { 
+  auto first1 = container_algorithm_internal::c_begin(c1); 
+  auto last1 = container_algorithm_internal::c_end(c1); 
+  auto first2 = container_algorithm_internal::c_begin(c2); 
+  auto last2 = container_algorithm_internal::c_end(c2); 
+ 
+  for (; first1 != last1 && first2 != last2; ++first1, (void)++first2) { 
+    if (!pred(*first1, *first2)) { 
+      break; 
+    } 
+  } 
+ 
+  return std::make_pair(first1, first2); 
 }
 
 // c_equal()
@@ -560,20 +560,20 @@ BidirectionalIterator c_move_backward(C&& src, BidirectionalIterator dest) {
 // c_swap_ranges()
 //
 // Container-based version of the <algorithm> `std::swap_ranges()` function to
-// swap a container's elements with another container's elements. Swaps the
-// first N elements of `c1` and `c2`, where N = min(size(c1), size(c2)).
+// swap a container's elements with another container's elements. Swaps the 
+// first N elements of `c1` and `c2`, where N = min(size(c1), size(c2)). 
 template <typename C1, typename C2>
 container_algorithm_internal::ContainerIter<C2> c_swap_ranges(C1& c1, C2& c2) {
-  auto first1 = container_algorithm_internal::c_begin(c1);
-  auto last1 = container_algorithm_internal::c_end(c1);
-  auto first2 = container_algorithm_internal::c_begin(c2);
-  auto last2 = container_algorithm_internal::c_end(c2);
-
-  using std::swap;
-  for (; first1 != last1 && first2 != last2; ++first1, (void)++first2) {
-    swap(*first1, *first2);
-  }
-  return first2;
+  auto first1 = container_algorithm_internal::c_begin(c1); 
+  auto last1 = container_algorithm_internal::c_end(c1); 
+  auto first2 = container_algorithm_internal::c_begin(c2); 
+  auto last2 = container_algorithm_internal::c_end(c2); 
+ 
+  using std::swap; 
+  for (; first1 != last1 && first2 != last2; ++first1, (void)++first2) { 
+    swap(*first1, *first2); 
+  } 
+  return first2; 
 }
 
 // c_transform()
@@ -591,23 +591,23 @@ OutputIterator c_transform(const InputSequence& input, OutputIterator output,
 }
 
 // Overload of c_transform() for performing a transformation using a binary
-// predicate. Applies `binary_op` to the first N elements of `c1` and `c2`,
-// where N = min(size(c1), size(c2)).
+// predicate. Applies `binary_op` to the first N elements of `c1` and `c2`, 
+// where N = min(size(c1), size(c2)). 
 template <typename InputSequence1, typename InputSequence2,
           typename OutputIterator, typename BinaryOp>
 OutputIterator c_transform(const InputSequence1& input1,
                            const InputSequence2& input2, OutputIterator output,
                            BinaryOp&& binary_op) {
-  auto first1 = container_algorithm_internal::c_begin(input1);
-  auto last1 = container_algorithm_internal::c_end(input1);
-  auto first2 = container_algorithm_internal::c_begin(input2);
-  auto last2 = container_algorithm_internal::c_end(input2);
-  for (; first1 != last1 && first2 != last2;
-       ++first1, (void)++first2, ++output) {
-    *output = binary_op(*first1, *first2);
-  }
-
-  return output;
+  auto first1 = container_algorithm_internal::c_begin(input1); 
+  auto last1 = container_algorithm_internal::c_end(input1); 
+  auto first2 = container_algorithm_internal::c_begin(input2); 
+  auto last2 = container_algorithm_internal::c_end(input2); 
+  for (; first1 != last1 && first2 != last2; 
+       ++first1, (void)++first2, ++output) { 
+    *output = binary_op(*first1, *first2); 
+  } 
+ 
+  return output; 
 }
 
 // c_replace()
@@ -979,10 +979,10 @@ void c_partial_sort(
 // c_partial_sort_copy()
 //
 // Container-based version of the <algorithm> `std::partial_sort_copy()`
-// function to sort the elements in the given range `result` within the larger
-// `sequence` in ascending order (and using `result` as the output parameter).
-// At most min(result.last - result.first, sequence.last - sequence.first)
-// elements from the sequence will be stored in the result.
+// function to sort the elements in the given range `result` within the larger 
+// `sequence` in ascending order (and using `result` as the output parameter). 
+// At most min(result.last - result.first, sequence.last - sequence.first) 
+// elements from the sequence will be stored in the result. 
 template <typename C, typename RandomAccessContainer>
 container_algorithm_internal::ContainerIter<RandomAccessContainer>
 c_partial_sort_copy(const C& sequence, RandomAccessContainer& result) {
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/algorithm/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/algorithm/ya.make
index b5ead45856..9a44988749 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/algorithm/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/algorithm/ya.make
@@ -1,14 +1,14 @@
-# Generated by devtools/yamaker.
-
-LIBRARY()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
-
-LICENSE(Apache-2.0)
-
-LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
-
-END()
+# Generated by devtools/yamaker. 
+ 
+LIBRARY() 
+ 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
+LICENSE(Apache-2.0) 
+ 
+LICENSE_TEXTS(.yandex_meta/licenses.list.txt) 
+ 
+END() 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/attributes.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/attributes.h
index 8321acda51..6730fe7683 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/attributes.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/attributes.h
@@ -30,12 +30,12 @@
 // of them are not supported in older version of Clang. Thus, we check
 // `__has_attribute()` first. If the check fails, we check if we are on GCC and
 // assume the attribute exists on GCC (which is verified on GCC 4.7).
-
+ 
 #ifndef ABSL_BASE_ATTRIBUTES_H_
 #define ABSL_BASE_ATTRIBUTES_H_
 
-#include "y_absl/base/config.h"
-
+#include "y_absl/base/config.h" 
+ 
 // ABSL_HAVE_ATTRIBUTE
 //
 // A function-like feature checking macro that is a wrapper around
@@ -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")))
@@ -210,7 +210,7 @@
 // out of bounds or does other scary things with memory.
 // NOTE: GCC supports AddressSanitizer(asan) since 4.8.
 // https://gcc.gnu.org/gcc-4.8/changes.html
-#if ABSL_HAVE_ATTRIBUTE(no_sanitize_address)
+#if ABSL_HAVE_ATTRIBUTE(no_sanitize_address) 
 #define ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS __attribute__((no_sanitize_address))
 #else
 #define ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS
@@ -218,13 +218,13 @@
 
 // ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY
 //
-// Tells the MemorySanitizer to relax the handling of a given function. All "Use
-// of uninitialized value" warnings from such functions will be suppressed, and
-// all values loaded from memory will be considered fully initialized.  This
-// attribute is similar to the ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS attribute
-// above, but deals with initialized-ness rather than addressability issues.
+// Tells the MemorySanitizer to relax the handling of a given function. All "Use 
+// of uninitialized value" warnings from such functions will be suppressed, and 
+// all values loaded from memory will be considered fully initialized.  This 
+// attribute is similar to the ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS attribute 
+// above, but deals with initialized-ness rather than addressability issues. 
 // NOTE: MemorySanitizer(msan) is supported by Clang but not GCC.
-#if ABSL_HAVE_ATTRIBUTE(no_sanitize_memory)
+#if ABSL_HAVE_ATTRIBUTE(no_sanitize_memory) 
 #define ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY __attribute__((no_sanitize_memory))
 #else
 #define ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY
@@ -235,7 +235,7 @@
 // Tells the ThreadSanitizer to not instrument a given function.
 // NOTE: GCC supports ThreadSanitizer(tsan) since 4.8.
 // https://gcc.gnu.org/gcc-4.8/changes.html
-#if ABSL_HAVE_ATTRIBUTE(no_sanitize_thread)
+#if ABSL_HAVE_ATTRIBUTE(no_sanitize_thread) 
 #define ABSL_ATTRIBUTE_NO_SANITIZE_THREAD __attribute__((no_sanitize_thread))
 #else
 #define ABSL_ATTRIBUTE_NO_SANITIZE_THREAD
@@ -247,11 +247,11 @@
 // where certain behavior (eg. division by zero) is being used intentionally.
 // NOTE: GCC supports UndefinedBehaviorSanitizer(ubsan) since 4.9.
 // https://gcc.gnu.org/gcc-4.9/changes.html
-#if ABSL_HAVE_ATTRIBUTE(no_sanitize_undefined)
-#define ABSL_ATTRIBUTE_NO_SANITIZE_UNDEFINED \
-  __attribute__((no_sanitize_undefined))
-#elif ABSL_HAVE_ATTRIBUTE(no_sanitize)
+#if ABSL_HAVE_ATTRIBUTE(no_sanitize_undefined) 
 #define ABSL_ATTRIBUTE_NO_SANITIZE_UNDEFINED \
+  __attribute__((no_sanitize_undefined)) 
+#elif ABSL_HAVE_ATTRIBUTE(no_sanitize) 
+#define ABSL_ATTRIBUTE_NO_SANITIZE_UNDEFINED \ 
   __attribute__((no_sanitize("undefined")))
 #else
 #define ABSL_ATTRIBUTE_NO_SANITIZE_UNDEFINED
@@ -261,7 +261,7 @@
 //
 // Tells the ControlFlowIntegrity sanitizer to not instrument a given function.
 // See https://clang.llvm.org/docs/ControlFlowIntegrity.html for details.
-#if ABSL_HAVE_ATTRIBUTE(no_sanitize)
+#if ABSL_HAVE_ATTRIBUTE(no_sanitize) 
 #define ABSL_ATTRIBUTE_NO_SANITIZE_CFI __attribute__((no_sanitize("cfi")))
 #else
 #define ABSL_ATTRIBUTE_NO_SANITIZE_CFI
@@ -271,7 +271,7 @@
 //
 // Tells the SafeStack to not instrument a given function.
 // See https://clang.llvm.org/docs/SafeStack.html for details.
-#if ABSL_HAVE_ATTRIBUTE(no_sanitize)
+#if ABSL_HAVE_ATTRIBUTE(no_sanitize) 
 #define ABSL_ATTRIBUTE_NO_SANITIZE_SAFESTACK \
   __attribute__((no_sanitize("safe-stack")))
 #else
@@ -490,10 +490,10 @@
 // packages/targets, as this may lead to conflicting definitions of functions at
 // link-time.
 //
-// XRay isn't currently supported on Android:
-// https://github.com/android/ndk/issues/368
+// XRay isn't currently supported on Android: 
+// https://github.com/android/ndk/issues/368 
 #if ABSL_HAVE_CPP_ATTRIBUTE(clang::xray_always_instrument) && \
-    !defined(ABSL_NO_XRAY_ATTRIBUTES) && !defined(__ANDROID__)
+    !defined(ABSL_NO_XRAY_ATTRIBUTES) && !defined(__ANDROID__) 
 #define ABSL_XRAY_ALWAYS_INSTRUMENT [[clang::xray_always_instrument]]
 #define ABSL_XRAY_NEVER_INSTRUMENT [[clang::xray_never_instrument]]
 #if ABSL_HAVE_CPP_ATTRIBUTE(clang::xray_log_args)
@@ -590,79 +590,79 @@
 #define ABSL_ATTRIBUTE_FUNC_ALIGN(bytes)
 #endif
 
-// ABSL_FALLTHROUGH_INTENDED
-//
-// Annotates implicit fall-through between switch labels, allowing a case to
-// indicate intentional fallthrough and turn off warnings about any lack of a
-// `break` statement. The ABSL_FALLTHROUGH_INTENDED macro should be followed by
-// a semicolon and can be used in most places where `break` can, provided that
-// no statements exist between it and the next switch label.
-//
-// Example:
-//
-//  switch (x) {
-//    case 40:
-//    case 41:
-//      if (truth_is_out_there) {
-//        ++x;
-//        ABSL_FALLTHROUGH_INTENDED;  // Use instead of/along with annotations
-//                                    // in comments
-//      } else {
-//        return x;
-//      }
-//    case 42:
-//      ...
-//
+// ABSL_FALLTHROUGH_INTENDED 
+// 
+// Annotates implicit fall-through between switch labels, allowing a case to 
+// indicate intentional fallthrough and turn off warnings about any lack of a 
+// `break` statement. The ABSL_FALLTHROUGH_INTENDED macro should be followed by 
+// a semicolon and can be used in most places where `break` can, provided that 
+// no statements exist between it and the next switch label. 
+// 
+// Example: 
+// 
+//  switch (x) { 
+//    case 40: 
+//    case 41: 
+//      if (truth_is_out_there) { 
+//        ++x; 
+//        ABSL_FALLTHROUGH_INTENDED;  // Use instead of/along with annotations 
+//                                    // in comments 
+//      } else { 
+//        return x; 
+//      } 
+//    case 42: 
+//      ... 
+// 
 // Notes: When supported, GCC and Clang can issue a warning on switch labels
 // with unannotated fallthrough using the warning `-Wimplicit-fallthrough`. See
 // clang documentation on language extensions for details:
-// https://clang.llvm.org/docs/AttributeReference.html#fallthrough-clang-fallthrough
-//
+// https://clang.llvm.org/docs/AttributeReference.html#fallthrough-clang-fallthrough 
+// 
 // 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."
+// behavior and performance of code. 
+ 
+#ifdef ABSL_FALLTHROUGH_INTENDED 
+#error "ABSL_FALLTHROUGH_INTENDED should not be defined." 
 #elif ABSL_HAVE_CPP_ATTRIBUTE(fallthrough)
 #define ABSL_FALLTHROUGH_INTENDED [[fallthrough]]
 #elif ABSL_HAVE_CPP_ATTRIBUTE(clang::fallthrough)
-#define ABSL_FALLTHROUGH_INTENDED [[clang::fallthrough]]
+#define ABSL_FALLTHROUGH_INTENDED [[clang::fallthrough]] 
 #elif ABSL_HAVE_CPP_ATTRIBUTE(gnu::fallthrough)
-#define ABSL_FALLTHROUGH_INTENDED [[gnu::fallthrough]]
-#else
-#define ABSL_FALLTHROUGH_INTENDED \
-  do {                            \
-  } while (0)
-#endif
-
-// ABSL_DEPRECATED()
-//
-// Marks a deprecated class, struct, enum, function, method and variable
-// declarations. The macro argument is used as a custom diagnostic message (e.g.
-// suggestion of a better alternative).
-//
-// Examples:
-//
-//   class ABSL_DEPRECATED("Use Bar instead") Foo {...};
-//
-//   ABSL_DEPRECATED("Use Baz() instead") void Bar() {...}
-//
-//   template <typename T>
-//   ABSL_DEPRECATED("Use DoThat() instead")
-//   void DoThis();
-//
-// 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
-#define ABSL_DEPRECATED(message) __attribute__((deprecated(message)))
-#endif
-
-#ifndef ABSL_DEPRECATED
-#define ABSL_DEPRECATED(message)
-#endif
-
+#define ABSL_FALLTHROUGH_INTENDED [[gnu::fallthrough]] 
+#else
+#define ABSL_FALLTHROUGH_INTENDED \ 
+  do {                            \ 
+  } while (0) 
+#endif 
+ 
+// ABSL_DEPRECATED() 
+// 
+// Marks a deprecated class, struct, enum, function, method and variable 
+// declarations. The macro argument is used as a custom diagnostic message (e.g. 
+// suggestion of a better alternative). 
+// 
+// Examples: 
+// 
+//   class ABSL_DEPRECATED("Use Bar instead") Foo {...}; 
+// 
+//   ABSL_DEPRECATED("Use Baz() instead") void Bar() {...} 
+// 
+//   template <typename T> 
+//   ABSL_DEPRECATED("Use DoThat() instead") 
+//   void DoThis(); 
+// 
+// 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 
+#define ABSL_DEPRECATED(message) __attribute__((deprecated(message))) 
+#endif 
+ 
+#ifndef ABSL_DEPRECATED 
+#define ABSL_DEPRECATED(message) 
+#endif 
+ 
 // ABSL_CONST_INIT
 //
 // A variable declaration annotated with the `ABSL_CONST_INIT` attribute will
@@ -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-tstring/y_absl/base/call_once.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/call_once.h
index 5d80e4e7ca..be338b43ca 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/call_once.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/call_once.h
@@ -175,10 +175,10 @@ void CallOnceImpl(std::atomic<uint32_t>* control,
                                        std::memory_order_relaxed) ||
       base_internal::SpinLockWait(control, ABSL_ARRAYSIZE(trans), trans,
                                   scheduling_mode) == kOnceInit) {
-    base_internal::invoke(std::forward<Callable>(fn),
+    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-tstring/y_absl/base/casts.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/casts.h
index 6270ede21e..9fa964584f 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/casts.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/casts.h
@@ -159,19 +159,19 @@ inline Dest bit_cast(const Source& source) {
   return dest;
 }
 
-// NOTE: This overload is only picked if the requirements of bit_cast are
-// not met. It is therefore UB, but is provided temporarily as previous
-// versions of this function template were unchecked. Do not use this in
-// new code.
+// NOTE: This overload is only picked if the requirements of bit_cast are 
+// not met. It is therefore UB, but is provided temporarily as previous 
+// versions of this function template were unchecked. Do not use this in 
+// new code. 
 template <
     typename Dest, typename Source,
     typename std::enable_if<
-        !internal_casts::is_bitcastable<Dest, Source>::value,
-        int>::type = 0>
+        !internal_casts::is_bitcastable<Dest, Source>::value, 
+        int>::type = 0> 
 ABSL_DEPRECATED(
-    "y_absl::bit_cast type requirements were violated. Update the types "
-    "being used such that they are the same size and are both "
-    "TriviallyCopyable.")
+    "y_absl::bit_cast type requirements were violated. Update the types " 
+    "being used such that they are the same size and are both " 
+    "TriviallyCopyable.") 
 inline Dest bit_cast(const Source& source) {
   static_assert(sizeof(Dest) == sizeof(Source),
                 "Source and destination types should have equal sizes.");
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/config.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/config.h
index 162843aa00..fc20249d89 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/config.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_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
@@ -189,12 +189,12 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 #define ABSL_INTERNAL_HAS_KEYWORD(x) 0
 #endif
 
-#ifdef __has_feature
-#define ABSL_HAVE_FEATURE(f) __has_feature(f)
-#else
-#define ABSL_HAVE_FEATURE(f) 0
-#endif
-
+#ifdef __has_feature 
+#define ABSL_HAVE_FEATURE(f) __has_feature(f) 
+#else 
+#define ABSL_HAVE_FEATURE(f) 0 
+#endif 
+ 
 // Portable check for GCC minimum version:
 // https://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html
 #if defined(__GNUC__) && defined(__GNUC_MINOR__)
@@ -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
 
@@ -285,9 +285,9 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 // * Xcode 9.3 started disallowing `thread_local` for 32-bit iOS simulator
 //   targeting iOS 9.x.
 // * Xcode 10 moves the deployment target check for iOS < 9.0 to link time
-//   making ABSL_HAVE_FEATURE unreliable there.
+//   making ABSL_HAVE_FEATURE unreliable there. 
 //
-#if ABSL_HAVE_FEATURE(cxx_thread_local) && \
+#if ABSL_HAVE_FEATURE(cxx_thread_local) && \ 
     !(TARGET_OS_IPHONE && __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_9_0)
 #define ABSL_HAVE_THREAD_LOCAL 1
 #endif
@@ -366,15 +366,15 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 #error ABSL_HAVE_EXCEPTIONS cannot be directly set.
 #elif ABSL_INTERNAL_HAVE_MIN_CLANG_VERSION(3, 6)
 // Clang >= 3.6
-#if ABSL_HAVE_FEATURE(cxx_exceptions)
+#if ABSL_HAVE_FEATURE(cxx_exceptions) 
 #define ABSL_HAVE_EXCEPTIONS 1
-#endif  // ABSL_HAVE_FEATURE(cxx_exceptions)
+#endif  // ABSL_HAVE_FEATURE(cxx_exceptions) 
 #elif defined(__clang__)
 // Clang < 3.6
 // http://releases.llvm.org/3.6.0/tools/clang/docs/ReleaseNotes.html#the-exceptions-macro
-#if defined(__EXCEPTIONS) && ABSL_HAVE_FEATURE(cxx_exceptions)
+#if defined(__EXCEPTIONS) && ABSL_HAVE_FEATURE(cxx_exceptions) 
 #define ABSL_HAVE_EXCEPTIONS 1
-#endif  // defined(__EXCEPTIONS) && ABSL_HAVE_FEATURE(cxx_exceptions)
+#endif  // defined(__EXCEPTIONS) && ABSL_HAVE_FEATURE(cxx_exceptions) 
 // Handle remaining special cases and default to exceptions being supported.
 #elif !(defined(__GNUC__) && (__GNUC__ < 5) && !defined(__EXCEPTIONS)) && \
     !(ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(5, 0) &&                        \
@@ -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
@@ -533,9 +533,9 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
   (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && \
    __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 120000) || \
   (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && \
-   __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 50000) || \
+   __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 50000) || \ 
   (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && \
-   __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 120000))
+   __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 120000)) 
 #define ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE 1
 #else
 #define ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE 0
@@ -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
@@ -721,47 +721,47 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 #define ABSL_DLL
 #endif  // defined(_MSC_VER)
 
-// ABSL_HAVE_MEMORY_SANITIZER
-//
-// MemorySanitizer (MSan) is a detector of uninitialized reads. It consists of
-// a compiler instrumentation module and a run-time library.
-#ifdef ABSL_HAVE_MEMORY_SANITIZER
-#error "ABSL_HAVE_MEMORY_SANITIZER cannot be directly set."
-#elif defined(__SANITIZE_MEMORY__)
-#define ABSL_HAVE_MEMORY_SANITIZER 1
-#elif !defined(__native_client__) && ABSL_HAVE_FEATURE(memory_sanitizer)
-#define ABSL_HAVE_MEMORY_SANITIZER 1
-#endif
-
-// ABSL_HAVE_THREAD_SANITIZER
-//
-// ThreadSanitizer (TSan) is a fast data race detector.
-#ifdef ABSL_HAVE_THREAD_SANITIZER
-#error "ABSL_HAVE_THREAD_SANITIZER cannot be directly set."
-#elif defined(__SANITIZE_THREAD__)
-#define ABSL_HAVE_THREAD_SANITIZER 1
-#elif ABSL_HAVE_FEATURE(thread_sanitizer)
-#define ABSL_HAVE_THREAD_SANITIZER 1
-#endif
-
-// ABSL_HAVE_ADDRESS_SANITIZER
-//
-// AddressSanitizer (ASan) is a fast memory error detector.
-#ifdef ABSL_HAVE_ADDRESS_SANITIZER
-#error "ABSL_HAVE_ADDRESS_SANITIZER cannot be directly set."
-#elif defined(__SANITIZE_ADDRESS__)
-#define ABSL_HAVE_ADDRESS_SANITIZER 1
-#elif ABSL_HAVE_FEATURE(address_sanitizer)
-#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_MEMORY_SANITIZER 
+// 
+// MemorySanitizer (MSan) is a detector of uninitialized reads. It consists of 
+// a compiler instrumentation module and a run-time library. 
+#ifdef ABSL_HAVE_MEMORY_SANITIZER 
+#error "ABSL_HAVE_MEMORY_SANITIZER cannot be directly set." 
+#elif defined(__SANITIZE_MEMORY__) 
+#define ABSL_HAVE_MEMORY_SANITIZER 1 
+#elif !defined(__native_client__) && ABSL_HAVE_FEATURE(memory_sanitizer) 
+#define ABSL_HAVE_MEMORY_SANITIZER 1 
+#endif 
+ 
+// ABSL_HAVE_THREAD_SANITIZER 
+// 
+// ThreadSanitizer (TSan) is a fast data race detector. 
+#ifdef ABSL_HAVE_THREAD_SANITIZER 
+#error "ABSL_HAVE_THREAD_SANITIZER cannot be directly set." 
+#elif defined(__SANITIZE_THREAD__) 
+#define ABSL_HAVE_THREAD_SANITIZER 1 
+#elif ABSL_HAVE_FEATURE(thread_sanitizer) 
+#define ABSL_HAVE_THREAD_SANITIZER 1 
+#endif 
+ 
+// ABSL_HAVE_ADDRESS_SANITIZER 
+// 
+// AddressSanitizer (ASan) is a fast memory error detector. 
+#ifdef ABSL_HAVE_ADDRESS_SANITIZER 
+#error "ABSL_HAVE_ADDRESS_SANITIZER cannot be directly set." 
+#elif defined(__SANITIZE_ADDRESS__) 
+#define ABSL_HAVE_ADDRESS_SANITIZER 1 
+#elif ABSL_HAVE_FEATURE(address_sanitizer) 
+#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 
+ 
 #endif  // ABSL_BASE_CONFIG_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/dynamic_annotations.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/dynamic_annotations.h
index 50b3122cf7..23bfaf2cd4 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/dynamic_annotations.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/dynamic_annotations.h
@@ -1,471 +1,471 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// This file defines dynamic annotations for use with dynamic analysis tool
-// such as valgrind, PIN, etc.
-//
-// Dynamic annotation is a source code annotation that affects the generated
-// code (that is, the annotation is not a comment). Each such annotation is
-// attached to a particular instruction and/or to a particular object (address)
-// in the program.
-//
-// The annotations that should be used by users are macros in all upper-case
-// (e.g., ABSL_ANNOTATE_THREAD_NAME).
-//
-// Actual implementation of these macros may differ depending on the dynamic
-// analysis tool being used.
-//
-// This file supports the following configurations:
-// - Dynamic Annotations enabled (with static thread-safety warnings disabled).
-//   In this case, macros expand to functions implemented by Thread Sanitizer,
-//   when building with TSan. When not provided an external implementation,
-//   dynamic_annotations.cc provides no-op implementations.
-//
-// - Static Clang thread-safety warnings enabled.
-//   When building with a Clang compiler that supports thread-safety warnings,
-//   a subset of annotations can be statically-checked at compile-time. We
-//   expand these macros to static-inline functions that can be analyzed for
-//   thread-safety, but afterwards elided when building the final binary.
-//
-// - All annotations are disabled.
-//   If neither Dynamic Annotations nor Clang thread-safety warnings are
-//   enabled, then all annotation-macros expand to empty.
-
-#ifndef ABSL_BASE_DYNAMIC_ANNOTATIONS_H_
-#define ABSL_BASE_DYNAMIC_ANNOTATIONS_H_
-
-#include <stddef.h>
-
-#include "y_absl/base/attributes.h"
-#include "y_absl/base/config.h"
-#ifdef __cplusplus
-#include "y_absl/base/macros.h"
-#endif
-
-// TODO(rogeeff): Remove after the backward compatibility period.
-#include "y_absl/base/internal/dynamic_annotations.h"  // IWYU pragma: export
-
-// -------------------------------------------------------------------------
-// Decide which features are enabled.
-
-#ifdef ABSL_HAVE_THREAD_SANITIZER
-
-#define ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED 1
-#define ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED 1
-#define ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED 1
-#define ABSL_INTERNAL_ANNOTALYSIS_ENABLED 0
-#define ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED 1
-
-#else
-
-#define ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED 0
-#define ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED 0
-#define ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED 0
-
-// Clang provides limited support for static thread-safety analysis through a
-// feature called Annotalysis. We configure macro-definitions according to
-// whether Annotalysis support is available. When running in opt-mode, GCC
-// will issue a warning, if these attributes are compiled. Only include them
-// when compiling using Clang.
-
-#if defined(__clang__)
-#define ABSL_INTERNAL_ANNOTALYSIS_ENABLED 1
-#if !defined(SWIG)
-#define ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED 1
-#endif
-#else
-#define ABSL_INTERNAL_ANNOTALYSIS_ENABLED 0
-#endif
-
-// Read/write annotations are enabled in Annotalysis mode; disabled otherwise.
-#define ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED \
-  ABSL_INTERNAL_ANNOTALYSIS_ENABLED
-
-#endif  // ABSL_HAVE_THREAD_SANITIZER
-
-#ifdef __cplusplus
-#define ABSL_INTERNAL_BEGIN_EXTERN_C extern "C" {
-#define ABSL_INTERNAL_END_EXTERN_C }  // extern "C"
-#define ABSL_INTERNAL_GLOBAL_SCOPED(F) ::F
-#define ABSL_INTERNAL_STATIC_INLINE inline
-#else
-#define ABSL_INTERNAL_BEGIN_EXTERN_C  // empty
-#define ABSL_INTERNAL_END_EXTERN_C    // empty
-#define ABSL_INTERNAL_GLOBAL_SCOPED(F) F
-#define ABSL_INTERNAL_STATIC_INLINE static inline
+// Copyright 2017 The Abseil Authors. 
+// 
+// Licensed under the Apache License, Version 2.0 (the "License"); 
+// you may not use this file except in compliance with the License. 
+// You may obtain a copy of the License at 
+// 
+//      https://www.apache.org/licenses/LICENSE-2.0 
+// 
+// Unless required by applicable law or agreed to in writing, software 
+// distributed under the License is distributed on an "AS IS" BASIS, 
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+// See the License for the specific language governing permissions and 
+// limitations under the License. 
+
+// This file defines dynamic annotations for use with dynamic analysis tool 
+// such as valgrind, PIN, etc. 
+// 
+// Dynamic annotation is a source code annotation that affects the generated 
+// code (that is, the annotation is not a comment). Each such annotation is 
+// attached to a particular instruction and/or to a particular object (address) 
+// in the program. 
+// 
+// The annotations that should be used by users are macros in all upper-case 
+// (e.g., ABSL_ANNOTATE_THREAD_NAME). 
+// 
+// Actual implementation of these macros may differ depending on the dynamic 
+// analysis tool being used. 
+// 
+// This file supports the following configurations: 
+// - Dynamic Annotations enabled (with static thread-safety warnings disabled). 
+//   In this case, macros expand to functions implemented by Thread Sanitizer, 
+//   when building with TSan. When not provided an external implementation, 
+//   dynamic_annotations.cc provides no-op implementations. 
+// 
+// - Static Clang thread-safety warnings enabled. 
+//   When building with a Clang compiler that supports thread-safety warnings, 
+//   a subset of annotations can be statically-checked at compile-time. We 
+//   expand these macros to static-inline functions that can be analyzed for 
+//   thread-safety, but afterwards elided when building the final binary. 
+// 
+// - All annotations are disabled. 
+//   If neither Dynamic Annotations nor Clang thread-safety warnings are 
+//   enabled, then all annotation-macros expand to empty. 
+
+#ifndef ABSL_BASE_DYNAMIC_ANNOTATIONS_H_ 
+#define ABSL_BASE_DYNAMIC_ANNOTATIONS_H_ 
+
+#include <stddef.h> 
+
+#include "y_absl/base/attributes.h" 
+#include "y_absl/base/config.h" 
+#ifdef __cplusplus 
+#include "y_absl/base/macros.h" 
+#endif 
+
+// TODO(rogeeff): Remove after the backward compatibility period. 
+#include "y_absl/base/internal/dynamic_annotations.h"  // IWYU pragma: export 
+
+// ------------------------------------------------------------------------- 
+// Decide which features are enabled. 
+
+#ifdef ABSL_HAVE_THREAD_SANITIZER 
+
+#define ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED 1 
+#define ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED 1 
+#define ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED 1 
+#define ABSL_INTERNAL_ANNOTALYSIS_ENABLED 0 
+#define ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED 1 
+ 
+#else 
+ 
+#define ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED 0 
+#define ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED 0 
+#define ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED 0 
+ 
+// Clang provides limited support for static thread-safety analysis through a 
+// feature called Annotalysis. We configure macro-definitions according to 
+// whether Annotalysis support is available. When running in opt-mode, GCC 
+// will issue a warning, if these attributes are compiled. Only include them 
+// when compiling using Clang. 
+ 
+#if defined(__clang__) 
+#define ABSL_INTERNAL_ANNOTALYSIS_ENABLED 1 
+#if !defined(SWIG) 
+#define ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED 1 
 #endif
-
-// -------------------------------------------------------------------------
-// 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.
-
-// -------------------------------------------------------------
-// Annotations that suppress errors. It is usually better to express the
-// program's synchronization using the other annotations, but these can be used
-// when all else fails.
-
-// Report that we may have a benign race at `pointer`, with size
-// "sizeof(*(pointer))". `pointer` must be a non-void* pointer. Insert at the
-// point where `pointer` has been allocated, preferably close to the point
-// where the race happens. See also ABSL_ANNOTATE_BENIGN_RACE_STATIC.
-#define ABSL_ANNOTATE_BENIGN_RACE(pointer, description) \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateBenignRaceSized)  \
-  (__FILE__, __LINE__, pointer, sizeof(*(pointer)), description)
-
-// Same as ABSL_ANNOTATE_BENIGN_RACE(`address`, `description`), but applies to
-// the memory range [`address`, `address`+`size`).
-#define ABSL_ANNOTATE_BENIGN_RACE_SIZED(address, size, description) \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateBenignRaceSized)              \
-  (__FILE__, __LINE__, address, size, description)
-
-// Enable (`enable`!=0) or disable (`enable`==0) race detection for all threads.
-// This annotation could be useful if you want to skip expensive race analysis
-// during some period of program execution, e.g. during initialization.
-#define ABSL_ANNOTATE_ENABLE_RACE_DETECTION(enable)        \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateEnableRaceDetection) \
-  (__FILE__, __LINE__, enable)
-
-// -------------------------------------------------------------
-// Annotations useful for debugging.
-
-// Report the current thread `name` to a race detector.
-#define ABSL_ANNOTATE_THREAD_NAME(name) \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateThreadName)(__FILE__, __LINE__, name)
-
-// -------------------------------------------------------------
-// Annotations useful when implementing locks. They are not normally needed by
-// modules that merely use locks. The `lock` argument is a pointer to the lock
-// object.
-
-// Report that a lock has been created at address `lock`.
-#define ABSL_ANNOTATE_RWLOCK_CREATE(lock) \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockCreate)(__FILE__, __LINE__, lock)
-
-// Report that a linker initialized lock has been created at address `lock`.
-#ifdef ABSL_HAVE_THREAD_SANITIZER
-#define ABSL_ANNOTATE_RWLOCK_CREATE_STATIC(lock)          \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockCreateStatic) \
-  (__FILE__, __LINE__, lock)
+#else 
+#define ABSL_INTERNAL_ANNOTALYSIS_ENABLED 0 
+#endif 
+
+// Read/write annotations are enabled in Annotalysis mode; disabled otherwise. 
+#define ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED \ 
+  ABSL_INTERNAL_ANNOTALYSIS_ENABLED 
+
+#endif  // ABSL_HAVE_THREAD_SANITIZER 
+
+#ifdef __cplusplus 
+#define ABSL_INTERNAL_BEGIN_EXTERN_C extern "C" { 
+#define ABSL_INTERNAL_END_EXTERN_C }  // extern "C" 
+#define ABSL_INTERNAL_GLOBAL_SCOPED(F) ::F 
+#define ABSL_INTERNAL_STATIC_INLINE inline 
+#else 
+#define ABSL_INTERNAL_BEGIN_EXTERN_C  // empty 
+#define ABSL_INTERNAL_END_EXTERN_C    // empty 
+#define ABSL_INTERNAL_GLOBAL_SCOPED(F) F 
+#define ABSL_INTERNAL_STATIC_INLINE static inline 
+#endif 
+
+// ------------------------------------------------------------------------- 
+// 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. 
+
+// ------------------------------------------------------------- 
+// Annotations that suppress errors. It is usually better to express the 
+// program's synchronization using the other annotations, but these can be used 
+// when all else fails. 
+
+// Report that we may have a benign race at `pointer`, with size 
+// "sizeof(*(pointer))". `pointer` must be a non-void* pointer. Insert at the 
+// point where `pointer` has been allocated, preferably close to the point 
+// where the race happens. See also ABSL_ANNOTATE_BENIGN_RACE_STATIC. 
+#define ABSL_ANNOTATE_BENIGN_RACE(pointer, description) \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateBenignRaceSized)  \ 
+  (__FILE__, __LINE__, pointer, sizeof(*(pointer)), description) 
+
+// Same as ABSL_ANNOTATE_BENIGN_RACE(`address`, `description`), but applies to 
+// the memory range [`address`, `address`+`size`). 
+#define ABSL_ANNOTATE_BENIGN_RACE_SIZED(address, size, description) \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateBenignRaceSized)              \ 
+  (__FILE__, __LINE__, address, size, description) 
+
+// Enable (`enable`!=0) or disable (`enable`==0) race detection for all threads. 
+// This annotation could be useful if you want to skip expensive race analysis 
+// during some period of program execution, e.g. during initialization. 
+#define ABSL_ANNOTATE_ENABLE_RACE_DETECTION(enable)        \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateEnableRaceDetection) \ 
+  (__FILE__, __LINE__, enable) 
+
+// ------------------------------------------------------------- 
+// Annotations useful for debugging. 
+ 
+// Report the current thread `name` to a race detector. 
+#define ABSL_ANNOTATE_THREAD_NAME(name) \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateThreadName)(__FILE__, __LINE__, name) 
+ 
+// ------------------------------------------------------------- 
+// Annotations useful when implementing locks. They are not normally needed by 
+// modules that merely use locks. The `lock` argument is a pointer to the lock 
+// object. 
+ 
+// Report that a lock has been created at address `lock`. 
+#define ABSL_ANNOTATE_RWLOCK_CREATE(lock) \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockCreate)(__FILE__, __LINE__, lock) 
+ 
+// Report that a linker initialized lock has been created at address `lock`. 
+#ifdef ABSL_HAVE_THREAD_SANITIZER 
+#define ABSL_ANNOTATE_RWLOCK_CREATE_STATIC(lock)          \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockCreateStatic) \ 
+  (__FILE__, __LINE__, lock) 
 #else
-#define ABSL_ANNOTATE_RWLOCK_CREATE_STATIC(lock) \
-  ABSL_ANNOTATE_RWLOCK_CREATE(lock)
+#define ABSL_ANNOTATE_RWLOCK_CREATE_STATIC(lock) \ 
+  ABSL_ANNOTATE_RWLOCK_CREATE(lock) 
 #endif
 
-// Report that the lock at address `lock` is about to be destroyed.
-#define ABSL_ANNOTATE_RWLOCK_DESTROY(lock) \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockDestroy)(__FILE__, __LINE__, lock)
-
-// Report that the lock at address `lock` has been acquired.
-// `is_w`=1 for writer lock, `is_w`=0 for reader lock.
-#define ABSL_ANNOTATE_RWLOCK_ACQUIRED(lock, is_w)     \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockAcquired) \
-  (__FILE__, __LINE__, lock, is_w)
-
-// Report that the lock at address `lock` is about to be released.
-// `is_w`=1 for writer lock, `is_w`=0 for reader lock.
-#define ABSL_ANNOTATE_RWLOCK_RELEASED(lock, is_w)     \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockReleased) \
-  (__FILE__, __LINE__, lock, is_w)
-
-// Apply ABSL_ANNOTATE_BENIGN_RACE_SIZED to a static variable `static_var`.
-#define ABSL_ANNOTATE_BENIGN_RACE_STATIC(static_var, description)      \
-  namespace {                                                          \
-  class static_var##_annotator {                                       \
-   public:                                                             \
-    static_var##_annotator() {                                         \
-      ABSL_ANNOTATE_BENIGN_RACE_SIZED(&static_var, sizeof(static_var), \
-                                      #static_var ": " description);   \
-    }                                                                  \
-  };                                                                   \
-  static static_var##_annotator the##static_var##_annotator;           \
-  }  // namespace
-
-// Function prototypes of annotations provided by the compiler-based sanitizer
-// implementation.
-ABSL_INTERNAL_BEGIN_EXTERN_C
-void AnnotateRWLockCreate(const char* file, int line,
-                          const volatile void* lock);
-void AnnotateRWLockCreateStatic(const char* file, int line,
-                                const volatile void* lock);
-void AnnotateRWLockDestroy(const char* file, int line,
-                           const volatile void* lock);
-void AnnotateRWLockAcquired(const char* file, int line,
-                            const volatile void* lock, long is_w);  // NOLINT
-void AnnotateRWLockReleased(const char* file, int line,
-                            const volatile void* lock, long is_w);  // NOLINT
-void AnnotateBenignRace(const char* file, int line,
-                        const volatile void* address, const char* description);
-void AnnotateBenignRaceSized(const char* file, int line,
-                             const volatile void* address, size_t size,
-                             const char* description);
-void AnnotateThreadName(const char* file, int line, const char* name);
-void AnnotateEnableRaceDetection(const char* file, int line, int enable);
-ABSL_INTERNAL_END_EXTERN_C
-
-#else  // ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED == 0
-
-#define ABSL_ANNOTATE_RWLOCK_CREATE(lock)                            // empty
-#define ABSL_ANNOTATE_RWLOCK_CREATE_STATIC(lock)                     // empty
-#define ABSL_ANNOTATE_RWLOCK_DESTROY(lock)                           // empty
-#define ABSL_ANNOTATE_RWLOCK_ACQUIRED(lock, is_w)                    // empty
-#define ABSL_ANNOTATE_RWLOCK_RELEASED(lock, is_w)                    // empty
-#define ABSL_ANNOTATE_BENIGN_RACE(address, description)              // empty
-#define ABSL_ANNOTATE_BENIGN_RACE_SIZED(address, size, description)  // empty
-#define ABSL_ANNOTATE_THREAD_NAME(name)                              // empty
-#define ABSL_ANNOTATE_ENABLE_RACE_DETECTION(enable)                  // empty
-#define ABSL_ANNOTATE_BENIGN_RACE_STATIC(static_var, description)    // empty
-
-#endif  // ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED
-
-// -------------------------------------------------------------------------
-// Define memory annotations.
-
-#ifdef ABSL_HAVE_MEMORY_SANITIZER
-
-#include <sanitizer/msan_interface.h>
-
-#define ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(address, size) \
-  __msan_unpoison(address, size)
-
-#define ABSL_ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size) \
-  __msan_allocated_memory(address, size)
-
-#else  // !defined(ABSL_HAVE_MEMORY_SANITIZER)
-
-// TODO(rogeeff): remove this branch
-#ifdef ABSL_HAVE_THREAD_SANITIZER
-#define ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(address, size) \
-  do {                                                     \
-    (void)(address);                                       \
-    (void)(size);                                          \
-  } while (0)
-#define ABSL_ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size) \
-  do {                                                       \
-    (void)(address);                                         \
-    (void)(size);                                            \
-  } while (0)
+// Report that the lock at address `lock` is about to be destroyed. 
+#define ABSL_ANNOTATE_RWLOCK_DESTROY(lock) \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockDestroy)(__FILE__, __LINE__, lock) 
+
+// Report that the lock at address `lock` has been acquired. 
+// `is_w`=1 for writer lock, `is_w`=0 for reader lock. 
+#define ABSL_ANNOTATE_RWLOCK_ACQUIRED(lock, is_w)     \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockAcquired) \ 
+  (__FILE__, __LINE__, lock, is_w) 
+
+// Report that the lock at address `lock` is about to be released. 
+// `is_w`=1 for writer lock, `is_w`=0 for reader lock. 
+#define ABSL_ANNOTATE_RWLOCK_RELEASED(lock, is_w)     \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockReleased) \ 
+  (__FILE__, __LINE__, lock, is_w) 
+
+// Apply ABSL_ANNOTATE_BENIGN_RACE_SIZED to a static variable `static_var`. 
+#define ABSL_ANNOTATE_BENIGN_RACE_STATIC(static_var, description)      \ 
+  namespace {                                                          \ 
+  class static_var##_annotator {                                       \ 
+   public:                                                             \ 
+    static_var##_annotator() {                                         \ 
+      ABSL_ANNOTATE_BENIGN_RACE_SIZED(&static_var, sizeof(static_var), \ 
+                                      #static_var ": " description);   \ 
+    }                                                                  \ 
+  };                                                                   \ 
+  static static_var##_annotator the##static_var##_annotator;           \ 
+  }  // namespace 
+
+// Function prototypes of annotations provided by the compiler-based sanitizer 
+// implementation. 
+ABSL_INTERNAL_BEGIN_EXTERN_C 
+void AnnotateRWLockCreate(const char* file, int line, 
+                          const volatile void* lock); 
+void AnnotateRWLockCreateStatic(const char* file, int line, 
+                                const volatile void* lock); 
+void AnnotateRWLockDestroy(const char* file, int line, 
+                           const volatile void* lock); 
+void AnnotateRWLockAcquired(const char* file, int line, 
+                            const volatile void* lock, long is_w);  // NOLINT 
+void AnnotateRWLockReleased(const char* file, int line, 
+                            const volatile void* lock, long is_w);  // NOLINT 
+void AnnotateBenignRace(const char* file, int line, 
+                        const volatile void* address, const char* description); 
+void AnnotateBenignRaceSized(const char* file, int line, 
+                             const volatile void* address, size_t size, 
+                             const char* description); 
+void AnnotateThreadName(const char* file, int line, const char* name); 
+void AnnotateEnableRaceDetection(const char* file, int line, int enable); 
+ABSL_INTERNAL_END_EXTERN_C 
+
+#else  // ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED == 0 
+
+#define ABSL_ANNOTATE_RWLOCK_CREATE(lock)                            // empty 
+#define ABSL_ANNOTATE_RWLOCK_CREATE_STATIC(lock)                     // empty 
+#define ABSL_ANNOTATE_RWLOCK_DESTROY(lock)                           // empty 
+#define ABSL_ANNOTATE_RWLOCK_ACQUIRED(lock, is_w)                    // empty 
+#define ABSL_ANNOTATE_RWLOCK_RELEASED(lock, is_w)                    // empty 
+#define ABSL_ANNOTATE_BENIGN_RACE(address, description)              // empty 
+#define ABSL_ANNOTATE_BENIGN_RACE_SIZED(address, size, description)  // empty 
+#define ABSL_ANNOTATE_THREAD_NAME(name)                              // empty 
+#define ABSL_ANNOTATE_ENABLE_RACE_DETECTION(enable)                  // empty 
+#define ABSL_ANNOTATE_BENIGN_RACE_STATIC(static_var, description)    // empty 
+
+#endif  // ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED 
+
+// ------------------------------------------------------------------------- 
+// Define memory annotations. 
+
+#ifdef ABSL_HAVE_MEMORY_SANITIZER 
+
+#include <sanitizer/msan_interface.h> 
+ 
+#define ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(address, size) \ 
+  __msan_unpoison(address, size) 
+ 
+#define ABSL_ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size) \ 
+  __msan_allocated_memory(address, size) 
+ 
+#else  // !defined(ABSL_HAVE_MEMORY_SANITIZER) 
+ 
+// TODO(rogeeff): remove this branch 
+#ifdef ABSL_HAVE_THREAD_SANITIZER 
+#define ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(address, size) \ 
+  do {                                                     \ 
+    (void)(address);                                       \ 
+    (void)(size);                                          \ 
+  } while (0) 
+#define ABSL_ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size) \ 
+  do {                                                       \ 
+    (void)(address);                                         \ 
+    (void)(size);                                            \ 
+  } while (0) 
 #else
 
-#define ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(address, size)    // empty
-#define ABSL_ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size)  // empty
-
+#define ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(address, size)    // empty 
+#define ABSL_ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size)  // empty 
+ 
 #endif
 
-#endif  // ABSL_HAVE_MEMORY_SANITIZER
-
-// -------------------------------------------------------------------------
-// Define IGNORE_READS_BEGIN/_END attributes.
-
-#if defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
-
-#define ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE \
-  __attribute((exclusive_lock_function("*")))
-#define ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE \
-  __attribute((unlock_function("*")))
-
-#else  // !defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
-
-#define ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE  // empty
-#define ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE    // empty
-
-#endif  // defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
-
-// -------------------------------------------------------------------------
-// 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.
-
-// 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__)
-
-// Stop ignoring reads.
-#define ABSL_ANNOTATE_IGNORE_READS_END()              \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsEnd) \
-  (__FILE__, __LINE__)
-
-// Function prototypes of annotations provided by the compiler-based sanitizer
-// implementation.
-ABSL_INTERNAL_BEGIN_EXTERN_C
-void AnnotateIgnoreReadsBegin(const char* file, int line)
-    ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE;
-void AnnotateIgnoreReadsEnd(const char* file,
-                            int line) ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE;
-ABSL_INTERNAL_END_EXTERN_C
-
-#elif defined(ABSL_INTERNAL_ANNOTALYSIS_ENABLED)
-
-// When Annotalysis is enabled without Dynamic Annotations, the use of
-// static-inline functions allows the annotations to be read at compile-time,
-// while still letting the compiler elide the functions from the final build.
-//
-// 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_END()                          \
-  ABSL_INTERNAL_GLOBAL_SCOPED(                                    \
-      ABSL_INTERNAL_C_SYMBOL(AbslInternalAnnotateIgnoreReadsEnd)) \
-  ()
-
-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_IGNORE_READS_END_ATTRIBUTE {}
-
+#endif  // ABSL_HAVE_MEMORY_SANITIZER 
+
+// ------------------------------------------------------------------------- 
+// Define IGNORE_READS_BEGIN/_END attributes. 
+
+#if defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED) 
+
+#define ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE \ 
+  __attribute((exclusive_lock_function("*"))) 
+#define ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE \ 
+  __attribute((unlock_function("*"))) 
+
+#else  // !defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED) 
+
+#define ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE  // empty 
+#define ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE    // empty 
+
+#endif  // defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED) 
+
+// ------------------------------------------------------------------------- 
+// 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. 
+
+// 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__) 
+
+// Stop ignoring reads. 
+#define ABSL_ANNOTATE_IGNORE_READS_END()              \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsEnd) \ 
+  (__FILE__, __LINE__) 
+
+// Function prototypes of annotations provided by the compiler-based sanitizer 
+// implementation. 
+ABSL_INTERNAL_BEGIN_EXTERN_C 
+void AnnotateIgnoreReadsBegin(const char* file, int line) 
+    ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE; 
+void AnnotateIgnoreReadsEnd(const char* file, 
+                            int line) ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE; 
+ABSL_INTERNAL_END_EXTERN_C 
+
+#elif defined(ABSL_INTERNAL_ANNOTALYSIS_ENABLED) 
+
+// When Annotalysis is enabled without Dynamic Annotations, the use of 
+// static-inline functions allows the annotations to be read at compile-time, 
+// while still letting the compiler elide the functions from the final build. 
+// 
+// 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_END()                          \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(                                    \ 
+      ABSL_INTERNAL_C_SYMBOL(AbslInternalAnnotateIgnoreReadsEnd)) \ 
+  () 
+ 
+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_IGNORE_READS_END_ATTRIBUTE {} 
+ 
 #else
 
-#define ABSL_ANNOTATE_IGNORE_READS_BEGIN()  // empty
-#define ABSL_ANNOTATE_IGNORE_READS_END()    // empty
-
+#define ABSL_ANNOTATE_IGNORE_READS_BEGIN()  // empty 
+#define ABSL_ANNOTATE_IGNORE_READS_END()    // empty 
+ 
 #endif
 
-// -------------------------------------------------------------------------
-// Define IGNORE_WRITES_BEGIN/_END annotations.
-
-#if ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED == 1
-
-// Similar to ABSL_ANNOTATE_IGNORE_READS_BEGIN, but ignore writes instead.
-#define ABSL_ANNOTATE_IGNORE_WRITES_BEGIN() \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreWritesBegin)(__FILE__, __LINE__)
-
-// Stop ignoring writes.
-#define ABSL_ANNOTATE_IGNORE_WRITES_END() \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreWritesEnd)(__FILE__, __LINE__)
-
-// Function prototypes of annotations provided by the compiler-based sanitizer
-// implementation.
-ABSL_INTERNAL_BEGIN_EXTERN_C
-void AnnotateIgnoreWritesBegin(const char* file, int line);
-void AnnotateIgnoreWritesEnd(const char* file, int line);
-ABSL_INTERNAL_END_EXTERN_C
-
-#else
-
-#define ABSL_ANNOTATE_IGNORE_WRITES_BEGIN()  // empty
-#define ABSL_ANNOTATE_IGNORE_WRITES_END()    // empty
-
+// ------------------------------------------------------------------------- 
+// Define IGNORE_WRITES_BEGIN/_END annotations. 
+
+#if ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED == 1 
+
+// Similar to ABSL_ANNOTATE_IGNORE_READS_BEGIN, but ignore writes instead. 
+#define ABSL_ANNOTATE_IGNORE_WRITES_BEGIN() \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreWritesBegin)(__FILE__, __LINE__) 
+ 
+// Stop ignoring writes. 
+#define ABSL_ANNOTATE_IGNORE_WRITES_END() \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreWritesEnd)(__FILE__, __LINE__) 
+ 
+// Function prototypes of annotations provided by the compiler-based sanitizer 
+// implementation. 
+ABSL_INTERNAL_BEGIN_EXTERN_C 
+void AnnotateIgnoreWritesBegin(const char* file, int line); 
+void AnnotateIgnoreWritesEnd(const char* file, int line); 
+ABSL_INTERNAL_END_EXTERN_C 
+ 
+#else 
+ 
+#define ABSL_ANNOTATE_IGNORE_WRITES_BEGIN()  // empty 
+#define ABSL_ANNOTATE_IGNORE_WRITES_END()    // empty 
+ 
 #endif
 
-// -------------------------------------------------------------------------
-// Define the ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_* annotations using the more
-// primitive annotations defined above.
-//
-//     Instead of doing
-//        ABSL_ANNOTATE_IGNORE_READS_BEGIN();
-//        ... = x;
-//        ABSL_ANNOTATE_IGNORE_READS_END();
-//     one can use
-//        ... = ABSL_ANNOTATE_UNPROTECTED_READ(x);
-
-#if defined(ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED)
-
-// Start ignoring all memory accesses (both reads and writes).
-#define ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN() \
-  do {                                                \
-    ABSL_ANNOTATE_IGNORE_READS_BEGIN();               \
-    ABSL_ANNOTATE_IGNORE_WRITES_BEGIN();              \
-  } while (0)
-
-// Stop ignoring both reads and writes.
-#define ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_END() \
-  do {                                              \
-    ABSL_ANNOTATE_IGNORE_WRITES_END();              \
-    ABSL_ANNOTATE_IGNORE_READS_END();               \
-  } while (0)
+// ------------------------------------------------------------------------- 
+// Define the ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_* annotations using the more 
+// primitive annotations defined above. 
+// 
+//     Instead of doing 
+//        ABSL_ANNOTATE_IGNORE_READS_BEGIN(); 
+//        ... = x; 
+//        ABSL_ANNOTATE_IGNORE_READS_END(); 
+//     one can use 
+//        ... = ABSL_ANNOTATE_UNPROTECTED_READ(x); 
+
+#if defined(ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED) 
+
+// Start ignoring all memory accesses (both reads and writes). 
+#define ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN() \ 
+  do {                                                \ 
+    ABSL_ANNOTATE_IGNORE_READS_BEGIN();               \ 
+    ABSL_ANNOTATE_IGNORE_WRITES_BEGIN();              \ 
+  } while (0) 
+
+// Stop ignoring both reads and writes. 
+#define ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_END() \ 
+  do {                                              \ 
+    ABSL_ANNOTATE_IGNORE_WRITES_END();              \ 
+    ABSL_ANNOTATE_IGNORE_READS_END();               \ 
+  } while (0) 
 
 #ifdef __cplusplus
-// ABSL_ANNOTATE_UNPROTECTED_READ is the preferred way to annotate racey reads.
-#define ABSL_ANNOTATE_UNPROTECTED_READ(x) \
-  y_absl::base_internal::AnnotateUnprotectedRead(x)
+// ABSL_ANNOTATE_UNPROTECTED_READ is the preferred way to annotate racey reads. 
+#define ABSL_ANNOTATE_UNPROTECTED_READ(x) \ 
+  y_absl::base_internal::AnnotateUnprotectedRead(x) 
 
-namespace y_absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
+namespace y_absl { 
+ABSL_NAMESPACE_BEGIN 
+namespace base_internal { 
 
 template <typename T>
-inline T AnnotateUnprotectedRead(const volatile T& x) {  // NOLINT
-  ABSL_ANNOTATE_IGNORE_READS_BEGIN();
+inline T AnnotateUnprotectedRead(const volatile T& x) {  // NOLINT 
+  ABSL_ANNOTATE_IGNORE_READS_BEGIN(); 
   T res = x;
-  ABSL_ANNOTATE_IGNORE_READS_END();
+  ABSL_ANNOTATE_IGNORE_READS_END(); 
   return res;
-}
-
-}  // namespace base_internal
-ABSL_NAMESPACE_END
-}  // namespace y_absl
-#endif
-
+} 
+ 
+}  // namespace base_internal 
+ABSL_NAMESPACE_END 
+}  // namespace y_absl 
+#endif 
+ 
 #else
-
-#define ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN()  // empty
-#define ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_END()    // empty
-#define ABSL_ANNOTATE_UNPROTECTED_READ(x) (x)
-
+ 
+#define ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN()  // empty 
+#define ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_END()    // empty 
+#define ABSL_ANNOTATE_UNPROTECTED_READ(x) (x) 
+ 
 #endif
 
-// -------------------------------------------------------------------------
-// Address sanitizer annotations
-
-#ifdef ABSL_HAVE_ADDRESS_SANITIZER
-// Describe the current state of a contiguous container such as e.g.
-// std::vector or TString. For more details see
-// sanitizer/common_interface_defs.h, which is provided by the compiler.
+// ------------------------------------------------------------------------- 
+// Address sanitizer annotations 
+ 
+#ifdef ABSL_HAVE_ADDRESS_SANITIZER 
+// Describe the current state of a contiguous container such as e.g. 
+// std::vector or TString. For more details see 
+// sanitizer/common_interface_defs.h, which is provided by the compiler. 
 #include <sanitizer/common_interface_defs.h>
-
-#define ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(beg, end, old_mid, new_mid) \
+ 
+#define ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(beg, end, old_mid, new_mid) \ 
   __sanitizer_annotate_contiguous_container(beg, end, old_mid, new_mid)
-#define ABSL_ADDRESS_SANITIZER_REDZONE(name) \
-  struct {                                   \
+#define ABSL_ADDRESS_SANITIZER_REDZONE(name) \ 
+  struct {                                   \ 
     alignas(8) char x[8];                    \
-  } name
-
+  } name 
+ 
 #else
 
-#define ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(beg, end, old_mid, new_mid)  // empty
-#define ABSL_ADDRESS_SANITIZER_REDZONE(name) static_assert(true, "")
-
-#endif  // ABSL_HAVE_ADDRESS_SANITIZER
-
-// -------------------------------------------------------------------------
-// Undefine the macros intended only for this file.
-
-#undef ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED
-#undef ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED
-#undef ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED
-#undef ABSL_INTERNAL_ANNOTALYSIS_ENABLED
-#undef ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED
-#undef ABSL_INTERNAL_BEGIN_EXTERN_C
-#undef ABSL_INTERNAL_END_EXTERN_C
-#undef ABSL_INTERNAL_STATIC_INLINE
-
-#endif  // ABSL_BASE_DYNAMIC_ANNOTATIONS_H_
+#define ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(beg, end, old_mid, new_mid)  // empty 
+#define ABSL_ADDRESS_SANITIZER_REDZONE(name) static_assert(true, "") 
+
+#endif  // ABSL_HAVE_ADDRESS_SANITIZER 
+ 
+// ------------------------------------------------------------------------- 
+// Undefine the macros intended only for this file. 
+ 
+#undef ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED 
+#undef ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED 
+#undef ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED 
+#undef ABSL_INTERNAL_ANNOTALYSIS_ENABLED 
+#undef ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED 
+#undef ABSL_INTERNAL_BEGIN_EXTERN_C 
+#undef ABSL_INTERNAL_END_EXTERN_C 
+#undef ABSL_INTERNAL_STATIC_INLINE 
+ 
+#endif  // ABSL_BASE_DYNAMIC_ANNOTATIONS_H_ 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/direct_mmap.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/direct_mmap.h
index 82be9f94ab..3f8a1eb8de 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/direct_mmap.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/direct_mmap.h
@@ -61,10 +61,10 @@ extern "C" void* __mmap2(void*, size_t, int, int, int, size_t);
 #endif
 #endif  // __BIONIC__
 
-#if defined(__NR_mmap2) && !defined(SYS_mmap2)
-#define SYS_mmap2 __NR_mmap2
-#endif
-
+#if defined(__NR_mmap2) && !defined(SYS_mmap2) 
+#define SYS_mmap2 __NR_mmap2 
+#endif 
+ 
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
 namespace base_internal {
@@ -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(__riscv) && __riscv_xlen == 32) ||                              \ 
+    (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-tstring/y_absl/base/internal/dynamic_annotations.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/dynamic_annotations.h
index 75f0022683..56c5963e0e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/dynamic_annotations.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/dynamic_annotations.h
@@ -1,398 +1,398 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// This file defines dynamic annotations for use with dynamic analysis tool
-// such as valgrind, PIN, etc.
-//
-// Dynamic annotation is a source code annotation that affects the generated
-// code (that is, the annotation is not a comment). Each such annotation is
-// attached to a particular instruction and/or to a particular object (address)
-// in the program.
-//
-// The annotations that should be used by users are macros in all upper-case
-// (e.g., ANNOTATE_THREAD_NAME).
-//
-// Actual implementation of these macros may differ depending on the dynamic
-// analysis tool being used.
-//
-// This file supports the following configurations:
-// - Dynamic Annotations enabled (with static thread-safety warnings disabled).
-//   In this case, macros expand to functions implemented by Thread Sanitizer,
-//   when building with TSan. When not provided an external implementation,
-//   dynamic_annotations.cc provides no-op implementations.
-//
-// - Static Clang thread-safety warnings enabled.
-//   When building with a Clang compiler that supports thread-safety warnings,
-//   a subset of annotations can be statically-checked at compile-time. We
-//   expand these macros to static-inline functions that can be analyzed for
-//   thread-safety, but afterwards elided when building the final binary.
-//
-// - All annotations are disabled.
-//   If neither Dynamic Annotations nor Clang thread-safety warnings are
-//   enabled, then all annotation-macros expand to empty.
-
-#ifndef ABSL_BASE_INTERNAL_DYNAMIC_ANNOTATIONS_H_
-#define ABSL_BASE_INTERNAL_DYNAMIC_ANNOTATIONS_H_
-
-#include <stddef.h>
-
-#include "y_absl/base/config.h"
-
-// -------------------------------------------------------------------------
-// Decide which features are enabled
-
-#ifndef DYNAMIC_ANNOTATIONS_ENABLED
-#define DYNAMIC_ANNOTATIONS_ENABLED 0
-#endif
-
-#if defined(__clang__) && !defined(SWIG)
-#define ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED 1
-#endif
-
-#if DYNAMIC_ANNOTATIONS_ENABLED != 0
-
-#define ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED 1
-#define ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED 1
-#define ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED 1
-#define ABSL_INTERNAL_ANNOTALYSIS_ENABLED 0
-#define ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED 1
-
-#else
-
-#define ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED 0
-#define ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED 0
-#define ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED 0
-
-// Clang provides limited support for static thread-safety analysis through a
-// feature called Annotalysis. We configure macro-definitions according to
-// whether Annotalysis support is available. When running in opt-mode, GCC
-// will issue a warning, if these attributes are compiled. Only include them
-// when compiling using Clang.
-
-// ANNOTALYSIS_ENABLED == 1 when IGNORE_READ_ATTRIBUTE_ENABLED == 1
-#define ABSL_INTERNAL_ANNOTALYSIS_ENABLED \
-  defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
-// Read/write annotations are enabled in Annotalysis mode; disabled otherwise.
-#define ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED \
-  ABSL_INTERNAL_ANNOTALYSIS_ENABLED
-#endif
-
-// Memory annotations are also made available to LLVM's Memory Sanitizer
-#if defined(ABSL_HAVE_MEMORY_SANITIZER) && !defined(__native_client__)
-#define ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED 1
-#endif
-
-#ifndef ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED
-#define ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED 0
-#endif
-
-#ifdef __cplusplus
-#define ABSL_INTERNAL_BEGIN_EXTERN_C extern "C" {
-#define ABSL_INTERNAL_END_EXTERN_C }  // extern "C"
-#define ABSL_INTERNAL_GLOBAL_SCOPED(F) ::F
-#define ABSL_INTERNAL_STATIC_INLINE inline
-#else
-#define ABSL_INTERNAL_BEGIN_EXTERN_C  // empty
-#define ABSL_INTERNAL_END_EXTERN_C    // empty
-#define ABSL_INTERNAL_GLOBAL_SCOPED(F) F
-#define ABSL_INTERNAL_STATIC_INLINE static inline
-#endif
-
-// -------------------------------------------------------------------------
-// Define race annotations.
-
-#if ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED == 1
-
-// -------------------------------------------------------------
-// Annotations that suppress errors. It is usually better to express the
-// program's synchronization using the other annotations, but these can be used
-// when all else fails.
-
-// Report that we may have a benign race at `pointer`, with size
-// "sizeof(*(pointer))". `pointer` must be a non-void* pointer. Insert at the
-// point where `pointer` has been allocated, preferably close to the point
-// where the race happens. See also ANNOTATE_BENIGN_RACE_STATIC.
-#define ANNOTATE_BENIGN_RACE(pointer, description)     \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateBenignRaceSized) \
-  (__FILE__, __LINE__, pointer, sizeof(*(pointer)), description)
-
-// Same as ANNOTATE_BENIGN_RACE(`address`, `description`), but applies to
-// the memory range [`address`, `address`+`size`).
-#define ANNOTATE_BENIGN_RACE_SIZED(address, size, description) \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateBenignRaceSized)         \
-  (__FILE__, __LINE__, address, size, description)
-
-// Enable (`enable`!=0) or disable (`enable`==0) race detection for all threads.
-// This annotation could be useful if you want to skip expensive race analysis
-// during some period of program execution, e.g. during initialization.
-#define ANNOTATE_ENABLE_RACE_DETECTION(enable)             \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateEnableRaceDetection) \
-  (__FILE__, __LINE__, enable)
-
-// -------------------------------------------------------------
-// Annotations useful for debugging.
-
-// Report the current thread `name` to a race detector.
-#define ANNOTATE_THREAD_NAME(name) \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateThreadName)(__FILE__, __LINE__, name)
-
-// -------------------------------------------------------------
-// Annotations useful when implementing locks. They are not normally needed by
-// modules that merely use locks. The `lock` argument is a pointer to the lock
-// object.
-
-// Report that a lock has been created at address `lock`.
-#define ANNOTATE_RWLOCK_CREATE(lock) \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockCreate)(__FILE__, __LINE__, lock)
-
-// Report that a linker initialized lock has been created at address `lock`.
-#ifdef ABSL_HAVE_THREAD_SANITIZER
-#define ANNOTATE_RWLOCK_CREATE_STATIC(lock)               \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockCreateStatic) \
-  (__FILE__, __LINE__, lock)
-#else
-#define ANNOTATE_RWLOCK_CREATE_STATIC(lock) ANNOTATE_RWLOCK_CREATE(lock)
-#endif
-
-// Report that the lock at address `lock` is about to be destroyed.
-#define ANNOTATE_RWLOCK_DESTROY(lock) \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockDestroy)(__FILE__, __LINE__, lock)
-
-// Report that the lock at address `lock` has been acquired.
-// `is_w`=1 for writer lock, `is_w`=0 for reader lock.
-#define ANNOTATE_RWLOCK_ACQUIRED(lock, is_w)          \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockAcquired) \
-  (__FILE__, __LINE__, lock, is_w)
-
-// Report that the lock at address `lock` is about to be released.
-// `is_w`=1 for writer lock, `is_w`=0 for reader lock.
-#define ANNOTATE_RWLOCK_RELEASED(lock, is_w)          \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockReleased) \
-  (__FILE__, __LINE__, lock, is_w)
-
-// Apply ANNOTATE_BENIGN_RACE_SIZED to a static variable `static_var`.
-#define ANNOTATE_BENIGN_RACE_STATIC(static_var, description)      \
-  namespace {                                                     \
-  class static_var##_annotator {                                  \
-   public:                                                        \
-    static_var##_annotator() {                                    \
-      ANNOTATE_BENIGN_RACE_SIZED(&static_var, sizeof(static_var), \
-                                 #static_var ": " description);   \
-    }                                                             \
-  };                                                              \
-  static static_var##_annotator the##static_var##_annotator;      \
-  }  // namespace
-
-#else  // ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED == 0
-
-#define ANNOTATE_RWLOCK_CREATE(lock)                            // empty
-#define ANNOTATE_RWLOCK_CREATE_STATIC(lock)                     // empty
-#define ANNOTATE_RWLOCK_DESTROY(lock)                           // empty
-#define ANNOTATE_RWLOCK_ACQUIRED(lock, is_w)                    // empty
-#define ANNOTATE_RWLOCK_RELEASED(lock, is_w)                    // empty
-#define ANNOTATE_BENIGN_RACE(address, description)              // empty
-#define ANNOTATE_BENIGN_RACE_SIZED(address, size, description)  // empty
-#define ANNOTATE_THREAD_NAME(name)                              // empty
-#define ANNOTATE_ENABLE_RACE_DETECTION(enable)                  // empty
-#define ANNOTATE_BENIGN_RACE_STATIC(static_var, description)    // empty
-
-#endif  // ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED
-
-// -------------------------------------------------------------------------
-// Define memory annotations.
-
-#if ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED == 1
-
-#include <sanitizer/msan_interface.h>
-
-#define ANNOTATE_MEMORY_IS_INITIALIZED(address, size) \
-  __msan_unpoison(address, size)
-
-#define ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size) \
-  __msan_allocated_memory(address, size)
-
-#else  // ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED == 0
-
-#if DYNAMIC_ANNOTATIONS_ENABLED == 1
-#define ANNOTATE_MEMORY_IS_INITIALIZED(address, size) \
-  do {                                                \
-    (void)(address);                                  \
-    (void)(size);                                     \
-  } while (0)
-#define ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size) \
-  do {                                                  \
-    (void)(address);                                    \
-    (void)(size);                                       \
-  } while (0)
-#else
-#define ANNOTATE_MEMORY_IS_INITIALIZED(address, size)    // empty
-#define ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size)  // empty
-#endif
-
-#endif  // ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED
-
-// -------------------------------------------------------------------------
-// Define IGNORE_READS_BEGIN/_END attributes.
-
-#if defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
-
-#define ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE \
-  __attribute((exclusive_lock_function("*")))
-#define ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE \
-  __attribute((unlock_function("*")))
-
-#else  // !defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
-
-#define ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE  // empty
-#define ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE    // empty
-
-#endif  // defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
-
-// -------------------------------------------------------------------------
-// Define IGNORE_READS_BEGIN/_END annotations.
-
-#if ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED == 1
-
-// Request the analysis tool to ignore all reads in the current thread until
-// ANNOTATE_IGNORE_READS_END is called. Useful to ignore intentional racey
-// reads, while still checking other reads and all writes.
-// See also ANNOTATE_UNPROTECTED_READ.
-#define ANNOTATE_IGNORE_READS_BEGIN() \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsBegin)(__FILE__, __LINE__)
-
-// Stop ignoring reads.
-#define ANNOTATE_IGNORE_READS_END() \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsEnd)(__FILE__, __LINE__)
-
-#elif defined(ABSL_INTERNAL_ANNOTALYSIS_ENABLED)
-
-// When Annotalysis is enabled without Dynamic Annotations, the use of
-// static-inline functions allows the annotations to be read at compile-time,
-// while still letting the compiler elide the functions from the final build.
-//
-// TODO(delesley) -- The exclusive lock here ignores writes as well, but
-// allows IGNORE_READS_AND_WRITES to work properly.
-
-#define ANNOTATE_IGNORE_READS_BEGIN() \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AbslInternalAnnotateIgnoreReadsBegin)()
-
-#define ANNOTATE_IGNORE_READS_END() \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AbslInternalAnnotateIgnoreReadsEnd)()
-
-#else
-
-#define ANNOTATE_IGNORE_READS_BEGIN()  // empty
-#define ANNOTATE_IGNORE_READS_END()    // empty
-
-#endif
-
-// -------------------------------------------------------------------------
-// Define IGNORE_WRITES_BEGIN/_END annotations.
-
-#if ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED == 1
-
-// Similar to ANNOTATE_IGNORE_READS_BEGIN, but ignore writes instead.
-#define ANNOTATE_IGNORE_WRITES_BEGIN() \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreWritesBegin)(__FILE__, __LINE__)
-
-// Stop ignoring writes.
-#define ANNOTATE_IGNORE_WRITES_END() \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreWritesEnd)(__FILE__, __LINE__)
-
-#else
-
-#define ANNOTATE_IGNORE_WRITES_BEGIN()  // empty
-#define ANNOTATE_IGNORE_WRITES_END()    // empty
-
-#endif
-
-// -------------------------------------------------------------------------
-// Define the ANNOTATE_IGNORE_READS_AND_WRITES_* annotations using the more
-// primitive annotations defined above.
-//
-//     Instead of doing
-//        ANNOTATE_IGNORE_READS_BEGIN();
-//        ... = x;
-//        ANNOTATE_IGNORE_READS_END();
-//     one can use
-//        ... = ANNOTATE_UNPROTECTED_READ(x);
-
-#if defined(ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED)
-
-// Start ignoring all memory accesses (both reads and writes).
-#define ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN() \
-  do {                                           \
-    ANNOTATE_IGNORE_READS_BEGIN();               \
-    ANNOTATE_IGNORE_WRITES_BEGIN();              \
-  } while (0)
-
-// Stop ignoring both reads and writes.
-#define ANNOTATE_IGNORE_READS_AND_WRITES_END() \
-  do {                                         \
-    ANNOTATE_IGNORE_WRITES_END();              \
-    ANNOTATE_IGNORE_READS_END();               \
-  } while (0)
-
-#ifdef __cplusplus
-// ANNOTATE_UNPROTECTED_READ is the preferred way to annotate racey reads.
-#define ANNOTATE_UNPROTECTED_READ(x) \
-  y_absl::base_internal::AnnotateUnprotectedRead(x)
-
-#endif
-
-#else
-
-#define ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN()  // empty
-#define ANNOTATE_IGNORE_READS_AND_WRITES_END()    // empty
-#define ANNOTATE_UNPROTECTED_READ(x) (x)
-
-#endif
-
-// -------------------------------------------------------------------------
-// Address sanitizer annotations
-
-#ifdef ABSL_HAVE_ADDRESS_SANITIZER
-// Describe the current state of a contiguous container such as e.g.
-// std::vector or TString. For more details see
-// sanitizer/common_interface_defs.h, which is provided by the compiler.
-#include <sanitizer/common_interface_defs.h>
-
-#define ANNOTATE_CONTIGUOUS_CONTAINER(beg, end, old_mid, new_mid) \
-  __sanitizer_annotate_contiguous_container(beg, end, old_mid, new_mid)
-#define ADDRESS_SANITIZER_REDZONE(name)    \
-  struct {                                 \
-    char x[8] __attribute__((aligned(8))); \
-  } name
-
-#else
-
-#define ANNOTATE_CONTIGUOUS_CONTAINER(beg, end, old_mid, new_mid)
-#define ADDRESS_SANITIZER_REDZONE(name) static_assert(true, "")
-
-#endif  // ABSL_HAVE_ADDRESS_SANITIZER
-
-// -------------------------------------------------------------------------
-// Undefine the macros intended only for this file.
-
-#undef ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED
-#undef ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED
-#undef ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED
-#undef ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED
-#undef ABSL_INTERNAL_ANNOTALYSIS_ENABLED
-#undef ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED
-#undef ABSL_INTERNAL_BEGIN_EXTERN_C
-#undef ABSL_INTERNAL_END_EXTERN_C
-#undef ABSL_INTERNAL_STATIC_INLINE
-
-#endif  // ABSL_BASE_INTERNAL_DYNAMIC_ANNOTATIONS_H_
+// Copyright 2017 The Abseil Authors. 
+// 
+// Licensed under the Apache License, Version 2.0 (the "License"); 
+// you may not use this file except in compliance with the License. 
+// You may obtain a copy of the License at 
+// 
+//      https://www.apache.org/licenses/LICENSE-2.0 
+// 
+// Unless required by applicable law or agreed to in writing, software 
+// distributed under the License is distributed on an "AS IS" BASIS, 
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+// See the License for the specific language governing permissions and 
+// limitations under the License. 
+ 
+// This file defines dynamic annotations for use with dynamic analysis tool 
+// such as valgrind, PIN, etc. 
+// 
+// Dynamic annotation is a source code annotation that affects the generated 
+// code (that is, the annotation is not a comment). Each such annotation is 
+// attached to a particular instruction and/or to a particular object (address) 
+// in the program. 
+// 
+// The annotations that should be used by users are macros in all upper-case 
+// (e.g., ANNOTATE_THREAD_NAME). 
+// 
+// Actual implementation of these macros may differ depending on the dynamic 
+// analysis tool being used. 
+// 
+// This file supports the following configurations: 
+// - Dynamic Annotations enabled (with static thread-safety warnings disabled). 
+//   In this case, macros expand to functions implemented by Thread Sanitizer, 
+//   when building with TSan. When not provided an external implementation, 
+//   dynamic_annotations.cc provides no-op implementations. 
+// 
+// - Static Clang thread-safety warnings enabled. 
+//   When building with a Clang compiler that supports thread-safety warnings, 
+//   a subset of annotations can be statically-checked at compile-time. We 
+//   expand these macros to static-inline functions that can be analyzed for 
+//   thread-safety, but afterwards elided when building the final binary. 
+// 
+// - All annotations are disabled. 
+//   If neither Dynamic Annotations nor Clang thread-safety warnings are 
+//   enabled, then all annotation-macros expand to empty. 
+ 
+#ifndef ABSL_BASE_INTERNAL_DYNAMIC_ANNOTATIONS_H_ 
+#define ABSL_BASE_INTERNAL_DYNAMIC_ANNOTATIONS_H_ 
+ 
+#include <stddef.h> 
+ 
+#include "y_absl/base/config.h" 
+ 
+// ------------------------------------------------------------------------- 
+// Decide which features are enabled 
+ 
+#ifndef DYNAMIC_ANNOTATIONS_ENABLED 
+#define DYNAMIC_ANNOTATIONS_ENABLED 0 
+#endif 
+ 
+#if defined(__clang__) && !defined(SWIG) 
+#define ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED 1 
+#endif 
+ 
+#if DYNAMIC_ANNOTATIONS_ENABLED != 0 
+ 
+#define ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED 1 
+#define ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED 1 
+#define ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED 1 
+#define ABSL_INTERNAL_ANNOTALYSIS_ENABLED 0 
+#define ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED 1 
+ 
+#else 
+ 
+#define ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED 0 
+#define ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED 0 
+#define ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED 0 
+ 
+// Clang provides limited support for static thread-safety analysis through a 
+// feature called Annotalysis. We configure macro-definitions according to 
+// whether Annotalysis support is available. When running in opt-mode, GCC 
+// will issue a warning, if these attributes are compiled. Only include them 
+// when compiling using Clang. 
+ 
+// ANNOTALYSIS_ENABLED == 1 when IGNORE_READ_ATTRIBUTE_ENABLED == 1 
+#define ABSL_INTERNAL_ANNOTALYSIS_ENABLED \ 
+  defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED) 
+// Read/write annotations are enabled in Annotalysis mode; disabled otherwise. 
+#define ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED \ 
+  ABSL_INTERNAL_ANNOTALYSIS_ENABLED 
+#endif 
+ 
+// Memory annotations are also made available to LLVM's Memory Sanitizer 
+#if defined(ABSL_HAVE_MEMORY_SANITIZER) && !defined(__native_client__) 
+#define ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED 1 
+#endif 
+ 
+#ifndef ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED 
+#define ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED 0 
+#endif 
+ 
+#ifdef __cplusplus 
+#define ABSL_INTERNAL_BEGIN_EXTERN_C extern "C" { 
+#define ABSL_INTERNAL_END_EXTERN_C }  // extern "C" 
+#define ABSL_INTERNAL_GLOBAL_SCOPED(F) ::F 
+#define ABSL_INTERNAL_STATIC_INLINE inline 
+#else 
+#define ABSL_INTERNAL_BEGIN_EXTERN_C  // empty 
+#define ABSL_INTERNAL_END_EXTERN_C    // empty 
+#define ABSL_INTERNAL_GLOBAL_SCOPED(F) F 
+#define ABSL_INTERNAL_STATIC_INLINE static inline 
+#endif 
+ 
+// ------------------------------------------------------------------------- 
+// Define race annotations. 
+ 
+#if ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED == 1 
+ 
+// ------------------------------------------------------------- 
+// Annotations that suppress errors. It is usually better to express the 
+// program's synchronization using the other annotations, but these can be used 
+// when all else fails. 
+ 
+// Report that we may have a benign race at `pointer`, with size 
+// "sizeof(*(pointer))". `pointer` must be a non-void* pointer. Insert at the 
+// point where `pointer` has been allocated, preferably close to the point 
+// where the race happens. See also ANNOTATE_BENIGN_RACE_STATIC. 
+#define ANNOTATE_BENIGN_RACE(pointer, description)     \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateBenignRaceSized) \ 
+  (__FILE__, __LINE__, pointer, sizeof(*(pointer)), description) 
+ 
+// Same as ANNOTATE_BENIGN_RACE(`address`, `description`), but applies to 
+// the memory range [`address`, `address`+`size`). 
+#define ANNOTATE_BENIGN_RACE_SIZED(address, size, description) \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateBenignRaceSized)         \ 
+  (__FILE__, __LINE__, address, size, description) 
+ 
+// Enable (`enable`!=0) or disable (`enable`==0) race detection for all threads. 
+// This annotation could be useful if you want to skip expensive race analysis 
+// during some period of program execution, e.g. during initialization. 
+#define ANNOTATE_ENABLE_RACE_DETECTION(enable)             \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateEnableRaceDetection) \ 
+  (__FILE__, __LINE__, enable) 
+ 
+// ------------------------------------------------------------- 
+// Annotations useful for debugging. 
+ 
+// Report the current thread `name` to a race detector. 
+#define ANNOTATE_THREAD_NAME(name) \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateThreadName)(__FILE__, __LINE__, name) 
+ 
+// ------------------------------------------------------------- 
+// Annotations useful when implementing locks. They are not normally needed by 
+// modules that merely use locks. The `lock` argument is a pointer to the lock 
+// object. 
+ 
+// Report that a lock has been created at address `lock`. 
+#define ANNOTATE_RWLOCK_CREATE(lock) \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockCreate)(__FILE__, __LINE__, lock) 
+ 
+// Report that a linker initialized lock has been created at address `lock`. 
+#ifdef ABSL_HAVE_THREAD_SANITIZER 
+#define ANNOTATE_RWLOCK_CREATE_STATIC(lock)               \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockCreateStatic) \ 
+  (__FILE__, __LINE__, lock) 
+#else 
+#define ANNOTATE_RWLOCK_CREATE_STATIC(lock) ANNOTATE_RWLOCK_CREATE(lock) 
+#endif 
+ 
+// Report that the lock at address `lock` is about to be destroyed. 
+#define ANNOTATE_RWLOCK_DESTROY(lock) \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockDestroy)(__FILE__, __LINE__, lock) 
+ 
+// Report that the lock at address `lock` has been acquired. 
+// `is_w`=1 for writer lock, `is_w`=0 for reader lock. 
+#define ANNOTATE_RWLOCK_ACQUIRED(lock, is_w)          \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockAcquired) \ 
+  (__FILE__, __LINE__, lock, is_w) 
+ 
+// Report that the lock at address `lock` is about to be released. 
+// `is_w`=1 for writer lock, `is_w`=0 for reader lock. 
+#define ANNOTATE_RWLOCK_RELEASED(lock, is_w)          \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockReleased) \ 
+  (__FILE__, __LINE__, lock, is_w) 
+ 
+// Apply ANNOTATE_BENIGN_RACE_SIZED to a static variable `static_var`. 
+#define ANNOTATE_BENIGN_RACE_STATIC(static_var, description)      \ 
+  namespace {                                                     \ 
+  class static_var##_annotator {                                  \ 
+   public:                                                        \ 
+    static_var##_annotator() {                                    \ 
+      ANNOTATE_BENIGN_RACE_SIZED(&static_var, sizeof(static_var), \ 
+                                 #static_var ": " description);   \ 
+    }                                                             \ 
+  };                                                              \ 
+  static static_var##_annotator the##static_var##_annotator;      \ 
+  }  // namespace 
+ 
+#else  // ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED == 0 
+ 
+#define ANNOTATE_RWLOCK_CREATE(lock)                            // empty 
+#define ANNOTATE_RWLOCK_CREATE_STATIC(lock)                     // empty 
+#define ANNOTATE_RWLOCK_DESTROY(lock)                           // empty 
+#define ANNOTATE_RWLOCK_ACQUIRED(lock, is_w)                    // empty 
+#define ANNOTATE_RWLOCK_RELEASED(lock, is_w)                    // empty 
+#define ANNOTATE_BENIGN_RACE(address, description)              // empty 
+#define ANNOTATE_BENIGN_RACE_SIZED(address, size, description)  // empty 
+#define ANNOTATE_THREAD_NAME(name)                              // empty 
+#define ANNOTATE_ENABLE_RACE_DETECTION(enable)                  // empty 
+#define ANNOTATE_BENIGN_RACE_STATIC(static_var, description)    // empty 
+ 
+#endif  // ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED 
+ 
+// ------------------------------------------------------------------------- 
+// Define memory annotations. 
+ 
+#if ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED == 1 
+ 
+#include <sanitizer/msan_interface.h> 
+ 
+#define ANNOTATE_MEMORY_IS_INITIALIZED(address, size) \ 
+  __msan_unpoison(address, size) 
+ 
+#define ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size) \ 
+  __msan_allocated_memory(address, size) 
+ 
+#else  // ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED == 0 
+ 
+#if DYNAMIC_ANNOTATIONS_ENABLED == 1 
+#define ANNOTATE_MEMORY_IS_INITIALIZED(address, size) \ 
+  do {                                                \ 
+    (void)(address);                                  \ 
+    (void)(size);                                     \ 
+  } while (0) 
+#define ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size) \ 
+  do {                                                  \ 
+    (void)(address);                                    \ 
+    (void)(size);                                       \ 
+  } while (0) 
+#else 
+#define ANNOTATE_MEMORY_IS_INITIALIZED(address, size)    // empty 
+#define ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size)  // empty 
+#endif 
+ 
+#endif  // ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED 
+ 
+// ------------------------------------------------------------------------- 
+// Define IGNORE_READS_BEGIN/_END attributes. 
+ 
+#if defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED) 
+ 
+#define ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE \ 
+  __attribute((exclusive_lock_function("*"))) 
+#define ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE \ 
+  __attribute((unlock_function("*"))) 
+ 
+#else  // !defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED) 
+ 
+#define ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE  // empty 
+#define ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE    // empty 
+ 
+#endif  // defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED) 
+ 
+// ------------------------------------------------------------------------- 
+// Define IGNORE_READS_BEGIN/_END annotations. 
+ 
+#if ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED == 1 
+ 
+// Request the analysis tool to ignore all reads in the current thread until 
+// ANNOTATE_IGNORE_READS_END is called. Useful to ignore intentional racey 
+// reads, while still checking other reads and all writes. 
+// See also ANNOTATE_UNPROTECTED_READ. 
+#define ANNOTATE_IGNORE_READS_BEGIN() \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsBegin)(__FILE__, __LINE__) 
+ 
+// Stop ignoring reads. 
+#define ANNOTATE_IGNORE_READS_END() \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsEnd)(__FILE__, __LINE__) 
+ 
+#elif defined(ABSL_INTERNAL_ANNOTALYSIS_ENABLED) 
+ 
+// When Annotalysis is enabled without Dynamic Annotations, the use of 
+// static-inline functions allows the annotations to be read at compile-time, 
+// while still letting the compiler elide the functions from the final build. 
+// 
+// TODO(delesley) -- The exclusive lock here ignores writes as well, but 
+// allows IGNORE_READS_AND_WRITES to work properly. 
+ 
+#define ANNOTATE_IGNORE_READS_BEGIN() \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(AbslInternalAnnotateIgnoreReadsBegin)() 
+ 
+#define ANNOTATE_IGNORE_READS_END() \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(AbslInternalAnnotateIgnoreReadsEnd)() 
+ 
+#else 
+ 
+#define ANNOTATE_IGNORE_READS_BEGIN()  // empty 
+#define ANNOTATE_IGNORE_READS_END()    // empty 
+ 
+#endif 
+ 
+// ------------------------------------------------------------------------- 
+// Define IGNORE_WRITES_BEGIN/_END annotations. 
+ 
+#if ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED == 1 
+ 
+// Similar to ANNOTATE_IGNORE_READS_BEGIN, but ignore writes instead. 
+#define ANNOTATE_IGNORE_WRITES_BEGIN() \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreWritesBegin)(__FILE__, __LINE__) 
+ 
+// Stop ignoring writes. 
+#define ANNOTATE_IGNORE_WRITES_END() \ 
+  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreWritesEnd)(__FILE__, __LINE__) 
+ 
+#else 
+ 
+#define ANNOTATE_IGNORE_WRITES_BEGIN()  // empty 
+#define ANNOTATE_IGNORE_WRITES_END()    // empty 
+ 
+#endif 
+ 
+// ------------------------------------------------------------------------- 
+// Define the ANNOTATE_IGNORE_READS_AND_WRITES_* annotations using the more 
+// primitive annotations defined above. 
+// 
+//     Instead of doing 
+//        ANNOTATE_IGNORE_READS_BEGIN(); 
+//        ... = x; 
+//        ANNOTATE_IGNORE_READS_END(); 
+//     one can use 
+//        ... = ANNOTATE_UNPROTECTED_READ(x); 
+ 
+#if defined(ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED) 
+ 
+// Start ignoring all memory accesses (both reads and writes). 
+#define ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN() \ 
+  do {                                           \ 
+    ANNOTATE_IGNORE_READS_BEGIN();               \ 
+    ANNOTATE_IGNORE_WRITES_BEGIN();              \ 
+  } while (0) 
+ 
+// Stop ignoring both reads and writes. 
+#define ANNOTATE_IGNORE_READS_AND_WRITES_END() \ 
+  do {                                         \ 
+    ANNOTATE_IGNORE_WRITES_END();              \ 
+    ANNOTATE_IGNORE_READS_END();               \ 
+  } while (0) 
+ 
+#ifdef __cplusplus 
+// ANNOTATE_UNPROTECTED_READ is the preferred way to annotate racey reads. 
+#define ANNOTATE_UNPROTECTED_READ(x) \ 
+  y_absl::base_internal::AnnotateUnprotectedRead(x) 
+ 
+#endif 
+ 
+#else 
+ 
+#define ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN()  // empty 
+#define ANNOTATE_IGNORE_READS_AND_WRITES_END()    // empty 
+#define ANNOTATE_UNPROTECTED_READ(x) (x) 
+ 
+#endif 
+ 
+// ------------------------------------------------------------------------- 
+// Address sanitizer annotations 
+ 
+#ifdef ABSL_HAVE_ADDRESS_SANITIZER 
+// Describe the current state of a contiguous container such as e.g. 
+// std::vector or TString. For more details see 
+// sanitizer/common_interface_defs.h, which is provided by the compiler. 
+#include <sanitizer/common_interface_defs.h> 
+ 
+#define ANNOTATE_CONTIGUOUS_CONTAINER(beg, end, old_mid, new_mid) \ 
+  __sanitizer_annotate_contiguous_container(beg, end, old_mid, new_mid) 
+#define ADDRESS_SANITIZER_REDZONE(name)    \ 
+  struct {                                 \ 
+    char x[8] __attribute__((aligned(8))); \ 
+  } name 
+ 
+#else 
+ 
+#define ANNOTATE_CONTIGUOUS_CONTAINER(beg, end, old_mid, new_mid) 
+#define ADDRESS_SANITIZER_REDZONE(name) static_assert(true, "") 
+ 
+#endif  // ABSL_HAVE_ADDRESS_SANITIZER 
+ 
+// ------------------------------------------------------------------------- 
+// Undefine the macros intended only for this file. 
+ 
+#undef ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED 
+#undef ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED 
+#undef ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED 
+#undef ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED 
+#undef ABSL_INTERNAL_ANNOTALYSIS_ENABLED 
+#undef ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED 
+#undef ABSL_INTERNAL_BEGIN_EXTERN_C 
+#undef ABSL_INTERNAL_END_EXTERN_C 
+#undef ABSL_INTERNAL_STATIC_INLINE 
+ 
+#endif  // ABSL_BASE_INTERNAL_DYNAMIC_ANNOTATIONS_H_ 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/endian.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/endian.h
index 0f7adb8bf6..d11a9a5ae8 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/endian.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/endian.h
@@ -26,7 +26,7 @@
 #endif
 
 #include <cstdint>
-#include "y_absl/base/casts.h"
+#include "y_absl/base/casts.h" 
 #include "y_absl/base/config.h"
 #include "y_absl/base/internal/unaligned_access.h"
 #include "y_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-tstring/y_absl/base/internal/fast_type_id.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/fast_type_id.h
index c82cba7b4a..1ab47fc376 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/fast_type_id.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/fast_type_id.h
@@ -1,48 +1,48 @@
-//
-// 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_BASE_INTERNAL_FAST_TYPE_ID_H_
-#define ABSL_BASE_INTERNAL_FAST_TYPE_ID_H_
-
-#include "y_absl/base/config.h"
-
-namespace y_absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-template <typename Type>
-struct FastTypeTag {
-  constexpr static char dummy_var = 0;
-};
-
-template <typename Type>
-constexpr char FastTypeTag<Type>::dummy_var;
-
-// FastTypeId<Type>() evaluates at compile/link-time to a unique pointer for the
-// passed-in type. These are meant to be good match for keys into maps or
-// straight up comparisons.
-using FastTypeIdType = const void*;
-
-template <typename Type>
-constexpr inline FastTypeIdType FastTypeId() {
-  return &FastTypeTag<Type>::dummy_var;
-}
-
-}  // namespace base_internal
-ABSL_NAMESPACE_END
-}  // namespace y_absl
-
-#endif  // ABSL_BASE_INTERNAL_FAST_TYPE_ID_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_BASE_INTERNAL_FAST_TYPE_ID_H_ 
+#define ABSL_BASE_INTERNAL_FAST_TYPE_ID_H_ 
+ 
+#include "y_absl/base/config.h" 
+ 
+namespace y_absl { 
+ABSL_NAMESPACE_BEGIN 
+namespace base_internal { 
+ 
+template <typename Type> 
+struct FastTypeTag { 
+  constexpr static char dummy_var = 0; 
+}; 
+ 
+template <typename Type> 
+constexpr char FastTypeTag<Type>::dummy_var; 
+ 
+// FastTypeId<Type>() evaluates at compile/link-time to a unique pointer for the 
+// passed-in type. These are meant to be good match for keys into maps or 
+// straight up comparisons. 
+using FastTypeIdType = const void*; 
+ 
+template <typename Type> 
+constexpr inline FastTypeIdType FastTypeId() { 
+  return &FastTypeTag<Type>::dummy_var; 
+} 
+ 
+}  // namespace base_internal 
+ABSL_NAMESPACE_END 
+}  // namespace y_absl 
+ 
+#endif  // ABSL_BASE_INTERNAL_FAST_TYPE_ID_H_ 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/invoke.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/invoke.h
index 928666ff44..21f6c309a1 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/invoke.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/invoke.h
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
-// y_absl::base_internal::invoke(f, args...) is an implementation of
+// y_absl::base_internal::invoke(f, args...) is an implementation of 
 // INVOKE(f, args...) from section [func.require] of the C++ standard.
 //
 // [func.require]
@@ -29,7 +29,7 @@
 //    is not one of the types described in the previous item;
 // 5. f(t1, t2, ..., tN) in all other cases.
 //
-// The implementation is SFINAE-friendly: substitution failure within invoke()
+// The implementation is SFINAE-friendly: substitution failure within invoke() 
 // isn't an error.
 
 #ifndef ABSL_BASE_INTERNAL_INVOKE_H_
@@ -170,13 +170,13 @@ struct Invoker {
 
 // The result type of Invoke<F, Args...>.
 template <typename F, typename... Args>
-using invoke_result_t = decltype(Invoker<F, Args...>::type::Invoke(
+using invoke_result_t = decltype(Invoker<F, Args...>::type::Invoke( 
     std::declval<F>(), std::declval<Args>()...));
 
 // Invoke(f, args...) is an implementation of INVOKE(f, args...) from section
 // [func.require] of the C++ standard.
 template <typename F, typename... Args>
-invoke_result_t<F, Args...> invoke(F&& f, Args&&... args) {
+invoke_result_t<F, Args...> invoke(F&& f, Args&&... args) { 
   return Invoker<F, Args...>::type::Invoke(std::forward<F>(f),
                                            std::forward<Args>(args)...);
 }
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc.cc
index 0c477d1b28..e1e439cc04 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc.cc
@@ -598,7 +598,7 @@ static void *DoAllocWithArena(size_t request, LowLevelAlloc::Arena *arena) {
     section.Leave();
     result = &s->levels;
   }
-  ABSL_ANNOTATE_MEMORY_IS_UNINITIALIZED(result, request);
+  ABSL_ANNOTATE_MEMORY_IS_UNINITIALIZED(result, request); 
   return result;
 }
 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc/ya.make
index fabba74677..77fcf095a4 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc/ya.make
@@ -2,13 +2,13 @@
 
 LIBRARY()
 
-WITHOUT_LICENSE_TEXTS()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
+WITHOUT_LICENSE_TEXTS() 
 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
 LICENSE(Apache-2.0)
 
 PEERDIR(
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_scheduling.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_scheduling.h
index 61eb4ac643..012b199385 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_scheduling.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_scheduling.h
@@ -18,7 +18,7 @@
 #ifndef ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_
 #define ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_
 
-#include "y_absl/base/internal/raw_logging.h"
+#include "y_absl/base/internal/raw_logging.h" 
 #include "y_absl/base/internal/scheduling_mode.h"
 #include "y_absl/base/macros.h"
 
@@ -30,13 +30,13 @@ extern "C" void __google_enable_rescheduling(bool disable_result);
 
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-class CondVar;
-class Mutex;
-
-namespace synchronization_internal {
-int MutexDelay(int32_t c, int mode);
-}  // namespace synchronization_internal
-
+class CondVar; 
+class Mutex; 
+ 
+namespace synchronization_internal { 
+int MutexDelay(int32_t c, int mode); 
+}  // namespace synchronization_internal 
+ 
 namespace base_internal {
 
 class SchedulingHelper;  // To allow use of SchedulingGuard.
@@ -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
@@ -86,23 +86,23 @@ class SchedulingGuard {
     bool disabled;
   };
 
-  // A scoped helper to enable rescheduling temporarily.
-  // REQUIRES: destructor must run in same thread as constructor.
-  class ScopedEnable {
-   public:
-    ScopedEnable();
-    ~ScopedEnable();
-
-   private:
-    int scheduling_disabled_depth_;
-  };
-
-  // Access to SchedulingGuard is explicitly permitted.
-  friend class y_absl::CondVar;
-  friend class y_absl::Mutex;
+  // A scoped helper to enable rescheduling temporarily. 
+  // REQUIRES: destructor must run in same thread as constructor. 
+  class ScopedEnable { 
+   public: 
+    ScopedEnable(); 
+    ~ScopedEnable(); 
+ 
+   private: 
+    int scheduling_disabled_depth_; 
+  }; 
+ 
+  // Access to SchedulingGuard is explicitly permitted. 
+  friend class y_absl::CondVar; 
+  friend class y_absl::Mutex; 
   friend class SchedulingHelper;
   friend class SpinLock;
-  friend int y_absl::synchronization_internal::MutexDelay(int32_t c, int mode);
+  friend int y_absl::synchronization_internal::MutexDelay(int32_t c, int mode); 
 };
 
 //------------------------------------------------------------------------------
@@ -121,12 +121,12 @@ inline void SchedulingGuard::EnableRescheduling(bool /* disable_result */) {
   return;
 }
 
-inline SchedulingGuard::ScopedEnable::ScopedEnable()
-    : scheduling_disabled_depth_(0) {}
-inline SchedulingGuard::ScopedEnable::~ScopedEnable() {
-  ABSL_RAW_CHECK(scheduling_disabled_depth_ == 0, "disable unused warning");
-}
-
+inline SchedulingGuard::ScopedEnable::ScopedEnable() 
+    : scheduling_disabled_depth_(0) {} 
+inline SchedulingGuard::ScopedEnable::~ScopedEnable() { 
+  ABSL_RAW_CHECK(scheduling_disabled_depth_ == 0, "disable unused warning"); 
+} 
+ 
 }  // namespace base_internal
 ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging.cc
index ea9a48c2c0..4fe222e723 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging.cc
@@ -67,32 +67,32 @@
 #undef ABSL_HAVE_RAW_IO
 #endif
 
-namespace y_absl {
-ABSL_NAMESPACE_BEGIN
-namespace raw_logging_internal {
-namespace {
-
+namespace y_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
-    y_absl::base_internal::AtomicHook<LogPrefixHook>
-        log_prefix_hook;
-ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES
-    y_absl::base_internal::AtomicHook<AbortHook>
-        abort_hook;
+ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES 
+    y_absl::base_internal::AtomicHook<LogPrefixHook> 
+        log_prefix_hook; 
+ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES 
+    y_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(y_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(y_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(y_absl::LogSeverity severity, const char* file, int line,
-                        const TString& 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(y_absl::LogSeverity severity, const char* file, int line, 
+                        const TString& message) { 
+  RawLog(severity, file, line, "%.*s", static_cast<int>(message.size()), 
+         message.data()); 
+} 
+ 
 }  // namespace
 
 void SafeWriteToStderr(const char *s, size_t len) {
@@ -225,14 +225,14 @@ bool RawLoggingFullySupported() {
 #endif  // !ABSL_LOW_LEVEL_WRITE_SUPPORTED
 }
 
-ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES ABSL_DLL
+ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES ABSL_DLL 
     y_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-tstring/y_absl/base/internal/raw_logging.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging.h
index 4d5c77003f..cd6603335b 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_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__;     \
-    ::y_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 == ::y_absl::LogSeverity::kFatal) \
-      ABSL_INTERNAL_UNREACHABLE;                                             \
+#define ABSL_INTERNAL_LOG(severity, message)                                 \ 
+  do {                                                                       \ 
+    constexpr const char* absl_raw_logging_internal_filename = __FILE__;     \ 
+    ::y_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 == ::y_absl::LogSeverity::kFatal) \ 
+      ABSL_INTERNAL_UNREACHABLE;                                             \ 
   } while (0)
 
 #define ABSL_INTERNAL_CHECK(condition, message)                    \
@@ -174,18 +174,18 @@ using InternalLogFunction = void (*)(y_absl::LogSeverity severity,
                                      const char* file, int line,
                                      const TString& message);
 
-ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES ABSL_DLL extern base_internal::AtomicHook<
+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-tstring/y_absl/base/internal/raw_logging/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging/ya.make
index e7cfe7d216..dbfdc41134 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging/ya.make
@@ -2,13 +2,13 @@
 
 LIBRARY()
 
-WITHOUT_LICENSE_TEXTS()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
+WITHOUT_LICENSE_TEXTS() 
 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
 LICENSE(Apache-2.0)
 
 PEERDIR(
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock.cc
index 2ee7cde432..ee7e4476c1 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock.cc
@@ -66,13 +66,13 @@ void RegisterSpinLockProfiler(void (*fn)(const void *contendedlock,
   submit_profile_data.Store(fn);
 }
 
-// Static member variable definitions.
-constexpr uint32_t SpinLock::kSpinLockHeld;
-constexpr uint32_t SpinLock::kSpinLockCooperative;
-constexpr uint32_t SpinLock::kSpinLockDisabledScheduling;
-constexpr uint32_t SpinLock::kSpinLockSleeper;
-constexpr uint32_t SpinLock::kWaitTimeMask;
-
+// Static member variable definitions. 
+constexpr uint32_t SpinLock::kSpinLockHeld; 
+constexpr uint32_t SpinLock::kSpinLockCooperative; 
+constexpr uint32_t SpinLock::kSpinLockDisabledScheduling; 
+constexpr uint32_t SpinLock::kSpinLockSleeper; 
+constexpr uint32_t SpinLock::kWaitTimeMask; 
+ 
 // Uncommon constructors.
 SpinLock::SpinLock(base_internal::SchedulingMode mode)
     : lockword_(IsCooperative(mode) ? kSpinLockCooperative : 0) {
@@ -105,14 +105,14 @@ void SpinLock::SlowLock() {
   if ((lock_value & kSpinLockHeld) == 0) {
     return;
   }
-
-  base_internal::SchedulingMode scheduling_mode;
-  if ((lock_value & kSpinLockCooperative) != 0) {
-    scheduling_mode = base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL;
-  } else {
-    scheduling_mode = base_internal::SCHEDULE_KERNEL_ONLY;
-  }
-
+ 
+  base_internal::SchedulingMode scheduling_mode; 
+  if ((lock_value & kSpinLockCooperative) != 0) { 
+    scheduling_mode = base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL; 
+  } else { 
+    scheduling_mode = base_internal::SCHEDULE_KERNEL_ONLY; 
+  } 
+ 
   // The lock was not obtained initially, so this thread needs to wait for
   // it.  Record the current timestamp in the local variable wait_start_time
   // so the total wait time can be stored in the lockword once this thread
@@ -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; 
       }
     }
 
@@ -185,32 +185,32 @@ void SpinLock::SlowUnlock(uint32_t lock_value) {
 // We use the upper 29 bits of the lock word to store the time spent waiting to
 // acquire this lock.  This is reported by contentionz profiling.  Since the
 // lower bits of the cycle counter wrap very quickly on high-frequency
-// processors we divide to reduce the granularity to 2^kProfileTimestampShift
+// processors we divide to reduce the granularity to 2^kProfileTimestampShift 
 // sized units.  On a 4Ghz machine this will lose track of wait times greater
 // than (2^29/4 Ghz)*128 =~ 17.2 seconds.  Such waits should be extremely rare.
-static constexpr int kProfileTimestampShift = 7;
-
-// We currently reserve the lower 3 bits.
-static constexpr int kLockwordReservedShift = 3;
+static constexpr int kProfileTimestampShift = 7; 
 
+// We currently reserve the lower 3 bits. 
+static constexpr int kLockwordReservedShift = 3; 
+ 
 uint32_t SpinLock::EncodeWaitCycles(int64_t wait_start_time,
                                     int64_t wait_end_time) {
   static const int64_t kMaxWaitTime =
-      std::numeric_limits<uint32_t>::max() >> kLockwordReservedShift;
+      std::numeric_limits<uint32_t>::max() >> kLockwordReservedShift; 
   int64_t scaled_wait_time =
-      (wait_end_time - wait_start_time) >> kProfileTimestampShift;
+      (wait_end_time - wait_start_time) >> kProfileTimestampShift; 
 
   // Return a representation of the time spent waiting that can be stored in
   // the lock word's upper bits.
   uint32_t clamped = static_cast<uint32_t>(
-      std::min(scaled_wait_time, kMaxWaitTime) << kLockwordReservedShift);
+      std::min(scaled_wait_time, kMaxWaitTime) << kLockwordReservedShift); 
 
   if (clamped == 0) {
     return kSpinLockSleeper;  // Just wake waiters, but don't record contention.
   }
   // Bump up value if necessary to avoid returning kSpinLockSleeper.
   const uint32_t kMinWaitTime =
-      kSpinLockSleeper + (1 << kLockwordReservedShift);
+      kSpinLockSleeper + (1 << kLockwordReservedShift); 
   if (clamped == kSpinLockSleeper) {
     return kMinWaitTime;
   }
@@ -221,7 +221,7 @@ uint64_t SpinLock::DecodeWaitCycles(uint32_t lock_value) {
   // Cast to uint32_t first to ensure bits [63:32] are cleared.
   const uint64_t scaled_wait_time =
       static_cast<uint32_t>(lock_value & kWaitTimeMask);
-  return scaled_wait_time << (kProfileTimestampShift - kLockwordReservedShift);
+  return scaled_wait_time << (kProfileTimestampShift - kLockwordReservedShift); 
 }
 
 }  // namespace base_internal
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock.h
index ef88cb52c0..3b636840d2 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_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)
 
@@ -35,7 +35,7 @@
 #include <atomic>
 
 #include "y_absl/base/attributes.h"
-#include "y_absl/base/const_init.h"
+#include "y_absl/base/const_init.h" 
 #include "y_absl/base/dynamic_annotations.h"
 #include "y_absl/base/internal/low_level_scheduling.h"
 #include "y_absl/base/internal/raw_logging.h"
@@ -59,18 +59,18 @@ class ABSL_LOCKABLE SpinLock {
   // inside thread schedulers.  Normal clients should not use these.
   explicit SpinLock(base_internal::SchedulingMode mode);
 
-  // Constructor for global SpinLock instances.  See y_absl/base/const_init.h.
-  constexpr SpinLock(y_absl::ConstInitType, base_internal::SchedulingMode mode)
-      : lockword_(IsCooperative(mode) ? kSpinLockCooperative : 0) {}
-
-  // For global SpinLock instances prefer trivial destructor when possible.
-  // Default but non-trivial destructor in some build configurations causes an
-  // extra static initializer.
-#ifdef ABSL_INTERNAL_HAVE_TSAN_INTERFACE
+  // Constructor for global SpinLock instances.  See y_absl/base/const_init.h. 
+  constexpr SpinLock(y_absl::ConstInitType, base_internal::SchedulingMode mode) 
+      : lockword_(IsCooperative(mode) ? kSpinLockCooperative : 0) {} 
+ 
+  // For global SpinLock instances prefer trivial destructor when possible. 
+  // Default but non-trivial destructor in some build configurations causes an 
+  // extra static initializer. 
+#ifdef ABSL_INTERNAL_HAVE_TSAN_INTERFACE 
   ~SpinLock() { ABSL_TSAN_MUTEX_DESTROY(this, __tsan_mutex_not_static); }
-#else
-  ~SpinLock() = default;
-#endif
+#else 
+  ~SpinLock() = default; 
+#endif 
 
   // Acquire this SpinLock.
   inline void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() {
@@ -139,27 +139,27 @@ 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.
-  static constexpr uint32_t kSpinLockHeld = 1;
-  static constexpr uint32_t kSpinLockCooperative = 2;
-  static constexpr uint32_t kSpinLockDisabledScheduling = 4;
-  static constexpr uint32_t kSpinLockSleeper = 8;
-  // Includes kSpinLockSleeper.
-  static constexpr uint32_t kWaitTimeMask =
-      ~(kSpinLockHeld | kSpinLockCooperative | kSpinLockDisabledScheduling);
+  //        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; 
+  static constexpr uint32_t kSpinLockSleeper = 8; 
+  // Includes kSpinLockSleeper. 
+  static constexpr uint32_t kWaitTimeMask = 
+      ~(kSpinLockHeld | kSpinLockCooperative | kSpinLockDisabledScheduling); 
 
   // Returns true if the provided scheduling mode is cooperative.
   static constexpr bool IsCooperative(
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_akaros.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_akaros.inc
index 69955dc765..bf2bfcac7c 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_akaros.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_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 */, y_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-tstring/y_absl/base/internal/spinlock_linux.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_linux.inc
index 5b4480d133..a2237a3f48 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_linux.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_linux.inc
@@ -46,17 +46,17 @@ static_assert(sizeof(std::atomic<uint32_t>) == sizeof(int),
 #endif
 #endif
 
-#if defined(__NR_futex_time64) && !defined(SYS_futex_time64)
-#define SYS_futex_time64 __NR_futex_time64
-#endif
-
-#if defined(SYS_futex_time64) && !defined(SYS_futex)
-#define SYS_futex SYS_futex_time64
-#endif
-
+#if defined(__NR_futex_time64) && !defined(SYS_futex_time64) 
+#define SYS_futex_time64 __NR_futex_time64 
+#endif 
+ 
+#if defined(SYS_futex_time64) && !defined(SYS_futex) 
+#define SYS_futex SYS_futex_time64 
+#endif 
+ 
 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,
     y_absl::base_internal::SchedulingMode) {
   y_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-tstring/y_absl/base/internal/spinlock_posix.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_posix.inc
index 12a9b86599..0c692f2d3d 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_posix.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_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,
     y_absl::base_internal::SchedulingMode /* mode */) {
   y_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-tstring/y_absl/base/internal/spinlock_wait.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait.h
index 2e34d7026b..782361d0c0 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_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,
     y_absl::base_internal::SchedulingMode scheduling_mode);
 }
 
 inline void y_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 y_absl::base_internal::SpinLockDelay(
     std::atomic<uint32_t> *w, uint32_t value, int loop,
     y_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-tstring/y_absl/base/internal/spinlock_wait/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait/ya.make
index 902ffe394f..a31df9455b 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait/ya.make
@@ -2,13 +2,13 @@
 
 LIBRARY()
 
-WITHOUT_LICENSE_TEXTS()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
+WITHOUT_LICENSE_TEXTS() 
 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
 LICENSE(Apache-2.0)
 
 ADDINCL(
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_win32.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_win32.inc
index 648f74134f..3d5d662335 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_win32.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_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,
-    y_absl::base_internal::SchedulingMode /* mode */) {
+void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)( 
+    std::atomic<uint32_t>* /* lock_word */, uint32_t /* value */, int loop, 
+    y_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-tstring/y_absl/base/internal/strerror.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/strerror.cc
index fe50d84a03..5d8deec11a 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/strerror.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/strerror.cc
@@ -1,88 +1,88 @@
-// 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 "y_absl/base/internal/strerror.h"
-
-#include <array>
-#include <cerrno>
-#include <cstddef>
-#include <cstdio>
-#include <cstring>
-#include <util/generic/string.h>
-#include <type_traits>
-
-#include "y_absl/base/internal/errno_saver.h"
-
-namespace y_absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-namespace {
-
-const char* StrErrorAdaptor(int errnum, char* buf, size_t buflen) {
-#if defined(_WIN32)
-  int rc = strerror_s(buf, buflen, errnum);
-  buf[buflen - 1] = '\0';  // guarantee NUL termination
-  if (rc == 0 && strncmp(buf, "Unknown error", buflen) == 0) *buf = '\0';
-  return buf;
-#else
-  // The type of `ret` is platform-specific; both of these branches must compile
-  // either way but only one will execute on any given platform:
-  auto ret = strerror_r(errnum, buf, buflen);
-  if (std::is_same<decltype(ret), int>::value) {
-    // XSI `strerror_r`; `ret` is `int`:
-    if (ret) *buf = '\0';
-    return buf;
-  } else {
-    // GNU `strerror_r`; `ret` is `char *`:
-    return reinterpret_cast<const char*>(ret);
-  }
-#endif
-}
-
-TString StrErrorInternal(int errnum) {
-  char buf[100];
-  const char* str = StrErrorAdaptor(errnum, buf, sizeof buf);
-  if (*str == '\0') {
-    snprintf(buf, sizeof buf, "Unknown error %d", errnum);
-    str = buf;
-  }
-  return str;
-}
-
-// kSysNerr is the number of errors from a recent glibc. `StrError()` falls back
-// to `StrErrorAdaptor()` if the value is larger than this.
-constexpr int kSysNerr = 135;
-
-std::array<TString, kSysNerr>* NewStrErrorTable() {
-  auto* table = new std::array<TString, kSysNerr>;
-  for (int i = 0; i < static_cast<int>(table->size()); ++i) {
-    (*table)[i] = StrErrorInternal(i);
-  }
-  return table;
-}
-
-}  // namespace
-
-TString StrError(int errnum) {
-  y_absl::base_internal::ErrnoSaver errno_saver;
-  static const auto* table = NewStrErrorTable();
-  if (errnum >= 0 && errnum < static_cast<int>(table->size())) {
-    return (*table)[errnum];
-  }
-  return StrErrorInternal(errnum);
-}
-
-}  // namespace base_internal
-ABSL_NAMESPACE_END
-}  // namespace y_absl
+// 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 "y_absl/base/internal/strerror.h" 
+ 
+#include <array> 
+#include <cerrno> 
+#include <cstddef> 
+#include <cstdio> 
+#include <cstring> 
+#include <util/generic/string.h> 
+#include <type_traits> 
+ 
+#include "y_absl/base/internal/errno_saver.h" 
+ 
+namespace y_absl { 
+ABSL_NAMESPACE_BEGIN 
+namespace base_internal { 
+namespace { 
+ 
+const char* StrErrorAdaptor(int errnum, char* buf, size_t buflen) { 
+#if defined(_WIN32) 
+  int rc = strerror_s(buf, buflen, errnum); 
+  buf[buflen - 1] = '\0';  // guarantee NUL termination 
+  if (rc == 0 && strncmp(buf, "Unknown error", buflen) == 0) *buf = '\0'; 
+  return buf; 
+#else 
+  // The type of `ret` is platform-specific; both of these branches must compile 
+  // either way but only one will execute on any given platform: 
+  auto ret = strerror_r(errnum, buf, buflen); 
+  if (std::is_same<decltype(ret), int>::value) { 
+    // XSI `strerror_r`; `ret` is `int`: 
+    if (ret) *buf = '\0'; 
+    return buf; 
+  } else { 
+    // GNU `strerror_r`; `ret` is `char *`: 
+    return reinterpret_cast<const char*>(ret); 
+  } 
+#endif 
+} 
+ 
+TString StrErrorInternal(int errnum) { 
+  char buf[100]; 
+  const char* str = StrErrorAdaptor(errnum, buf, sizeof buf); 
+  if (*str == '\0') { 
+    snprintf(buf, sizeof buf, "Unknown error %d", errnum); 
+    str = buf; 
+  } 
+  return str; 
+} 
+ 
+// kSysNerr is the number of errors from a recent glibc. `StrError()` falls back 
+// to `StrErrorAdaptor()` if the value is larger than this. 
+constexpr int kSysNerr = 135; 
+ 
+std::array<TString, kSysNerr>* NewStrErrorTable() { 
+  auto* table = new std::array<TString, kSysNerr>; 
+  for (int i = 0; i < static_cast<int>(table->size()); ++i) { 
+    (*table)[i] = StrErrorInternal(i); 
+  } 
+  return table; 
+} 
+ 
+}  // namespace 
+ 
+TString StrError(int errnum) { 
+  y_absl::base_internal::ErrnoSaver errno_saver; 
+  static const auto* table = NewStrErrorTable(); 
+  if (errnum >= 0 && errnum < static_cast<int>(table->size())) { 
+    return (*table)[errnum]; 
+  } 
+  return StrErrorInternal(errnum); 
+} 
+ 
+}  // namespace base_internal 
+ABSL_NAMESPACE_END 
+}  // namespace y_absl 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/strerror.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/strerror.h
index a80a7b9c35..00479ab9eb 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/strerror.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/strerror.h
@@ -1,39 +1,39 @@
-// 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_BASE_INTERNAL_STRERROR_H_
-#define ABSL_BASE_INTERNAL_STRERROR_H_
-
-#include <util/generic/string.h>
-
-#include "y_absl/base/config.h"
-
-namespace y_absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-// A portable and thread-safe alternative to C89's `strerror`.
-//
-// The C89 specification of `strerror` is not suitable for use in a
-// multi-threaded application as the returned string may be changed by calls to
-// `strerror` from another thread.  The many non-stdlib alternatives differ
-// enough in their names, availability, and semantics to justify this wrapper
-// around them.  `errno` will not be modified by a call to `y_absl::StrError`.
-TString StrError(int errnum);
-
-}  // namespace base_internal
-ABSL_NAMESPACE_END
-}  // namespace y_absl
-
-#endif  // ABSL_BASE_INTERNAL_STRERROR_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_BASE_INTERNAL_STRERROR_H_ 
+#define ABSL_BASE_INTERNAL_STRERROR_H_ 
+ 
+#include <util/generic/string.h> 
+ 
+#include "y_absl/base/config.h" 
+ 
+namespace y_absl { 
+ABSL_NAMESPACE_BEGIN 
+namespace base_internal { 
+ 
+// A portable and thread-safe alternative to C89's `strerror`. 
+// 
+// The C89 specification of `strerror` is not suitable for use in a 
+// multi-threaded application as the returned string may be changed by calls to 
+// `strerror` from another thread.  The many non-stdlib alternatives differ 
+// enough in their names, availability, and semantics to justify this wrapper 
+// around them.  `errno` will not be modified by a call to `y_absl::StrError`. 
+TString StrError(int errnum); 
+ 
+}  // namespace base_internal 
+ABSL_NAMESPACE_END 
+}  // namespace y_absl 
+ 
+#endif  // ABSL_BASE_INTERNAL_STRERROR_H_ 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/sysinfo.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/sysinfo.cc
index 9eb0cf3f8c..ab4bcee26c 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/sysinfo.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/sysinfo.cc
@@ -39,7 +39,7 @@
 #endif
 
 #include <string.h>
-
+ 
 #include <cassert>
 #include <cstdint>
 #include <cstdio>
@@ -51,11 +51,11 @@
 #include <vector>
 
 #include "y_absl/base/call_once.h"
-#include "y_absl/base/config.h"
+#include "y_absl/base/config.h" 
 #include "y_absl/base/internal/raw_logging.h"
 #include "y_absl/base/internal/spinlock.h"
 #include "y_absl/base/internal/unscaledcycleclock.h"
-#include "y_absl/base/thread_annotations.h"
+#include "y_absl/base/thread_annotations.h" 
 
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
@@ -144,12 +144,12 @@ static int GetNumCPUs() {
 #if defined(_WIN32)
 
 static double GetNominalCPUFrequency() {
-#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) && \
-    !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-  // UWP apps don't have access to the registry and currently don't provide an
-  // API informing about CPU nominal frequency.
-  return 1.0;
-#else
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) && \ 
+    !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) 
+  // UWP apps don't have access to the registry and currently don't provide an 
+  // API informing about CPU nominal frequency. 
+  return 1.0; 
+#else 
 #pragma comment(lib, "advapi32.lib")  // For Reg* functions.
   HKEY key;
   // Use the Reg* functions rather than the SH functions because shlwapi.dll
@@ -169,7 +169,7 @@ static double GetNominalCPUFrequency() {
     }
   }
   return 1.0;
-#endif  // WINAPI_PARTITION_APP && !WINAPI_PARTITION_DESKTOP
+#endif  // WINAPI_PARTITION_APP && !WINAPI_PARTITION_DESKTOP 
 }
 
 #elif defined(CTL_HW) && defined(HW_CPU_FREQ)
@@ -415,16 +415,16 @@ pid_t GetTID() {
 #else
 
 // Fallback implementation of GetTID using pthread_getspecific.
-ABSL_CONST_INIT static once_flag tid_once;
-ABSL_CONST_INIT static pthread_key_t tid_key;
-ABSL_CONST_INIT static y_absl::base_internal::SpinLock tid_lock(
-    y_absl::kConstInit, base_internal::SCHEDULE_KERNEL_ONLY);
+ABSL_CONST_INIT static once_flag tid_once; 
+ABSL_CONST_INIT static pthread_key_t tid_key; 
+ABSL_CONST_INIT static y_absl::base_internal::SpinLock tid_lock( 
+    y_absl::kConstInit, base_internal::SCHEDULE_KERNEL_ONLY); 
 
 // We set a bit per thread in this array to indicate that an ID is in
 // use. ID 0 is unused because it is the default value returned by
 // pthread_getspecific().
-ABSL_CONST_INIT static std::vector<uint32_t> *tid_array
-    ABSL_GUARDED_BY(tid_lock) = nullptr;
+ABSL_CONST_INIT static std::vector<uint32_t> *tid_array 
+    ABSL_GUARDED_BY(tid_lock) = nullptr; 
 static constexpr int kBitsPerWord = 32;  // tid_array is uint32_t.
 
 // Returns the TID to tid_array.
@@ -491,18 +491,18 @@ pid_t GetTID() {
 
 #endif
 
-// GetCachedTID() caches the thread ID in thread-local storage (which is a
-// 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
-  static thread_local pid_t thread_id = GetTID();
-  return thread_id;
-#else
-  return GetTID();
-#endif  // ABSL_HAVE_THREAD_LOCAL
-}
-
+// GetCachedTID() caches the thread ID in thread-local storage (which is a 
+// 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 
+  static thread_local pid_t thread_id = GetTID(); 
+  return thread_id; 
+#else 
+  return GetTID(); 
+#endif  // ABSL_HAVE_THREAD_LOCAL 
+} 
+ 
 }  // namespace base_internal
 ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/sysinfo.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/sysinfo.h
index 0fd7207a38..bb20639029 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/sysinfo.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/sysinfo.h
@@ -30,7 +30,7 @@
 
 #include <cstdint>
 
-#include "y_absl/base/config.h"
+#include "y_absl/base/config.h" 
 #include "y_absl/base/port.h"
 
 namespace y_absl {
@@ -60,13 +60,13 @@ using pid_t = uint32_t;
 #endif
 pid_t GetTID();
 
-// Like GetTID(), but caches the result in thread-local storage in order
-// to avoid unnecessary system calls. Note that there are some cases where
-// one must call through to GetTID directly, which is why this exists as a
-// separate function. For example, GetCachedTID() is not safe to call in
-// an asynchronous signal-handling context nor right after a call to fork().
-pid_t GetCachedTID();
-
+// Like GetTID(), but caches the result in thread-local storage in order 
+// to avoid unnecessary system calls. Note that there are some cases where 
+// one must call through to GetTID directly, which is why this exists as a 
+// separate function. For example, GetCachedTID() is not safe to call in 
+// an asynchronous signal-handling context nor right after a call to fork(). 
+pid_t GetCachedTID(); 
+ 
 }  // namespace base_internal
 ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/thread_identity.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/thread_identity.cc
index b5e88ae302..5182ae164d 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/thread_identity.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/thread_identity.cc
@@ -23,7 +23,7 @@
 #include <cassert>
 #include <memory>
 
-#include "y_absl/base/attributes.h"
+#include "y_absl/base/attributes.h" 
 #include "y_absl/base/call_once.h"
 #include "y_absl/base/internal/raw_logging.h"
 #include "y_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-tstring/y_absl/base/internal/thread_identity.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/thread_identity.h
index 09a6c0bce1..9e9da41303 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/thread_identity.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/thread_identity.h
@@ -32,7 +32,7 @@
 
 #include "y_absl/base/config.h"
 #include "y_absl/base/internal/per_thread_tls.h"
-#include "y_absl/base/optimization.h"
+#include "y_absl/base/optimization.h" 
 
 namespace y_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 y_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-tstring/y_absl/base/internal/throw_delegate.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate.cc
index dcce5aedc3..489993d30d 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate.cc
@@ -18,7 +18,7 @@
 #include <functional>
 #include <new>
 #include <stdexcept>
-
+ 
 #include "y_absl/base/config.h"
 #include "y_absl/base/internal/raw_logging.h"
 
@@ -26,186 +26,186 @@ namespace y_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 TString& 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 TString& 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 TString& 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 TString& 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 TString& 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 TString& 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 TString& 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 TString& 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 TString& 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-tstring/y_absl/base/internal/throw_delegate/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate/ya.make
index 1b956ad494..843d4bf838 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate/ya.make
@@ -2,13 +2,13 @@
 
 LIBRARY()
 
-WITHOUT_LICENSE_TEXTS()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
+WITHOUT_LICENSE_TEXTS() 
 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
 LICENSE(Apache-2.0)
 
 PEERDIR(
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/tsan_mutex_interface.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/tsan_mutex_interface.h
index 69a61d0814..3777338512 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/tsan_mutex_interface.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/tsan_mutex_interface.h
@@ -19,8 +19,8 @@
 #ifndef ABSL_BASE_INTERNAL_TSAN_MUTEX_INTERFACE_H_
 #define ABSL_BASE_INTERNAL_TSAN_MUTEX_INTERFACE_H_
 
-#include "y_absl/base/config.h"
-
+#include "y_absl/base/config.h" 
+ 
 // ABSL_INTERNAL_HAVE_TSAN_INTERFACE
 // Macro intended only for internal use.
 //
@@ -30,7 +30,7 @@
 #error "ABSL_INTERNAL_HAVE_TSAN_INTERFACE cannot be directly set."
 #endif
 
-#if defined(ABSL_HAVE_THREAD_SANITIZER) && defined(__has_include)
+#if defined(ABSL_HAVE_THREAD_SANITIZER) && defined(__has_include) 
 #if __has_include(<sanitizer/tsan_interface.h>)
 #define ABSL_INTERNAL_HAVE_TSAN_INTERFACE 1
 #endif
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/unscaledcycleclock.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/unscaledcycleclock.cc
index 072a9852fa..f3035252a5 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/unscaledcycleclock.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/unscaledcycleclock.cc
@@ -139,7 +139,7 @@ double UnscaledCycleClock::Frequency() {
 
 #pragma intrinsic(__rdtsc)
 
-int64_t UnscaledCycleClock::Now() { return __rdtsc(); }
+int64_t UnscaledCycleClock::Now() { return __rdtsc(); } 
 
 double UnscaledCycleClock::Frequency() {
   return base_internal::NominalCPUFrequency();
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/unscaledcycleclock.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/unscaledcycleclock.h
index 618c5c7e73..ef3df43616 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/unscaledcycleclock.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/unscaledcycleclock.h
@@ -15,8 +15,8 @@
 // UnscaledCycleClock
 //    An UnscaledCycleClock yields the value and frequency of a cycle counter
 //    that increments at a rate that is approximately constant.
-//    This class is for internal use only, you should consider using CycleClock
-//    instead.
+//    This class is for internal use only, you should consider using CycleClock 
+//    instead. 
 //
 // Notes:
 // The cycle counter frequency is not necessarily the core clock frequency.
@@ -109,7 +109,7 @@ class UnscaledCycleClock {
   // value.
   static double Frequency();
 
-  // Allowed users
+  // Allowed users 
   friend class base_internal::CycleClock;
   friend class time_internal::UnscaledCycleClockWrapperForGetCurrentTime;
   friend class base_internal::UnscaledCycleClockWrapperForInitializeFrequency;
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity.h
index 26f20ad8e1..e6850cb189 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_BASE_LOG_SEVERITY_H_
-#define ABSL_BASE_LOG_SEVERITY_H_
+#ifndef ABSL_BASE_LOG_SEVERITY_H_ 
+#define ABSL_BASE_LOG_SEVERITY_H_ 
 
 #include <array>
 #include <ostream>
@@ -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<y_absl::LogSeverity>(100));
@@ -118,4 +118,4 @@ std::ostream& operator<<(std::ostream& os, y_absl::LogSeverity s);
 ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_BASE_LOG_SEVERITY_H_
+#endif  // ABSL_BASE_LOG_SEVERITY_H_ 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity/ya.make
index 3e4b5634c2..2e8412dd6f 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity/ya.make
@@ -2,13 +2,13 @@
 
 LIBRARY()
 
-WITHOUT_LICENSE_TEXTS()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
+WITHOUT_LICENSE_TEXTS() 
 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
 LICENSE(Apache-2.0)
 
 ADDINCL(
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/macros.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/macros.h
index b09a81877d..7c541c249f 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/macros.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/macros.h
@@ -32,7 +32,7 @@
 #include <cstddef>
 
 #include "y_absl/base/attributes.h"
-#include "y_absl/base/config.h"
+#include "y_absl/base/config.h" 
 #include "y_absl/base/optimization.h"
 #include "y_absl/base/port.h"
 
@@ -99,41 +99,41 @@ ABSL_NAMESPACE_END
                              : [] { assert(false && #expr); }())  // NOLINT
 #endif
 
-// `ABSL_INTERNAL_HARDENING_ABORT()` controls how `ABSL_HARDENING_ASSERT()`
-// aborts the program in release mode (when NDEBUG is defined). The
-// implementation should abort the program as quickly as possible and ideally it
-// should not be possible to ignore the abort request.
-#if (ABSL_HAVE_BUILTIN(__builtin_trap) &&         \
-     ABSL_HAVE_BUILTIN(__builtin_unreachable)) || \
-    (defined(__GNUC__) && !defined(__clang__))
-#define ABSL_INTERNAL_HARDENING_ABORT() \
-  do {                                  \
-    __builtin_trap();                   \
-    __builtin_unreachable();            \
-  } while (false)
-#else
-#define ABSL_INTERNAL_HARDENING_ABORT() abort()
-#endif
-
-// ABSL_HARDENING_ASSERT()
-//
-// `ABSL_HARDENING_ASSERT()` is like `ABSL_ASSERT()`, but used to implement
-// runtime assertions that should be enabled in hardened builds even when
-// `NDEBUG` is defined.
-//
-// When `NDEBUG` is not defined, `ABSL_HARDENING_ASSERT()` is identical to
-// `ABSL_ASSERT()`.
-//
-// See `ABSL_OPTION_HARDENED` in `y_absl/base/options.h` for more information on
-// hardened mode.
-#if ABSL_OPTION_HARDENED == 1 && defined(NDEBUG)
-#define ABSL_HARDENING_ASSERT(expr)                 \
-  (ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0) \
-                             : [] { ABSL_INTERNAL_HARDENING_ABORT(); }())
-#else
-#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
-#endif
-
+// `ABSL_INTERNAL_HARDENING_ABORT()` controls how `ABSL_HARDENING_ASSERT()` 
+// aborts the program in release mode (when NDEBUG is defined). The 
+// implementation should abort the program as quickly as possible and ideally it 
+// should not be possible to ignore the abort request. 
+#if (ABSL_HAVE_BUILTIN(__builtin_trap) &&         \ 
+     ABSL_HAVE_BUILTIN(__builtin_unreachable)) || \ 
+    (defined(__GNUC__) && !defined(__clang__)) 
+#define ABSL_INTERNAL_HARDENING_ABORT() \ 
+  do {                                  \ 
+    __builtin_trap();                   \ 
+    __builtin_unreachable();            \ 
+  } while (false) 
+#else 
+#define ABSL_INTERNAL_HARDENING_ABORT() abort() 
+#endif 
+ 
+// ABSL_HARDENING_ASSERT() 
+// 
+// `ABSL_HARDENING_ASSERT()` is like `ABSL_ASSERT()`, but used to implement 
+// runtime assertions that should be enabled in hardened builds even when 
+// `NDEBUG` is defined. 
+// 
+// When `NDEBUG` is not defined, `ABSL_HARDENING_ASSERT()` is identical to 
+// `ABSL_ASSERT()`. 
+// 
+// See `ABSL_OPTION_HARDENED` in `y_absl/base/options.h` for more information on 
+// hardened mode. 
+#if ABSL_OPTION_HARDENED == 1 && defined(NDEBUG) 
+#define ABSL_HARDENING_ASSERT(expr)                 \ 
+  (ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0) \ 
+                             : [] { ABSL_INTERNAL_HARDENING_ABORT(); }()) 
+#else 
+#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr) 
+#endif 
+ 
 #ifdef ABSL_HAVE_EXCEPTIONS
 #define ABSL_INTERNAL_TRY try
 #define ABSL_INTERNAL_CATCH_ANY catch (...)
@@ -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-tstring/y_absl/base/optimization.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/optimization.h
index 501530ae30..02e465c2b9 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/optimization.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_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 "y_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.
@@ -174,71 +174,71 @@
 // to yield performance improvements.
 #if ABSL_HAVE_BUILTIN(__builtin_expect) || \
     (defined(__GNUC__) && !defined(__clang__))
-#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
+#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) 
 #define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
 #else
 #define ABSL_PREDICT_FALSE(x) (x)
 #define ABSL_PREDICT_TRUE(x) (x)
 #endif
 
-// ABSL_INTERNAL_ASSUME(cond)
-// 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().
-// NOTE: The expression must not have side effects, as it will only be evaluated
-// in some compilation modes and not others.
-//
-// Example:
-//
-//   int x = ...;
-//   ABSL_INTERNAL_ASSUME(x >= 0);
-//   // The compiler can optimize the division to a simple right shift using the
-//   // assumption specified above.
-//   int y = x / 16;
-//
-#if !defined(NDEBUG)
-#define ABSL_INTERNAL_ASSUME(cond) assert(cond)
-#elif ABSL_HAVE_BUILTIN(__builtin_assume)
-#define ABSL_INTERNAL_ASSUME(cond) __builtin_assume(cond)
-#elif defined(__GNUC__) || ABSL_HAVE_BUILTIN(__builtin_unreachable)
-#define ABSL_INTERNAL_ASSUME(cond)        \
-  do {                                    \
-    if (!(cond)) __builtin_unreachable(); \
-  } while (0)
-#elif defined(_MSC_VER)
-#define ABSL_INTERNAL_ASSUME(cond) __assume(cond)
-#else
-#define ABSL_INTERNAL_ASSUME(cond)      \
-  do {                                  \
-    static_cast<void>(false && (cond)); \
-  } while (0)
-#endif
-
-// ABSL_INTERNAL_UNIQUE_SMALL_NAME(cond)
-// 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
-// conflict.
-//
-// Example:
-//
-// #define MY_MACRO(txt)
-// namespace {
-//  char VeryVeryLongVarName[] ABSL_INTERNAL_UNIQUE_SMALL_NAME() = txt;
-//  const char* VeryVeryLongFuncName() ABSL_INTERNAL_UNIQUE_SMALL_NAME();
-//  const char* VeryVeryLongFuncName() { return txt; }
-// }
-//
-
-#if defined(__GNUC__)
-#define ABSL_INTERNAL_UNIQUE_SMALL_NAME2(x) #x
-#define ABSL_INTERNAL_UNIQUE_SMALL_NAME1(x) ABSL_INTERNAL_UNIQUE_SMALL_NAME2(x)
-#define ABSL_INTERNAL_UNIQUE_SMALL_NAME() \
-  asm(ABSL_INTERNAL_UNIQUE_SMALL_NAME1(.y_absl.__COUNTER__))
-#else
-#define ABSL_INTERNAL_UNIQUE_SMALL_NAME()
-#endif
-
+// ABSL_INTERNAL_ASSUME(cond) 
+// 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(). 
+// NOTE: The expression must not have side effects, as it will only be evaluated 
+// in some compilation modes and not others. 
+// 
+// Example: 
+// 
+//   int x = ...; 
+//   ABSL_INTERNAL_ASSUME(x >= 0); 
+//   // The compiler can optimize the division to a simple right shift using the 
+//   // assumption specified above. 
+//   int y = x / 16; 
+// 
+#if !defined(NDEBUG) 
+#define ABSL_INTERNAL_ASSUME(cond) assert(cond) 
+#elif ABSL_HAVE_BUILTIN(__builtin_assume) 
+#define ABSL_INTERNAL_ASSUME(cond) __builtin_assume(cond) 
+#elif defined(__GNUC__) || ABSL_HAVE_BUILTIN(__builtin_unreachable) 
+#define ABSL_INTERNAL_ASSUME(cond)        \ 
+  do {                                    \ 
+    if (!(cond)) __builtin_unreachable(); \ 
+  } while (0) 
+#elif defined(_MSC_VER) 
+#define ABSL_INTERNAL_ASSUME(cond) __assume(cond) 
+#else 
+#define ABSL_INTERNAL_ASSUME(cond)      \ 
+  do {                                  \ 
+    static_cast<void>(false && (cond)); \ 
+  } while (0) 
+#endif 
+ 
+// ABSL_INTERNAL_UNIQUE_SMALL_NAME(cond) 
+// 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 
+// conflict. 
+// 
+// Example: 
+// 
+// #define MY_MACRO(txt) 
+// namespace { 
+//  char VeryVeryLongVarName[] ABSL_INTERNAL_UNIQUE_SMALL_NAME() = txt; 
+//  const char* VeryVeryLongFuncName() ABSL_INTERNAL_UNIQUE_SMALL_NAME(); 
+//  const char* VeryVeryLongFuncName() { return txt; } 
+// } 
+// 
+ 
+#if defined(__GNUC__) 
+#define ABSL_INTERNAL_UNIQUE_SMALL_NAME2(x) #x 
+#define ABSL_INTERNAL_UNIQUE_SMALL_NAME1(x) ABSL_INTERNAL_UNIQUE_SMALL_NAME2(x) 
+#define ABSL_INTERNAL_UNIQUE_SMALL_NAME() \ 
+  asm(ABSL_INTERNAL_UNIQUE_SMALL_NAME1(.y_absl.__COUNTER__)) 
+#else 
+#define ABSL_INTERNAL_UNIQUE_SMALL_NAME() 
+#endif 
+ 
 #endif  // ABSL_BASE_OPTIMIZATION_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/options.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/options.h
index 906310cde0..6bb7000f1e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/options.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/options.h
@@ -64,9 +64,9 @@
 // proper Abseil implementation at compile-time, which will not be sufficient
 // to guarantee ABI stability to package managers.
 
-#ifndef ABSL_BASE_OPTIONS_H_
-#define ABSL_BASE_OPTIONS_H_
-
+#ifndef ABSL_BASE_OPTIONS_H_ 
+#define ABSL_BASE_OPTIONS_H_ 
+ 
 // Include a standard library header to allow configuration based on the
 // standard library in use.
 #ifdef __cplusplus
@@ -208,31 +208,31 @@
 #define ABSL_OPTION_USE_INLINE_NAMESPACE 1
 #define ABSL_OPTION_INLINE_NAMESPACE_NAME lts_y_20211102
 
-// ABSL_OPTION_HARDENED
-//
-// This option enables a "hardened" build in release mode (in this context,
-// release mode is defined as a build where the `NDEBUG` macro is defined).
-//
-// A value of 0 means that "hardened" mode is not enabled.
-//
-// A value of 1 means that "hardened" mode is enabled.
-//
-// Hardened builds have additional security checks enabled when `NDEBUG` is
-// defined. Defining `NDEBUG` is normally used to turn `assert()` macro into a
-// no-op, as well as disabling other bespoke program consistency checks. By
-// defining ABSL_OPTION_HARDENED to 1, a select set of checks remain enabled in
-// release mode. These checks guard against programming errors that may lead to
-// security vulnerabilities. In release mode, when one of these programming
-// errors is encountered, the program will immediately abort, possibly without
-// any attempt at logging.
-//
-// The checks enabled by this option are not free; they do incur runtime cost.
-//
-// The checks enabled by this option are always active when `NDEBUG` is not
-// defined, even in the case when ABSL_OPTION_HARDENED is defined to 0. The
-// checks enabled by this option may abort the program in a different way and
-// log additional information when `NDEBUG` is not defined.
-
-#define ABSL_OPTION_HARDENED 0
-
+// ABSL_OPTION_HARDENED 
+// 
+// This option enables a "hardened" build in release mode (in this context, 
+// release mode is defined as a build where the `NDEBUG` macro is defined). 
+// 
+// A value of 0 means that "hardened" mode is not enabled. 
+// 
+// A value of 1 means that "hardened" mode is enabled. 
+// 
+// Hardened builds have additional security checks enabled when `NDEBUG` is 
+// defined. Defining `NDEBUG` is normally used to turn `assert()` macro into a 
+// no-op, as well as disabling other bespoke program consistency checks. By 
+// defining ABSL_OPTION_HARDENED to 1, a select set of checks remain enabled in 
+// release mode. These checks guard against programming errors that may lead to 
+// security vulnerabilities. In release mode, when one of these programming 
+// errors is encountered, the program will immediately abort, possibly without 
+// any attempt at logging. 
+// 
+// The checks enabled by this option are not free; they do incur runtime cost. 
+// 
+// The checks enabled by this option are always active when `NDEBUG` is not 
+// defined, even in the case when ABSL_OPTION_HARDENED is defined to 0. The 
+// checks enabled by this option may abort the program in a different way and 
+// log additional information when `NDEBUG` is not defined. 
+ 
+#define ABSL_OPTION_HARDENED 0 
+ 
 #endif  // ABSL_BASE_OPTIONS_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/policy_checks.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/policy_checks.h
index 06b3243916..c1cdca12f5 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/policy_checks.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/policy_checks.h
@@ -41,7 +41,7 @@
 #endif
 
 // -----------------------------------------------------------------------------
-// Toolchain Check
+// Toolchain Check 
 // -----------------------------------------------------------------------------
 
 // We support MSVC++ 14.0 update 2 and later.
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/thread_annotations.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/thread_annotations.h
index aba5d58dc3..f50c0b8e48 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/thread_annotations.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/thread_annotations.h
@@ -34,7 +34,7 @@
 #ifndef ABSL_BASE_THREAD_ANNOTATIONS_H_
 #define ABSL_BASE_THREAD_ANNOTATIONS_H_
 
-#include "y_absl/base/attributes.h"
+#include "y_absl/base/attributes.h" 
 #include "y_absl/base/config.h"
 // TODO(mbonadei): Remove after the backward compatibility period.
 #include "y_absl/base/internal/thread_annotations.h"  // IWYU pragma: export
@@ -56,11 +56,11 @@
 //     int p1_ ABSL_GUARDED_BY(mu_);
 //     ...
 //   };
-#if ABSL_HAVE_ATTRIBUTE(guarded_by)
-#define ABSL_GUARDED_BY(x) __attribute__((guarded_by(x)))
-#else
-#define ABSL_GUARDED_BY(x)
-#endif
+#if ABSL_HAVE_ATTRIBUTE(guarded_by) 
+#define ABSL_GUARDED_BY(x) __attribute__((guarded_by(x))) 
+#else 
+#define ABSL_GUARDED_BY(x) 
+#endif 
 
 // ABSL_PT_GUARDED_BY()
 //
@@ -82,11 +82,11 @@
 //   // `q_`, guarded by `mu1_`, points to a shared memory location that is
 //   // guarded by `mu2_`:
 //   int *q_ ABSL_GUARDED_BY(mu1_) ABSL_PT_GUARDED_BY(mu2_);
-#if ABSL_HAVE_ATTRIBUTE(pt_guarded_by)
-#define ABSL_PT_GUARDED_BY(x) __attribute__((pt_guarded_by(x)))
-#else
-#define ABSL_PT_GUARDED_BY(x)
-#endif
+#if ABSL_HAVE_ATTRIBUTE(pt_guarded_by) 
+#define ABSL_PT_GUARDED_BY(x) __attribute__((pt_guarded_by(x))) 
+#else 
+#define ABSL_PT_GUARDED_BY(x) 
+#endif 
 
 // ABSL_ACQUIRED_AFTER() / ABSL_ACQUIRED_BEFORE()
 //
@@ -103,17 +103,17 @@
 //
 //   Mutex m1_;
 //   Mutex m2_ ABSL_ACQUIRED_AFTER(m1_);
-#if ABSL_HAVE_ATTRIBUTE(acquired_after)
-#define ABSL_ACQUIRED_AFTER(...) __attribute__((acquired_after(__VA_ARGS__)))
-#else
-#define ABSL_ACQUIRED_AFTER(...)
-#endif
+#if ABSL_HAVE_ATTRIBUTE(acquired_after) 
+#define ABSL_ACQUIRED_AFTER(...) __attribute__((acquired_after(__VA_ARGS__))) 
+#else 
+#define ABSL_ACQUIRED_AFTER(...) 
+#endif 
 
-#if ABSL_HAVE_ATTRIBUTE(acquired_before)
-#define ABSL_ACQUIRED_BEFORE(...) __attribute__((acquired_before(__VA_ARGS__)))
-#else
-#define ABSL_ACQUIRED_BEFORE(...)
-#endif
+#if ABSL_HAVE_ATTRIBUTE(acquired_before) 
+#define ABSL_ACQUIRED_BEFORE(...) __attribute__((acquired_before(__VA_ARGS__))) 
+#else 
+#define ABSL_ACQUIRED_BEFORE(...) 
+#endif 
 
 // ABSL_EXCLUSIVE_LOCKS_REQUIRED() / ABSL_SHARED_LOCKS_REQUIRED()
 //
@@ -138,50 +138,50 @@
 //
 //   void foo() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu1, mu2) { ... }
 //   void bar() const ABSL_SHARED_LOCKS_REQUIRED(mu1, mu2) { ... }
-#if ABSL_HAVE_ATTRIBUTE(exclusive_locks_required)
-#define ABSL_EXCLUSIVE_LOCKS_REQUIRED(...) \
-  __attribute__((exclusive_locks_required(__VA_ARGS__)))
-#else
-#define ABSL_EXCLUSIVE_LOCKS_REQUIRED(...)
-#endif
+#if ABSL_HAVE_ATTRIBUTE(exclusive_locks_required) 
+#define ABSL_EXCLUSIVE_LOCKS_REQUIRED(...) \ 
+  __attribute__((exclusive_locks_required(__VA_ARGS__))) 
+#else 
+#define ABSL_EXCLUSIVE_LOCKS_REQUIRED(...) 
+#endif 
 
-#if ABSL_HAVE_ATTRIBUTE(shared_locks_required)
+#if ABSL_HAVE_ATTRIBUTE(shared_locks_required) 
 #define ABSL_SHARED_LOCKS_REQUIRED(...) \
-  __attribute__((shared_locks_required(__VA_ARGS__)))
-#else
-#define ABSL_SHARED_LOCKS_REQUIRED(...)
-#endif
+  __attribute__((shared_locks_required(__VA_ARGS__))) 
+#else 
+#define ABSL_SHARED_LOCKS_REQUIRED(...) 
+#endif 
 
 // ABSL_LOCKS_EXCLUDED()
 //
 // Documents the locks acquired in the body of the function. These locks
 // cannot be held when calling this function (as Abseil's `Mutex` locks are
 // non-reentrant).
-#if ABSL_HAVE_ATTRIBUTE(locks_excluded)
-#define ABSL_LOCKS_EXCLUDED(...) __attribute__((locks_excluded(__VA_ARGS__)))
-#else
-#define ABSL_LOCKS_EXCLUDED(...)
-#endif
+#if ABSL_HAVE_ATTRIBUTE(locks_excluded) 
+#define ABSL_LOCKS_EXCLUDED(...) __attribute__((locks_excluded(__VA_ARGS__))) 
+#else 
+#define ABSL_LOCKS_EXCLUDED(...) 
+#endif 
 
 // ABSL_LOCK_RETURNED()
 //
 // Documents a function that returns a mutex without acquiring it.  For example,
 // a public getter method that returns a pointer to a private mutex should
 // be annotated with ABSL_LOCK_RETURNED.
-#if ABSL_HAVE_ATTRIBUTE(lock_returned)
-#define ABSL_LOCK_RETURNED(x) __attribute__((lock_returned(x)))
-#else
-#define ABSL_LOCK_RETURNED(x)
-#endif
+#if ABSL_HAVE_ATTRIBUTE(lock_returned) 
+#define ABSL_LOCK_RETURNED(x) __attribute__((lock_returned(x))) 
+#else 
+#define ABSL_LOCK_RETURNED(x) 
+#endif 
 
 // ABSL_LOCKABLE
 //
 // Documents if a class/type is a lockable type (such as the `Mutex` class).
-#if ABSL_HAVE_ATTRIBUTE(lockable)
-#define ABSL_LOCKABLE __attribute__((lockable))
-#else
-#define ABSL_LOCKABLE
-#endif
+#if ABSL_HAVE_ATTRIBUTE(lockable) 
+#define ABSL_LOCKABLE __attribute__((lockable)) 
+#else 
+#define ABSL_LOCKABLE 
+#endif 
 
 // ABSL_SCOPED_LOCKABLE
 //
@@ -190,43 +190,43 @@
 // acquired, and the destructor should use `UNLOCK_FUNCTION()` with no
 // arguments; the analysis will assume that the destructor unlocks whatever the
 // constructor locked.
-#if ABSL_HAVE_ATTRIBUTE(scoped_lockable)
-#define ABSL_SCOPED_LOCKABLE __attribute__((scoped_lockable))
-#else
-#define ABSL_SCOPED_LOCKABLE
-#endif
+#if ABSL_HAVE_ATTRIBUTE(scoped_lockable) 
+#define ABSL_SCOPED_LOCKABLE __attribute__((scoped_lockable)) 
+#else 
+#define ABSL_SCOPED_LOCKABLE 
+#endif 
 
 // ABSL_EXCLUSIVE_LOCK_FUNCTION()
 //
 // Documents functions that acquire a lock in the body of a function, and do
 // not release it.
-#if ABSL_HAVE_ATTRIBUTE(exclusive_lock_function)
-#define ABSL_EXCLUSIVE_LOCK_FUNCTION(...) \
-  __attribute__((exclusive_lock_function(__VA_ARGS__)))
-#else
-#define ABSL_EXCLUSIVE_LOCK_FUNCTION(...)
-#endif
+#if ABSL_HAVE_ATTRIBUTE(exclusive_lock_function) 
+#define ABSL_EXCLUSIVE_LOCK_FUNCTION(...) \ 
+  __attribute__((exclusive_lock_function(__VA_ARGS__))) 
+#else 
+#define ABSL_EXCLUSIVE_LOCK_FUNCTION(...) 
+#endif 
 
 // ABSL_SHARED_LOCK_FUNCTION()
 //
 // Documents functions that acquire a shared (reader) lock in the body of a
 // function, and do not release it.
-#if ABSL_HAVE_ATTRIBUTE(shared_lock_function)
+#if ABSL_HAVE_ATTRIBUTE(shared_lock_function) 
 #define ABSL_SHARED_LOCK_FUNCTION(...) \
-  __attribute__((shared_lock_function(__VA_ARGS__)))
-#else
-#define ABSL_SHARED_LOCK_FUNCTION(...)
-#endif
+  __attribute__((shared_lock_function(__VA_ARGS__))) 
+#else 
+#define ABSL_SHARED_LOCK_FUNCTION(...) 
+#endif 
 
 // ABSL_UNLOCK_FUNCTION()
 //
 // Documents functions that expect a lock to be held on entry to the function,
 // and release it in the body of the function.
-#if ABSL_HAVE_ATTRIBUTE(unlock_function)
-#define ABSL_UNLOCK_FUNCTION(...) __attribute__((unlock_function(__VA_ARGS__)))
-#else
-#define ABSL_UNLOCK_FUNCTION(...)
-#endif
+#if ABSL_HAVE_ATTRIBUTE(unlock_function) 
+#define ABSL_UNLOCK_FUNCTION(...) __attribute__((unlock_function(__VA_ARGS__))) 
+#else 
+#define ABSL_UNLOCK_FUNCTION(...) 
+#endif 
 
 // ABSL_EXCLUSIVE_TRYLOCK_FUNCTION() / ABSL_SHARED_TRYLOCK_FUNCTION()
 //
@@ -236,49 +236,49 @@
 // success, or `false` for functions that return `false` on success. The second
 // argument specifies the mutex that is locked on success. If unspecified, this
 // mutex is assumed to be `this`.
-#if ABSL_HAVE_ATTRIBUTE(exclusive_trylock_function)
+#if ABSL_HAVE_ATTRIBUTE(exclusive_trylock_function) 
 #define ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(...) \
-  __attribute__((exclusive_trylock_function(__VA_ARGS__)))
-#else
-#define ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(...)
-#endif
+  __attribute__((exclusive_trylock_function(__VA_ARGS__))) 
+#else 
+#define ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(...) 
+#endif 
 
-#if ABSL_HAVE_ATTRIBUTE(shared_trylock_function)
-#define ABSL_SHARED_TRYLOCK_FUNCTION(...) \
-  __attribute__((shared_trylock_function(__VA_ARGS__)))
-#else
-#define ABSL_SHARED_TRYLOCK_FUNCTION(...)
-#endif
+#if ABSL_HAVE_ATTRIBUTE(shared_trylock_function) 
+#define ABSL_SHARED_TRYLOCK_FUNCTION(...) \ 
+  __attribute__((shared_trylock_function(__VA_ARGS__))) 
+#else 
+#define ABSL_SHARED_TRYLOCK_FUNCTION(...) 
+#endif 
 
 // ABSL_ASSERT_EXCLUSIVE_LOCK() / ABSL_ASSERT_SHARED_LOCK()
 //
 // Documents functions that dynamically check to see if a lock is held, and fail
 // if it is not held.
-#if ABSL_HAVE_ATTRIBUTE(assert_exclusive_lock)
+#if ABSL_HAVE_ATTRIBUTE(assert_exclusive_lock) 
 #define ABSL_ASSERT_EXCLUSIVE_LOCK(...) \
-  __attribute__((assert_exclusive_lock(__VA_ARGS__)))
-#else
-#define ABSL_ASSERT_EXCLUSIVE_LOCK(...)
-#endif
+  __attribute__((assert_exclusive_lock(__VA_ARGS__))) 
+#else 
+#define ABSL_ASSERT_EXCLUSIVE_LOCK(...) 
+#endif 
 
-#if ABSL_HAVE_ATTRIBUTE(assert_shared_lock)
+#if ABSL_HAVE_ATTRIBUTE(assert_shared_lock) 
 #define ABSL_ASSERT_SHARED_LOCK(...) \
-  __attribute__((assert_shared_lock(__VA_ARGS__)))
-#else
-#define ABSL_ASSERT_SHARED_LOCK(...)
-#endif
+  __attribute__((assert_shared_lock(__VA_ARGS__))) 
+#else 
+#define ABSL_ASSERT_SHARED_LOCK(...) 
+#endif 
 
 // ABSL_NO_THREAD_SAFETY_ANALYSIS
 //
 // Turns off thread safety checking within the body of a particular function.
 // This annotation is used to mark functions that are known to be correct, but
 // the locking behavior is more complicated than the analyzer can handle.
-#if ABSL_HAVE_ATTRIBUTE(no_thread_safety_analysis)
+#if ABSL_HAVE_ATTRIBUTE(no_thread_safety_analysis) 
 #define ABSL_NO_THREAD_SAFETY_ANALYSIS \
-  __attribute__((no_thread_safety_analysis))
-#else
-#define ABSL_NO_THREAD_SAFETY_ANALYSIS
-#endif
+  __attribute__((no_thread_safety_analysis)) 
+#else 
+#define ABSL_NO_THREAD_SAFETY_ANALYSIS 
+#endif 
 
 //------------------------------------------------------------------------------
 // Tool-Supplied Annotations
@@ -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-tstring/y_absl/base/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/base/ya.make
index 9e0d53060e..6c2fd0516e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/ya.make
@@ -2,15 +2,15 @@
 
 LIBRARY()
 
-OWNER(
-    somov
-    g:cpp-contrib
-)
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
 
 LICENSE(Apache-2.0)
 
-LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
-
+LICENSE_TEXTS(.yandex_meta/licenses.list.txt) 
+ 
 PEERDIR(
     contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging
     contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/city/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/city/ya.make
index 7fc856d796..915fbcaa7f 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/city/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/city/ya.make
@@ -2,22 +2,22 @@
 
 LIBRARY()
 
-WITHOUT_LICENSE_TEXTS()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
+WITHOUT_LICENSE_TEXTS() 
 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
 LICENSE(Apache-2.0)
 
-PEERDIR(
-    contrib/restricted/abseil-cpp-tstring/y_absl/base
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity
-)
-
+PEERDIR( 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity 
+) 
+ 
 ADDINCL(
     GLOBAL contrib/restricted/abseil-cpp-tstring
 )
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/.yandex_meta/licenses.list.txt b/contrib/restricted/abseil-cpp-tstring/y_absl/container/.yandex_meta/licenses.list.txt
index f39e683596..27eb40bafa 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/.yandex_meta/licenses.list.txt
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/.yandex_meta/licenses.list.txt
@@ -1,24 +1,24 @@
-====================Apache-2.0====================
-// 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====================
-// Copyright 2017 The Abseil Authors.
-
-
-====================COPYRIGHT====================
-// Copyright 2018 The Abseil Authors.
-
-
-====================COPYRIGHT====================
-// Copyright 2019 The Abseil Authors.
+====================Apache-2.0==================== 
+// 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==================== 
+// Copyright 2017 The Abseil Authors. 
+ 
+ 
+====================COPYRIGHT==================== 
+// Copyright 2018 The Abseil Authors. 
+ 
+ 
+====================COPYRIGHT==================== 
+// Copyright 2019 The Abseil Authors. 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_map.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_map.h
index 3f46c541b8..298b259885 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_map.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_map.h
@@ -185,7 +185,7 @@ class btree_map
   // template <typename K> size_type erase(const K& key):
   //
   //   Erases the element with the matching key, if it exists, returning the
-  //   number of elements erased (0 or 1).
+  //   number of elements erased (0 or 1). 
   using Base::erase;
 
   // btree_map::insert()
@@ -318,18 +318,18 @@ class btree_map
   //   Extracts the element at the indicated position and returns a node handle
   //   owning that extracted data.
   //
-  // template <typename K> node_type extract(const K& k):
+  // template <typename K> node_type extract(const K& k): 
   //
   //   Extracts the element with the key matching the passed key value and
   //   returns a node handle owning that extracted data. If the `btree_map`
   //   does not contain an element with a matching key, this function returns an
   //   empty node handle.
   //
-  // NOTE: when compiled in an earlier version of C++ than C++17,
-  // `node_type::key()` returns a const reference to the key instead of a
-  // mutable reference. We cannot safely return a mutable reference without
-  // std::launder (which is not available before C++17).
-  //
+  // NOTE: when compiled in an earlier version of C++ than C++17, 
+  // `node_type::key()` returns a const reference to the key instead of a 
+  // mutable reference. We cannot safely return a mutable reference without 
+  // std::launder (which is not available before C++17). 
+  // 
   // NOTE: In this context, `node_type` refers to the C++17 concept of a
   // move-only type that owns and provides access to the elements in associative
   // containers (https://en.cppreference.com/w/cpp/container/node_handle).
@@ -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()
@@ -673,18 +673,18 @@ class btree_multimap
   //   Extracts the element at the indicated position and returns a node handle
   //   owning that extracted data.
   //
-  // template <typename K> node_type extract(const K& k):
+  // template <typename K> node_type extract(const K& k): 
   //
   //   Extracts the element with the key matching the passed key value and
   //   returns a node handle owning that extracted data. If the `btree_multimap`
   //   does not contain an element with a matching key, this function returns an
   //   empty node handle.
   //
-  // NOTE: when compiled in an earlier version of C++ than C++17,
-  // `node_type::key()` returns a const reference to the key instead of a
-  // mutable reference. We cannot safely return a mutable reference without
-  // std::launder (which is not available before C++17).
-  //
+  // NOTE: when compiled in an earlier version of C++ than C++17, 
+  // `node_type::key()` returns a const reference to the key instead of a 
+  // mutable reference. We cannot safely return a mutable reference without 
+  // std::launder (which is not available before C++17). 
+  // 
   // NOTE: In this context, `node_type` refers to the C++17 concept of a
   // move-only type that owns and provides access to the elements in associative
   // containers (https://en.cppreference.com/w/cpp/container/node_handle).
@@ -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-tstring/y_absl/container/btree_set.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_set.h
index 905fb8e964..0c51f24be7 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_set.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_set.h
@@ -183,7 +183,7 @@ class btree_set
   // template <typename K> size_type erase(const K& key):
   //
   //   Erases the element with the matching key, if it exists, returning the
-  //   number of elements erased (0 or 1).
+  //   number of elements erased (0 or 1). 
   using Base::erase;
 
   // btree_set::insert()
@@ -263,7 +263,7 @@ class btree_set
   //   Extracts the element at the indicated position and returns a node handle
   //   owning that extracted data.
   //
-  // template <typename K> node_type extract(const K& k):
+  // template <typename K> node_type extract(const K& k): 
   //
   //   Extracts the element with the key matching the passed key value and
   //   returns a node handle owning that extracted data. If the `btree_set`
@@ -589,7 +589,7 @@ class btree_multiset
   //   Extracts the element at the indicated position and returns a node handle
   //   owning that extracted data.
   //
-  // template <typename K> node_type extract(const K& k):
+  // template <typename K> node_type extract(const K& k): 
   //
   //   Extracts the element with the key matching the passed key value and
   //   returns a node handle owning that extracted data. If the `btree_multiset`
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_test.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_test.h
index 97ed054ce8..76e2a4fd05 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_test.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_test.h
@@ -25,7 +25,7 @@
 #include "y_absl/container/btree_map.h"
 #include "y_absl/container/btree_set.h"
 #include "y_absl/container/flat_hash_set.h"
-#include "y_absl/strings/cord.h"
+#include "y_absl/strings/cord.h" 
 #include "y_absl/time/time.h"
 
 namespace y_absl {
@@ -101,16 +101,16 @@ struct Generator<TString> {
   }
 };
 
-template <>
-struct Generator<Cord> {
-  int maxval;
-  explicit Generator(int m) : maxval(m) {}
-  Cord operator()(int i) const {
-    char buf[16];
-    return Cord(GenerateDigits(buf, i, maxval));
-  }
-};
-
+template <> 
+struct Generator<Cord> { 
+  int maxval; 
+  explicit Generator(int m) : maxval(m) {} 
+  Cord operator()(int i) const { 
+    char buf[16]; 
+    return Cord(GenerateDigits(buf, i, maxval)); 
+  } 
+}; 
+ 
 template <typename T, typename U>
 struct Generator<std::pair<T, U> > {
   Generator<typename remove_pair_const<T>::type> tgen;
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/fixed_array.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/fixed_array.h
index 33b6caf00d..afa8cc35b7 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/fixed_array.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/fixed_array.h
@@ -41,7 +41,7 @@
 #include <type_traits>
 
 #include "y_absl/algorithm/algorithm.h"
-#include "y_absl/base/config.h"
+#include "y_absl/base/config.h" 
 #include "y_absl/base/dynamic_annotations.h"
 #include "y_absl/base/internal/throw_delegate.h"
 #include "y_absl/base/macros.h"
@@ -102,13 +102,13 @@ class FixedArray {
 
  public:
   using allocator_type = typename AllocatorTraits::allocator_type;
-  using value_type = typename AllocatorTraits::value_type;
-  using pointer = typename AllocatorTraits::pointer;
-  using const_pointer = typename AllocatorTraits::const_pointer;
-  using reference = value_type&;
-  using const_reference = const value_type&;
-  using size_type = typename AllocatorTraits::size_type;
-  using difference_type = typename AllocatorTraits::difference_type;
+  using value_type = typename AllocatorTraits::value_type; 
+  using pointer = typename AllocatorTraits::pointer; 
+  using const_pointer = typename AllocatorTraits::const_pointer; 
+  using reference = value_type&; 
+  using const_reference = const value_type&; 
+  using size_type = typename AllocatorTraits::size_type; 
+  using difference_type = typename AllocatorTraits::difference_type; 
   using iterator = pointer;
   using const_iterator = const_pointer;
   using reverse_iterator = std::reverse_iterator<iterator>;
@@ -213,7 +213,7 @@ class FixedArray {
   // Returns a reference the ith element of the fixed array.
   // REQUIRES: 0 <= i < size()
   reference operator[](size_type i) {
-    ABSL_HARDENING_ASSERT(i < size());
+    ABSL_HARDENING_ASSERT(i < size()); 
     return data()[i];
   }
 
@@ -221,14 +221,14 @@ class FixedArray {
   // ith element of the fixed array.
   // REQUIRES: 0 <= i < size()
   const_reference operator[](size_type i) const {
-    ABSL_HARDENING_ASSERT(i < size());
+    ABSL_HARDENING_ASSERT(i < size()); 
     return data()[i];
   }
 
   // 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");
@@ -248,32 +248,32 @@ class FixedArray {
   // FixedArray::front()
   //
   // Returns a reference to the first element of the fixed array.
-  reference front() {
-    ABSL_HARDENING_ASSERT(!empty());
-    return data()[0];
-  }
+  reference front() { 
+    ABSL_HARDENING_ASSERT(!empty()); 
+    return data()[0]; 
+  } 
 
   // Overload of FixedArray::front() to return a reference to the first element
   // of a fixed array of const values.
-  const_reference front() const {
-    ABSL_HARDENING_ASSERT(!empty());
-    return data()[0];
-  }
+  const_reference front() const { 
+    ABSL_HARDENING_ASSERT(!empty()); 
+    return data()[0]; 
+  } 
 
   // FixedArray::back()
   //
   // Returns a reference to the last element of the fixed array.
-  reference back() {
-    ABSL_HARDENING_ASSERT(!empty());
-    return data()[size() - 1];
-  }
+  reference back() { 
+    ABSL_HARDENING_ASSERT(!empty()); 
+    return data()[size() - 1]; 
+  } 
 
   // Overload of FixedArray::back() to return a reference to the last element
   // of a fixed array of const values.
-  const_reference back() const {
-    ABSL_HARDENING_ASSERT(!empty());
-    return data()[size() - 1];
-  }
+  const_reference back() const { 
+    ABSL_HARDENING_ASSERT(!empty()); 
+    return data()[size() - 1]; 
+  } 
 
   // FixedArray::begin()
   //
@@ -418,15 +418,15 @@ class FixedArray {
     void AnnotateConstruct(size_type n);
     void AnnotateDestruct(size_type n);
 
-#ifdef ABSL_HAVE_ADDRESS_SANITIZER
+#ifdef ABSL_HAVE_ADDRESS_SANITIZER 
     void* RedzoneBegin() { return &redzone_begin_; }
     void* RedzoneEnd() { return &redzone_end_ + 1; }
-#endif  // ABSL_HAVE_ADDRESS_SANITIZER
+#endif  // ABSL_HAVE_ADDRESS_SANITIZER 
 
    private:
-    ABSL_ADDRESS_SANITIZER_REDZONE(redzone_begin_);
+    ABSL_ADDRESS_SANITIZER_REDZONE(redzone_begin_); 
     alignas(StorageElement) char buff_[sizeof(StorageElement[inline_elements])];
-    ABSL_ADDRESS_SANITIZER_REDZONE(redzone_end_);
+    ABSL_ADDRESS_SANITIZER_REDZONE(redzone_end_); 
   };
 
   class EmptyInlinedStorage {
@@ -499,26 +499,26 @@ constexpr typename FixedArray<T, N, A>::size_type
 template <typename T, size_t N, typename A>
 void FixedArray<T, N, A>::NonEmptyInlinedStorage::AnnotateConstruct(
     typename FixedArray<T, N, A>::size_type n) {
-#ifdef ABSL_HAVE_ADDRESS_SANITIZER
+#ifdef ABSL_HAVE_ADDRESS_SANITIZER 
   if (!n) return;
-  ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(data(), RedzoneEnd(), RedzoneEnd(),
-                                     data() + n);
-  ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(RedzoneBegin(), data(), data(),
-                                     RedzoneBegin());
-#endif  // ABSL_HAVE_ADDRESS_SANITIZER
+  ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(data(), RedzoneEnd(), RedzoneEnd(), 
+                                     data() + n); 
+  ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(RedzoneBegin(), data(), data(), 
+                                     RedzoneBegin()); 
+#endif  // ABSL_HAVE_ADDRESS_SANITIZER 
   static_cast<void>(n);  // Mark used when not in asan mode
 }
 
 template <typename T, size_t N, typename A>
 void FixedArray<T, N, A>::NonEmptyInlinedStorage::AnnotateDestruct(
     typename FixedArray<T, N, A>::size_type n) {
-#ifdef ABSL_HAVE_ADDRESS_SANITIZER
+#ifdef ABSL_HAVE_ADDRESS_SANITIZER 
   if (!n) return;
-  ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(data(), RedzoneEnd(), data() + n,
-                                     RedzoneEnd());
-  ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(RedzoneBegin(), data(), RedzoneBegin(),
-                                     data());
-#endif  // ABSL_HAVE_ADDRESS_SANITIZER
+  ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(data(), RedzoneEnd(), data() + n, 
+                                     RedzoneEnd()); 
+  ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(RedzoneBegin(), data(), RedzoneBegin(), 
+                                     data()); 
+#endif  // ABSL_HAVE_ADDRESS_SANITIZER 
   static_cast<void>(n);  // Mark used when not in asan mode
 }
 ABSL_NAMESPACE_END
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/flat_hash_map.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/flat_hash_map.h
index eb3f09f06d..94e84ab363 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/flat_hash_map.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/flat_hash_map.h
@@ -234,8 +234,8 @@ class flat_hash_map : public y_absl::container_internal::raw_hash_map<
   //
   // size_type erase(const key_type& key):
   //
-  //   Erases the element with the matching key, if it exists, returning the
-  //   number of elements erased (0 or 1).
+  //   Erases the element with the matching key, if it exists, returning the 
+  //   number of elements erased (0 or 1). 
   using Base::erase;
 
   // flat_hash_map::insert()
@@ -384,11 +384,11 @@ class flat_hash_map : public y_absl::container_internal::raw_hash_map<
   //   key value and returns a node handle owning that extracted data. If the
   //   `flat_hash_map` does not contain an element with a matching key, this
   //   function returns an empty node handle.
-  //
-  // NOTE: when compiled in an earlier version of C++ than C++17,
-  // `node_type::key()` returns a const reference to the key instead of a
-  // mutable reference. We cannot safely return a mutable reference without
-  // std::launder (which is not available before C++17).
+  // 
+  // NOTE: when compiled in an earlier version of C++ than C++17, 
+  // `node_type::key()` returns a const reference to the key instead of a 
+  // mutable reference. We cannot safely return a mutable reference without 
+  // std::launder (which is not available before C++17). 
   using Base::extract;
 
   // flat_hash_map::merge()
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/flat_hash_set.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/flat_hash_set.h
index 23fe02a950..576bd2808d 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/flat_hash_set.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/flat_hash_set.h
@@ -227,8 +227,8 @@ class flat_hash_set
   //
   // size_type erase(const key_type& key):
   //
-  //   Erases the element with the matching key, if it exists, returning the
-  //   number of elements erased (0 or 1).
+  //   Erases the element with the matching key, if it exists, returning the 
+  //   number of elements erased (0 or 1). 
   using Base::erase;
 
   // flat_hash_set::insert()
@@ -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-tstring/y_absl/container/inlined_vector.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/inlined_vector.h
index 34af121cf7..1b177f8197 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/inlined_vector.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/inlined_vector.h
@@ -48,7 +48,7 @@
 
 #include "y_absl/algorithm/algorithm.h"
 #include "y_absl/base/internal/throw_delegate.h"
-#include "y_absl/base/macros.h"
+#include "y_absl/base/macros.h" 
 #include "y_absl/base/optimization.h"
 #include "y_absl/base/port.h"
 #include "y_absl/container/internal/inlined_vector.h"
@@ -64,7 +64,7 @@ ABSL_NAMESPACE_BEGIN
 // `std::vector` for use cases where the vector's size is sufficiently small
 // that it can be inlined. If the inlined vector does grow beyond its estimated
 // capacity, it will trigger an initial allocation on the heap, and will behave
-// as a `std::vector`. The API of the `y_absl::InlinedVector` within this file is
+// as a `std::vector`. The API of the `y_absl::InlinedVector` within this file is 
 // designed to cover the same API footprint as covered by `std::vector`.
 template <typename T, size_t N, typename A = std::allocator<T>>
 class InlinedVector {
@@ -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_); 
     }
   }
 
@@ -319,14 +319,14 @@ class InlinedVector {
   //
   // Returns a `reference` to the `i`th element of the inlined vector.
   reference operator[](size_type i) {
-    ABSL_HARDENING_ASSERT(i < size());
+    ABSL_HARDENING_ASSERT(i < size()); 
     return data()[i];
   }
 
   // Overload of `InlinedVector::operator[](...)` that returns a
   // `const_reference` to the `i`th element of the inlined vector.
   const_reference operator[](size_type i) const {
-    ABSL_HARDENING_ASSERT(i < size());
+    ABSL_HARDENING_ASSERT(i < size()); 
     return data()[i];
   }
 
@@ -361,30 +361,30 @@ class InlinedVector {
   //
   // Returns a `reference` to the first element of the inlined vector.
   reference front() {
-    ABSL_HARDENING_ASSERT(!empty());
-    return data()[0];
+    ABSL_HARDENING_ASSERT(!empty()); 
+    return data()[0]; 
   }
 
   // Overload of `InlinedVector::front()` that returns a `const_reference` to
   // the first element of the inlined vector.
   const_reference front() const {
-    ABSL_HARDENING_ASSERT(!empty());
-    return data()[0];
+    ABSL_HARDENING_ASSERT(!empty()); 
+    return data()[0]; 
   }
 
   // `InlinedVector::back()`
   //
   // Returns a `reference` to the last element of the inlined vector.
   reference back() {
-    ABSL_HARDENING_ASSERT(!empty());
-    return data()[size() - 1];
+    ABSL_HARDENING_ASSERT(!empty()); 
+    return data()[size() - 1]; 
   }
 
   // Overload of `InlinedVector::back()` that returns a `const_reference` to the
   // last element of the inlined vector.
   const_reference back() const {
-    ABSL_HARDENING_ASSERT(!empty());
-    return data()[size() - 1];
+    ABSL_HARDENING_ASSERT(!empty()); 
+    return data()[size() - 1]; 
   }
 
   // `InlinedVector::begin()`
@@ -535,7 +535,7 @@ class InlinedVector {
   void assign(InputIterator first, InputIterator last) {
     size_type i = 0;
     for (; i < size() && first != last; ++i, static_cast<void>(++first)) {
-      data()[i] = *first;
+      data()[i] = *first; 
     }
 
     erase(data() + i, data() + size());
@@ -546,12 +546,12 @@ class InlinedVector {
   //
   // Resizes the inlined vector to contain `n` elements.
   //
-  // NOTE: If `n` is smaller than `size()`, extra elements are destroyed. If `n`
+  // NOTE: If `n` is smaller than `size()`, extra elements are destroyed. If `n` 
   // is larger than `size()`, new elements are value-initialized.
-  void resize(size_type n) {
-    ABSL_HARDENING_ASSERT(n <= max_size());
+  void resize(size_type n) { 
+    ABSL_HARDENING_ASSERT(n <= max_size()); 
     storage_.Resize(DefaultValueAdapter<A>(), n);
-  }
+  } 
 
   // Overload of `InlinedVector::resize(...)` that resizes the inlined vector to
   // contain `n` elements.
@@ -559,7 +559,7 @@ class InlinedVector {
   // NOTE: if `n` is smaller than `size()`, extra elements are destroyed. If `n`
   // is larger than `size()`, new elements are copied-constructed from `v`.
   void resize(size_type n, const_reference v) {
-    ABSL_HARDENING_ASSERT(n <= max_size());
+    ABSL_HARDENING_ASSERT(n <= max_size()); 
     storage_.Resize(CopyValueAdapter<A>(std::addressof(v)), n);
   }
 
@@ -581,8 +581,8 @@ class InlinedVector {
   // of `v` starting at `pos`, returning an `iterator` pointing to the first of
   // the newly inserted elements.
   iterator insert(const_iterator pos, size_type n, const_reference v) {
-    ABSL_HARDENING_ASSERT(pos >= begin());
-    ABSL_HARDENING_ASSERT(pos <= end());
+    ABSL_HARDENING_ASSERT(pos >= begin()); 
+    ABSL_HARDENING_ASSERT(pos <= end()); 
 
     if (ABSL_PREDICT_TRUE(n != 0)) {
       value_type dealias = v;
@@ -609,8 +609,8 @@ class InlinedVector {
             EnableIfAtLeastForwardIterator<ForwardIterator> = 0>
   iterator insert(const_iterator pos, ForwardIterator first,
                   ForwardIterator last) {
-    ABSL_HARDENING_ASSERT(pos >= begin());
-    ABSL_HARDENING_ASSERT(pos <= end());
+    ABSL_HARDENING_ASSERT(pos >= begin()); 
+    ABSL_HARDENING_ASSERT(pos <= end()); 
 
     if (ABSL_PREDICT_TRUE(first != last)) {
       return storage_.Insert(pos,
@@ -629,8 +629,8 @@ class InlinedVector {
   template <typename InputIterator,
             DisableIfAtLeastForwardIterator<InputIterator> = 0>
   iterator insert(const_iterator pos, InputIterator first, InputIterator last) {
-    ABSL_HARDENING_ASSERT(pos >= begin());
-    ABSL_HARDENING_ASSERT(pos <= end());
+    ABSL_HARDENING_ASSERT(pos >= begin()); 
+    ABSL_HARDENING_ASSERT(pos <= end()); 
 
     size_type index = std::distance(cbegin(), pos);
     for (size_type i = index; first != last; ++i, static_cast<void>(++first)) {
@@ -646,8 +646,8 @@ class InlinedVector {
   // `pos`, returning an `iterator` pointing to the newly emplaced element.
   template <typename... Args>
   iterator emplace(const_iterator pos, Args&&... args) {
-    ABSL_HARDENING_ASSERT(pos >= begin());
-    ABSL_HARDENING_ASSERT(pos <= end());
+    ABSL_HARDENING_ASSERT(pos >= begin()); 
+    ABSL_HARDENING_ASSERT(pos <= end()); 
 
     value_type dealias(std::forward<Args>(args)...);
     return storage_.Insert(pos,
@@ -680,7 +680,7 @@ class InlinedVector {
   //
   // Destroys the element at `back()`, reducing the size by `1`.
   void pop_back() noexcept {
-    ABSL_HARDENING_ASSERT(!empty());
+    ABSL_HARDENING_ASSERT(!empty()); 
 
     AllocatorTraits<A>::destroy(storage_.GetAllocator(), data() + (size() - 1));
     storage_.SubtractSize(1);
@@ -693,8 +693,8 @@ class InlinedVector {
   //
   // NOTE: may return `end()`, which is not dereferencable.
   iterator erase(const_iterator pos) {
-    ABSL_HARDENING_ASSERT(pos >= begin());
-    ABSL_HARDENING_ASSERT(pos < end());
+    ABSL_HARDENING_ASSERT(pos >= begin()); 
+    ABSL_HARDENING_ASSERT(pos < end()); 
 
     return storage_.Erase(pos, pos + 1);
   }
@@ -705,9 +705,9 @@ class InlinedVector {
   //
   // NOTE: may return `end()`, which is not dereferencable.
   iterator erase(const_iterator from, const_iterator to) {
-    ABSL_HARDENING_ASSERT(from >= begin());
-    ABSL_HARDENING_ASSERT(from <= to);
-    ABSL_HARDENING_ASSERT(to <= end());
+    ABSL_HARDENING_ASSERT(from >= begin()); 
+    ABSL_HARDENING_ASSERT(from <= to); 
+    ABSL_HARDENING_ASSERT(to <= end()); 
 
     if (ABSL_PREDICT_TRUE(from != to)) {
       return storage_.Erase(from, to);
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/absl_hashtablez_sampler/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/absl_hashtablez_sampler/ya.make
index 54874c0466..f0651b0b41 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/absl_hashtablez_sampler/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/absl_hashtablez_sampler/ya.make
@@ -1,49 +1,49 @@
-# Generated by devtools/yamaker.
-
-LIBRARY()
-
-WITHOUT_LICENSE_TEXTS()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
-
-LICENSE(Apache-2.0)
-
-PEERDIR(
-    contrib/restricted/abseil-cpp-tstring/y_absl/base
+# Generated by devtools/yamaker. 
+ 
+LIBRARY() 
+ 
+WITHOUT_LICENSE_TEXTS() 
+ 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
+LICENSE(Apache-2.0) 
+ 
+PEERDIR( 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base 
     contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity 
     contrib/restricted/abseil-cpp-tstring/y_absl/debugging
     contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace
     contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize
     contrib/restricted/abseil-cpp-tstring/y_absl/demangle
-    contrib/restricted/abseil-cpp-tstring/y_absl/numeric
+    contrib/restricted/abseil-cpp-tstring/y_absl/numeric 
     contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/exponential_biased
-    contrib/restricted/abseil-cpp-tstring/y_absl/strings
+    contrib/restricted/abseil-cpp-tstring/y_absl/strings 
     contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_strings_internal
     contrib/restricted/abseil-cpp-tstring/y_absl/synchronization
     contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal
     contrib/restricted/abseil-cpp-tstring/y_absl/time
     contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time
     contrib/restricted/abseil-cpp-tstring/y_absl/time/time_zone
-)
-
-ADDINCL(
-    GLOBAL contrib/restricted/abseil-cpp-tstring
-)
-
-NO_COMPILER_WARNINGS()
-
+) 
+ 
+ADDINCL( 
+    GLOBAL contrib/restricted/abseil-cpp-tstring 
+) 
+ 
+NO_COMPILER_WARNINGS() 
+ 
 SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/container/internal)
-
-SRCS(
+ 
+SRCS( 
     hashtablez_sampler.cc
     hashtablez_sampler_force_weak_definition.cc
-)
-
-END()
+) 
+ 
+END() 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/btree.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/btree.h
index a249260811..40e81d5cae 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/btree.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/btree.h
@@ -65,7 +65,7 @@
 #include "y_absl/container/internal/layout.h"
 #include "y_absl/memory/memory.h"
 #include "y_absl/meta/type_traits.h"
-#include "y_absl/strings/cord.h"
+#include "y_absl/strings/cord.h" 
 #include "y_absl/strings/string_view.h"
 #include "y_absl/types/compare.h"
 #include "y_absl/utility/utility.h"
@@ -99,19 +99,19 @@ struct StringBtreeDefaultLess {
                                  y_absl::string_view rhs) const {
     return compare_internal::compare_result_as_ordering(lhs.compare(rhs));
   }
-  StringBtreeDefaultLess(std::less<y_absl::Cord>) {}  // NOLINT
-  y_absl::weak_ordering operator()(const y_absl::Cord &lhs,
-                                 const y_absl::Cord &rhs) const {
-    return compare_internal::compare_result_as_ordering(lhs.Compare(rhs));
-  }
-  y_absl::weak_ordering operator()(const y_absl::Cord &lhs,
-                                 y_absl::string_view rhs) const {
-    return compare_internal::compare_result_as_ordering(lhs.Compare(rhs));
-  }
-  y_absl::weak_ordering operator()(y_absl::string_view lhs,
-                                 const y_absl::Cord &rhs) const {
-    return compare_internal::compare_result_as_ordering(-rhs.Compare(lhs));
-  }
+  StringBtreeDefaultLess(std::less<y_absl::Cord>) {}  // NOLINT 
+  y_absl::weak_ordering operator()(const y_absl::Cord &lhs, 
+                                 const y_absl::Cord &rhs) const { 
+    return compare_internal::compare_result_as_ordering(lhs.Compare(rhs)); 
+  } 
+  y_absl::weak_ordering operator()(const y_absl::Cord &lhs, 
+                                 y_absl::string_view rhs) const { 
+    return compare_internal::compare_result_as_ordering(lhs.Compare(rhs)); 
+  } 
+  y_absl::weak_ordering operator()(y_absl::string_view lhs, 
+                                 const y_absl::Cord &rhs) const { 
+    return compare_internal::compare_result_as_ordering(-rhs.Compare(lhs)); 
+  } 
 };
 
 struct StringBtreeDefaultGreater {
@@ -131,30 +131,30 @@ struct StringBtreeDefaultGreater {
                                  y_absl::string_view rhs) const {
     return compare_internal::compare_result_as_ordering(rhs.compare(lhs));
   }
-  StringBtreeDefaultGreater(std::greater<y_absl::Cord>) {}  // NOLINT
-  y_absl::weak_ordering operator()(const y_absl::Cord &lhs,
-                                 const y_absl::Cord &rhs) const {
-    return compare_internal::compare_result_as_ordering(rhs.Compare(lhs));
-  }
-  y_absl::weak_ordering operator()(const y_absl::Cord &lhs,
-                                 y_absl::string_view rhs) const {
-    return compare_internal::compare_result_as_ordering(-lhs.Compare(rhs));
-  }
-  y_absl::weak_ordering operator()(y_absl::string_view lhs,
-                                 const y_absl::Cord &rhs) const {
-    return compare_internal::compare_result_as_ordering(rhs.Compare(lhs));
-  }
+  StringBtreeDefaultGreater(std::greater<y_absl::Cord>) {}  // NOLINT 
+  y_absl::weak_ordering operator()(const y_absl::Cord &lhs, 
+                                 const y_absl::Cord &rhs) const { 
+    return compare_internal::compare_result_as_ordering(rhs.Compare(lhs)); 
+  } 
+  y_absl::weak_ordering operator()(const y_absl::Cord &lhs, 
+                                 y_absl::string_view rhs) const { 
+    return compare_internal::compare_result_as_ordering(-lhs.Compare(rhs)); 
+  } 
+  y_absl::weak_ordering operator()(y_absl::string_view lhs, 
+                                 const y_absl::Cord &rhs) const { 
+    return compare_internal::compare_result_as_ordering(rhs.Compare(lhs)); 
+  } 
 };
 
 // A helper class to convert a boolean comparison into a three-way "compare-to"
-// comparison that returns an `y_absl::weak_ordering`. This helper
+// comparison that returns an `y_absl::weak_ordering`. This helper 
 // class is specialized for less<TString>, greater<TString>,
-// less<string_view>, greater<string_view>, less<y_absl::Cord>, and
-// greater<y_absl::Cord>.
+// less<string_view>, greater<string_view>, less<y_absl::Cord>, and 
+// greater<y_absl::Cord>. 
 //
 // key_compare_to_adapter is provided so that btree users
 // automatically get the more efficient compare-to code when using common
-// Abseil string types with common comparison functors.
+// Abseil string types with common comparison functors. 
 // These string-like specializations also turn on heterogeneous lookup by
 // default.
 template <typename Compare>
@@ -182,54 +182,54 @@ struct key_compare_to_adapter<std::greater<y_absl::string_view>> {
   using type = StringBtreeDefaultGreater;
 };
 
-template <>
-struct key_compare_to_adapter<std::less<y_absl::Cord>> {
-  using type = StringBtreeDefaultLess;
-};
-
-template <>
-struct key_compare_to_adapter<std::greater<y_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, y_absl::void_t<typename T::absl_btree_prefer_linear_node_search>>
-    : std::true_type {};
-template <typename T>
-struct prefers_linear_node_search<
-    T, y_absl::void_t<typename T::absl_btree_prefer_linear_node_search>>
-    : T::absl_btree_prefer_linear_node_search {};
-
+template <> 
+struct key_compare_to_adapter<std::less<y_absl::Cord>> { 
+  using type = StringBtreeDefaultLess; 
+}; 
+ 
+template <> 
+struct key_compare_to_adapter<std::greater<y_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, y_absl::void_t<typename T::absl_btree_prefer_linear_node_search>> 
+    : std::true_type {}; 
+template <typename T> 
+struct prefers_linear_node_search< 
+    T, y_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 {
   using original_key_compare = Compare;
 
-  // If Compare is a common comparator for a string-like type, then we adapt it
+  // If Compare is a common comparator for a string-like type, then we adapt it 
   // to use heterogeneous lookup and to be a key-compare-to comparator.
   using key_compare = typename key_compare_to_adapter<Compare>::type;
   // A type which indicates if we have a key-compare-to functor or a plain old
@@ -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,
 
@@ -348,17 +348,17 @@ struct map_params : common_params<Key, Compare, Alloc, TargetNodeSize, Multi,
   };
   using is_map_container = std::true_type;
 
-  template <typename V>
-  static auto key(const V &value) -> decltype(value.first) {
-    return value.first;
-  }
-  static const Key &key(const slot_type *s) { return slot_policy::key(s); }
-  static const Key &key(slot_type *s) { return slot_policy::key(s); }
-  // For use in node handle.
-  static auto mutable_key(slot_type *s)
-      -> decltype(slot_policy::mutable_key(s)) {
-    return slot_policy::mutable_key(s);
-  }
+  template <typename V> 
+  static auto key(const V &value) -> decltype(value.first) { 
+    return value.first; 
+  } 
+  static const Key &key(const slot_type *s) { return slot_policy::key(s); } 
+  static const Key &key(slot_type *s) { return slot_policy::key(s); } 
+  // For use in node handle. 
+  static auto mutable_key(slot_type *s) 
+      -> decltype(slot_policy::mutable_key(s)) { 
+    return slot_policy::mutable_key(s); 
+  } 
   static mapped_type &value(value_type *value) { return value->second; }
 };
 
@@ -413,10 +413,10 @@ struct set_params : common_params<Key, Compare, Alloc, TargetNodeSize, Multi,
       typename set_params::common_params::original_key_compare;
   using is_map_container = std::false_type;
 
-  template <typename V>
-  static const V &key(const V &value) { return value; }
-  static const Key &key(const slot_type *slot) { return *slot; }
-  static const Key &key(slot_type *slot) { return *slot; }
+  template <typename V> 
+  static const V &key(const V &value) { return value; } 
+  static const Key &key(const slot_type *slot) { return *slot; } 
+  static const Key &key(slot_type *slot) { return *slot; } 
 };
 
 // An adapter class that converts a lower-bound compare into an upper-bound
@@ -426,8 +426,8 @@ struct set_params : common_params<Key, Compare, Alloc, TargetNodeSize, Multi,
 template <typename Compare>
 struct upper_bound_adapter {
   explicit upper_bound_adapter(const Compare &c) : comp(c) {}
-  template <typename K1, typename K2>
-  bool operator()(const K1 &a, const K2 &b) const {
+  template <typename K1, typename K2> 
+  bool operator()(const K1 &a, const K2 &b) const { 
     // Returns true when a is not greater than b.
     return !compare_internal::compare_result_as_less_than(comp(b, a));
   }
@@ -452,10 +452,10 @@ struct SearchResult {
 // useful information.
 template <typename V>
 struct SearchResult<V, false> {
-  SearchResult() {}
-  explicit SearchResult(V value) : value(value) {}
-  SearchResult(V value, MatchKind /*match*/) : value(value) {}
-
+  SearchResult() {} 
+  explicit SearchResult(V value) : value(value) {} 
+  SearchResult(V value, MatchKind /*match*/) : value(value) {} 
+ 
   V value;
 
   static constexpr bool HasMatch() { return false; }
@@ -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 y_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 = y_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;
   }
 
@@ -748,7 +748,7 @@ class btree_node {
       }
       ++s;
     }
-    return SearchResult<int, false>{s};
+    return SearchResult<int, false>{s}; 
   }
 
   // Returns the position of the first value whose key is not less than k using
@@ -783,7 +783,7 @@ class btree_node {
         e = mid;
       }
     }
-    return SearchResult<int, false>{s};
+    return SearchResult<int, false>{s}; 
   }
 
   // Returns the position of the first value whose key is not less than k using
@@ -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 y_absl::weak_ordering c = comp(key(mid), k);
@@ -831,10 +831,10 @@ class btree_node {
   template <typename... Args>
   void emplace_value(size_type i, allocator_type *alloc, Args &&... args);
 
-  // Removes the values at positions [i, i + to_erase), shifting all existing
-  // values and children after that range to the left by to_erase. Clears all
-  // children between [i, i + to_erase).
-  void remove_values(field_type i, field_type to_erase, allocator_type *alloc);
+  // Removes the values at positions [i, i + to_erase), shifting all existing 
+  // values and children after that range to the left by to_erase. Clears all 
+  // children between [i, i + to_erase). 
+  void remove_values(field_type i, field_type to_erase, allocator_type *alloc); 
 
   // Rebalances a node with its right sibling.
   void rebalance_right_to_left(int to_move, btree_node *right,
@@ -846,87 +846,87 @@ class btree_node {
   void split(int insert_position, btree_node *dest, allocator_type *alloc);
 
   // Merges a node with its right sibling, moving all of the values and the
-  // delimiting key in the parent node onto itself, and deleting the src node.
-  void merge(btree_node *src, allocator_type *alloc);
+  // delimiting key in the parent node onto itself, and deleting the src node. 
+  void merge(btree_node *src, allocator_type *alloc); 
 
   // Node allocation/deletion routines.
-  void init_leaf(btree_node *parent, int max_count) {
-    set_parent(parent);
-    set_position(0);
-    set_start(0);
-    set_finish(0);
-    set_max_count(max_count);
+  void init_leaf(btree_node *parent, int max_count) { 
+    set_parent(parent); 
+    set_position(0); 
+    set_start(0); 
+    set_finish(0); 
+    set_max_count(max_count); 
     y_absl::container_internal::SanitizerPoisonMemoryRegion(
-        start_slot(), max_count * sizeof(slot_type));
+        start_slot(), max_count * sizeof(slot_type)); 
   }
-  void init_internal(btree_node *parent) {
-    init_leaf(parent, kNodeSlots);
+  void init_internal(btree_node *parent) { 
+    init_leaf(parent, kNodeSlots); 
     // Set `max_count` to a sentinel value to indicate that this node is
     // internal.
-    set_max_count(kInternalNodeMaxCount);
+    set_max_count(kInternalNodeMaxCount); 
     y_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,
-                         allocator_type *alloc) {
-    y_absl::container_internal::Deallocate<Alignment()>(alloc, node, size);
+  static void deallocate(const size_type size, btree_node *node, 
+                         allocator_type *alloc) { 
+    y_absl::container_internal::Deallocate<Alignment()>(alloc, node, size); 
   }
 
-  // Deletes a node and all of its children.
-  static void clear_and_delete(btree_node *node, allocator_type *alloc);
-
+  // Deletes a node and all of its children. 
+  static void clear_and_delete(btree_node *node, allocator_type *alloc); 
+ 
  private:
   template <typename... Args>
-  void value_init(const field_type i, allocator_type *alloc, Args &&... args) {
+  void value_init(const field_type i, allocator_type *alloc, Args &&... args) { 
     y_absl::container_internal::SanitizerUnpoisonObject(slot(i));
     params_type::construct(alloc, slot(i), std::forward<Args>(args)...);
   }
-  void value_destroy(const field_type i, allocator_type *alloc) {
+  void value_destroy(const field_type i, allocator_type *alloc) { 
     params_type::destroy(alloc, slot(i));
     y_absl::container_internal::SanitizerPoisonObject(slot(i));
   }
-  void value_destroy_n(const field_type i, const field_type n,
-                       allocator_type *alloc) {
-    for (slot_type *s = slot(i), *end = slot(i + n); s != end; ++s) {
-      params_type::destroy(alloc, s);
-      y_absl::container_internal::SanitizerPoisonObject(s);
-    }
-  }
-
-  static void transfer(slot_type *dest, slot_type *src, allocator_type *alloc) {
-    y_absl::container_internal::SanitizerUnpoisonObject(dest);
-    params_type::transfer(alloc, dest, src);
-    y_absl::container_internal::SanitizerPoisonObject(src);
-  }
-
-  // Transfers value from slot `src_i` in `src_node` to slot `dest_i` in `this`.
-  void transfer(const size_type dest_i, const size_type src_i,
-                btree_node *src_node, allocator_type *alloc) {
-    transfer(slot(dest_i), src_node->slot(src_i), alloc);
-  }
-
-  // Transfers `n` values starting at value `src_i` in `src_node` into the
-  // values starting at value `dest_i` in `this`.
-  void transfer_n(const size_type n, const size_type dest_i,
-                  const size_type src_i, btree_node *src_node,
-                  allocator_type *alloc) {
-    for (slot_type *src = src_node->slot(src_i), *end = src + n,
-                   *dest = slot(dest_i);
+  void value_destroy_n(const field_type i, const field_type n, 
+                       allocator_type *alloc) { 
+    for (slot_type *s = slot(i), *end = slot(i + n); s != end; ++s) { 
+      params_type::destroy(alloc, s); 
+      y_absl::container_internal::SanitizerPoisonObject(s); 
+    } 
+  } 
+
+  static void transfer(slot_type *dest, slot_type *src, allocator_type *alloc) { 
+    y_absl::container_internal::SanitizerUnpoisonObject(dest); 
+    params_type::transfer(alloc, dest, src); 
+    y_absl::container_internal::SanitizerPoisonObject(src); 
+  } 
+ 
+  // Transfers value from slot `src_i` in `src_node` to slot `dest_i` in `this`. 
+  void transfer(const size_type dest_i, const size_type src_i, 
+                btree_node *src_node, allocator_type *alloc) { 
+    transfer(slot(dest_i), src_node->slot(src_i), alloc); 
+  } 
+ 
+  // Transfers `n` values starting at value `src_i` in `src_node` into the 
+  // values starting at value `dest_i` in `this`. 
+  void transfer_n(const size_type n, const size_type dest_i, 
+                  const size_type src_i, btree_node *src_node, 
+                  allocator_type *alloc) { 
+    for (slot_type *src = src_node->slot(src_i), *end = src + n, 
+                   *dest = slot(dest_i); 
          src != end; ++src, ++dest) {
-      transfer(dest, src, alloc);
+      transfer(dest, src, alloc); 
     }
   }
 
-  // Same as above, except that we start at the end and work our way to the
-  // beginning.
-  void transfer_n_backward(const size_type n, const size_type dest_i,
-                           const size_type src_i, btree_node *src_node,
-                           allocator_type *alloc) {
-    for (slot_type *src = src_node->slot(src_i + n - 1), *end = src - n,
-                   *dest = slot(dest_i + n - 1);
-         src != end; --src, --dest) {
-      transfer(dest, src, alloc);
+  // Same as above, except that we start at the end and work our way to the 
+  // beginning. 
+  void transfer_n_backward(const size_type n, const size_type dest_i, 
+                           const size_type src_i, btree_node *src_node, 
+                           allocator_type *alloc) { 
+    for (slot_type *src = src_node->slot(src_i + n - 1), *end = src - n, 
+                   *dest = slot(dest_i + n - 1); 
+         src != end; --src, --dest) { 
+      transfer(dest, src, alloc); 
     }
   }
 
@@ -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,
             y_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
-      : node(other.node), position(other.position) {}
+  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,8 +992,8 @@ 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)
-      : node(const_cast<node_type *>(other.node)), position(other.position) {}
+  explicit btree_iterator(const btree_iterator<N, R, P> other) 
+      : node(const_cast<node_type *>(other.node)), position(other.position) {} 
 
   // Increment/decrement the iterator.
   void increment() {
@@ -1013,27 +1013,27 @@ struct btree_iterator {
   void decrement_slow();
 
  public:
-  bool operator==(const iterator &other) const {
-    return node == other.node && position == other.position;
+  bool operator==(const iterator &other) const { 
+    return node == other.node && position == other.position; 
   }
-  bool operator==(const const_iterator &other) const {
-    return node == other.node && position == other.position;
-  }
-  bool operator!=(const iterator &other) const {
-    return node != other.node || position != other.position;
-  }
-  bool operator!=(const const_iterator &other) const {
-    return node != other.node || position != other.position;
+  bool operator==(const const_iterator &other) const { 
+    return node == other.node && position == other.position; 
   }
+  bool operator!=(const iterator &other) const { 
+    return node != other.node || position != other.position; 
+  } 
+  bool operator!=(const const_iterator &other) const { 
+    return node != other.node || position != other.position; 
+  } 
 
   // Accessors for the key/value the iterator is pointing at.
-  reference operator*() const {
-    ABSL_HARDENING_ASSERT(node != nullptr);
-    ABSL_HARDENING_ASSERT(node->start() <= position);
-    ABSL_HARDENING_ASSERT(node->finish() > position);
-    return node->value(position);
-  }
-  pointer operator->() const { return &operator*(); }
+  reference operator*() const { 
+    ABSL_HARDENING_ASSERT(node != nullptr); 
+    ABSL_HARDENING_ASSERT(node->start() <= position); 
+    ABSL_HARDENING_ASSERT(node->finish() > position); 
+    return node->value(position); 
+  } 
+  pointer operator->() const { return &operator*(); } 
 
   btree_iterator &operator++() {
     increment();
@@ -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>
@@ -1076,8 +1076,8 @@ struct btree_iterator {
   // The node in the tree the iterator is pointing at.
   Node *node;
   // The position within the node of the tree the iterator is pointing at.
-  // NOTE: this is an int rather than a field_type because iterators can point
-  // to invalid positions (such as -1) in certain circumstances.
+  // NOTE: this is an int rather than a field_type because iterators can point 
+  // to invalid positions (such as -1) in certain circumstances. 
   int position;
 };
 
@@ -1085,8 +1085,8 @@ template <typename Params>
 class btree {
   using node_type = btree_node<Params>;
   using is_key_compare_to = typename Params::is_key_compare_to;
-  using init_type = typename Params::init_type;
-  using field_type = typename node_type::field_type;
+  using init_type = typename Params::init_type; 
+  using field_type = typename node_type::field_type; 
 
   // We use a static empty node for the root/leftmost/rightmost of empty btrees
   // in order to avoid branching in begin()/end().
@@ -1121,9 +1121,9 @@ class btree {
 #endif
   }
 
-  enum : uint32_t {
-    kNodeSlots = node_type::kNodeSlots,
-    kMinNodeValues = kNodeSlots / 2,
+  enum : uint32_t { 
+    kNodeSlots = node_type::kNodeSlots, 
+    kMinNodeValues = kNodeSlots / 2, 
   };
 
   struct node_stats {
@@ -1131,9 +1131,9 @@ class btree {
 
     node_stats(size_type l, size_type i) : leaf_nodes(l), internal_nodes(i) {}
 
-    node_stats &operator+=(const node_stats &other) {
-      leaf_nodes += other.leaf_nodes;
-      internal_nodes += other.internal_nodes;
+    node_stats &operator+=(const node_stats &other) { 
+      leaf_nodes += other.leaf_nodes; 
+      internal_nodes += other.internal_nodes; 
       return *this;
     }
 
@@ -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>;
@@ -1167,47 +1167,47 @@ 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));
-  }
+  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)); 
+  } 
 
   // 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.
+  // 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(btree &&other) noexcept
-      : root_(std::move(other.root_)),
-        rightmost_(y_absl::exchange(other.rightmost_, EmptyNode())),
-        size_(y_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(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_(y_absl::exchange(other.rightmost_, EmptyNode())), 
+        size_(y_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() {
     // Put static_asserts in destructor to avoid triggering them before the type
@@ -1216,9 +1216,9 @@ class btree {
     clear();
   }
 
-  // Assign the contents of other to *this.
-  btree &operator=(const btree &other);
-  btree &operator=(btree &&other) noexcept;
+  // Assign the contents of other to *this. 
+  btree &operator=(const btree &other); 
+  btree &operator=(btree &&other) noexcept; 
 
   iterator begin() { return iterator(leftmost()); }
   const_iterator begin() const { return const_iterator(leftmost()); }
@@ -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));
   }
@@ -1261,21 +1261,21 @@ class btree {
   }
 
   // Finds the range of values which compare equal to key. The first member of
-  // the returned pair is equal to lower_bound(key). The second member of the
-  // pair is equal to upper_bound(key).
+  // the returned pair is equal to lower_bound(key). The second member of the 
+  // pair is equal to upper_bound(key). 
   template <typename K>
-  std::pair<iterator, iterator> equal_range(const K &key);
+  std::pair<iterator, iterator> equal_range(const K &key); 
   template <typename K>
   std::pair<const_iterator, const_iterator> equal_range(const K &key) const {
-    return const_cast<btree *>(this)->equal_range(key);
+    return const_cast<btree *>(this)->equal_range(key); 
   }
 
   // Inserts a value into the btree only if it does not already exist. The
   // boolean return value indicates whether insertion succeeded or failed.
   // Requirement: if `key` already exists in the btree, does not consume `args`.
   // Requirement: `key` is never referenced after consuming `args`.
-  template <typename K, typename... Args>
-  std::pair<iterator, bool> insert_unique(const K &key, Args &&... args);
+  template <typename K, typename... Args> 
+  std::pair<iterator, bool> insert_unique(const K &key, Args &&... args); 
 
   // Inserts with hint. Checks to see if the value should be placed immediately
   // before `position` in the tree. If so, then the insertion will take
@@ -1283,23 +1283,23 @@ class btree {
   // logarithmic time as if a call to insert_unique() were made.
   // Requirement: if `key` already exists in the btree, does not consume `args`.
   // Requirement: `key` is never referenced after consuming `args`.
-  template <typename K, typename... Args>
+  template <typename K, typename... Args> 
   std::pair<iterator, bool> insert_hint_unique(iterator position,
-                                               const K &key,
+                                               const K &key, 
                                                Args &&... args);
 
   // Insert a range of values into the btree.
-  // Note: the first overload avoids constructing a value_type if the key
-  // already exists in the btree.
-  template <typename InputIterator,
-            typename = decltype(std::declval<const key_compare &>()(
-                params_type::key(*std::declval<InputIterator>()),
-                std::declval<const key_type &>()))>
-  void insert_iterator_unique(InputIterator b, InputIterator e, int);
-  // We need the second overload for cases in which we need to construct a
-  // value_type in order to compare it with the keys already in the btree.
+  // Note: the first overload avoids constructing a value_type if the key 
+  // already exists in the btree. 
+  template <typename InputIterator, 
+            typename = decltype(std::declval<const key_compare &>()( 
+                params_type::key(*std::declval<InputIterator>()), 
+                std::declval<const key_type &>()))> 
+  void insert_iterator_unique(InputIterator b, InputIterator e, int); 
+  // We need the second overload for cases in which we need to construct a 
+  // value_type in order to compare it with the keys already in the btree. 
   template <typename InputIterator>
-  void insert_iterator_unique(InputIterator b, InputIterator e, char);
+  void insert_iterator_unique(InputIterator b, InputIterator e, char); 
 
   // Inserts a value into the btree.
   template <typename ValueType>
@@ -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));
@@ -1346,15 +1346,15 @@ class btree {
   // Clear the btree, deleting all of the values it contains.
   void clear();
 
-  // Swaps the contents of `this` and `other`.
-  void swap(btree &other);
+  // Swaps the contents of `this` and `other`. 
+  void swap(btree &other); 
 
   const key_compare &key_comp() const noexcept {
     return root_.template get<0>();
   }
-  template <typename K1, typename K2>
-  bool compare_keys(const K1 &a, const K2 &b) const {
-    return compare_internal::compare_result_as_less_than(key_comp()(a, b));
+  template <typename K1, typename K2> 
+  bool compare_keys(const K1 &a, const K2 &b) const { 
+    return compare_internal::compare_result_as_less_than(key_comp()(a, b)); 
   }
 
   value_compare value_comp() const {
@@ -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
@@ -1468,19 +1468,19 @@ class btree {
 
   // Node creation/deletion routines.
   node_type *new_internal_node(node_type *parent) {
-    node_type *n = allocate(node_type::InternalSize());
-    n->init_internal(parent);
-    return n;
+    node_type *n = allocate(node_type::InternalSize()); 
+    n->init_internal(parent); 
+    return n; 
   }
   node_type *new_leaf_node(node_type *parent) {
-    node_type *n = allocate(node_type::LeafSize());
-    n->init_leaf(parent, kNodeSlots);
-    return n;
+    node_type *n = allocate(node_type::LeafSize()); 
+    n->init_leaf(parent, kNodeSlots); 
+    return n; 
   }
   node_type *new_leaf_root_node(const int max_count) {
-    node_type *n = allocate(node_type::LeafSize(max_count));
-    n->init_leaf(/*parent=*/n, max_count);
-    return n;
+    node_type *n = allocate(node_type::LeafSize(max_count)); 
+    n->init_leaf(/*parent=*/n, max_count); 
+    return n; 
   }
 
   // Deletion helper routines.
@@ -1523,19 +1523,19 @@ class btree {
   static IterType internal_last(IterType iter);
 
   // Returns an iterator pointing to the leaf position at which key would
-  // reside in the tree, unless there is an exact match - in which case, the
-  // result may not be on a leaf. When there's a three-way comparator, we can
-  // return whether there was an exact match. This allows the caller to avoid a
-  // subsequent comparison to determine if an exact match was made, which is
-  // important for keys with expensive comparison, such as strings.
+  // reside in the tree, unless there is an exact match - in which case, the 
+  // result may not be on a leaf. When there's a three-way comparator, we can 
+  // return whether there was an exact match. This allows the caller to avoid a 
+  // subsequent comparison to determine if an exact match was made, which is 
+  // important for keys with expensive comparison, such as strings. 
   template <typename K>
   SearchResult<iterator, is_key_compare_to::value> internal_locate(
       const K &key) const;
 
   // 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>
@@ -1590,8 +1590,8 @@ inline void btree_node<P>::emplace_value(const size_type i,
   // Shift old values to create space for new value and then construct it in
   // place.
   if (i < finish()) {
-    transfer_n_backward(finish() - i, /*dest_i=*/i + 1, /*src_i=*/i, this,
-                        alloc);
+    transfer_n_backward(finish() - i, /*dest_i=*/i + 1, /*src_i=*/i, this, 
+                        alloc); 
   }
   value_init(i, alloc, std::forward<Args>(args)...);
   set_finish(finish() + 1);
@@ -1605,27 +1605,27 @@ inline void btree_node<P>::emplace_value(const size_type i,
 }
 
 template <typename P>
-inline void btree_node<P>::remove_values(const field_type i,
-                                         const field_type to_erase,
-                                         allocator_type *alloc) {
-  // Transfer values after the removed range into their new places.
-  value_destroy_n(i, to_erase, alloc);
-  const field_type orig_finish = finish();
-  const field_type src_i = i + to_erase;
-  transfer_n(orig_finish - src_i, i, src_i, this, alloc);
-
-  if (!leaf()) {
-    // Delete all children between begin and end.
-    for (int j = 0; j < to_erase; ++j) {
-      clear_and_delete(child(i + j + 1), alloc);
-    }
-    // Rotate children after end into new positions.
-    for (int j = i + to_erase + 1; j <= orig_finish; ++j) {
-      set_child(j - to_erase, child(j));
-      clear_child(j);
+inline void btree_node<P>::remove_values(const field_type i, 
+                                         const field_type to_erase, 
+                                         allocator_type *alloc) { 
+  // Transfer values after the removed range into their new places. 
+  value_destroy_n(i, to_erase, alloc); 
+  const field_type orig_finish = finish(); 
+  const field_type src_i = i + to_erase; 
+  transfer_n(orig_finish - src_i, i, src_i, this, alloc); 
+ 
+  if (!leaf()) { 
+    // Delete all children between begin and end. 
+    for (int j = 0; j < to_erase; ++j) { 
+      clear_and_delete(child(i + j + 1), alloc); 
     }
+    // Rotate children after end into new positions. 
+    for (int j = i + to_erase + 1; j <= orig_finish; ++j) { 
+      set_child(j - to_erase, child(j)); 
+      clear_child(j); 
+    } 
   }
-  set_finish(orig_finish - to_erase);
+  set_finish(orig_finish - to_erase); 
 }
 
 template <typename P>
@@ -1639,17 +1639,17 @@ void btree_node<P>::rebalance_right_to_left(const int to_move,
   assert(to_move <= right->count());
 
   // 1) Move the delimiting value in the parent to the left node.
-  transfer(finish(), position(), parent(), alloc);
+  transfer(finish(), position(), parent(), alloc); 
 
   // 2) Move the (to_move - 1) values from the right node to the left node.
-  transfer_n(to_move - 1, finish() + 1, right->start(), right, alloc);
+  transfer_n(to_move - 1, finish() + 1, right->start(), right, alloc); 
 
   // 3) Move the new delimiting value to the parent from the right node.
-  parent()->transfer(position(), right->start() + to_move - 1, right, alloc);
+  parent()->transfer(position(), right->start() + to_move - 1, right, alloc); 
 
-  // 4) Shift the values in the right node to their correct positions.
-  right->transfer_n(right->count() - to_move, right->start(),
-                    right->start() + to_move, right, alloc);
+  // 4) Shift the values in the right node to their correct positions. 
+  right->transfer_n(right->count() - to_move, right->start(), 
+                    right->start() + to_move, right, alloc); 
 
   if (!leaf()) {
     // Move the child pointers from the right to the left node.
@@ -1684,19 +1684,19 @@ void btree_node<P>::rebalance_left_to_right(const int to_move,
   // Lastly, a new delimiting value is moved from the left node into the
   // parent, and the remaining empty left node entries are destroyed.
 
-  // 1) Shift existing values in the right node to their correct positions.
-  right->transfer_n_backward(right->count(), right->start() + to_move,
-                             right->start(), right, alloc);
+  // 1) Shift existing values in the right node to their correct positions. 
+  right->transfer_n_backward(right->count(), right->start() + to_move, 
+                             right->start(), right, alloc); 
 
-  // 2) Move the delimiting value in the parent to the right node.
-  right->transfer(right->start() + to_move - 1, position(), parent(), alloc);
+  // 2) Move the delimiting value in the parent to the right node. 
+  right->transfer(right->start() + to_move - 1, position(), parent(), alloc); 
 
-  // 3) Move the (to_move - 1) values from the left node to the right node.
-  right->transfer_n(to_move - 1, right->start(), finish() - (to_move - 1), this,
-                    alloc);
+  // 3) Move the (to_move - 1) values from the left node to the right node. 
+  right->transfer_n(to_move - 1, right->start(), finish() - (to_move - 1), this, 
+                    alloc); 
 
   // 4) Move the new delimiting value to the parent from the left node.
-  parent()->transfer(position(), finish() - to_move, this, alloc);
+  parent()->transfer(position(), finish() - to_move, this, alloc); 
 
   if (!leaf()) {
     // Move the child pointers from the left to the right node.
@@ -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);
@@ -1736,7 +1736,7 @@ void btree_node<P>::split(const int insert_position, btree_node *dest,
   assert(count() >= 1);
 
   // Move values from the left sibling to the right sibling.
-  dest->transfer_n(dest->count(), dest->start(), finish(), this, alloc);
+  dest->transfer_n(dest->count(), dest->start(), finish(), this, alloc); 
 
   // The split key is the largest value in the left sibling.
   --mutable_finish();
@@ -1763,7 +1763,7 @@ void btree_node<P>::merge(btree_node *src, allocator_type *alloc) {
   value_init(finish(), alloc, parent()->slot(position()));
 
   // Move the values from the right to the left node.
-  transfer_n(src->count(), finish() + 1, src->start(), src, alloc);
+  transfer_n(src->count(), finish() + 1, src->start(), src, alloc); 
 
   if (!leaf()) {
     // Move the child pointers from the right to the left node.
@@ -1777,58 +1777,58 @@ void btree_node<P>::merge(btree_node *src, allocator_type *alloc) {
   set_finish(start() + 1 + count() + src->count());
   src->set_finish(src->start());
 
-  // Remove the value on the parent node and delete the src node.
-  parent()->remove_values(position(), /*to_erase=*/1, alloc);
+  // Remove the value on the parent node and delete the src node. 
+  parent()->remove_values(position(), /*to_erase=*/1, alloc); 
 }
 
 template <typename P>
-void btree_node<P>::clear_and_delete(btree_node *node, allocator_type *alloc) {
-  if (node->leaf()) {
-    node->value_destroy_n(node->start(), node->count(), alloc);
-    deallocate(LeafSize(node->max_count()), node, alloc);
-    return;
-  }
-  if (node->count() == 0) {
-    deallocate(InternalSize(), node, alloc);
-    return;
-  }
-
-  // The parent of the root of the subtree we are deleting.
-  btree_node *delete_root_parent = node->parent();
-
-  // 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
-  // isn't guaranteed to be a valid `field_type`.
-  int pos = node->position();
-  btree_node *parent = node->parent();
-  for (;;) {
-    // In each iteration of the next loop, we delete one leaf node and go right.
-    assert(pos <= parent->finish());
-    do {
-      node = parent->child(pos);
-      if (!node->leaf()) {
-        // Navigate to the leftmost leaf under node.
-        while (!node->leaf()) node = node->start_child();
-        pos = node->position();
-        parent = node->parent();
-      }
-      node->value_destroy_n(node->start(), node->count(), alloc);
-      deallocate(LeafSize(node->max_count()), node, alloc);
-      ++pos;
-    } while (pos <= parent->finish());
-
-    // Once we've deleted all children of parent, delete parent and go up/right.
-    assert(pos > parent->finish());
-    do {
-      node = parent;
-      pos = node->position();
-      parent = node->parent();
-      node->value_destroy_n(node->start(), node->count(), alloc);
-      deallocate(InternalSize(), node, alloc);
-      if (parent == delete_root_parent) return;
-      ++pos;
-    } while (pos > parent->finish());
+void btree_node<P>::clear_and_delete(btree_node *node, allocator_type *alloc) { 
+  if (node->leaf()) { 
+    node->value_destroy_n(node->start(), node->count(), alloc); 
+    deallocate(LeafSize(node->max_count()), node, alloc); 
+    return; 
+  }
+  if (node->count() == 0) { 
+    deallocate(InternalSize(), node, alloc); 
+    return; 
+  }
+
+  // The parent of the root of the subtree we are deleting. 
+  btree_node *delete_root_parent = node->parent(); 
+
+  // 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 
+  // isn't guaranteed to be a valid `field_type`. 
+  int pos = node->position(); 
+  btree_node *parent = node->parent(); 
+  for (;;) { 
+    // In each iteration of the next loop, we delete one leaf node and go right. 
+    assert(pos <= parent->finish()); 
+    do { 
+      node = parent->child(pos); 
+      if (!node->leaf()) { 
+        // Navigate to the leftmost leaf under node. 
+        while (!node->leaf()) node = node->start_child(); 
+        pos = node->position(); 
+        parent = node->parent(); 
+      } 
+      node->value_destroy_n(node->start(), node->count(), alloc); 
+      deallocate(LeafSize(node->max_count()), node, alloc); 
+      ++pos; 
+    } while (pos <= parent->finish()); 
+ 
+    // Once we've deleted all children of parent, delete parent and go up/right. 
+    assert(pos > parent->finish()); 
+    do { 
+      node = parent; 
+      pos = node->position(); 
+      parent = node->parent(); 
+      node->value_destroy_n(node->start(), node->count(), alloc); 
+      deallocate(InternalSize(), node, alloc); 
+      if (parent == delete_root_parent) return; 
+      ++pos; 
+    } while (pos > parent->finish()); 
   }
 }
 
@@ -1844,7 +1844,7 @@ void btree_iterator<N, R, P>::increment_slow() {
       position = node->position();
       node = node->parent();
     }
-    // TODO(ezb): assert we aren't incrementing end() instead of handling.
+    // TODO(ezb): assert we aren't incrementing end() instead of handling. 
     if (position == node->finish()) {
       *this = save;
     }
@@ -1868,7 +1868,7 @@ void btree_iterator<N, R, P>::decrement_slow() {
       position = node->position() - 1;
       node = node->parent();
     }
-    // TODO(ezb): assert we aren't decrementing begin() instead of handling.
+    // TODO(ezb): assert we aren't decrementing begin() instead of handling. 
     if (position < node->start()) {
       *this = save;
     }
@@ -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 y_absl::{weak,strong}_ordering or bool.
@@ -1937,57 +1937,57 @@ 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 iterator next = std::next(lower);
-  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
-    // (see https://en.cppreference.com/w/cpp/named_req/Compare).
-    assert(next == end() || compare_keys(key, next.key()));
-    return {lower, next};
-  }
-  // 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.
-  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)
-  // behavior if we were to iterate over equal keys.
-  return {lower, upper_bound(key)};
+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 iterator next = std::next(lower); 
+  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 
+    // (see https://en.cppreference.com/w/cpp/named_req/Compare). 
+    assert(next == end() || compare_keys(key, next.key())); 
+    return {lower, next}; 
+  } 
+  // 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. 
+  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) 
+  // behavior if we were to iterate over equal keys. 
+  return {lower, upper_bound(key)}; 
 }
 
 template <typename P>
-template <typename K, typename... Args>
-auto btree<P>::insert_unique(const K &key, Args &&... args)
+template <typename K, typename... Args> 
+auto btree<P>::insert_unique(const K &key, Args &&... args) 
     -> std::pair<iterator, bool> {
   if (empty()) {
     mutable_root() = rightmost_ = new_leaf_root_node(1);
   }
 
-  SearchResult<iterator, is_key_compare_to::value> res = internal_locate(key);
-  iterator iter = res.value;
+  SearchResult<iterator, is_key_compare_to::value> res = internal_locate(key); 
+  iterator iter = res.value; 
 
   if (res.HasMatch()) {
     if (res.IsEq()) {
@@ -2005,8 +2005,8 @@ auto btree<P>::insert_unique(const K &key, Args &&... args)
 }
 
 template <typename P>
-template <typename K, typename... Args>
-inline auto btree<P>::insert_hint_unique(iterator position, const K &key,
+template <typename K, typename... Args> 
+inline auto btree<P>::insert_hint_unique(iterator position, const K &key, 
                                          Args &&... args)
     -> std::pair<iterator, bool> {
   if (!empty()) {
@@ -2030,23 +2030,23 @@ inline auto btree<P>::insert_hint_unique(iterator position, const K &key,
 }
 
 template <typename P>
-template <typename InputIterator, typename>
-void btree<P>::insert_iterator_unique(InputIterator b, InputIterator e, int) {
+template <typename InputIterator, typename> 
+void btree<P>::insert_iterator_unique(InputIterator b, InputIterator e, int) { 
   for (; b != e; ++b) {
     insert_hint_unique(end(), params_type::key(*b), *b);
   }
 }
 
 template <typename P>
-template <typename InputIterator>
-void btree<P>::insert_iterator_unique(InputIterator b, InputIterator e, char) {
-  for (; b != e; ++b) {
-    init_type value(*b);
-    insert_hint_unique(end(), params_type::key(value), std::move(value));
-  }
-}
-
-template <typename P>
+template <typename InputIterator> 
+void btree<P>::insert_iterator_unique(InputIterator b, InputIterator e, char) { 
+  for (; b != e; ++b) { 
+    init_type value(*b); 
+    insert_hint_unique(end(), params_type::key(value), std::move(value)); 
+  } 
+} 
+ 
+template <typename P> 
 template <typename ValueType>
 auto btree<P>::insert_multi(const key_type &key, ValueType &&v) -> iterator {
   if (empty()) {
@@ -2091,47 +2091,47 @@ void btree<P>::insert_iterator_multi(InputIterator b, InputIterator e) {
 }
 
 template <typename P>
-auto btree<P>::operator=(const btree &other) -> btree & {
-  if (this != &other) {
+auto btree<P>::operator=(const btree &other) -> btree & { 
+  if (this != &other) { 
     clear();
 
-    *mutable_key_comp() = other.key_comp();
+    *mutable_key_comp() = other.key_comp(); 
     if (y_absl::allocator_traits<
             allocator_type>::propagate_on_container_copy_assignment::value) {
-      *mutable_allocator() = other.allocator();
+      *mutable_allocator() = other.allocator(); 
     }
 
-    copy_or_move_values_in_order(other);
+    copy_or_move_values_in_order(other); 
   }
   return *this;
 }
 
 template <typename P>
-auto btree<P>::operator=(btree &&other) noexcept -> btree & {
-  if (this != &other) {
+auto btree<P>::operator=(btree &&other) noexcept -> btree & { 
+  if (this != &other) { 
     clear();
 
     using std::swap;
     if (y_absl::allocator_traits<
             allocator_type>::propagate_on_container_copy_assignment::value) {
       // Note: `root_` also contains the allocator and the key comparator.
-      swap(root_, other.root_);
-      swap(rightmost_, other.rightmost_);
-      swap(size_, other.size_);
+      swap(root_, other.root_); 
+      swap(rightmost_, other.rightmost_); 
+      swap(size_, other.size_); 
     } else {
-      if (allocator() == other.allocator()) {
-        swap(mutable_root(), other.mutable_root());
-        swap(*mutable_key_comp(), *other.mutable_key_comp());
-        swap(rightmost_, other.rightmost_);
-        swap(size_, other.size_);
+      if (allocator() == other.allocator()) { 
+        swap(mutable_root(), other.mutable_root()); 
+        swap(*mutable_key_comp(), *other.mutable_key_comp()); 
+        swap(rightmost_, other.rightmost_); 
+        swap(size_, other.size_); 
       } else {
         // We aren't allowed to propagate the allocator and the allocator is
         // different so we can't take over its memory. We must move each element
-        // individually. We need both `other` and `this` to have `other`s key
-        // 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);
+        // individually. We need both `other` and `this` to have `other`s key 
+        // 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); 
       }
     }
   }
@@ -2143,7 +2143,7 @@ auto btree<P>::erase(iterator iter) -> iterator {
   bool internal_delete = false;
   if (!iter.node->leaf()) {
     // Deletion of a value on an internal node. First, move the largest value
-    // from our left child here, then delete that position (in remove_values()
+    // from our left child here, then delete that position (in remove_values() 
     // below). We can get to the largest value from our left child by
     // decrementing iter.
     iterator internal_iter(iter);
@@ -2155,7 +2155,7 @@ auto btree<P>::erase(iterator iter) -> iterator {
   }
 
   // Delete the key from the leaf.
-  iter.node->remove_values(iter.position, /*to_erase=*/1, mutable_allocator());
+  iter.node->remove_values(iter.position, /*to_erase=*/1, mutable_allocator()); 
   --size_;
 
   // We want to return the next value after the one we just erased. If we
@@ -2230,9 +2230,9 @@ auto btree<P>::erase_range(iterator begin, iterator end)
   }
 
   if (begin.node == end.node) {
-    assert(end.position > begin.position);
-    begin.node->remove_values(begin.position, end.position - begin.position,
-                              mutable_allocator());
+    assert(end.position > begin.position); 
+    begin.node->remove_values(begin.position, end.position - begin.position, 
+                              mutable_allocator()); 
     size_ -= count;
     return {count, rebalance_after_delete(begin)};
   }
@@ -2242,11 +2242,11 @@ auto btree<P>::erase_range(iterator begin, iterator end)
     if (begin.node->leaf()) {
       const size_type remaining_to_erase = size_ - target_size;
       const size_type remaining_in_node = begin.node->finish() - begin.position;
-      const size_type to_erase =
-          (std::min)(remaining_to_erase, remaining_in_node);
-      begin.node->remove_values(begin.position, to_erase, mutable_allocator());
-      size_ -= to_erase;
-      begin = rebalance_after_delete(begin);
+      const size_type to_erase = 
+          (std::min)(remaining_to_erase, remaining_in_node); 
+      begin.node->remove_values(begin.position, to_erase, mutable_allocator()); 
+      size_ -= to_erase; 
+      begin = rebalance_after_delete(begin); 
     } else {
       begin = erase(begin);
     }
@@ -2257,7 +2257,7 @@ auto btree<P>::erase_range(iterator begin, iterator end)
 template <typename P>
 void btree<P>::clear() {
   if (!empty()) {
-    node_type::clear_and_delete(root(), mutable_allocator());
+    node_type::clear_and_delete(root(), mutable_allocator()); 
   }
   mutable_root() = EmptyNode();
   rightmost_ = EmptyNode();
@@ -2265,20 +2265,20 @@ void btree<P>::clear() {
 }
 
 template <typename P>
-void btree<P>::swap(btree &other) {
+void btree<P>::swap(btree &other) { 
   using std::swap;
   if (y_absl::allocator_traits<
           allocator_type>::propagate_on_container_swap::value) {
     // Note: `root_` also contains the allocator and the key comparator.
-    swap(root_, other.root_);
+    swap(root_, other.root_); 
   } else {
     // It's undefined behavior if the allocators are unequal here.
-    assert(allocator() == other.allocator());
-    swap(mutable_root(), other.mutable_root());
-    swap(*mutable_key_comp(), *other.mutable_key_comp());
+    assert(allocator() == other.allocator()); 
+    swap(mutable_root(), other.mutable_root()); 
+    swap(*mutable_key_comp(), *other.mutable_key_comp()); 
   }
-  swap(rightmost_, other.rightmost_);
-  swap(size_, other.size_);
+  swap(rightmost_, other.rightmost_); 
+  swap(size_, other.size_); 
 }
 
 template <typename P>
@@ -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);
     }
@@ -2398,7 +2398,7 @@ void btree<P>::rebalance_or_split(iterator *iter) {
 template <typename P>
 void btree<P>::merge_nodes(node_type *left, node_type *right) {
   left->merge(right, mutable_allocator());
-  if (rightmost_ == right) rightmost_ = left;
+  if (rightmost_ == right) rightmost_ = left; 
 }
 
 template <typename P>
@@ -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;
     }
@@ -2455,20 +2455,20 @@ bool btree<P>::try_merge_or_rebalance(iterator *iter) {
 
 template <typename P>
 void btree<P>::try_shrink() {
-  node_type *orig_root = root();
-  if (orig_root->count() > 0) {
+  node_type *orig_root = root(); 
+  if (orig_root->count() > 0) { 
     return;
   }
   // Deleted the last item on the root node, shrink the height of the tree.
-  if (orig_root->leaf()) {
+  if (orig_root->leaf()) { 
     assert(size() == 0);
-    mutable_root() = rightmost_ = EmptyNode();
+    mutable_root() = rightmost_ = EmptyNode(); 
   } else {
-    node_type *child = orig_root->start_child();
+    node_type *child = orig_root->start_child(); 
     child->make_root();
     mutable_root() = child;
   }
-  node_type::clear_and_delete(orig_root, mutable_allocator());
+  node_type::clear_and_delete(orig_root, mutable_allocator()); 
 }
 
 template <typename P>
@@ -2496,30 +2496,30 @@ inline auto btree<P>::internal_emplace(iterator iter, Args &&... args)
     --iter;
     ++iter.position;
   }
-  const field_type max_count = iter.node->max_count();
-  allocator_type *alloc = mutable_allocator();
+  const field_type max_count = iter.node->max_count(); 
+  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));
-      // Transfer the values from the old root to the new root.
-      node_type *old_root = root();
-      node_type *new_root = iter.node;
-      new_root->transfer_n(old_root->count(), new_root->start(),
-                           old_root->start(), old_root, alloc);
-      new_root->set_finish(old_root->finish());
-      old_root->set_finish(old_root->start());
-      node_type::clear_and_delete(old_root, alloc);
-      mutable_root() = rightmost_ = new_root;
+          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; 
+      new_root->transfer_n(old_root->count(), new_root->start(), 
+                           old_root->start(), old_root, alloc); 
+      new_root->set_finish(old_root->finish()); 
+      old_root->set_finish(old_root->start()); 
+      node_type::clear_and_delete(old_root, alloc); 
+      mutable_root() = rightmost_ = new_root; 
     } else {
       rebalance_or_split(&iter);
     }
   }
-  iter.node->emplace_value(iter.position, alloc, std::forward<Args>(args)...);
+  iter.node->emplace_value(iter.position, alloc, std::forward<Args>(args)...); 
   ++size_;
   return iter;
 }
@@ -2530,49 +2530,49 @@ inline auto btree<P>::internal_locate(const K &key) const
     -> SearchResult<iterator, is_key_compare_to::value> {
   iterator iter(const_cast<node_type *>(root()));
   for (;;) {
-    SearchResult<int, is_key_compare_to::value> res =
-        iter.node->lower_bound(key, key_comp());
+    SearchResult<int, is_key_compare_to::value> res = 
+        iter.node->lower_bound(key, key_comp()); 
     iter.position = res.value;
-    if (res.IsEq()) {
+    if (res.IsEq()) { 
       return {iter, MatchKind::kEq};
     }
-    // Note: in the non-key-compare-to case, we don't need to walk all the way
-    // down the tree if the keys are equal, but determining equality would
-    // require doing an extra comparison on each node on the way down, and we
-    // will need to go all the way to the leaf node in the expected case.
+    // Note: in the non-key-compare-to case, we don't need to walk all the way 
+    // down the tree if the keys are equal, but determining equality would 
+    // require doing an extra comparison on each node on the way down, and we 
+    // will need to go all the way to the leaf node in the expected case. 
     if (iter.node->leaf()) {
       break;
     }
     iter.node = iter.node->child(iter.position);
   }
-  // Note: in the non-key-compare-to case, the key may actually be equivalent
-  // here (and the MatchKind::kNe is ignored).
+  // Note: in the non-key-compare-to case, the key may actually be equivalent 
+  // here (and the MatchKind::kNe is ignored). 
   return {iter, MatchKind::kNe};
 }
 
 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>
@@ -2592,7 +2592,7 @@ auto btree<P>::internal_upper_bound(const K &key) const -> iterator {
 template <typename P>
 template <typename K>
 auto btree<P>::internal_find(const K &key) const -> iterator {
-  SearchResult<iterator, is_key_compare_to::value> res = internal_locate(key);
+  SearchResult<iterator, is_key_compare_to::value> res = internal_locate(key); 
   if (res.HasMatch()) {
     if (res.IsEq()) {
       return res.value;
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/btree_container.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/btree_container.h
index d23feff31b..d67a7fe890 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/btree_container.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/btree_container.h
@@ -24,7 +24,7 @@
 #include "y_absl/base/internal/throw_delegate.h"
 #include "y_absl/container/internal/btree.h"  // IWYU pragma: export
 #include "y_absl/container/internal/common.h"
-#include "y_absl/memory/memory.h"
+#include "y_absl/memory/memory.h" 
 #include "y_absl/meta/type_traits.h"
 
 namespace y_absl {
@@ -70,23 +70,23 @@ 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, y_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(
+  explicit btree_container(const allocator_type &alloc) 
+      : tree_(key_compare(), alloc) {} 
+ 
+  btree_container(const btree_container &other) 
+      : btree_container(other, y_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;
 
   // Iterator routines.
@@ -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) {
@@ -178,7 +178,7 @@ class btree_container {
 
   // Utility routines.
   ABSL_ATTRIBUTE_REINITIALIZES void clear() { tree_.clear(); }
-  void swap(btree_container &other) { tree_.swap(other.tree_); }
+  void swap(btree_container &other) { tree_.swap(other.tree_); } 
   void verify() const { tree_.verify(); }
 
   // Size routines.
@@ -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,55 +267,55 @@ 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) {
-    return this->tree_.insert_unique(params_type::key(v), v);
+  std::pair<iterator, bool> insert(const value_type &v) { 
+    return this->tree_.insert_unique(params_type::key(v), v); 
   }
-  std::pair<iterator, bool> insert(value_type &&v) {
-    return this->tree_.insert_unique(params_type::key(v), std::move(v));
+  std::pair<iterator, bool> insert(value_type &&v) { 
+    return this->tree_.insert_unique(params_type::key(v), std::move(v)); 
   }
   template <typename... Args>
   std::pair<iterator, bool> emplace(Args &&... args) {
     init_type v(std::forward<Args>(args)...);
     return this->tree_.insert_unique(params_type::key(v), std::move(v));
   }
-  iterator insert(const_iterator hint, const value_type &v) {
+  iterator insert(const_iterator hint, const value_type &v) { 
     return this->tree_
-        .insert_hint_unique(iterator(hint), params_type::key(v), v)
+        .insert_hint_unique(iterator(hint), params_type::key(v), v) 
         .first;
   }
-  iterator insert(const_iterator hint, value_type &&v) {
+  iterator insert(const_iterator hint, value_type &&v) { 
     return this->tree_
-        .insert_hint_unique(iterator(hint), params_type::key(v), std::move(v))
+        .insert_hint_unique(iterator(hint), params_type::key(v), std::move(v)) 
         .first;
   }
   template <typename... Args>
-  iterator emplace_hint(const_iterator hint, Args &&... args) {
+  iterator emplace_hint(const_iterator hint, Args &&... args) { 
     init_type v(std::forward<Args>(args)...);
     return this->tree_
-        .insert_hint_unique(iterator(hint), params_type::key(v), std::move(v))
+        .insert_hint_unique(iterator(hint), params_type::key(v), std::move(v)) 
         .first;
   }
   template <typename InputIterator>
   void insert(InputIterator b, InputIterator e) {
-    this->tree_.insert_iterator_unique(b, e, 0);
+    this->tree_.insert_iterator_unique(b, e, 0); 
   }
   void insert(std::initializer_list<init_type> init) {
-    this->tree_.insert_iterator_unique(init.begin(), init.end(), 0);
+    this->tree_.insert_iterator_unique(init.begin(), init.end(), 0); 
   }
   insert_return_type insert(node_type &&node) {
     if (!node) return {this->end(), false, node_type()};
@@ -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;
 
@@ -362,7 +362,7 @@ class btree_set_container : public btree_container<Tree> {
           int> = 0>
   void merge(btree_container<T> &src) {  // NOLINT
     for (auto src_it = src.begin(); src_it != src.end();) {
-      if (insert(std::move(params_type::element(src_it.slot()))).second) {
+      if (insert(std::move(params_type::element(src_it.slot()))).second) { 
         src_it = src.erase(src_it);
       } else {
         ++src_it;
@@ -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>
@@ -411,72 +411,72 @@ class btree_map_container : public btree_set_container<Tree> {
   // Insertion routines.
   // Note: the nullptr template arguments and extra `const M&` overloads allow
   // for supporting bitfield arguments.
-  template <typename K = key_type, class M>
-  std::pair<iterator, bool> insert_or_assign(const key_arg<K> &k,
-                                             const M &obj) {
-    return insert_or_assign_impl(k, obj);
+  template <typename K = key_type, class M> 
+  std::pair<iterator, bool> insert_or_assign(const key_arg<K> &k, 
+                                             const M &obj) { 
+    return insert_or_assign_impl(k, obj); 
   }
-  template <typename K = key_type, class M, K * = nullptr>
-  std::pair<iterator, bool> insert_or_assign(key_arg<K> &&k, const M &obj) {
-    return insert_or_assign_impl(std::forward<K>(k), obj);
+  template <typename K = key_type, class M, K * = nullptr> 
+  std::pair<iterator, bool> insert_or_assign(key_arg<K> &&k, const M &obj) { 
+    return insert_or_assign_impl(std::forward<K>(k), obj); 
   }
-  template <typename K = key_type, class M, M * = nullptr>
-  std::pair<iterator, bool> insert_or_assign(const key_arg<K> &k, M &&obj) {
-    return insert_or_assign_impl(k, std::forward<M>(obj));
+  template <typename K = key_type, class M, M * = nullptr> 
+  std::pair<iterator, bool> insert_or_assign(const key_arg<K> &k, M &&obj) { 
+    return insert_or_assign_impl(k, std::forward<M>(obj)); 
   }
-  template <typename K = key_type, class M, K * = nullptr, M * = nullptr>
-  std::pair<iterator, bool> insert_or_assign(key_arg<K> &&k, M &&obj) {
-    return insert_or_assign_impl(std::forward<K>(k), std::forward<M>(obj));
+  template <typename K = key_type, class M, K * = nullptr, M * = nullptr> 
+  std::pair<iterator, bool> insert_or_assign(key_arg<K> &&k, M &&obj) { 
+    return insert_or_assign_impl(std::forward<K>(k), std::forward<M>(obj)); 
   }
-  template <typename K = key_type, class M>
-  iterator insert_or_assign(const_iterator hint, const key_arg<K> &k,
+  template <typename K = key_type, class M> 
+  iterator insert_or_assign(const_iterator hint, const key_arg<K> &k, 
                             const M &obj) {
-    return insert_or_assign_hint_impl(hint, k, obj);
-  }
-  template <typename K = key_type, class M, K * = nullptr>
-  iterator insert_or_assign(const_iterator hint, key_arg<K> &&k, const M &obj) {
-    return insert_or_assign_hint_impl(hint, std::forward<K>(k), obj);
-  }
-  template <typename K = key_type, class M, M * = nullptr>
-  iterator insert_or_assign(const_iterator hint, const key_arg<K> &k, M &&obj) {
-    return insert_or_assign_hint_impl(hint, k, std::forward<M>(obj));
-  }
-  template <typename K = key_type, class M, K * = nullptr, M * = nullptr>
-  iterator insert_or_assign(const_iterator hint, key_arg<K> &&k, M &&obj) {
-    return insert_or_assign_hint_impl(hint, std::forward<K>(k),
-                                      std::forward<M>(obj));
-  }
-
-  template <typename K = key_type, typename... Args,
-            typename y_absl::enable_if_t<
-                !std::is_convertible<K, const_iterator>::value, int> = 0>
-  std::pair<iterator, bool> try_emplace(const key_arg<K> &k, Args &&... args) {
-    return try_emplace_impl(k, std::forward<Args>(args)...);
-  }
-  template <typename K = key_type, typename... Args,
-            typename y_absl::enable_if_t<
-                !std::is_convertible<K, const_iterator>::value, int> = 0>
-  std::pair<iterator, bool> try_emplace(key_arg<K> &&k, Args &&... args) {
-    return try_emplace_impl(std::forward<K>(k), std::forward<Args>(args)...);
-  }
-  template <typename K = key_type, typename... Args>
-  iterator try_emplace(const_iterator hint, const key_arg<K> &k,
+    return insert_or_assign_hint_impl(hint, k, obj); 
+  }
+  template <typename K = key_type, class M, K * = nullptr> 
+  iterator insert_or_assign(const_iterator hint, key_arg<K> &&k, const M &obj) { 
+    return insert_or_assign_hint_impl(hint, std::forward<K>(k), obj); 
+  }
+  template <typename K = key_type, class M, M * = nullptr> 
+  iterator insert_or_assign(const_iterator hint, const key_arg<K> &k, M &&obj) { 
+    return insert_or_assign_hint_impl(hint, k, std::forward<M>(obj)); 
+  }
+  template <typename K = key_type, class M, K * = nullptr, M * = nullptr> 
+  iterator insert_or_assign(const_iterator hint, key_arg<K> &&k, M &&obj) { 
+    return insert_or_assign_hint_impl(hint, std::forward<K>(k), 
+                                      std::forward<M>(obj)); 
+  }
+ 
+  template <typename K = key_type, typename... Args, 
+            typename y_absl::enable_if_t< 
+                !std::is_convertible<K, const_iterator>::value, int> = 0> 
+  std::pair<iterator, bool> try_emplace(const key_arg<K> &k, Args &&... args) { 
+    return try_emplace_impl(k, std::forward<Args>(args)...); 
+  }
+  template <typename K = key_type, typename... Args, 
+            typename y_absl::enable_if_t< 
+                !std::is_convertible<K, const_iterator>::value, int> = 0> 
+  std::pair<iterator, bool> try_emplace(key_arg<K> &&k, Args &&... args) { 
+    return try_emplace_impl(std::forward<K>(k), std::forward<Args>(args)...); 
+  }
+  template <typename K = key_type, typename... Args> 
+  iterator try_emplace(const_iterator hint, const key_arg<K> &k, 
                        Args &&... args) {
-    return try_emplace_hint_impl(hint, k, std::forward<Args>(args)...);
+    return try_emplace_hint_impl(hint, k, std::forward<Args>(args)...); 
   }
-  template <typename K = key_type, typename... Args>
-  iterator try_emplace(const_iterator hint, key_arg<K> &&k, Args &&... args) {
-    return try_emplace_hint_impl(hint, std::forward<K>(k),
-                                 std::forward<Args>(args)...);
+  template <typename K = key_type, typename... Args> 
+  iterator try_emplace(const_iterator hint, key_arg<K> &&k, Args &&... args) { 
+    return try_emplace_hint_impl(hint, std::forward<K>(k), 
+                                 std::forward<Args>(args)...); 
   }
-
-  template <typename K = key_type>
-  mapped_type &operator[](const key_arg<K> &k) {
+ 
+  template <typename K = key_type> 
+  mapped_type &operator[](const key_arg<K> &k) { 
     return try_emplace(k).first->second;
   }
-  template <typename K = key_type>
-  mapped_type &operator[](key_arg<K> &&k) {
-    return try_emplace(std::forward<K>(k)).first->second;
+  template <typename K = key_type> 
+  mapped_type &operator[](key_arg<K> &&k) { 
+    return try_emplace(std::forward<K>(k)).first->second; 
   }
 
   template <typename K = key_type>
@@ -493,40 +493,40 @@ class btree_map_container : public btree_set_container<Tree> {
       base_internal::ThrowStdOutOfRange("y_absl::btree_map::at");
     return it->second;
   }
-
- private:
-  // Note: when we call `std::forward<M>(obj)` twice, it's safe because
-  // insert_unique/insert_hint_unique are guaranteed to not consume `obj` when
-  // `ret.second` is false.
-  template <class K, class M>
-  std::pair<iterator, bool> insert_or_assign_impl(K &&k, M &&obj) {
-    const std::pair<iterator, bool> ret =
-        this->tree_.insert_unique(k, std::forward<K>(k), std::forward<M>(obj));
-    if (!ret.second) ret.first->second = std::forward<M>(obj);
-    return ret;
-  }
-  template <class K, class M>
-  iterator insert_or_assign_hint_impl(const_iterator hint, K &&k, M &&obj) {
-    const std::pair<iterator, bool> ret = this->tree_.insert_hint_unique(
-        iterator(hint), k, std::forward<K>(k), std::forward<M>(obj));
-    if (!ret.second) ret.first->second = std::forward<M>(obj);
-    return ret.first;
-  }
-
-  template <class K, class... Args>
-  std::pair<iterator, bool> try_emplace_impl(K &&k, Args &&... args) {
-    return this->tree_.insert_unique(
-        k, std::piecewise_construct, std::forward_as_tuple(std::forward<K>(k)),
-        std::forward_as_tuple(std::forward<Args>(args)...));
-  }
-  template <class K, class... Args>
-  iterator try_emplace_hint_impl(const_iterator hint, K &&k, Args &&... args) {
-    return this->tree_
-        .insert_hint_unique(iterator(hint), k, std::piecewise_construct,
-                            std::forward_as_tuple(std::forward<K>(k)),
-                            std::forward_as_tuple(std::forward<Args>(args)...))
-        .first;
-  }
+ 
+ private: 
+  // Note: when we call `std::forward<M>(obj)` twice, it's safe because 
+  // insert_unique/insert_hint_unique are guaranteed to not consume `obj` when 
+  // `ret.second` is false. 
+  template <class K, class M> 
+  std::pair<iterator, bool> insert_or_assign_impl(K &&k, M &&obj) { 
+    const std::pair<iterator, bool> ret = 
+        this->tree_.insert_unique(k, std::forward<K>(k), std::forward<M>(obj)); 
+    if (!ret.second) ret.first->second = std::forward<M>(obj); 
+    return ret; 
+  } 
+  template <class K, class M> 
+  iterator insert_or_assign_hint_impl(const_iterator hint, K &&k, M &&obj) { 
+    const std::pair<iterator, bool> ret = this->tree_.insert_hint_unique( 
+        iterator(hint), k, std::forward<K>(k), std::forward<M>(obj)); 
+    if (!ret.second) ret.first->second = std::forward<M>(obj); 
+    return ret.first; 
+  } 
+ 
+  template <class K, class... Args> 
+  std::pair<iterator, bool> try_emplace_impl(K &&k, Args &&... args) { 
+    return this->tree_.insert_unique( 
+        k, std::piecewise_construct, std::forward_as_tuple(std::forward<K>(k)), 
+        std::forward_as_tuple(std::forward<Args>(args)...)); 
+  } 
+  template <class K, class... Args> 
+  iterator try_emplace_hint_impl(const_iterator hint, K &&k, Args &&... args) { 
+    return this->tree_ 
+        .insert_hint_unique(iterator(hint), k, std::piecewise_construct, 
+                            std::forward_as_tuple(std::forward<K>(k)), 
+                            std::forward_as_tuple(std::forward<Args>(args)...)) 
+        .first; 
+  } 
 };
 
 // A common base class for btree_multiset and btree_multimap.
@@ -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,30 +562,30 @@ 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); }
-  iterator insert(value_type &&v) {
-    return this->tree_.insert_multi(std::move(v));
+  iterator insert(const value_type &v) { return this->tree_.insert_multi(v); } 
+  iterator insert(value_type &&v) { 
+    return this->tree_.insert_multi(std::move(v)); 
   }
-  iterator insert(const_iterator hint, const value_type &v) {
-    return this->tree_.insert_hint_multi(iterator(hint), v);
+  iterator insert(const_iterator hint, const value_type &v) { 
+    return this->tree_.insert_hint_multi(iterator(hint), v); 
   }
-  iterator insert(const_iterator hint, value_type &&v) {
-    return this->tree_.insert_hint_multi(iterator(hint), std::move(v));
+  iterator insert(const_iterator hint, value_type &&v) { 
+    return this->tree_.insert_hint_multi(iterator(hint), std::move(v)); 
   }
   template <typename InputIterator>
   void insert(InputIterator b, InputIterator e) {
@@ -599,9 +599,9 @@ class btree_multiset_container : public btree_container<Tree> {
     return this->tree_.insert_multi(init_type(std::forward<Args>(args)...));
   }
   template <typename... Args>
-  iterator emplace_hint(const_iterator hint, Args &&... args) {
+  iterator emplace_hint(const_iterator hint, Args &&... args) { 
     return this->tree_.insert_hint_multi(
-        iterator(hint), init_type(std::forward<Args>(args)...));
+        iterator(hint), init_type(std::forward<Args>(args)...)); 
   }
   iterator insert(node_type &&node) {
     if (!node) return this->end();
@@ -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;
 
@@ -642,9 +642,9 @@ class btree_multiset_container : public btree_container<Tree> {
                            typename T::params_type::is_map_container>>::value,
           int> = 0>
   void merge(btree_container<T> &src) {  // NOLINT
-    for (auto src_it = src.begin(), end = src.end(); src_it != end; ++src_it) {
-      insert(std::move(params_type::element(src_it.slot())));
-    }
+    for (auto src_it = src.begin(), end = src.end(); src_it != end; ++src_it) { 
+      insert(std::move(params_type::element(src_it.slot()))); 
+    } 
     src.clear();
   }
 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/common.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/common.h
index ec84f975e5..1e02f0ca34 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/common.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/common.h
@@ -138,7 +138,7 @@ class node_handle<Policy, PolicyTraits, Alloc,
                   y_absl::void_t<typename Policy::mapped_type>>
     : public node_handle_base<PolicyTraits, Alloc> {
   using Base = node_handle_base<PolicyTraits, Alloc>;
-  using slot_type = typename PolicyTraits::slot_type;
+  using slot_type = typename PolicyTraits::slot_type; 
 
  public:
   using key_type = typename Policy::key_type;
@@ -146,11 +146,11 @@ class node_handle<Policy, PolicyTraits, Alloc,
 
   constexpr node_handle() {}
 
-  // When C++17 is available, we can use std::launder to provide mutable
-  // access to the key. Otherwise, we provide const access.
-  auto key() const
-      -> decltype(PolicyTraits::mutable_key(std::declval<slot_type*>())) {
-    return PolicyTraits::mutable_key(this->slot());
+  // When C++17 is available, we can use std::launder to provide mutable 
+  // access to the key. Otherwise, we provide const access. 
+  auto key() const 
+      -> decltype(PolicyTraits::mutable_key(std::declval<slot_type*>())) { 
+    return PolicyTraits::mutable_key(this->slot()); 
   }
 
   mapped_type& mapped() const {
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/compressed_tuple.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/compressed_tuple.h
index 735b738a9b..e12cc50a81 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/compressed_tuple.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/compressed_tuple.h
@@ -169,34 +169,34 @@ constexpr bool ShouldAnyUseBase() {
 }
 
 template <typename T, typename V>
-using TupleElementMoveConstructible =
-    typename std::conditional<std::is_reference<T>::value,
-                              std::is_convertible<V, T>,
-                              std::is_constructible<T, V&&>>::type;
-
-template <bool SizeMatches, class T, class... Vs>
-struct TupleMoveConstructible : std::false_type {};
-
-template <class... Ts, class... Vs>
-struct TupleMoveConstructible<true, CompressedTuple<Ts...>, Vs...>
-    : std::integral_constant<
-          bool, y_absl::conjunction<
-                    TupleElementMoveConstructible<Ts, Vs&&>...>::value> {};
-
-template <typename T>
-struct compressed_tuple_size;
-
-template <typename... Es>
-struct compressed_tuple_size<CompressedTuple<Es...>>
-    : public std::integral_constant<std::size_t, sizeof...(Es)> {};
-
-template <class T, class... Vs>
-struct TupleItemsMoveConstructible
-    : std::integral_constant<
-          bool, TupleMoveConstructible<compressed_tuple_size<T>::value ==
-                                           sizeof...(Vs),
-                                       T, Vs...>::value> {};
-
+using TupleElementMoveConstructible = 
+    typename std::conditional<std::is_reference<T>::value, 
+                              std::is_convertible<V, T>, 
+                              std::is_constructible<T, V&&>>::type; 
+
+template <bool SizeMatches, class T, class... Vs> 
+struct TupleMoveConstructible : std::false_type {}; 
+ 
+template <class... Ts, class... Vs> 
+struct TupleMoveConstructible<true, CompressedTuple<Ts...>, Vs...> 
+    : std::integral_constant< 
+          bool, y_absl::conjunction< 
+                    TupleElementMoveConstructible<Ts, Vs&&>...>::value> {}; 
+ 
+template <typename T> 
+struct compressed_tuple_size; 
+ 
+template <typename... Es> 
+struct compressed_tuple_size<CompressedTuple<Es...>> 
+    : public std::integral_constant<std::size_t, sizeof...(Es)> {}; 
+ 
+template <class T, class... Vs> 
+struct TupleItemsMoveConstructible 
+    : std::integral_constant< 
+          bool, TupleMoveConstructible<compressed_tuple_size<T>::value == 
+                                           sizeof...(Vs), 
+                                       T, Vs...>::value> {}; 
+ 
 }  // namespace internal_compressed_tuple
 
 // Helper class to perform the Empty Base Class Optimization.
@@ -241,23 +241,23 @@ class ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple
   explicit constexpr CompressedTuple(const Ts&... base)
       : CompressedTuple::CompressedTupleImpl(y_absl::in_place, base...) {}
 
-  template <typename First, typename... Vs,
+  template <typename First, typename... Vs, 
             y_absl::enable_if_t<
                 y_absl::conjunction<
                     // Ensure we are not hiding default copy/move constructors.
                     y_absl::negation<std::is_same<void(CompressedTuple),
-                                                void(y_absl::decay_t<First>)>>,
-                    internal_compressed_tuple::TupleItemsMoveConstructible<
-                        CompressedTuple<Ts...>, First, Vs...>>::value,
+                                                void(y_absl::decay_t<First>)>>, 
+                    internal_compressed_tuple::TupleItemsMoveConstructible< 
+                        CompressedTuple<Ts...>, First, Vs...>>::value, 
                 bool> = true>
-  explicit constexpr CompressedTuple(First&& first, Vs&&... base)
+  explicit constexpr CompressedTuple(First&& first, Vs&&... base) 
       : CompressedTuple::CompressedTupleImpl(y_absl::in_place,
-                                             y_absl::forward<First>(first),
+                                             y_absl::forward<First>(first), 
                                              y_absl::forward<Vs>(base)...) {}
 
   template <int I>
   ElemT<I>& get() & {
-    return StorageT<I>::get();
+    return StorageT<I>::get(); 
   }
 
   template <int I>
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/container_memory.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/container_memory.h
index 348bc8c0d0..669c8965ab 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/container_memory.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/container_memory.h
@@ -18,31 +18,31 @@
 #include <cassert>
 #include <cstddef>
 #include <memory>
-#include <new>
+#include <new> 
 #include <tuple>
 #include <type_traits>
 #include <utility>
 
-#include "y_absl/base/config.h"
+#include "y_absl/base/config.h" 
 #include "y_absl/memory/memory.h"
-#include "y_absl/meta/type_traits.h"
+#include "y_absl/meta/type_traits.h" 
 #include "y_absl/utility/utility.h"
 
-#ifdef ABSL_HAVE_ADDRESS_SANITIZER
-#include <sanitizer/asan_interface.h>
-#endif
-
-#ifdef ABSL_HAVE_MEMORY_SANITIZER
-#include <sanitizer/msan_interface.h>
-#endif
-
+#ifdef ABSL_HAVE_ADDRESS_SANITIZER 
+#include <sanitizer/asan_interface.h> 
+#endif 
+ 
+#ifdef ABSL_HAVE_MEMORY_SANITIZER 
+#include <sanitizer/msan_interface.h> 
+#endif 
+ 
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
-template <size_t Alignment>
-struct alignas(Alignment) AlignedType {};
-
+template <size_t Alignment> 
+struct alignas(Alignment) AlignedType {}; 
+ 
 // Allocates at least n bytes aligned to the specified alignment.
 // Alignment must be a power of 2. It must be positive.
 //
@@ -54,14 +54,14 @@ template <size_t Alignment, class Alloc>
 void* Allocate(Alloc* alloc, size_t n) {
   static_assert(Alignment > 0, "");
   assert(n && "n must be positive");
-  using M = AlignedType<Alignment>;
+  using M = AlignedType<Alignment>; 
   using A = typename y_absl::allocator_traits<Alloc>::template rebind_alloc<M>;
   using AT = typename y_absl::allocator_traits<Alloc>::template rebind_traits<M>;
-  // On macOS, "mem_alloc" is a #define with one argument defined in
-  // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it
-  // with the "foo(bar)" syntax.
-  A my_mem_alloc(*alloc);
-  void* p = AT::allocate(my_mem_alloc, (n + sizeof(M) - 1) / sizeof(M));
+  // On macOS, "mem_alloc" is a #define with one argument defined in 
+  // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it 
+  // with the "foo(bar)" syntax. 
+  A my_mem_alloc(*alloc); 
+  void* p = AT::allocate(my_mem_alloc, (n + sizeof(M) - 1) / sizeof(M)); 
   assert(reinterpret_cast<uintptr_t>(p) % Alignment == 0 &&
          "allocator does not respect alignment");
   return p;
@@ -73,14 +73,14 @@ template <size_t Alignment, class Alloc>
 void Deallocate(Alloc* alloc, void* p, size_t n) {
   static_assert(Alignment > 0, "");
   assert(n && "n must be positive");
-  using M = AlignedType<Alignment>;
+  using M = AlignedType<Alignment>; 
   using A = typename y_absl::allocator_traits<Alloc>::template rebind_alloc<M>;
   using AT = typename y_absl::allocator_traits<Alloc>::template rebind_traits<M>;
-  // On macOS, "mem_alloc" is a #define with one argument defined in
-  // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it
-  // with the "foo(bar)" syntax.
-  A my_mem_alloc(*alloc);
-  AT::deallocate(my_mem_alloc, static_cast<M*>(p),
+  // On macOS, "mem_alloc" is a #define with one argument defined in 
+  // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it 
+  // with the "foo(bar)" syntax. 
+  A my_mem_alloc(*alloc); 
+  AT::deallocate(my_mem_alloc, static_cast<M*>(p), 
                  (n + sizeof(M) - 1) / sizeof(M));
 }
 
@@ -217,10 +217,10 @@ DecomposeValue(F&& f, Arg&& arg) {
 
 // Helper functions for asan and msan.
 inline void SanitizerPoisonMemoryRegion(const void* m, size_t s) {
-#ifdef ABSL_HAVE_ADDRESS_SANITIZER
+#ifdef ABSL_HAVE_ADDRESS_SANITIZER 
   ASAN_POISON_MEMORY_REGION(m, s);
 #endif
-#ifdef ABSL_HAVE_MEMORY_SANITIZER
+#ifdef ABSL_HAVE_MEMORY_SANITIZER 
   __msan_poison(m, s);
 #endif
   (void)m;
@@ -228,10 +228,10 @@ inline void SanitizerPoisonMemoryRegion(const void* m, size_t s) {
 }
 
 inline void SanitizerUnpoisonMemoryRegion(const void* m, size_t s) {
-#ifdef ABSL_HAVE_ADDRESS_SANITIZER
+#ifdef ABSL_HAVE_ADDRESS_SANITIZER 
   ASAN_UNPOISON_MEMORY_REGION(m, s);
 #endif
-#ifdef ABSL_HAVE_MEMORY_SANITIZER
+#ifdef ABSL_HAVE_MEMORY_SANITIZER 
   __msan_unpoison(m, s);
 #endif
   (void)m;
@@ -258,8 +258,8 @@ namespace memory_internal {
 // type, which is non-portable.
 template <class Pair, class = std::true_type>
 struct OffsetOf {
-  static constexpr size_t kFirst = static_cast<size_t>(-1);
-  static constexpr size_t kSecond = static_cast<size_t>(-1);
+  static constexpr size_t kFirst = static_cast<size_t>(-1); 
+  static constexpr size_t kSecond = static_cast<size_t>(-1); 
 };
 
 template <class Pair>
@@ -328,12 +328,12 @@ union map_slot_type {
   map_slot_type() {}
   ~map_slot_type() = delete;
   using value_type = std::pair<const K, V>;
-  using mutable_value_type =
-      std::pair<y_absl::remove_const_t<K>, y_absl::remove_const_t<V>>;
+  using mutable_value_type = 
+      std::pair<y_absl::remove_const_t<K>, y_absl::remove_const_t<V>>; 
 
   value_type value;
   mutable_value_type mutable_value;
-  y_absl::remove_const_t<K> key;
+  y_absl::remove_const_t<K> key; 
 };
 
 template <class K, class V>
@@ -359,20 +359,20 @@ struct map_slot_policy {
     return slot->value;
   }
 
-  // When C++17 is available, we can use std::launder to provide mutable
-  // access to the key for use in node handle.
-#if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606
-  static K& mutable_key(slot_type* slot) {
-    // Still check for kMutableKeys so that we can avoid calling std::launder
-    // unless necessary because it can interfere with optimizations.
-    return kMutableKeys::value ? slot->key
-                               : *std::launder(const_cast<K*>(
-                                     std::addressof(slot->value.first)));
-  }
-#else  // !(defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606)
-  static const K& mutable_key(slot_type* slot) { return key(slot); }
-#endif
-
+  // When C++17 is available, we can use std::launder to provide mutable 
+  // access to the key for use in node handle. 
+#if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606 
+  static K& mutable_key(slot_type* slot) { 
+    // Still check for kMutableKeys so that we can avoid calling std::launder 
+    // unless necessary because it can interfere with optimizations. 
+    return kMutableKeys::value ? slot->key 
+                               : *std::launder(const_cast<K*>( 
+                                     std::addressof(slot->value.first))); 
+  } 
+#else  // !(defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606) 
+  static const K& mutable_key(slot_type* slot) { return key(slot); } 
+#endif 
+ 
   static const K& key(const slot_type* slot) {
     return kMutableKeys::value ? slot->key : slot->value.first;
   }
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/counting_allocator.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/counting_allocator.h
index c8975dbd90..ae486af9dc 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/counting_allocator.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/counting_allocator.h
@@ -30,63 +30,63 @@ namespace container_internal {
 // containers - that chain of allocators uses the same state and is
 // thus easier to query for aggregate allocation information.
 template <typename T>
-class CountingAllocator {
+class CountingAllocator { 
  public:
-  using Allocator = std::allocator<T>;
-  using AllocatorTraits = std::allocator_traits<Allocator>;
-  using value_type = typename AllocatorTraits::value_type;
-  using pointer = typename AllocatorTraits::pointer;
-  using const_pointer = typename AllocatorTraits::const_pointer;
-  using size_type = typename AllocatorTraits::size_type;
-  using difference_type = typename AllocatorTraits::difference_type;
-
-  CountingAllocator() = default;
-  explicit CountingAllocator(int64_t* bytes_used) : bytes_used_(bytes_used) {}
-  CountingAllocator(int64_t* bytes_used, int64_t* instance_count)
-      : bytes_used_(bytes_used), instance_count_(instance_count) {}
+  using Allocator = std::allocator<T>; 
+  using AllocatorTraits = std::allocator_traits<Allocator>; 
+  using value_type = typename AllocatorTraits::value_type; 
+  using pointer = typename AllocatorTraits::pointer; 
+  using const_pointer = typename AllocatorTraits::const_pointer; 
+  using size_type = typename AllocatorTraits::size_type; 
+  using difference_type = typename AllocatorTraits::difference_type; 
+
+  CountingAllocator() = default; 
+  explicit CountingAllocator(int64_t* bytes_used) : bytes_used_(bytes_used) {} 
+  CountingAllocator(int64_t* bytes_used, int64_t* instance_count) 
+      : bytes_used_(bytes_used), instance_count_(instance_count) {} 
 
   template <typename U>
   CountingAllocator(const CountingAllocator<U>& x)
-      : bytes_used_(x.bytes_used_), instance_count_(x.instance_count_) {}
-
-  pointer allocate(
-      size_type n,
-      typename AllocatorTraits::const_void_pointer hint = nullptr) {
-    Allocator allocator;
-    pointer ptr = AllocatorTraits::allocate(allocator, n, hint);
-    if (bytes_used_ != nullptr) {
-      *bytes_used_ += n * sizeof(T);
-    }
-    return ptr;
+      : bytes_used_(x.bytes_used_), instance_count_(x.instance_count_) {} 
+
+  pointer allocate( 
+      size_type n, 
+      typename AllocatorTraits::const_void_pointer hint = nullptr) { 
+    Allocator allocator; 
+    pointer ptr = AllocatorTraits::allocate(allocator, n, hint); 
+    if (bytes_used_ != nullptr) { 
+      *bytes_used_ += n * sizeof(T); 
+    } 
+    return ptr; 
   }
 
   void deallocate(pointer p, size_type n) {
-    Allocator allocator;
-    AllocatorTraits::deallocate(allocator, p, n);
-    if (bytes_used_ != nullptr) {
-      *bytes_used_ -= n * sizeof(T);
-    }
-  }
-
-  template <typename U, typename... Args>
-  void construct(U* p, Args&&... args) {
-    Allocator allocator;
-    AllocatorTraits::construct(allocator, p, std::forward<Args>(args)...);
-    if (instance_count_ != nullptr) {
-      *instance_count_ += 1;
-    }
+    Allocator allocator; 
+    AllocatorTraits::deallocate(allocator, p, n); 
+    if (bytes_used_ != nullptr) { 
+      *bytes_used_ -= n * sizeof(T); 
+    } 
   }
 
-  template <typename U>
-  void destroy(U* p) {
-    Allocator allocator;
-    AllocatorTraits::destroy(allocator, p);
-    if (instance_count_ != nullptr) {
-      *instance_count_ -= 1;
-    }
-  }
-
-  template <typename U>
+  template <typename U, typename... Args> 
+  void construct(U* p, Args&&... args) { 
+    Allocator allocator; 
+    AllocatorTraits::construct(allocator, p, std::forward<Args>(args)...); 
+    if (instance_count_ != nullptr) { 
+      *instance_count_ += 1; 
+    } 
+  } 
+ 
+  template <typename U> 
+  void destroy(U* p) { 
+    Allocator allocator; 
+    AllocatorTraits::destroy(allocator, p); 
+    if (instance_count_ != nullptr) { 
+      *instance_count_ -= 1; 
+    } 
+  } 
+ 
+  template <typename U> 
   class rebind {
    public:
     using other = CountingAllocator<U>;
@@ -94,8 +94,8 @@ class CountingAllocator {
 
   friend bool operator==(const CountingAllocator& a,
                          const CountingAllocator& b) {
-    return a.bytes_used_ == b.bytes_used_ &&
-           a.instance_count_ == b.instance_count_;
+    return a.bytes_used_ == b.bytes_used_ && 
+           a.instance_count_ == b.instance_count_; 
   }
 
   friend bool operator!=(const CountingAllocator& a,
@@ -103,8 +103,8 @@ class CountingAllocator {
     return !(a == b);
   }
 
-  int64_t* bytes_used_ = nullptr;
-  int64_t* instance_count_ = nullptr;
+  int64_t* bytes_used_ = nullptr; 
+  int64_t* instance_count_ = nullptr; 
 };
 
 }  // namespace container_internal
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_function_defaults.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_function_defaults.h
index 68a18058d1..1407979619 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_function_defaults.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_function_defaults.h
@@ -53,7 +53,7 @@
 
 #include "y_absl/base/config.h"
 #include "y_absl/hash/hash.h"
-#include "y_absl/strings/cord.h"
+#include "y_absl/strings/cord.h" 
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
@@ -73,9 +73,9 @@ struct StringHash {
   size_t operator()(y_absl::string_view v) const {
     return y_absl::Hash<y_absl::string_view>{}(v);
   }
-  size_t operator()(const y_absl::Cord& v) const {
-    return y_absl::Hash<y_absl::Cord>{}(v);
-  }
+  size_t operator()(const y_absl::Cord& v) const { 
+    return y_absl::Hash<y_absl::Cord>{}(v); 
+  } 
 };
 
 struct StringEq {
@@ -104,8 +104,8 @@ template <>
 struct HashEq<TString> : StringHashEq {};
 template <>
 struct HashEq<y_absl::string_view> : StringHashEq {};
-template <>
-struct HashEq<y_absl::Cord> : StringHashEq {};
+template <> 
+struct HashEq<y_absl::Cord> : StringHashEq {}; 
 
 // Supports heterogeneous lookup for pointers and smart pointers.
 template <class T>
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_policy_traits.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_policy_traits.h
index 33f704fc4b..b4d8d913ee 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_policy_traits.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_policy_traits.h
@@ -17,7 +17,7 @@
 
 #include <cstddef>
 #include <memory>
-#include <new>
+#include <new> 
 #include <type_traits>
 #include <utility>
 
@@ -30,34 +30,34 @@ namespace container_internal {
 // Defines how slots are initialized/destroyed/moved.
 template <class Policy, class = void>
 struct hash_policy_traits {
-  // The type of the keys stored in the hashtable.
-  using key_type = typename Policy::key_type;
-
+  // The type of the keys stored in the hashtable. 
+  using key_type = typename Policy::key_type; 
+ 
  private:
   struct ReturnKey {
-    // When C++17 is available, we can use std::launder to provide mutable
-    // access to the key for use in node handle.
-#if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606
-    template <class Key,
-              y_absl::enable_if_t<std::is_lvalue_reference<Key>::value, int> = 0>
-    static key_type& Impl(Key&& k, int) {
-      return *std::launder(
-          const_cast<key_type*>(std::addressof(std::forward<Key>(k))));
-    }
-#endif
-
-    template <class Key>
-    static Key Impl(Key&& k, char) {
-      return std::forward<Key>(k);
-    }
-
+    // When C++17 is available, we can use std::launder to provide mutable 
+    // access to the key for use in node handle. 
+#if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606 
+    template <class Key, 
+              y_absl::enable_if_t<std::is_lvalue_reference<Key>::value, int> = 0> 
+    static key_type& Impl(Key&& k, int) { 
+      return *std::launder( 
+          const_cast<key_type*>(std::addressof(std::forward<Key>(k)))); 
+    } 
+#endif 
+ 
+    template <class Key> 
+    static Key Impl(Key&& k, char) { 
+      return std::forward<Key>(k); 
+    } 
+ 
     // When Key=T&, we forward the lvalue reference.
     // When Key=T, we return by value to avoid a dangling reference.
     // eg, for string_hash_map.
     template <class Key, class... Args>
-    auto operator()(Key&& k, const Args&...) const
-        -> decltype(Impl(std::forward<Key>(k), 0)) {
-      return Impl(std::forward<Key>(k), 0);
+    auto operator()(Key&& k, const Args&...) const 
+        -> decltype(Impl(std::forward<Key>(k), 0)) { 
+      return Impl(std::forward<Key>(k), 0); 
     }
   };
 
@@ -173,7 +173,7 @@ struct hash_policy_traits {
   // Returns the "key" portion of the slot.
   // Used for node handle manipulation.
   template <class P = Policy>
-  static auto mutable_key(slot_type* slot)
+  static auto mutable_key(slot_type* slot) 
       -> decltype(P::apply(ReturnKey(), element(slot))) {
     return P::apply(ReturnKey(), element(slot));
   }
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler.cc
index 6017ac9bb0..e20e5642d6 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler.cc
@@ -65,12 +65,12 @@ void HashtablezInfo::PrepareForSampling() {
   capacity.store(0, std::memory_order_relaxed);
   size.store(0, std::memory_order_relaxed);
   num_erases.store(0, std::memory_order_relaxed);
-  num_rehashes.store(0, std::memory_order_relaxed);
+  num_rehashes.store(0, std::memory_order_relaxed); 
   max_probe_length.store(0, std::memory_order_relaxed);
   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 = y_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;
@@ -146,7 +146,7 @@ void RecordInsertSlow(HashtablezInfo* info, size_t hash,
   // SwissTables probe in groups of 16, so scale this to count items probes and
   // not offset from desired.
   size_t probe_length = distance_from_desired;
-#if ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2
+#if ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2 
   probe_length /= 16;
 #else
   probe_length /= 8;
@@ -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-tstring/y_absl/container/internal/hashtablez_sampler.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler.h
index 8521ee754a..656be23f07 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler.h
@@ -74,12 +74,12 @@ struct HashtablezInfo : public profiling_internal::Sample<HashtablezInfo> {
   std::atomic<size_t> capacity;
   std::atomic<size_t> size;
   std::atomic<size_t> num_erases;
-  std::atomic<size_t> num_rehashes;
+  std::atomic<size_t> num_rehashes; 
   std::atomic<size_t> max_probe_length;
   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
@@ -95,18 +95,18 @@ struct HashtablezInfo : public profiling_internal::Sample<HashtablezInfo> {
 };
 
 inline void RecordRehashSlow(HashtablezInfo* info, size_t total_probe_length) {
-#if ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2
+#if ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2 
   total_probe_length /= 16;
 #else
   total_probe_length /= 8;
 #endif
   info->total_probe_length.store(total_probe_length, std::memory_order_relaxed);
   info->num_erases.store(0, std::memory_order_relaxed);
-  // There is only one concurrent writer, so `load` then `store` is sufficient
-  // instead of using `fetch_add`.
-  info->num_rehashes.store(
-      1 + info->num_rehashes.load(std::memory_order_relaxed),
-      std::memory_order_relaxed);
+  // There is only one concurrent writer, so `load` then `store` is sufficient 
+  // instead of using `fetch_add`. 
+  info->num_rehashes.store( 
+      1 + info->num_rehashes.load(std::memory_order_relaxed), 
+      std::memory_order_relaxed); 
 }
 
 inline void RecordReservationSlow(HashtablezInfo* info,
@@ -127,8 +127,8 @@ inline void RecordStorageChangedSlow(HashtablezInfo* info, size_t size,
   info->capacity.store(capacity, std::memory_order_relaxed);
   if (size == 0) {
     // This is a clear, reset the total/num_erases too.
-    info->total_probe_length.store(0, std::memory_order_relaxed);
-    info->num_erases.store(0, std::memory_order_relaxed);
+    info->total_probe_length.store(0, std::memory_order_relaxed); 
+    info->num_erases.store(0, std::memory_order_relaxed); 
   }
 }
 
@@ -137,21 +137,21 @@ void RecordInsertSlow(HashtablezInfo* info, size_t hash,
 
 inline void RecordEraseSlow(HashtablezInfo* info) {
   info->size.fetch_sub(1, std::memory_order_relaxed);
-  // There is only one concurrent writer, so `load` then `store` is sufficient
-  // instead of using `fetch_add`.
-  info->num_erases.store(
-      1 + info->num_erases.load(std::memory_order_relaxed),
-      std::memory_order_relaxed);
+  // There is only one concurrent writer, so `load` then `store` is sufficient 
+  // instead of using `fetch_add`. 
+  info->num_erases.store( 
+      1 + info->num_erases.load(std::memory_order_relaxed), 
+      std::memory_order_relaxed); 
 }
 
 HashtablezInfo* SampleSlow(int64_t* next_sample, size_t inline_element_size);
 void UnsampleSlow(HashtablezInfo* info);
 
-#if defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
-#error ABSL_INTERNAL_HASHTABLEZ_SAMPLE cannot be directly set
-#endif  // defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
-
-#if defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
+#if defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE) 
+#error ABSL_INTERNAL_HASHTABLEZ_SAMPLE cannot be directly set 
+#endif  // defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE) 
+ 
+#if defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE) 
 class HashtablezInfoHandle {
  public:
   explicit HashtablezInfoHandle() : info_(nullptr) {}
@@ -213,29 +213,29 @@ class HashtablezInfoHandle {
   friend class HashtablezInfoHandlePeer;
   HashtablezInfo* info_;
 };
-#else
-// Ensure that when Hashtablez is turned off at compile time, HashtablezInfo can
-// be removed by the linker, in order to reduce the binary size.
-class HashtablezInfoHandle {
- public:
-  explicit HashtablezInfoHandle() = default;
-  explicit HashtablezInfoHandle(std::nullptr_t) {}
-
-  inline void RecordStorageChanged(size_t /*size*/, size_t /*capacity*/) {}
-  inline void RecordRehash(size_t /*total_probe_length*/) {}
+#else 
+// Ensure that when Hashtablez is turned off at compile time, HashtablezInfo can 
+// be removed by the linker, in order to reduce the binary size. 
+class HashtablezInfoHandle { 
+ public: 
+  explicit HashtablezInfoHandle() = default; 
+  explicit HashtablezInfoHandle(std::nullptr_t) {} 
+
+  inline void RecordStorageChanged(size_t /*size*/, size_t /*capacity*/) {} 
+  inline void RecordRehash(size_t /*total_probe_length*/) {} 
   inline void RecordReservation(size_t /*target_capacity*/) {}
   inline void RecordClearedReservation() {}
-  inline void RecordInsert(size_t /*hash*/, size_t /*distance_from_desired*/) {}
-  inline void RecordErase() {}
-
-  friend inline void swap(HashtablezInfoHandle& /*lhs*/,
-                          HashtablezInfoHandle& /*rhs*/) {}
-};
+  inline void RecordInsert(size_t /*hash*/, size_t /*distance_from_desired*/) {} 
+  inline void RecordErase() {} 
+ 
+  friend inline void swap(HashtablezInfoHandle& /*lhs*/, 
+                          HashtablezInfoHandle& /*rhs*/) {} 
+}; 
 #endif  // defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
 
 #if defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
 extern ABSL_PER_THREAD_TLS_KEYWORD int64_t global_next_sample;
-#endif  // defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
+#endif  // defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE) 
 
 // Returns an RAII sampling handle that manages registration and unregistation
 // with the global sampler.
@@ -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-tstring/y_absl/container/internal/hashtablez_sampler_force_weak_definition.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler_force_weak_definition.cc
index 79a3122981..4536de40c8 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler_force_weak_definition.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_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-tstring/y_absl/container/internal/have_sse.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/have_sse.h
index e75e1a16d3..58da3b3163 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/have_sse.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/have_sse.h
@@ -16,34 +16,34 @@
 #ifndef ABSL_CONTAINER_INTERNAL_HAVE_SSE_H_
 #define ABSL_CONTAINER_INTERNAL_HAVE_SSE_H_
 
-#ifndef ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2
+#ifndef ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2 
 #if defined(__SSE2__) ||  \
     (defined(_MSC_VER) && \
      (defined(_M_X64) || (defined(_M_IX86) && _M_IX86_FP >= 2)))
-#define ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2 1
+#define ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2 1 
 #else
-#define ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2 0
+#define ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2 0 
 #endif
 #endif
 
-#ifndef ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3
+#ifndef ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3 
 #ifdef __SSSE3__
-#define ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3 1
+#define ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3 1 
 #else
-#define ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3 0
+#define ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3 0 
 #endif
 #endif
 
-#if ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3 && \
-    !ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2
+#if ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3 && \ 
+    !ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2 
 #error "Bad configuration!"
 #endif
 
-#if ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2
+#if ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2 
 #include <emmintrin.h>
 #endif
 
-#if ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3
+#if ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3 
 #include <tmmintrin.h>
 #endif
 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/inlined_vector.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/inlined_vector.h
index e6488e843e..b5cd516154 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/inlined_vector.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/inlined_vector.h
@@ -36,13 +36,13 @@ namespace y_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 y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/layout.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/layout.h
index 4c3f668943..327d910d60 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/layout.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/layout.h
@@ -163,7 +163,7 @@
 #include <assert.h>
 #include <stddef.h>
 #include <stdint.h>
-
+ 
 #include <ostream>
 #include <util/generic/string.h>
 #include <tuple>
@@ -171,16 +171,16 @@
 #include <typeinfo>
 #include <utility>
 
-#include "y_absl/base/config.h"
+#include "y_absl/base/config.h" 
 #include "y_absl/meta/type_traits.h"
 #include "y_absl/strings/str_cat.h"
 #include "y_absl/types/span.h"
 #include "y_absl/utility/utility.h"
 
-#ifdef ABSL_HAVE_ADDRESS_SANITIZER
-#include <sanitizer/asan_interface.h>
-#endif
-
+#ifdef ABSL_HAVE_ADDRESS_SANITIZER 
+#include <sanitizer/asan_interface.h> 
+#endif 
+ 
 #if defined(__GXX_RTTI)
 #define ABSL_INTERNAL_HAS_CXA_DEMANGLE
 #endif
@@ -404,7 +404,7 @@ class LayoutImpl<std::tuple<Elements...>, y_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...>, y_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
@@ -616,12 +616,12 @@ class LayoutImpl<std::tuple<Elements...>, y_absl::index_sequence<SizeSeq...>,
   void PoisonPadding(const Char* p) const {
     static_assert(N < NumOffsets, "Index out of bounds");
     (void)p;
-#ifdef ABSL_HAVE_ADDRESS_SANITIZER
+#ifdef ABSL_HAVE_ADDRESS_SANITIZER 
     PoisonPadding<Char, N - 1>(p);
     // 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...>, y_absl::index_sequence<SizeSeq...>,
   // produce "unsigned*" where another produces "unsigned int *".
   TString DebugString() const {
     const auto offsets = Offsets();
-    const size_t sizes[] = {SizeOf<ElementType<OffsetSeq>>::value...};
+    const size_t sizes[] = {SizeOf<ElementType<OffsetSeq>>::value...}; 
     const TString types[] = {
         adl_barrier::TypeName<ElementType<OffsetSeq>>()...};
     TString res = y_absl::StrCat("@0", types[0], "(", sizes[0], ")");
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set.cc
index bf2a15a678..5da7c92dbc 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_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 y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set.h
index 8f45559b31..a493faea66 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set.h
@@ -114,7 +114,7 @@
 #include <utility>
 
 #include "y_absl/base/internal/endian.h"
-#include "y_absl/base/optimization.h"
+#include "y_absl/base/optimization.h" 
 #include "y_absl/base/port.h"
 #include "y_absl/container/internal/common.h"
 #include "y_absl/container/internal/compressed_tuple.h"
@@ -125,23 +125,23 @@
 #include "y_absl/container/internal/have_sse.h"
 #include "y_absl/memory/memory.h"
 #include "y_absl/meta/type_traits.h"
-#include "y_absl/numeric/bits.h"
+#include "y_absl/numeric/bits.h" 
 #include "y_absl/utility/utility.h"
 
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
-template <typename AllocType>
-void SwapAlloc(AllocType& lhs, AllocType& rhs,
-               std::true_type /* propagate_on_container_swap */) {
-  using std::swap;
-  swap(lhs, rhs);
-}
-template <typename AllocType>
-void SwapAlloc(AllocType& /*lhs*/, AllocType& /*rhs*/,
-               std::false_type /* propagate_on_container_swap */) {}
-
+template <typename AllocType> 
+void SwapAlloc(AllocType& lhs, AllocType& rhs, 
+               std::true_type /* propagate_on_container_swap */) { 
+  using std::swap; 
+  swap(lhs, rhs); 
+} 
+template <typename AllocType> 
+void SwapAlloc(AllocType& /*lhs*/, AllocType& /*rhs*/, 
+               std::false_type /* propagate_on_container_swap */) {} 
+ 
 template <size_t Width>
 class probe_seq {
  public:
@@ -189,19 +189,19 @@ struct IsDecomposable<
 
 // TODO(alkis): Switch to std::is_nothrow_swappable when gcc/clang supports it.
 template <class T>
-constexpr bool IsNoThrowSwappable(std::true_type = {} /* is_swappable */) {
+constexpr bool IsNoThrowSwappable(std::true_type = {} /* is_swappable */) { 
   using std::swap;
   return noexcept(swap(std::declval<T&>(), std::declval<T&>()));
 }
-template <class T>
-constexpr bool IsNoThrowSwappable(std::false_type /* is_swappable */) {
-  return false;
+template <class T> 
+constexpr bool IsNoThrowSwappable(std::false_type /* is_swappable */) { 
+  return false; 
 }
 
 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:
@@ -331,7 +331,7 @@ inline bool IsFull(ctrl_t c) { return c >= static_cast<ctrl_t>(0); }
 inline bool IsDeleted(ctrl_t c) { return c == ctrl_t::kDeleted; }
 inline bool IsEmptyOrDeleted(ctrl_t c) { return c < ctrl_t::kSentinel; }
 
-#if ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2
+#if ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2 
 
 // https://github.com/abseil/abseil-cpp/issues/209
 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=87853
@@ -365,7 +365,7 @@ struct GroupSse2Impl {
 
   // Returns a bitmask representing the positions of empty slots.
   BitMask<uint32_t, kWidth> MatchEmpty() const {
-#if ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3
+#if ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3 
     // This only works because ctrl_t::kEmpty is -128.
     return BitMask<uint32_t, kWidth>(
         _mm_movemask_epi8(_mm_sign_epi8(ctrl, ctrl)));
@@ -384,14 +384,14 @@ 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 {
     auto msbs = _mm_set1_epi8(static_cast<char>(-128));
     auto x126 = _mm_set1_epi8(126);
-#if ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3
+#if ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3 
     auto res = _mm_or_si128(_mm_shuffle_epi8(x126, ctrl), msbs);
 #else
     auto zero = _mm_setzero_si128();
@@ -403,7 +403,7 @@ struct GroupSse2Impl {
 
   __m128i ctrl;
 };
-#endif  // ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2
+#endif  // ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2 
 
 struct GroupPortableImpl {
   static constexpr size_t kWidth = 8;
@@ -457,7 +457,7 @@ struct GroupPortableImpl {
   uint64_t ctrl;
 };
 
-#if ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2
+#if ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2 
 using Group = GroupSse2Impl;
 #else
 using Group = GroupPortableImpl;
@@ -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) {
@@ -533,78 +533,78 @@ size_t SelectBucketCountForIterRange(InputIter first, InputIter last,
   return 0;
 }
 
-inline void AssertIsFull(ctrl_t* ctrl) {
-  ABSL_HARDENING_ASSERT((ctrl != nullptr && IsFull(*ctrl)) &&
-                        "Invalid operation on iterator. The element might have "
-                        "been erased, or the table might have rehashed.");
-}
-
-inline void AssertIsValid(ctrl_t* ctrl) {
-  ABSL_HARDENING_ASSERT((ctrl == nullptr || IsFull(*ctrl)) &&
-                        "Invalid operation on iterator. The element might have "
-                        "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
+inline void AssertIsFull(ctrl_t* ctrl) { 
+  ABSL_HARDENING_ASSERT((ctrl != nullptr && IsFull(*ctrl)) && 
+                        "Invalid operation on iterator. The element might have " 
+                        "been erased, or the table might have rehashed."); 
+} 
+ 
+inline void AssertIsValid(ctrl_t* ctrl) { 
+  ABSL_HARDENING_ASSERT((ctrl == nullptr || IsFull(*ctrl)) && 
+                        "Invalid operation on iterator. The element might have " 
+                        "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 
 //  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.
@@ -669,8 +669,8 @@ inline size_t AllocSize(size_t capacity, size_t slot_size, size_t slot_align) {
 // if they are equal, false if they are not. If two keys compare equal, then
 // their hash values as defined by Hash MUST be equal.
 //
-// Allocator: an Allocator
-// [https://en.cppreference.com/w/cpp/named_req/Allocator] with which
+// Allocator: an Allocator 
+// [https://en.cppreference.com/w/cpp/named_req/Allocator] with which 
 // the storage of the hashtable will be allocated and the elements will be
 // constructed and destroyed.
 template <class Policy, class Hash, class Eq, class Alloc>
@@ -769,7 +769,7 @@ class raw_hash_set {
 
     // PRECONDITION: not an end() iterator.
     reference operator*() const {
-      AssertIsFull(ctrl_);
+      AssertIsFull(ctrl_); 
       return PolicyTraits::element(slot_);
     }
 
@@ -778,7 +778,7 @@ class raw_hash_set {
 
     // PRECONDITION: not an end() iterator.
     iterator& operator++() {
-      AssertIsFull(ctrl_);
+      AssertIsFull(ctrl_); 
       ++ctrl_;
       ++slot_;
       skip_empty_or_deleted();
@@ -792,8 +792,8 @@ class raw_hash_set {
     }
 
     friend bool operator==(const iterator& a, const iterator& b) {
-      AssertIsValid(a.ctrl_);
-      AssertIsValid(b.ctrl_);
+      AssertIsValid(a.ctrl_); 
+      AssertIsValid(b.ctrl_); 
       return a.ctrl_ == b.ctrl_;
     }
     friend bool operator!=(const iterator& a, const iterator& b) {
@@ -801,10 +801,10 @@ class raw_hash_set {
     }
 
    private:
-    iterator(ctrl_t* ctrl, slot_type* slot) : ctrl_(ctrl), slot_(slot) {
-      // This assumption helps the compiler know that any non-end iterator is
-      // not equal to any end iterator.
-      ABSL_INTERNAL_ASSUME(ctrl != nullptr);
+    iterator(ctrl_t* ctrl, slot_type* slot) : ctrl_(ctrl), slot_(slot) { 
+      // This assumption helps the compiler know that any non-end iterator is 
+      // not equal to any end iterator. 
+      ABSL_INTERNAL_ASSUME(ctrl != nullptr); 
     }
 
     void skip_empty_or_deleted() {
@@ -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_(y_absl::exchange(that.growth_left(), 0),
-                  y_absl::exchange(that.infoz(), HashtablezInfoHandle()),
-                  that.hash_ref(), that.eq_ref(), that.alloc_ref()) {}
+        settings_(y_absl::exchange(that.growth_left(), 0), 
+                  y_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
@@ -1056,12 +1056,12 @@ class raw_hash_set {
     it.skip_empty_or_deleted();
     return it;
   }
-  iterator end() { return {}; }
+  iterator end() { return {}; } 
 
   const_iterator begin() const {
     return const_cast<raw_hash_set*>(this)->begin();
   }
-  const_iterator end() const { return {}; }
+  const_iterator end() const { return {}; } 
   const_iterator cbegin() const { return begin(); }
   const_iterator cend() const { return end(); }
 
@@ -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
@@ -1324,7 +1324,7 @@ class raw_hash_set {
   // This overload is necessary because otherwise erase<K>(const K&) would be
   // a better match if non-const iterator is passed as an argument.
   void erase(iterator it) {
-    AssertIsFull(it.ctrl_);
+    AssertIsFull(it.ctrl_); 
     PolicyTraits::destroy(&alloc_ref(), it.slot_);
     erase_meta_only(it);
   }
@@ -1358,7 +1358,7 @@ class raw_hash_set {
   }
 
   node_type extract(const_iterator position) {
-    AssertIsFull(position.inner_.ctrl_);
+    AssertIsFull(position.inner_.ctrl_); 
     auto node =
         CommonAccess::Transfer<node_type>(alloc_ref(), position.inner_.slot_);
     erase_meta_only(position);
@@ -1375,8 +1375,8 @@ class raw_hash_set {
 
   void swap(raw_hash_set& that) noexcept(
       IsNoThrowSwappable<hasher>() && IsNoThrowSwappable<key_equal>() &&
-      IsNoThrowSwappable<allocator_type>(
-          typename AllocTraits::propagate_on_container_swap{})) {
+      IsNoThrowSwappable<allocator_type>( 
+          typename AllocTraits::propagate_on_container_swap{})) { 
     using std::swap;
     swap(ctrl_, that.ctrl_);
     swap(slots_, that.slots_);
@@ -1385,16 +1385,16 @@ 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());
-    SwapAlloc(alloc_ref(), that.alloc_ref(),
-              typename AllocTraits::propagate_on_container_swap{});
+    swap(infoz(), that.infoz()); 
+    SwapAlloc(alloc_ref(), that.alloc_ref(), 
+              typename AllocTraits::propagate_on_container_swap{}); 
   }
 
   void rehash(size_t n) {
     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
-  y_absl::container_internal::CompressedTuple<size_t /* growth_left */,
-                                            HashtablezInfoHandle, hasher,
+  y_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, y_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-tstring/y_absl/container/internal/raw_hash_set/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set/ya.make
index d636929b87..8091b96b3c 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set/ya.make
@@ -2,13 +2,13 @@
 
 LIBRARY()
 
-WITHOUT_LICENSE_TEXTS()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
+WITHOUT_LICENSE_TEXTS() 
 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
 LICENSE(Apache-2.0)
 
 PEERDIR(
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_constructor_test.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_constructor_test.h
index f55d6293ae..8d75094512 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_constructor_test.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_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-tstring/y_absl/container/internal/unordered_map_modifiers_test.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_modifiers_test.h
index 725cfdc345..fd4e3977a2 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_modifiers_test.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_modifiers_test.h
@@ -319,8 +319,8 @@ class UniquePtrModifiersTest : public ::testing::Test {
   }
 };
 
-GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(UniquePtrModifiersTest);
-
+GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(UniquePtrModifiersTest); 
+ 
 TYPED_TEST_SUITE_P(UniquePtrModifiersTest);
 
 // Test that we do not move from rvalue arguments if an insertion does not
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/node_hash_map.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/node_hash_map.h
index 07e26def79..f3cdce8f22 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/node_hash_map.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/node_hash_map.h
@@ -225,8 +225,8 @@ class node_hash_map
   //
   // size_type erase(const key_type& key):
   //
-  //   Erases the element with the matching key, if it exists, returning the
-  //   number of elements erased (0 or 1).
+  //   Erases the element with the matching key, if it exists, returning the 
+  //   number of elements erased (0 or 1). 
   using Base::erase;
 
   // node_hash_map::insert()
@@ -375,11 +375,11 @@ class node_hash_map
   //   key value and returns a node handle owning that extracted data. If the
   //   `node_hash_map` does not contain an element with a matching key, this
   //   function returns an empty node handle.
-  //
-  // NOTE: when compiled in an earlier version of C++ than C++17,
-  // `node_type::key()` returns a const reference to the key instead of a
-  // mutable reference. We cannot safely return a mutable reference without
-  // std::launder (which is not available before C++17).
+  // 
+  // NOTE: when compiled in an earlier version of C++ than C++17, 
+  // `node_type::key()` returns a const reference to the key instead of a 
+  // mutable reference. We cannot safely return a mutable reference without 
+  // std::launder (which is not available before C++17). 
   using Base::extract;
 
   // node_hash_map::merge()
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/node_hash_set.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/node_hash_set.h
index aa98bb29b8..bd8fe21a70 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/node_hash_set.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/node_hash_set.h
@@ -18,7 +18,7 @@
 //
 // An `y_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
-//   y_absl::node_hash_set<TString> ducks =
+//   y_absl::node_hash_set<TString> 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 `y_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):
   //
@@ -217,8 +217,8 @@ class node_hash_set
   //
   // size_type erase(const key_type& key):
   //
-  //   Erases the element with the matching key, if it exists, returning the
-  //   number of elements erased (0 or 1).
+  //   Erases the element with the matching key, if it exists, returning the 
+  //   number of elements erased (0 or 1). 
   using Base::erase;
 
   // node_hash_set::insert()
@@ -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-tstring/y_absl/container/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/container/ya.make
index b5ead45856..9a44988749 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/ya.make
@@ -1,14 +1,14 @@
-# Generated by devtools/yamaker.
-
-LIBRARY()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
-
-LICENSE(Apache-2.0)
-
-LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
-
-END()
+# Generated by devtools/yamaker. 
+ 
+LIBRARY() 
+ 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
+LICENSE(Apache-2.0) 
+ 
+LICENSE_TEXTS(.yandex_meta/licenses.list.txt) 
+ 
+END() 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/.yandex_meta/licenses.list.txt b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/.yandex_meta/licenses.list.txt
index 030c5b94cf..ca4f3ce315 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/.yandex_meta/licenses.list.txt
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/.yandex_meta/licenses.list.txt
@@ -1,24 +1,24 @@
-====================Apache-2.0====================
-// 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====================
-// Copyright 2017 The Abseil Authors.
-
-
-====================COPYRIGHT====================
-// Copyright 2018 The Abseil Authors.
-
-
-====================COPYRIGHT====================
-// Copyright 2020 The Abseil Authors.
+====================Apache-2.0==================== 
+// 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==================== 
+// Copyright 2017 The Abseil Authors. 
+ 
+ 
+====================COPYRIGHT==================== 
+// Copyright 2018 The Abseil Authors. 
+ 
+ 
+====================COPYRIGHT==================== 
+// Copyright 2020 The Abseil Authors. 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler.cc
index fa6e30f935..4ea649a95e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_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,10 +136,10 @@ 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;
-#if defined(ABSL_HAVE_ADDRESS_SANITIZER) || \
-    defined(ABSL_HAVE_MEMORY_SANITIZER) || defined(ABSL_HAVE_THREAD_SANITIZER)
+  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.
   stack_size *= 5;
 #endif
@@ -221,24 +221,24 @@ static void WriteToStderr(const char* data) {
   y_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-tstring/y_absl/debugging/failure_signal_handler.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler.h
index 879df3c434..a84149f38a 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler.h
@@ -88,7 +88,7 @@ struct FailureSignalHandlerOptions {
   bool call_previous_handler = false;
 
   // If non-null, indicates a pointer to a callback function that will be called
-  // upon failure, with a string argument containing failure data. This function
+  // upon failure, with a string argument containing failure data. This function 
   // may be used as a hook to write failure data to a secondary location, such
   // as a log file. This function will also be called with null data, as a hint
   // to flush any buffered data before the program may be terminated. Consider
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler/ya.make
index 0c71cb5547..19bbc5bbcc 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler/ya.make
@@ -1,43 +1,43 @@
-# Generated by devtools/yamaker.
-
-LIBRARY()
-
-WITHOUT_LICENSE_TEXTS()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
-
-LICENSE(Apache-2.0)
-
-PEERDIR(
-    contrib/restricted/abseil-cpp-tstring/y_absl/base
+# Generated by devtools/yamaker. 
+ 
+LIBRARY() 
+ 
+WITHOUT_LICENSE_TEXTS() 
+ 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
+LICENSE(Apache-2.0) 
+ 
+PEERDIR( 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base 
     contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity 
     contrib/restricted/abseil-cpp-tstring/y_absl/debugging
     contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal
     contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace
     contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize
     contrib/restricted/abseil-cpp-tstring/y_absl/demangle
-    contrib/restricted/abseil-cpp-tstring/y_absl/numeric
-    contrib/restricted/abseil-cpp-tstring/y_absl/strings
+    contrib/restricted/abseil-cpp-tstring/y_absl/numeric 
+    contrib/restricted/abseil-cpp-tstring/y_absl/strings 
     contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_strings_internal
-)
-
-ADDINCL(
-    GLOBAL contrib/restricted/abseil-cpp-tstring
-)
-
-NO_COMPILER_WARNINGS()
-
+) 
+ 
+ADDINCL( 
+    GLOBAL contrib/restricted/abseil-cpp-tstring 
+) 
+ 
+NO_COMPILER_WARNINGS() 
+ 
 SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/debugging)
-
-SRCS(
+ 
+SRCS( 
     failure_signal_handler.cc
-)
-
-END()
+) 
+ 
+END() 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/.yandex_meta/licenses.list.txt b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/.yandex_meta/licenses.list.txt
index aac6c71d05..45dccf6b8e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/.yandex_meta/licenses.list.txt
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/.yandex_meta/licenses.list.txt
@@ -1,4 +1,4 @@
-====================Apache-2.0====================
+====================Apache-2.0==================== 
  * 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
@@ -13,40 +13,40 @@
 
 
 ====================Apache-2.0====================
-// 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.
-
-
-====================Apache-2.0====================
-// 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====================
-// Copyright 2017 The Abseil Authors.
-
-
-====================COPYRIGHT====================
-// Copyright 2018 The Abseil Authors.
-
-
-====================COPYRIGHT====================
-// 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. 
+ 
+ 
+====================Apache-2.0==================== 
+// 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==================== 
+// Copyright 2017 The Abseil Authors. 
+ 
+ 
+====================COPYRIGHT==================== 
+// Copyright 2018 The Abseil Authors. 
+ 
+ 
+====================COPYRIGHT==================== 
+// Copyright 2021 The Abseil Authors. 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/address_is_readable.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/address_is_readable.cc
index df217335ea..befdd47a37 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/address_is_readable.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_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) {
   y_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-tstring/y_absl/debugging/internal/demangle.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/demangle.cc
index 0a4daa2f5c..7df72d4e3f 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/demangle.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/demangle.cc
@@ -126,7 +126,7 @@ static const AbbrevPair kBuiltinTypeList[] = {
     {"Dn", "std::nullptr_t", 0},  // i.e., decltype(nullptr)
     {"Df", "decimal32", 0},       // IEEE 754r decimal floating point (32 bits)
     {"Di", "char32_t", 0},
-    {"Du", "char8_t", 0},
+    {"Du", "char8_t", 0}, 
     {"Ds", "char16_t", 0},
     {"Dh", "float16", 0},         // IEEE 754r half-precision float (16 bits)
     {nullptr, nullptr, 0},
@@ -152,7 +152,7 @@ static const AbbrevPair kSubstitutionList[] = {
 // frame, so every byte counts.
 typedef struct {
   int mangled_idx;                   // Cursor of mangled name.
-  int out_cur_idx;                   // Cursor of output string.
+  int out_cur_idx;                   // Cursor of output string. 
   int prev_name_idx;                 // For constructors/destructors.
   signed int prev_name_length : 16;  // For constructors/destructors.
   signed int nest_level : 15;        // For nested names.
@@ -173,8 +173,8 @@ static_assert(sizeof(ParseState) == 4 * sizeof(int),
 // Only one copy of this exists for each call to Demangle, so the size of this
 // struct is nearly inconsequential.
 typedef struct {
-  const char *mangled_begin;  // Beginning of input string.
-  char *out;                  // Beginning of output string.
+  const char *mangled_begin;  // Beginning of input string. 
+  char *out;                  // Beginning of output string. 
   int out_end_idx;            // One past last allowed output character.
   int recursion_depth;        // For stack exhaustion prevention.
   int steps;               // Cap how much work we'll do, regardless of depth.
@@ -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".
@@ -414,7 +414,7 @@ static bool IsFunctionCloneSuffix(const char *str) {
 
 static bool EndsWith(State *state, const char chr) {
   return state->parse_state.out_cur_idx > 0 &&
-         state->parse_state.out_cur_idx < state->out_end_idx &&
+         state->parse_state.out_cur_idx < state->out_end_idx && 
          chr == state->out[state->parse_state.out_cur_idx - 1];
 }
 
@@ -427,10 +427,10 @@ static void MaybeAppendWithLength(State *state, const char *const str,
     if (str[0] == '<' && EndsWith(state, '<')) {
       Append(state, " ", 1);
     }
-    // Remember the last identifier name for ctors/dtors,
-    // but only if we haven't yet overflown the buffer.
-    if (state->parse_state.out_cur_idx < state->out_end_idx &&
-        (IsAlpha(str[0]) || str[0] == '_')) {
+    // Remember the last identifier name for ctors/dtors, 
+    // but only if we haven't yet overflown the buffer. 
+    if (state->parse_state.out_cur_idx < state->out_end_idx && 
+        (IsAlpha(str[0]) || str[0] == '_')) { 
       state->parse_state.prev_name_idx = state->parse_state.out_cur_idx;
       state->parse_state.prev_name_length = length;
     }
@@ -970,7 +970,7 @@ static bool ParseOperatorName(State *state, int *arity) {
 //                ::= TT <type>
 //                ::= TI <type>
 //                ::= TS <type>
-//                ::= TH <type>  # thread-local
+//                ::= TH <type>  # thread-local 
 //                ::= Tc <call-offset> <call-offset> <(base) encoding>
 //                ::= GV <(object) name>
 //                ::= T <call-offset> <(base) encoding>
@@ -989,7 +989,7 @@ static bool ParseSpecialName(State *state) {
   ComplexityGuard guard(state);
   if (guard.IsTooComplex()) return false;
   ParseState copy = state->parse_state;
-  if (ParseOneCharToken(state, 'T') && ParseCharClass(state, "VTISH") &&
+  if (ParseOneCharToken(state, 'T') && ParseCharClass(state, "VTISH") && 
       ParseType(state)) {
     return true;
   }
@@ -1086,28 +1086,28 @@ static bool ParseVOffset(State *state) {
   return false;
 }
 
-// <ctor-dtor-name> ::= C1 | C2 | C3 | CI1 <base-class-type> | CI2
-// <base-class-type>
+// <ctor-dtor-name> ::= C1 | C2 | C3 | CI1 <base-class-type> | CI2 
+// <base-class-type> 
 //                  ::= D0 | D1 | D2
 // # GCC extensions: "unified" constructor/destructor.  See
-// #
-// https://github.com/gcc-mirror/gcc/blob/7ad17b583c3643bd4557f29b8391ca7ef08391f5/gcc/cp/mangle.c#L1847
+// # 
+// https://github.com/gcc-mirror/gcc/blob/7ad17b583c3643bd4557f29b8391ca7ef08391f5/gcc/cp/mangle.c#L1847 
 //                  ::= C4 | D4
 static bool ParseCtorDtorName(State *state) {
   ComplexityGuard guard(state);
   if (guard.IsTooComplex()) return false;
   ParseState copy = state->parse_state;
-  if (ParseOneCharToken(state, 'C')) {
-    if (ParseCharClass(state, "1234")) {
-      const char *const prev_name =
-          state->out + state->parse_state.prev_name_idx;
-      MaybeAppendWithLength(state, prev_name,
-                            state->parse_state.prev_name_length);
-      return true;
-    } else if (ParseOneCharToken(state, 'I') && ParseCharClass(state, "12") &&
-               ParseClassEnumType(state)) {
-      return true;
-    }
+  if (ParseOneCharToken(state, 'C')) { 
+    if (ParseCharClass(state, "1234")) { 
+      const char *const prev_name = 
+          state->out + state->parse_state.prev_name_idx; 
+      MaybeAppendWithLength(state, prev_name, 
+                            state->parse_state.prev_name_length); 
+      return true; 
+    } else if (ParseOneCharToken(state, 'I') && ParseCharClass(state, "12") && 
+               ParseClassEnumType(state)) { 
+      return true; 
+    } 
   }
   state->parse_state = copy;
 
@@ -1156,7 +1156,7 @@ static bool ParseDecltype(State *state) {
 //        ::= <decltype>
 //        ::= <substitution>
 //        ::= Dp <type>          # pack expansion of (C++0x)
-//        ::= Dv <num-elems> _   # GNU vector extension
+//        ::= Dv <num-elems> _   # GNU vector extension 
 //
 static bool ParseType(State *state) {
   ComplexityGuard guard(state);
@@ -1223,12 +1223,12 @@ static bool ParseType(State *state) {
     return true;
   }
 
-  if (ParseTwoCharToken(state, "Dv") && ParseNumber(state, nullptr) &&
-      ParseOneCharToken(state, '_')) {
-    return true;
-  }
-  state->parse_state = copy;
-
+  if (ParseTwoCharToken(state, "Dv") && ParseNumber(state, nullptr) && 
+      ParseOneCharToken(state, '_')) { 
+    return true; 
+  } 
+  state->parse_state = copy; 
+ 
   return false;
 }
 
@@ -1277,42 +1277,42 @@ static bool ParseBuiltinType(State *state) {
   return false;
 }
 
-//  <exception-spec> ::= Do                # non-throwing
-//                                           exception-specification (e.g.,
-//                                           noexcept, throw())
-//                   ::= DO <expression> E # computed (instantiation-dependent)
-//                                           noexcept
-//                   ::= Dw <type>+ E      # dynamic exception specification
-//                                           with instantiation-dependent types
-static bool ParseExceptionSpec(State *state) {
-  ComplexityGuard guard(state);
-  if (guard.IsTooComplex()) return false;
-
-  if (ParseTwoCharToken(state, "Do")) return true;
-
-  ParseState copy = state->parse_state;
-  if (ParseTwoCharToken(state, "DO") && ParseExpression(state) &&
-      ParseOneCharToken(state, 'E')) {
-    return true;
-  }
-  state->parse_state = copy;
-  if (ParseTwoCharToken(state, "Dw") && OneOrMore(ParseType, state) &&
-      ParseOneCharToken(state, 'E')) {
-    return true;
-  }
-  state->parse_state = copy;
-
-  return false;
-}
-
-// <function-type> ::= [exception-spec] F [Y] <bare-function-type> [O] E
+//  <exception-spec> ::= Do                # non-throwing 
+//                                           exception-specification (e.g., 
+//                                           noexcept, throw()) 
+//                   ::= DO <expression> E # computed (instantiation-dependent) 
+//                                           noexcept 
+//                   ::= Dw <type>+ E      # dynamic exception specification 
+//                                           with instantiation-dependent types 
+static bool ParseExceptionSpec(State *state) { 
+  ComplexityGuard guard(state); 
+  if (guard.IsTooComplex()) return false; 
+ 
+  if (ParseTwoCharToken(state, "Do")) return true; 
+ 
+  ParseState copy = state->parse_state; 
+  if (ParseTwoCharToken(state, "DO") && ParseExpression(state) && 
+      ParseOneCharToken(state, 'E')) { 
+    return true; 
+  } 
+  state->parse_state = copy; 
+  if (ParseTwoCharToken(state, "Dw") && OneOrMore(ParseType, state) && 
+      ParseOneCharToken(state, 'E')) { 
+    return true; 
+  } 
+  state->parse_state = copy; 
+ 
+  return false; 
+} 
+ 
+// <function-type> ::= [exception-spec] F [Y] <bare-function-type> [O] E 
 static bool ParseFunctionType(State *state) {
   ComplexityGuard guard(state);
   if (guard.IsTooComplex()) return false;
   ParseState copy = state->parse_state;
-  if (Optional(ParseExceptionSpec(state)) && ParseOneCharToken(state, 'F') &&
+  if (Optional(ParseExceptionSpec(state)) && ParseOneCharToken(state, 'F') && 
       Optional(ParseOneCharToken(state, 'Y')) && ParseBareFunctionType(state) &&
-      Optional(ParseOneCharToken(state, 'O')) &&
+      Optional(ParseOneCharToken(state, 'O')) && 
       ParseOneCharToken(state, 'E')) {
     return true;
   }
@@ -1950,8 +1950,8 @@ static bool Overflowed(const State *state) {
 bool Demangle(const char *mangled, char *out, int out_size) {
   State state;
   InitState(&state, mangled, out, out_size);
-  return ParseTopLevelMangledName(&state) && !Overflowed(&state) &&
-         state.parse_state.out_cur_idx > 0;
+  return ParseTopLevelMangledName(&state) && !Overflowed(&state) && 
+         state.parse_state.out_cur_idx > 0; 
 }
 
 }  // namespace debugging_internal
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/examine_stack.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/examine_stack.cc
index c59d92b6a3..96fd5c6ce7 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/examine_stack.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/examine_stack.cc
@@ -20,10 +20,10 @@
 #include <unistd.h>
 #endif
 
-#ifdef __APPLE__
-#include <sys/ucontext.h>
-#endif
-
+#ifdef __APPLE__ 
+#include <sys/ucontext.h> 
+#endif 
+ 
 #include <csignal>
 #include <cstdio>
 
@@ -46,72 +46,72 @@ 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
   }
-#elif defined(__APPLE__)
-  if (vuc != nullptr) {
-    ucontext_t* signal_ucontext = reinterpret_cast<ucontext_t*>(vuc);
-#if defined(__aarch64__)
-    return reinterpret_cast<void*>(
-        __darwin_arm_thread_state64_get_pc(signal_ucontext->uc_mcontext->__ss));
-#elif defined(__arm__)
-#if __DARWIN_UNIX03
-    return reinterpret_cast<void*>(signal_ucontext->uc_mcontext->__ss.__pc);
-#else
-    return reinterpret_cast<void*>(signal_ucontext->uc_mcontext->ss.pc);
-#endif
-#elif defined(__i386__)
-#if __DARWIN_UNIX03
-    return reinterpret_cast<void*>(signal_ucontext->uc_mcontext->__ss.__eip);
-#else
-    return reinterpret_cast<void*>(signal_ucontext->uc_mcontext->ss.eip);
-#endif
-#elif defined(__x86_64__)
-#if __DARWIN_UNIX03
-    return reinterpret_cast<void*>(signal_ucontext->uc_mcontext->__ss.__rip);
-#else
-    return reinterpret_cast<void*>(signal_ucontext->uc_mcontext->ss.rip);
-#endif
-#endif
-  }
+#elif defined(__APPLE__) 
+  if (vuc != nullptr) { 
+    ucontext_t* signal_ucontext = reinterpret_cast<ucontext_t*>(vuc); 
+#if defined(__aarch64__) 
+    return reinterpret_cast<void*>( 
+        __darwin_arm_thread_state64_get_pc(signal_ucontext->uc_mcontext->__ss)); 
+#elif defined(__arm__) 
+#if __DARWIN_UNIX03 
+    return reinterpret_cast<void*>(signal_ucontext->uc_mcontext->__ss.__pc); 
+#else 
+    return reinterpret_cast<void*>(signal_ucontext->uc_mcontext->ss.pc); 
+#endif 
+#elif defined(__i386__) 
+#if __DARWIN_UNIX03 
+    return reinterpret_cast<void*>(signal_ucontext->uc_mcontext->__ss.__eip); 
+#else 
+    return reinterpret_cast<void*>(signal_ucontext->uc_mcontext->ss.eip); 
+#endif 
+#elif defined(__x86_64__) 
+#if __DARWIN_UNIX03 
+    return reinterpret_cast<void*>(signal_ucontext->uc_mcontext->__ss.__rip); 
+#else 
+    return reinterpret_cast<void*>(signal_ucontext->uc_mcontext->ss.rip); 
+#endif 
+#endif 
+  } 
 #elif defined(__akaros__)
   auto* ctx = reinterpret_cast<struct user_context*>(vuc);
   return reinterpret_cast<void*>(get_user_ctx_pc(ctx));
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stack_consumption.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stack_consumption.h
index 80137ad0eb..9cddb3e2b2 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stack_consumption.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stack_consumption.h
@@ -24,8 +24,8 @@
 // Use this feature test macro to detect its availability.
 #ifdef ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION
 #error ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION cannot be set directly
-#elif !defined(__APPLE__) && !defined(_WIN32) &&                     \
-    (defined(__i386__) || defined(__x86_64__) || defined(__ppc__) || \
+#elif !defined(__APPLE__) && !defined(_WIN32) &&                     \ 
+    (defined(__i386__) || defined(__x86_64__) || defined(__ppc__) || \ 
      defined(__aarch64__) || defined(__riscv))
 #define ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION 1
 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_aarch64-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_aarch64-inl.inc
index 700f607488..45e0a50746 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_aarch64-inl.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_aarch64-inl.inc
@@ -37,11 +37,11 @@ static const unsigned char* GetKernelRtSigreturnAddress() {
   y_absl::debugging_internal::VDSOSupport vdso;
   if (vdso.IsPresent()) {
     y_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.
@@ -77,8 +77,8 @@ static inline uintptr_t ComputeStackFrameSize(const T* low,
 // checks (the strictness of which is controlled by the boolean parameter
 // "STRICT_UNWINDING") to reduce the chance that a bad pointer is returned.
 template<bool STRICT_UNWINDING, bool WITH_CONTEXT>
-ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
-ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
+ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack. 
+ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack. 
 static void **NextStackFrame(void **old_frame_pointer, const void *uc) {
   void **new_frame_pointer = reinterpret_cast<void**>(*old_frame_pointer);
   bool check_frame_size = true;
@@ -128,8 +128,8 @@ static void **NextStackFrame(void **old_frame_pointer, const void *uc) {
 }
 
 template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
-ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
-ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
+ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack. 
+ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack. 
 static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
                       const void *ucp, int *min_dropped_frames) {
 #ifdef __GNUC__
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_arm-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_arm-inl.inc
index b73307120e..d9e6fbcf19 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_arm-inl.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_arm-inl.inc
@@ -1,17 +1,17 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// Copyright 2017 The Abseil Authors. 
 //
+// Licensed under the Apache License, Version 2.0 (the "License"); 
+// you may not use this file except in compliance with the License. 
+// You may obtain a copy of the License at 
+// 
+//      https://www.apache.org/licenses/LICENSE-2.0 
+// 
+// Unless required by applicable law or agreed to in writing, software 
+// distributed under the License is distributed on an "AS IS" BASIS, 
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+// See the License for the specific language governing permissions and 
+// limitations under the License. 
+// 
 // This is inspired by Craig Silverstein's PowerPC stacktrace code.
 
 #ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_ARM_INL_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_config.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_config.h
index 7ba212ab03..79ff5a1e47 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_config.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_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 "y_absl/base/config.h"
-
+#include "y_absl/base/config.h" 
+ 
 #if defined(ABSL_STACKTRACE_INL_HEADER)
 #error ABSL_STACKTRACE_INL_HEADER cannot be directly set
 
@@ -30,56 +30,56 @@
 #define ABSL_STACKTRACE_INL_HEADER \
     "y_absl/debugging/internal/stacktrace_win32-inl.inc"
 
-#elif defined(__APPLE__)
-#ifdef ABSL_HAVE_THREAD_LOCAL
-// Thread local support required for UnwindImpl.
-#define ABSL_STACKTRACE_INL_HEADER \
-  "y_absl/debugging/internal/stacktrace_generic-inl.inc"
+#elif defined(__APPLE__) 
+#ifdef ABSL_HAVE_THREAD_LOCAL 
+// Thread local support required for UnwindImpl. 
+#define ABSL_STACKTRACE_INL_HEADER \ 
+  "y_absl/debugging/internal/stacktrace_generic-inl.inc" 
 #endif  // defined(ABSL_HAVE_THREAD_LOCAL)
-
+ 
 #elif defined(__EMSCRIPTEN__)
 #define ABSL_STACKTRACE_INL_HEADER \
   "y_absl/debugging/internal/stacktrace_emscripten-inl.inc"
 
 #elif defined(__linux__) && !defined(__ANDROID__)
 
-#if defined(NO_FRAME_POINTER) && \
-    (defined(__i386__) || defined(__x86_64__) || defined(__aarch64__))
-// Note: The libunwind-based implementation is not available to open-source
-// users.
+#if defined(NO_FRAME_POINTER) && \ 
+    (defined(__i386__) || defined(__x86_64__) || defined(__aarch64__)) 
+// Note: The libunwind-based implementation is not available to open-source 
+// users. 
 #define ABSL_STACKTRACE_INL_HEADER \
-  "y_absl/debugging/internal/stacktrace_libunwind-inl.inc"
-#define STACKTRACE_USES_LIBUNWIND 1
-#elif defined(NO_FRAME_POINTER) && defined(__has_include)
-#if __has_include(<execinfo.h>)
+  "y_absl/debugging/internal/stacktrace_libunwind-inl.inc" 
+#define STACKTRACE_USES_LIBUNWIND 1 
+#elif defined(NO_FRAME_POINTER) && defined(__has_include) 
+#if __has_include(<execinfo.h>) 
 // Note: When using glibc this may require -funwind-tables to function properly.
 #define ABSL_STACKTRACE_INL_HEADER \
   "y_absl/debugging/internal/stacktrace_generic-inl.inc"
 #endif  // __has_include(<execinfo.h>)
-#elif defined(__i386__) || defined(__x86_64__)
+#elif defined(__i386__) || defined(__x86_64__) 
 #define ABSL_STACKTRACE_INL_HEADER \
-  "y_absl/debugging/internal/stacktrace_x86-inl.inc"
-#elif defined(__ppc__) || defined(__PPC__)
+  "y_absl/debugging/internal/stacktrace_x86-inl.inc" 
+#elif defined(__ppc__) || defined(__PPC__) 
 #define ABSL_STACKTRACE_INL_HEADER \
-  "y_absl/debugging/internal/stacktrace_powerpc-inl.inc"
-#elif defined(__aarch64__)
+  "y_absl/debugging/internal/stacktrace_powerpc-inl.inc" 
+#elif defined(__aarch64__) 
 #define ABSL_STACKTRACE_INL_HEADER \
-  "y_absl/debugging/internal/stacktrace_aarch64-inl.inc"
+  "y_absl/debugging/internal/stacktrace_aarch64-inl.inc" 
 #elif defined(__riscv)
 #define ABSL_STACKTRACE_INL_HEADER \
   "y_absl/debugging/internal/stacktrace_riscv-inl.inc"
-#elif defined(__has_include)
-#if __has_include(<execinfo.h>)
-// Note: When using glibc this may require -funwind-tables to function properly.
+#elif defined(__has_include) 
+#if __has_include(<execinfo.h>) 
+// Note: When using glibc this may require -funwind-tables to function properly. 
 #define ABSL_STACKTRACE_INL_HEADER \
-  "y_absl/debugging/internal/stacktrace_generic-inl.inc"
+  "y_absl/debugging/internal/stacktrace_generic-inl.inc" 
 #endif  // __has_include(<execinfo.h>)
 #endif  // defined(__has_include)
 
 #endif  // defined(__linux__) && !defined(__ANDROID__)
-
-// Fallback to the empty implementation.
-#if !defined(ABSL_STACKTRACE_INL_HEADER)
+ 
+// Fallback to the empty implementation. 
+#if !defined(ABSL_STACKTRACE_INL_HEADER) 
 #define ABSL_STACKTRACE_INL_HEADER \
   "y_absl/debugging/internal/stacktrace_unimplemented-inl.inc"
 #endif
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_generic-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_generic-inl.inc
index fa623aa954..a35de63b1a 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_generic-inl.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_generic-inl.inc
@@ -1,17 +1,17 @@
-// Copyright 2017 The Abseil Authors.
+// Copyright 2017 The Abseil Authors. 
 //
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// 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. 
+// 
 // Portable implementation - just use glibc
 //
 // Note:  The glibc implementation may cause a call to malloc.
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_powerpc-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_powerpc-inl.inc
index 1e41c4ebf2..09c5a1708a 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_powerpc-inl.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_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-tstring/y_absl/debugging/internal/stacktrace_win32-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_win32-inl.inc
index 69bd7e3f2f..56f7af56db 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_win32-inl.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_win32-inl.inc
@@ -46,19 +46,19 @@ typedef USHORT NTAPI RtlCaptureStackBackTrace_Function(
     OUT PVOID *backtrace,
     OUT PULONG backtrace_hash);
 
-// It is not possible to load RtlCaptureStackBackTrace at static init time in
-// UWP. CaptureStackBackTrace is the public version of RtlCaptureStackBackTrace
-#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) && \
-    !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-static RtlCaptureStackBackTrace_Function* const RtlCaptureStackBackTrace_fn =
-    &::CaptureStackBackTrace;
-#else
+// It is not possible to load RtlCaptureStackBackTrace at static init time in 
+// UWP. CaptureStackBackTrace is the public version of RtlCaptureStackBackTrace 
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) && \ 
+    !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) 
+static RtlCaptureStackBackTrace_Function* const RtlCaptureStackBackTrace_fn = 
+    &::CaptureStackBackTrace; 
+#else 
 // Load the function we need at static init time, where we don't have
 // to worry about someone else holding the loader's lock.
 static RtlCaptureStackBackTrace_Function* const RtlCaptureStackBackTrace_fn =
-    (RtlCaptureStackBackTrace_Function*)GetProcAddress(
-        GetModuleHandleA("ntdll.dll"), "RtlCaptureStackBackTrace");
-#endif  // WINAPI_PARTITION_APP && !WINAPI_PARTITION_DESKTOP
+    (RtlCaptureStackBackTrace_Function*)GetProcAddress( 
+        GetModuleHandleA("ntdll.dll"), "RtlCaptureStackBackTrace"); 
+#endif  // WINAPI_PARTITION_APP && !WINAPI_PARTITION_DESKTOP 
 
 template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
 static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/symbolize.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/symbolize.h
index e6e2b0724a..b61f75af71 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/symbolize.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/symbolize.h
@@ -18,13 +18,13 @@
 #ifndef ABSL_DEBUGGING_INTERNAL_SYMBOLIZE_H_
 #define ABSL_DEBUGGING_INTERNAL_SYMBOLIZE_H_
 
-#ifdef __cplusplus
-
+#ifdef __cplusplus 
+ 
 #include <cstddef>
 #include <cstdint>
 
 #include "y_absl/base/config.h"
-#include "y_absl/strings/string_view.h"
+#include "y_absl/strings/string_view.h" 
 
 #ifdef ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE
 #error ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE cannot be directly set
@@ -48,7 +48,7 @@ namespace debugging_internal {
 //
 // This is not async-signal-safe.
 bool ForEachSection(int fd,
-                    const std::function<bool(y_absl::string_view name,
+                    const std::function<bool(y_absl::string_view name, 
                                              const ElfW(Shdr) &)>& callback);
 
 // Gets the section header for the given name, if it exists. Returns true on
@@ -62,12 +62,12 @@ ABSL_NAMESPACE_END
 
 #endif  // ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE
 
-#ifdef ABSL_INTERNAL_HAVE_DARWIN_SYMBOLIZE
-#error ABSL_INTERNAL_HAVE_DARWIN_SYMBOLIZE cannot be directly set
-#elif defined(__APPLE__)
-#define ABSL_INTERNAL_HAVE_DARWIN_SYMBOLIZE 1
-#endif
-
+#ifdef ABSL_INTERNAL_HAVE_DARWIN_SYMBOLIZE 
+#error ABSL_INTERNAL_HAVE_DARWIN_SYMBOLIZE cannot be directly set 
+#elif defined(__APPLE__) 
+#define ABSL_INTERNAL_HAVE_DARWIN_SYMBOLIZE 1 
+#endif 
+ 
 #ifdef ABSL_INTERNAL_HAVE_EMSCRIPTEN_SYMBOLIZE
 #error ABSL_INTERNAL_HAVE_EMSCRIPTEN_SYMBOLIZE cannot be directly set
 #elif defined(__EMSCRIPTEN__)
@@ -124,30 +124,30 @@ bool RemoveAllSymbolDecorators(void);
 //   filename != nullptr
 //
 // Returns true if the file was successfully registered.
-bool RegisterFileMappingHint(const void* start, const void* end,
-                             uint64_t offset, const char* filename);
+bool RegisterFileMappingHint(const void* start, const void* end, 
+                             uint64_t offset, const char* filename); 
 
 // Looks up the file mapping registered by RegisterFileMappingHint for an
 // address range. If there is one, the file name is stored in *filename and
 // *start and *end are modified to reflect the registered mapping. Returns
 // whether any hint was found.
-bool GetFileMappingHint(const void** start, const void** end, uint64_t* offset,
+bool GetFileMappingHint(const void** start, const void** end, uint64_t* offset, 
                         const char** filename);
 
 }  // namespace debugging_internal
 ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // __cplusplus
-
-#include <stdbool.h>
-
-#ifdef __cplusplus
-extern "C"
-#endif  // __cplusplus
-
-    bool
-    YAbslInternalGetFileMappingHint(const void** start, const void** end,
-                                   uint64_t* offset, const char** filename);
-
+#endif  // __cplusplus 
+ 
+#include <stdbool.h> 
+ 
+#ifdef __cplusplus 
+extern "C" 
+#endif  // __cplusplus 
+ 
+    bool 
+    YAbslInternalGetFileMappingHint(const void** start, const void** end, 
+                                   uint64_t* offset, const char** filename); 
+ 
 #endif  // ABSL_DEBUGGING_INTERNAL_SYMBOLIZE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/ya.make
index e07162537b..b0bfe96ae7 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/ya.make
@@ -1,40 +1,40 @@
-# Generated by devtools/yamaker.
-
-LIBRARY()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
-
-LICENSE(Apache-2.0)
-
+# Generated by devtools/yamaker. 
+ 
+LIBRARY() 
+ 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
+LICENSE(Apache-2.0) 
+ 
 LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
 
-PEERDIR(
-    contrib/restricted/abseil-cpp-tstring/y_absl/base
+PEERDIR( 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base 
     contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity 
     contrib/restricted/abseil-cpp-tstring/y_absl/debugging
     contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace
     contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize
     contrib/restricted/abseil-cpp-tstring/y_absl/demangle
-    contrib/restricted/abseil-cpp-tstring/y_absl/numeric
-    contrib/restricted/abseil-cpp-tstring/y_absl/strings
+    contrib/restricted/abseil-cpp-tstring/y_absl/numeric 
+    contrib/restricted/abseil-cpp-tstring/y_absl/strings 
     contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_strings_internal
-)
-
-ADDINCL(
-    GLOBAL contrib/restricted/abseil-cpp-tstring
-)
-
-NO_COMPILER_WARNINGS()
-
-SRCS(
+) 
+ 
+ADDINCL( 
+    GLOBAL contrib/restricted/abseil-cpp-tstring 
+) 
+ 
+NO_COMPILER_WARNINGS() 
+ 
+SRCS( 
     examine_stack.cc
-)
-
-END()
+) 
+ 
+END() 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check.cc
index ae5cf79fe2..ec47ebf46e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_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 "y_absl/base/attributes.h"
+#include "y_absl/base/attributes.h" 
 #include "y_absl/debugging/leak_check.h"
 
 #ifndef LEAK_SANITIZER
@@ -24,7 +24,7 @@
 namespace y_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 y_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-tstring/y_absl/debugging/leak_check.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check.h
index d69f08f248..39ae49e8fd 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_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-tstring/y_absl/debugging/leak_check/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check/ya.make
index f22152ef8a..b79477daf0 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check/ya.make
@@ -2,13 +2,13 @@
 
 LIBRARY()
 
-WITHOUT_LICENSE_TEXTS()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
+WITHOUT_LICENSE_TEXTS() 
 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
 LICENSE(Apache-2.0)
 
 ADDINCL(
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check_disable/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check_disable/ya.make
index 41792f1bc6..9c0fddc01b 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check_disable/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check_disable/ya.make
@@ -2,13 +2,13 @@
 
 LIBRARY()
 
-WITHOUT_LICENSE_TEXTS()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
+WITHOUT_LICENSE_TEXTS() 
 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
 LICENSE(Apache-2.0)
 
 ADDINCL(
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace/ya.make
index a56bdc8a4c..ac25d049cc 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace/ya.make
@@ -2,13 +2,13 @@
 
 LIBRARY()
 
-WITHOUT_LICENSE_TEXTS()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
+WITHOUT_LICENSE_TEXTS() 
 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
 LICENSE(Apache-2.0)
 
 PEERDIR(
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize.cc
index 88c92a19ea..91bcd408a6 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize.cc
@@ -14,23 +14,23 @@
 
 #include "y_absl/debugging/symbolize.h"
 
-#ifdef _WIN32
-#include <winapifamily.h>
-#if !(WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)) || \
-    WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-// UWP doesn't have access to win32 APIs.
-#define ABSL_INTERNAL_HAVE_SYMBOLIZE_WIN32
-#endif
-#endif
-
+#ifdef _WIN32 
+#include <winapifamily.h> 
+#if !(WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)) || \ 
+    WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) 
+// UWP doesn't have access to win32 APIs. 
+#define ABSL_INTERNAL_HAVE_SYMBOLIZE_WIN32 
+#endif 
+#endif 
+ 
 #if defined(ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE)
 #include "y_absl/debugging/symbolize_elf.inc"
-#elif defined(ABSL_INTERNAL_HAVE_SYMBOLIZE_WIN32)
+#elif defined(ABSL_INTERNAL_HAVE_SYMBOLIZE_WIN32) 
 // The Windows Symbolizer only works if PDB files containing the debug info
 // are available to the program at runtime.
 #include "y_absl/debugging/symbolize_win32.inc"
-#elif defined(__APPLE__)
-#include "y_absl/debugging/symbolize_darwin.inc"
+#elif defined(__APPLE__) 
+#include "y_absl/debugging/symbolize_darwin.inc" 
 #elif defined(__EMSCRIPTEN__)
 #include "y_absl/debugging/symbolize_emscripten.inc"
 #else
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize/ya.make
index 58f9d70682..21581340de 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize/ya.make
@@ -2,13 +2,13 @@
 
 LIBRARY()
 
-WITHOUT_LICENSE_TEXTS()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
+WITHOUT_LICENSE_TEXTS() 
 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
 LICENSE(Apache-2.0)
 
 PEERDIR(
@@ -16,12 +16,12 @@ PEERDIR(
     contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc
     contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging
     contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate 
     contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity
     contrib/restricted/abseil-cpp-tstring/y_absl/debugging
     contrib/restricted/abseil-cpp-tstring/y_absl/demangle
-    contrib/restricted/abseil-cpp-tstring/y_absl/numeric
-    contrib/restricted/abseil-cpp-tstring/y_absl/strings
+    contrib/restricted/abseil-cpp-tstring/y_absl/numeric 
+    contrib/restricted/abseil-cpp-tstring/y_absl/strings 
     contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_strings_internal
 )
 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_darwin.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_darwin.inc
index c5960a7938..adc0c11913 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_darwin.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_darwin.inc
@@ -1,101 +1,101 @@
-// 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 <cxxabi.h>
-#include <execinfo.h>
-
-#include <algorithm>
-#include <cstring>
-
-#include "y_absl/base/internal/raw_logging.h"
-#include "y_absl/debugging/internal/demangle.h"
-#include "y_absl/strings/numbers.h"
-#include "y_absl/strings/str_cat.h"
-#include "y_absl/strings/string_view.h"
-
-namespace y_absl {
-ABSL_NAMESPACE_BEGIN
-
-void InitializeSymbolizer(const char*) {}
-
-namespace debugging_internal {
-namespace {
-
-static TString GetSymbolString(y_absl::string_view backtrace_line) {
-  // Example Backtrace lines:
-  // 0   libimaging_shared.dylib             0x018c152a
-  // _ZNSt11_Deque_baseIN3nik7mediadb4PageESaIS2_EE17_M_initialize_mapEm + 3478
-  //
-  // or
-  // 0   libimaging_shared.dylib             0x0000000001895c39
-  // _ZN3nik4util19register_shared_ptrINS_3gpu7TextureEEEvPKvS5_ + 39
-  //
-  // or
-  // 0   mysterious_app                      0x0124000120120009 main + 17
-  auto address_pos = backtrace_line.find(" 0x");
-  if (address_pos == y_absl::string_view::npos) return TString();
-  y_absl::string_view symbol_view = backtrace_line.substr(address_pos + 1);
-
-  auto space_pos = symbol_view.find(" ");
-  if (space_pos == y_absl::string_view::npos) return TString();
-  symbol_view = symbol_view.substr(space_pos + 1);  // to mangled symbol
-
-  auto plus_pos = symbol_view.find(" + ");
-  if (plus_pos == y_absl::string_view::npos) return TString();
-  symbol_view = symbol_view.substr(0, plus_pos);  // strip remainng
-
-  return TString(symbol_view);
-}
-
-}  // namespace
-}  // namespace debugging_internal
-
-bool Symbolize(const void* pc, char* out, int out_size) {
-  if (out_size <= 0 || pc == nullptr) {
-    out = nullptr;
-    return false;
-  }
-
-  // This allocates a char* array.
-  char** frame_strings = backtrace_symbols(const_cast<void**>(&pc), 1);
-
-  if (frame_strings == nullptr) return false;
-
-  TString symbol = debugging_internal::GetSymbolString(frame_strings[0]);
-  free(frame_strings);
-
-  char tmp_buf[1024];
-  if (debugging_internal::Demangle(symbol.c_str(), tmp_buf, sizeof(tmp_buf))) {
-    size_t len = strlen(tmp_buf);
-    if (len + 1 <= static_cast<size_t>(out_size)) {  // +1 for '\0'
-      assert(len < sizeof(tmp_buf));
-      memmove(out, tmp_buf, len + 1);
-    }
-  } else {
-    strncpy(out, symbol.c_str(), out_size);
-  }
-
-  if (out[out_size - 1] != '\0') {
-    // strncpy() does not '\0' terminate when it truncates.
-    static constexpr char kEllipsis[] = "...";
-    int ellipsis_size = std::min<int>(sizeof(kEllipsis) - 1, out_size - 1);
-    memcpy(out + out_size - ellipsis_size - 1, kEllipsis, ellipsis_size);
-    out[out_size - 1] = '\0';
-  }
-
-  return true;
-}
-
-ABSL_NAMESPACE_END
-}  // namespace y_absl
+// 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 <cxxabi.h> 
+#include <execinfo.h> 
+ 
+#include <algorithm> 
+#include <cstring> 
+ 
+#include "y_absl/base/internal/raw_logging.h" 
+#include "y_absl/debugging/internal/demangle.h" 
+#include "y_absl/strings/numbers.h" 
+#include "y_absl/strings/str_cat.h" 
+#include "y_absl/strings/string_view.h" 
+ 
+namespace y_absl { 
+ABSL_NAMESPACE_BEGIN 
+ 
+void InitializeSymbolizer(const char*) {} 
+ 
+namespace debugging_internal { 
+namespace { 
+ 
+static TString GetSymbolString(y_absl::string_view backtrace_line) { 
+  // Example Backtrace lines: 
+  // 0   libimaging_shared.dylib             0x018c152a 
+  // _ZNSt11_Deque_baseIN3nik7mediadb4PageESaIS2_EE17_M_initialize_mapEm + 3478 
+  // 
+  // or 
+  // 0   libimaging_shared.dylib             0x0000000001895c39 
+  // _ZN3nik4util19register_shared_ptrINS_3gpu7TextureEEEvPKvS5_ + 39 
+  // 
+  // or 
+  // 0   mysterious_app                      0x0124000120120009 main + 17 
+  auto address_pos = backtrace_line.find(" 0x"); 
+  if (address_pos == y_absl::string_view::npos) return TString(); 
+  y_absl::string_view symbol_view = backtrace_line.substr(address_pos + 1); 
+ 
+  auto space_pos = symbol_view.find(" "); 
+  if (space_pos == y_absl::string_view::npos) return TString(); 
+  symbol_view = symbol_view.substr(space_pos + 1);  // to mangled symbol 
+ 
+  auto plus_pos = symbol_view.find(" + "); 
+  if (plus_pos == y_absl::string_view::npos) return TString(); 
+  symbol_view = symbol_view.substr(0, plus_pos);  // strip remainng 
+ 
+  return TString(symbol_view); 
+} 
+ 
+}  // namespace 
+}  // namespace debugging_internal 
+ 
+bool Symbolize(const void* pc, char* out, int out_size) { 
+  if (out_size <= 0 || pc == nullptr) { 
+    out = nullptr; 
+    return false; 
+  } 
+ 
+  // This allocates a char* array. 
+  char** frame_strings = backtrace_symbols(const_cast<void**>(&pc), 1); 
+ 
+  if (frame_strings == nullptr) return false; 
+ 
+  TString symbol = debugging_internal::GetSymbolString(frame_strings[0]); 
+  free(frame_strings); 
+ 
+  char tmp_buf[1024]; 
+  if (debugging_internal::Demangle(symbol.c_str(), tmp_buf, sizeof(tmp_buf))) { 
+    size_t len = strlen(tmp_buf); 
+    if (len + 1 <= static_cast<size_t>(out_size)) {  // +1 for '\0' 
+      assert(len < sizeof(tmp_buf)); 
+      memmove(out, tmp_buf, len + 1); 
+    } 
+  } else { 
+    strncpy(out, symbol.c_str(), out_size); 
+  } 
+ 
+  if (out[out_size - 1] != '\0') { 
+    // strncpy() does not '\0' terminate when it truncates. 
+    static constexpr char kEllipsis[] = "..."; 
+    int ellipsis_size = std::min<int>(sizeof(kEllipsis) - 1, out_size - 1); 
+    memcpy(out + out_size - ellipsis_size - 1, kEllipsis, ellipsis_size); 
+    out[out_size - 1] = '\0'; 
+  } 
+ 
+  return true; 
+} 
+ 
+ABSL_NAMESPACE_END 
+}  // namespace y_absl 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_elf.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_elf.inc
index 18297405e3..f7b07cc09b 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_elf.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_elf.inc
@@ -57,7 +57,7 @@
 #include <unistd.h>
 
 #include <algorithm>
-#include <array>
+#include <array> 
 #include <atomic>
 #include <cerrno>
 #include <cinttypes>
@@ -75,7 +75,7 @@
 #include "y_absl/base/port.h"
 #include "y_absl/debugging/internal/demangle.h"
 #include "y_absl/debugging/internal/vdso_support.h"
-#include "y_absl/strings/string_view.h"
+#include "y_absl/strings/string_view.h" 
 
 #if defined(__FreeBSD__) && !defined(ElfW)
 #define ElfW(x) __ElfN(x)
@@ -88,12 +88,12 @@ ABSL_NAMESPACE_BEGIN
 static char *argv0_value = nullptr;
 
 void InitializeSymbolizer(const char *argv0) {
-#ifdef ABSL_HAVE_VDSO_SUPPORT
-  // We need to make sure VDSOSupport::Init() is called before any setuid or
-  // chroot calls, so InitializeSymbolizer() should be called very early in the
-  // life of a program.
-  y_absl::debugging_internal::VDSOSupport::Init();
-#endif
+#ifdef ABSL_HAVE_VDSO_SUPPORT 
+  // We need to make sure VDSOSupport::Init() is called before any setuid or 
+  // chroot calls, so InitializeSymbolizer() should be called very early in the 
+  // life of a program. 
+  y_absl::debugging_internal::VDSOSupport::Init(); 
+#endif 
   if (argv0_value != nullptr) {
     free(argv0_value);
     argv0_value = nullptr;
@@ -161,15 +161,15 @@ struct FileMappingHint {
 // Moreover, we are using only TryLock(), if the decorator list
 // is being modified (is busy), we skip all decorators, and possibly
 // loose some info. Sorry, that's the best we could do.
-ABSL_CONST_INIT y_absl::base_internal::SpinLock g_decorators_mu(
-    y_absl::kConstInit, y_absl::base_internal::SCHEDULE_KERNEL_ONLY);
+ABSL_CONST_INIT y_absl::base_internal::SpinLock g_decorators_mu( 
+    y_absl::kConstInit, y_absl::base_internal::SCHEDULE_KERNEL_ONLY); 
 
 const int kMaxFileMappingHints = 8;
 int g_num_file_mapping_hints;
 FileMappingHint g_file_mapping_hints[kMaxFileMappingHints];
 // Protects g_file_mapping_hints.
-ABSL_CONST_INIT y_absl::base_internal::SpinLock g_file_mapping_mu(
-    y_absl::kConstInit, y_absl::base_internal::SCHEDULE_KERNEL_ONLY);
+ABSL_CONST_INIT y_absl::base_internal::SpinLock g_file_mapping_mu( 
+    y_absl::kConstInit, y_absl::base_internal::SCHEDULE_KERNEL_ONLY); 
 
 // Async-signal-safe function to zero a buffer.
 // memset() is not guaranteed to be async-signal-safe.
@@ -189,7 +189,7 @@ struct ObjFile {
         fd(-1),
         elf_type(-1) {
     SafeMemZero(&elf_header, sizeof(elf_header));
-    SafeMemZero(&phdr[0], sizeof(phdr));
+    SafeMemZero(&phdr[0], sizeof(phdr)); 
   }
 
   char *filename;
@@ -202,10 +202,10 @@ struct ObjFile {
   int fd;
   int elf_type;
   ElfW(Ehdr) elf_header;
-
-  // PT_LOAD program header describing executable code.
-  // Normally we expect just one, but SWIFT binaries have two.
-  std::array<ElfW(Phdr), 2> phdr;
+ 
+  // PT_LOAD program header describing executable code. 
+  // Normally we expect just one, but SWIFT binaries have two. 
+  std::array<ElfW(Phdr), 2> phdr; 
 };
 
 // Build 4-way associative cache for symbols. Within each cache line, symbols
@@ -515,7 +515,7 @@ static ABSL_ATTRIBUTE_NOINLINE bool GetSectionHeaderByType(
 const int kMaxSectionNameLen = 64;
 
 bool ForEachSection(int fd,
-                    const std::function<bool(y_absl::string_view name,
+                    const std::function<bool(y_absl::string_view name, 
                                              const ElfW(Shdr) &)> &callback) {
   ElfW(Ehdr) elf_header;
   if (!ReadFromOffsetExact(fd, &elf_header, sizeof(elf_header), 0)) {
@@ -537,7 +537,7 @@ bool ForEachSection(int fd,
       return false;
     }
     off_t name_offset = shstrtab.sh_offset + out.sh_name;
-    char header_name[kMaxSectionNameLen];
+    char header_name[kMaxSectionNameLen]; 
     ssize_t n_read =
         ReadFromOffset(fd, &header_name, kMaxSectionNameLen, name_offset);
     if (n_read == -1) {
@@ -547,7 +547,7 @@ bool ForEachSection(int fd,
       return false;
     }
 
-    y_absl::string_view name(header_name, strnlen(header_name, n_read));
+    y_absl::string_view name(header_name, strnlen(header_name, n_read)); 
     if (!callback(name, out)) {
       break;
     }
@@ -1292,36 +1292,36 @@ static bool MaybeInitializeObjFile(ObjFile *obj) {
       ABSL_RAW_LOG(WARNING, "%s: failed to read elf header", obj->filename);
       return false;
     }
-    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;
-    for (int j = 0; j < phnum; j++) {
-      ElfW(Phdr) phdr;
-      if (!ReadFromOffsetExact(obj->fd, &phdr, sizeof(phdr), phoff)) {
-        ABSL_RAW_LOG(WARNING, "%s: failed to read program header %d",
-                     obj->filename, j);
-        return false;
-      }
-      phoff += phentsize;
-      constexpr int rx = PF_X | PF_R;
-      if (phdr.p_type != PT_LOAD || (phdr.p_flags & rx) != rx) {
-        // Not a LOAD segment, or not executable code.
-        continue;
-      }
-      if (num_executable_load_segments < obj->phdr.size()) {
-        memcpy(&obj->phdr[num_executable_load_segments++], &phdr, sizeof(phdr));
-      } else {
-        ABSL_RAW_LOG(WARNING, "%s: too many executable LOAD segments",
-                     obj->filename);
-        break;
-      }
-    }
-    if (num_executable_load_segments == 0) {
-      // This object has no "r-x" LOAD segments. That's unexpected.
-      ABSL_RAW_LOG(WARNING, "%s: no executable LOAD segments", obj->filename);
-      return false;
-    }
+    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; 
+    for (int j = 0; j < phnum; j++) { 
+      ElfW(Phdr) phdr; 
+      if (!ReadFromOffsetExact(obj->fd, &phdr, sizeof(phdr), phoff)) { 
+        ABSL_RAW_LOG(WARNING, "%s: failed to read program header %d", 
+                     obj->filename, j); 
+        return false; 
+      } 
+      phoff += phentsize; 
+      constexpr int rx = PF_X | PF_R; 
+      if (phdr.p_type != PT_LOAD || (phdr.p_flags & rx) != rx) { 
+        // Not a LOAD segment, or not executable code. 
+        continue; 
+      } 
+      if (num_executable_load_segments < obj->phdr.size()) { 
+        memcpy(&obj->phdr[num_executable_load_segments++], &phdr, sizeof(phdr)); 
+      } else { 
+        ABSL_RAW_LOG(WARNING, "%s: too many executable LOAD segments", 
+                     obj->filename); 
+        break; 
+      } 
+    } 
+    if (num_executable_load_segments == 0) { 
+      // This object has no "r-x" LOAD segments. That's unexpected. 
+      ABSL_RAW_LOG(WARNING, "%s: no executable LOAD segments", obj->filename); 
+      return false; 
+    } 
   }
   return true;
 }
@@ -1345,52 +1345,52 @@ const char *Symbolizer::GetSymbol(const void *const pc) {
   int fd = -1;
   if (obj != nullptr) {
     if (MaybeInitializeObjFile(obj)) {
-      const size_t start_addr = reinterpret_cast<size_t>(obj->start_addr);
-      if (obj->elf_type == ET_DYN && start_addr >= obj->offset) {
+      const size_t start_addr = reinterpret_cast<size_t>(obj->start_addr); 
+      if (obj->elf_type == ET_DYN && start_addr >= obj->offset) { 
         // This object was relocated.
         //
         // For obj->offset > 0, adjust the relocation since a mapping at offset
         // X in the file will have a start address of [true relocation]+X.
-        relocation = start_addr - obj->offset;
-
-        // 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++) {
-          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
-            // write over (i.e. we exhausted all interesting PT_LOADs).
-            ABSL_RAW_CHECK(p.p_type == PT_NULL, "unexpected p_type");
-            break;
-          }
-          if (pc < reinterpret_cast<void *>(start_addr + p.p_memsz)) {
-            phdr = &p;
-            break;
-          }
-        }
-        if (phdr == nullptr) {
-          // That's unexpected. Hope for the best.
-          ABSL_RAW_LOG(
-              WARNING,
-              "%s: unable to find LOAD segment for pc: %p, start_addr: %zx",
-              obj->filename, pc, start_addr);
-        } else {
-          // Adjust relocation in case phdr.p_vaddr != 0.
-          // This happens for binaries linked with `lld --rosegment`, and for
-          // binaries linked with BFD `ld -z separate-code`.
-          relocation -= phdr->p_vaddr - phdr->p_offset;
-        }
+        relocation = start_addr - obj->offset; 
+ 
+        // 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++) { 
+          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 
+            // write over (i.e. we exhausted all interesting PT_LOADs). 
+            ABSL_RAW_CHECK(p.p_type == PT_NULL, "unexpected p_type"); 
+            break; 
+          } 
+          if (pc < reinterpret_cast<void *>(start_addr + p.p_memsz)) { 
+            phdr = &p; 
+            break; 
+          } 
+        } 
+        if (phdr == nullptr) { 
+          // That's unexpected. Hope for the best. 
+          ABSL_RAW_LOG( 
+              WARNING, 
+              "%s: unable to find LOAD segment for pc: %p, start_addr: %zx", 
+              obj->filename, pc, start_addr); 
+        } else { 
+          // Adjust relocation in case phdr.p_vaddr != 0. 
+          // This happens for binaries linked with `lld --rosegment`, and for 
+          // binaries linked with BFD `ld -z separate-code`. 
+          relocation -= phdr->p_vaddr - phdr->p_offset; 
+        } 
       }
 
       fd = obj->fd;
-      if (GetSymbolFromObjectFile(*obj, pc, relocation, symbol_buf_,
-                                  sizeof(symbol_buf_), tmp_buf_,
-                                  sizeof(tmp_buf_)) == SYMBOL_FOUND) {
-        // Only try to demangle the symbol name if it fit into symbol_buf_.
-        DemangleInplace(symbol_buf_, sizeof(symbol_buf_), tmp_buf_,
-                        sizeof(tmp_buf_));
-      }
+      if (GetSymbolFromObjectFile(*obj, pc, relocation, symbol_buf_, 
+                                  sizeof(symbol_buf_), tmp_buf_, 
+                                  sizeof(tmp_buf_)) == SYMBOL_FOUND) { 
+        // Only try to demangle the symbol name if it fit into symbol_buf_. 
+        DemangleInplace(symbol_buf_, sizeof(symbol_buf_), tmp_buf_, 
+                        sizeof(tmp_buf_)); 
+      } 
     }
   } else {
 #if ABSL_HAVE_VDSO_SUPPORT
@@ -1461,7 +1461,7 @@ int InstallSymbolDecorator(SymbolDecorator decorator, void *arg) {
 
   if (!g_decorators_mu.TryLock()) {
     // Someone else is using decorators. Get out.
-    return -2;
+    return -2; 
   }
   int ret = ticket;
   if (g_num_decorators >= kMaxDecorators) {
@@ -1489,7 +1489,7 @@ bool RegisterFileMappingHint(const void *start, const void *end, uint64_t offset
   if (g_num_file_mapping_hints >= kMaxFileMappingHints) {
     ret = false;
   } else {
-    // TODO(ckennelly): Move this into a string copy routine.
+    // TODO(ckennelly): Move this into a string copy routine. 
     int len = strlen(filename);
     char *dst = static_cast<char *>(
         base_internal::LowLevelAlloc::AllocWithArena(len + 1, SigSafeArena()));
@@ -1540,7 +1540,7 @@ bool GetFileMappingHint(const void **start, const void **end, uint64_t *offset,
 
 bool Symbolize(const void *pc, char *out, int out_size) {
   // Symbolization is very slow under tsan.
-  ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN();
+  ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN(); 
   SAFE_ASSERT(out_size >= 0);
   debugging_internal::Symbolizer *s = debugging_internal::AllocateSymbolizer();
   const char *name = s->GetSymbol(pc);
@@ -1559,16 +1559,16 @@ bool Symbolize(const void *pc, char *out, int out_size) {
     }
   }
   debugging_internal::FreeSymbolizer(s);
-  ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_END();
+  ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_END(); 
   return ok;
 }
 
 ABSL_NAMESPACE_END
 }  // namespace y_absl
-
-extern "C" bool YAbslInternalGetFileMappingHint(const void **start,
-                                               const void **end, uint64_t *offset,
-                                               const char **filename) {
-  return y_absl::debugging_internal::GetFileMappingHint(start, end, offset,
-                                                      filename);
-}
+ 
+extern "C" bool YAbslInternalGetFileMappingHint(const void **start, 
+                                               const void **end, uint64_t *offset, 
+                                               const char **filename) { 
+  return y_absl::debugging_internal::GetFileMappingHint(start, end, offset, 
+                                                      filename); 
+} 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/ya.make
index d768f195c2..b9b179d0a7 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/ya.make
@@ -2,15 +2,15 @@
 
 LIBRARY()
 
-OWNER(
-    somov
-    g:cpp-contrib
-)
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
 
 LICENSE(Apache-2.0)
 
-LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
-
+LICENSE_TEXTS(.yandex_meta/licenses.list.txt) 
+ 
 PEERDIR(
     contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging
     contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/demangle/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/demangle/ya.make
index a1abc9f615..c09d2c8b09 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/demangle/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/demangle/ya.make
@@ -2,13 +2,13 @@
 
 LIBRARY()
 
-WITHOUT_LICENSE_TEXTS()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
+WITHOUT_LICENSE_TEXTS() 
 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
 LICENSE(Apache-2.0)
 
 PEERDIR(
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/functional/.yandex_meta/licenses.list.txt b/contrib/restricted/abseil-cpp-tstring/y_absl/functional/.yandex_meta/licenses.list.txt
index 7b6169efac..43c757a619 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/functional/.yandex_meta/licenses.list.txt
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/functional/.yandex_meta/licenses.list.txt
@@ -1,20 +1,20 @@
-====================Apache-2.0====================
-// 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====================
-// Copyright 2018 The Abseil Authors.
-
-
-====================COPYRIGHT====================
-// Copyright 2019 The Abseil Authors.
+====================Apache-2.0==================== 
+// 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==================== 
+// Copyright 2018 The Abseil Authors. 
+ 
+ 
+====================COPYRIGHT==================== 
+// Copyright 2019 The Abseil Authors. 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/functional/function_ref.h b/contrib/restricted/abseil-cpp-tstring/y_absl/functional/function_ref.h
index 6ae4c63c9e..d238d1ea0d 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/functional/function_ref.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/functional/function_ref.h
@@ -91,7 +91,7 @@ class FunctionRef<R(Args...)> {
   // Used to disable constructors for objects that are not compatible with the
   // signature of this FunctionRef.
   template <typename F,
-            typename FR = y_absl::base_internal::invoke_result_t<F, Args&&...>>
+            typename FR = y_absl::base_internal::invoke_result_t<F, Args&&...>> 
   using EnableIfCompatible =
       typename std::enable_if<std::is_void<R>::value ||
                               std::is_convertible<FR, R>::value>::type;
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/functional/internal/front_binder.h b/contrib/restricted/abseil-cpp-tstring/y_absl/functional/internal/front_binder.h
index b2fff44274..e0cd7aad8b 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/functional/internal/front_binder.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/functional/internal/front_binder.h
@@ -33,7 +33,7 @@ namespace functional_internal {
 // Invoke the method, expanding the tuple of bound arguments.
 template <class R, class Tuple, size_t... Idx, class... Args>
 R Apply(Tuple&& bound, y_absl::index_sequence<Idx...>, Args&&... free) {
-  return base_internal::invoke(
+  return base_internal::invoke( 
       y_absl::forward<Tuple>(bound).template get<Idx>()...,
       y_absl::forward<Args>(free)...);
 }
@@ -50,22 +50,22 @@ class FrontBinder {
   constexpr explicit FrontBinder(y_absl::in_place_t, Ts&&... ts)
       : bound_args_(y_absl::forward<Ts>(ts)...) {}
 
-  template <class... FreeArgs, class R = base_internal::invoke_result_t<
-                                   F&, BoundArgs&..., FreeArgs&&...>>
+  template <class... FreeArgs, class R = base_internal::invoke_result_t< 
+                                   F&, BoundArgs&..., FreeArgs&&...>> 
   R operator()(FreeArgs&&... free_args) & {
     return functional_internal::Apply<R>(bound_args_, Idx(),
                                          y_absl::forward<FreeArgs>(free_args)...);
   }
 
   template <class... FreeArgs,
-            class R = base_internal::invoke_result_t<
-                const F&, const BoundArgs&..., FreeArgs&&...>>
+            class R = base_internal::invoke_result_t< 
+                const F&, const BoundArgs&..., FreeArgs&&...>> 
   R operator()(FreeArgs&&... free_args) const& {
     return functional_internal::Apply<R>(bound_args_, Idx(),
                                          y_absl::forward<FreeArgs>(free_args)...);
   }
 
-  template <class... FreeArgs, class R = base_internal::invoke_result_t<
+  template <class... FreeArgs, class R = base_internal::invoke_result_t< 
                                    F&&, BoundArgs&&..., FreeArgs&&...>>
   R operator()(FreeArgs&&... free_args) && {
     // This overload is called when *this is an rvalue. If some of the bound
@@ -75,8 +75,8 @@ class FrontBinder {
   }
 
   template <class... FreeArgs,
-            class R = base_internal::invoke_result_t<
-                const F&&, const BoundArgs&&..., FreeArgs&&...>>
+            class R = base_internal::invoke_result_t< 
+                const F&&, const BoundArgs&&..., FreeArgs&&...>> 
   R operator()(FreeArgs&&... free_args) const&& {
     // This overload is called when *this is an rvalue. If some of the bound
     // arguments are stored by value or rvalue reference, we move them.
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/functional/internal/function_ref.h b/contrib/restricted/abseil-cpp-tstring/y_absl/functional/internal/function_ref.h
index 1ba81ee96a..8650a1d50b 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/functional/internal/function_ref.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/functional/internal/function_ref.h
@@ -71,14 +71,14 @@ template <typename Obj, typename R, typename... Args>
 R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   auto o = static_cast<const Obj*>(ptr.obj);
   return static_cast<R>(
-      y_absl::base_internal::invoke(*o, std::forward<Args>(args)...));
+      y_absl::base_internal::invoke(*o, std::forward<Args>(args)...)); 
 }
 
 template <typename Fun, typename R, typename... Args>
 R InvokeFunction(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   auto f = reinterpret_cast<Fun>(ptr.fun);
   return static_cast<R>(
-      y_absl::base_internal::invoke(f, std::forward<Args>(args)...));
+      y_absl::base_internal::invoke(f, std::forward<Args>(args)...)); 
 }
 
 template <typename Sig>
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/functional/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/functional/ya.make
index b5ead45856..9a44988749 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/functional/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/functional/ya.make
@@ -1,14 +1,14 @@
-# Generated by devtools/yamaker.
-
-LIBRARY()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
-
-LICENSE(Apache-2.0)
-
-LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
-
-END()
+# Generated by devtools/yamaker. 
+ 
+LIBRARY() 
+ 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
+LICENSE(Apache-2.0) 
+ 
+LICENSE_TEXTS(.yandex_meta/licenses.list.txt) 
+ 
+END() 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/.yandex_meta/licenses.list.txt b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/.yandex_meta/licenses.list.txt
index 6e98312194..c5a2f873ac 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/.yandex_meta/licenses.list.txt
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/.yandex_meta/licenses.list.txt
@@ -1,16 +1,16 @@
-====================Apache-2.0====================
-// 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====================
-// Copyright 2018 The Abseil Authors.
+====================Apache-2.0==================== 
+// 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==================== 
+// Copyright 2018 The Abseil Authors. 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/hash.h b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/hash.h
index 1e93ee96d9..0353501df1 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/hash.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/hash.h
@@ -37,12 +37,12 @@
 // types. Hashing of that combined state is separately done by `y_absl::Hash`.
 //
 // One should assume that a hash algorithm is chosen randomly at the start of
-// each process.  E.g., `y_absl::Hash<int>{}(9)` in one process and
-// `y_absl::Hash<int>{}(9)` in another process are likely to differ.
-//
-// `y_absl::Hash` is intended to strongly mix input bits with a target of passing
-// an [Avalanche Test](https://en.wikipedia.org/wiki/Avalanche_effect).
+// each process.  E.g., `y_absl::Hash<int>{}(9)` in one process and 
+// `y_absl::Hash<int>{}(9)` in another process are likely to differ. 
 //
+// `y_absl::Hash` is intended to strongly mix input bits with a target of passing 
+// an [Avalanche Test](https://en.wikipedia.org/wiki/Avalanche_effect). 
+// 
 // Example:
 //
 //   // Suppose we have a class `Circle` for which we want to add hashing:
@@ -102,7 +102,7 @@ ABSL_NAMESPACE_BEGIN
 //   * std::tuple<Ts...>, if all the Ts... are hashable
 //   * std::unique_ptr and std::shared_ptr
 //   * All string-like types including:
-//     * y_absl::Cord
+//     * y_absl::Cord 
 //     * TString
 //     * std::string_view (as well as any instance of std::basic_string that
 //       uses char and std::char_traits)
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/.yandex_meta/licenses.list.txt b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/.yandex_meta/licenses.list.txt
index bbc98ff778..757688c969 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/.yandex_meta/licenses.list.txt
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/.yandex_meta/licenses.list.txt
@@ -1,34 +1,34 @@
-====================Apache-2.0====================
-// 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.
-
-
-====================Apache-2.0====================
-// 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====================
-// Copyright 2018 The Abseil Authors.
-
-
-====================COPYRIGHT====================
-// Copyright 2020 The Abseil Authors.
+====================Apache-2.0==================== 
+// 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. 
+ 
+ 
+====================Apache-2.0==================== 
+// 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==================== 
+// Copyright 2018 The Abseil Authors. 
+ 
+ 
+====================COPYRIGHT==================== 
+// Copyright 2020 The Abseil Authors. 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/city.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/city.cc
index 5f1b655e7e..27d253ebd8 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/city.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_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;
@@ -254,8 +254,8 @@ static uint64_t HashLen17to32(const char *s, size_t len) {
 
 // Return a 16-byte hash for 48 bytes.  Quick and dirty.
 // Callers do best to use "random-looking" values for a and b.
-static std::pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
-    uint64_t w, uint64_t x, uint64_t y, uint64_t z, uint64_t a, uint64_t b) {
+static std::pair<uint64_t, uint64_t> WeakHashLen32WithSeeds( 
+    uint64_t w, uint64_t x, uint64_t y, uint64_t z, uint64_t a, uint64_t b) { 
   a += w;
   b = Rotate(b + a + z, 21);
   uint64_t c = a;
@@ -266,9 +266,9 @@ static std::pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
 }
 
 // Return a 16-byte hash for s[0] ... s[31], a, and b.  Quick and dirty.
-static std::pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(const char *s,
-                                                            uint64_t a,
-                                                            uint64_t b) {
+static std::pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(const char *s, 
+                                                            uint64_t a, 
+                                                            uint64_t b) { 
   return WeakHashLen32WithSeeds(Fetch64(s), Fetch64(s + 8), Fetch64(s + 16),
                                 Fetch64(s + 24), a, b);
 }
@@ -311,10 +311,10 @@ uint64_t CityHash64(const char *s, size_t len) {
   uint64_t x = Fetch64(s + len - 40);
   uint64_t y = Fetch64(s + len - 16) + Fetch64(s + len - 56);
   uint64_t z = HashLen16(Fetch64(s + len - 48) + len, Fetch64(s + len - 24));
-  std::pair<uint64_t, uint64_t> v =
-      WeakHashLen32WithSeeds(s + len - 64, len, z);
-  std::pair<uint64_t, uint64_t> w =
-      WeakHashLen32WithSeeds(s + len - 32, y + k1, x);
+  std::pair<uint64_t, uint64_t> v = 
+      WeakHashLen32WithSeeds(s + len - 64, len, z); 
+  std::pair<uint64_t, uint64_t> w = 
+      WeakHashLen32WithSeeds(s + len - 32, y + k1, x); 
   x = x * k1 + Fetch64(s);
 
   // Decrease len to the nearest multiple of 64, and operate on 64-byte chunks.
@@ -340,7 +340,7 @@ uint64_t CityHash64WithSeed(const char *s, size_t len, uint64_t seed) {
 }
 
 uint64_t CityHash64WithSeeds(const char *s, size_t len, uint64_t seed0,
-                             uint64_t seed1) {
+                             uint64_t seed1) { 
   return HashLen16(CityHash64(s, len) - seed0, seed1);
 }
 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/city.h b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/city.h
index d2b32f0068..4efdc6ead1 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/city.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/city.h
@@ -66,7 +66,7 @@ uint64_t CityHash64WithSeed(const char *s, size_t len, uint64_t seed);
 // Hash function for a byte array.  For convenience, two seeds are also
 // hashed into the result.
 uint64_t CityHash64WithSeeds(const char *s, size_t len, uint64_t seed0,
-                             uint64_t seed1);
+                             uint64_t seed1); 
 
 // Hash function for a byte array.  Most useful in 32-bit binaries.
 uint32_t CityHash32(const char *s, size_t len);
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/hash.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/hash.cc
index fe075de43a..68123f84cb 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/hash.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_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 y_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 y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/hash.h b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/hash.h
index fcbe43accd..37cf79a7b4 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/hash.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/hash.h
@@ -39,8 +39,8 @@
 #include <utility>
 #include <vector>
 
-#include "y_absl/base/config.h"
-#include "y_absl/base/internal/unaligned_access.h"
+#include "y_absl/base/config.h" 
+#include "y_absl/base/internal/unaligned_access.h" 
 #include "y_absl/base/port.h"
 #include "y_absl/container/fixed_array.h"
 #include "y_absl/hash/internal/city.h"
@@ -60,61 +60,61 @@ namespace hash_internal {
 // returns the size of these chunks.
 constexpr size_t PiecewiseChunkSize() { return 1024; }
 
-// PiecewiseCombiner
-//
-// PiecewiseCombiner is an internal-only helper class for hashing a piecewise
-// buffer of `char` or `unsigned char` as though it were contiguous.  This class
-// provides two methods:
-//
-//   H add_buffer(state, data, size)
-//   H finalize(state)
-//
-// `add_buffer` can be called zero or more times, followed by a single call to
-// `finalize`.  This will produce the same hash expansion as concatenating each
-// buffer piece into a single contiguous buffer, and passing this to
-// `H::combine_contiguous`.
-//
-//  Example usage:
-//    PiecewiseCombiner combiner;
-//    for (const auto& piece : pieces) {
-//      state = combiner.add_buffer(std::move(state), piece.data, piece.size);
-//    }
-//    return combiner.finalize(std::move(state));
-class PiecewiseCombiner {
- public:
-  PiecewiseCombiner() : position_(0) {}
-  PiecewiseCombiner(const PiecewiseCombiner&) = delete;
-  PiecewiseCombiner& operator=(const PiecewiseCombiner&) = delete;
-
-  // PiecewiseCombiner::add_buffer()
-  //
-  // Appends the given range of bytes to the sequence to be hashed, which may
-  // modify the provided hash state.
-  template <typename H>
-  H add_buffer(H state, const unsigned char* data, size_t size);
-  template <typename H>
-  H add_buffer(H state, const char* data, size_t size) {
-    return add_buffer(std::move(state),
-                      reinterpret_cast<const unsigned char*>(data), size);
-  }
-
-  // PiecewiseCombiner::finalize()
-  //
-  // Finishes combining the hash sequence, which may may modify the provided
-  // hash state.
-  //
-  // Once finalize() is called, add_buffer() may no longer be called. The
-  // resulting hash state will be the same as if the pieces passed to
-  // add_buffer() were concatenated into a single flat buffer, and then provided
-  // to H::combine_contiguous().
-  template <typename H>
-  H finalize(H state);
-
- private:
-  unsigned char buf_[PiecewiseChunkSize()];
-  size_t position_;
-};
-
+// PiecewiseCombiner 
+// 
+// PiecewiseCombiner is an internal-only helper class for hashing a piecewise 
+// buffer of `char` or `unsigned char` as though it were contiguous.  This class 
+// provides two methods: 
+// 
+//   H add_buffer(state, data, size) 
+//   H finalize(state) 
+// 
+// `add_buffer` can be called zero or more times, followed by a single call to 
+// `finalize`.  This will produce the same hash expansion as concatenating each 
+// buffer piece into a single contiguous buffer, and passing this to 
+// `H::combine_contiguous`. 
+// 
+//  Example usage: 
+//    PiecewiseCombiner combiner; 
+//    for (const auto& piece : pieces) { 
+//      state = combiner.add_buffer(std::move(state), piece.data, piece.size); 
+//    } 
+//    return combiner.finalize(std::move(state)); 
+class PiecewiseCombiner { 
+ public: 
+  PiecewiseCombiner() : position_(0) {} 
+  PiecewiseCombiner(const PiecewiseCombiner&) = delete; 
+  PiecewiseCombiner& operator=(const PiecewiseCombiner&) = delete; 
+ 
+  // PiecewiseCombiner::add_buffer() 
+  // 
+  // Appends the given range of bytes to the sequence to be hashed, which may 
+  // modify the provided hash state. 
+  template <typename H> 
+  H add_buffer(H state, const unsigned char* data, size_t size); 
+  template <typename H> 
+  H add_buffer(H state, const char* data, size_t size) { 
+    return add_buffer(std::move(state), 
+                      reinterpret_cast<const unsigned char*>(data), size); 
+  } 
+ 
+  // PiecewiseCombiner::finalize() 
+  // 
+  // Finishes combining the hash sequence, which may may modify the provided 
+  // hash state. 
+  // 
+  // Once finalize() is called, add_buffer() may no longer be called. The 
+  // resulting hash state will be the same as if the pieces passed to 
+  // add_buffer() were concatenated into a single flat buffer, and then provided 
+  // to H::combine_contiguous(). 
+  template <typename H> 
+  H finalize(H state); 
+ 
+ private: 
+  unsigned char buf_[PiecewiseChunkSize()]; 
+  size_t position_; 
+}; 
+ 
 // HashStateBase
 //
 // A hash state object represents an intermediate state in the computation
@@ -181,7 +181,7 @@ class HashStateBase {
   template <typename T>
   static H combine_contiguous(H state, const T* data, size_t size);
 
-  using AbslInternalPiecewiseCombiner = PiecewiseCombiner;
+  using AbslInternalPiecewiseCombiner = PiecewiseCombiner; 
 };
 
 // is_uniquely_represented
@@ -413,7 +413,7 @@ H AbslHashValue(H hash_state, const std::shared_ptr<T>& ptr) {
 // All the string-like types supported here provide the same hash expansion for
 // the same character sequence. These types are:
 //
-//  - `y_absl::Cord`
+//  - `y_absl::Cord` 
 //  - `TString` (and std::basic_string<char, std::char_traits<char>, A> for
 //      any allocator A)
 //  - `y_absl::string_view` and `std::string_view`
@@ -576,13 +576,13 @@ typename std::enable_if<is_hashable<Key>::value, H>::type AbslHashValue(
 // AbslHashValue for Wrapper Types
 // -----------------------------------------------------------------------------
 
-// AbslHashValue for hashing std::reference_wrapper
-template <typename H, typename T>
-typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
-    H hash_state, std::reference_wrapper<T> opt) {
-  return H::combine(std::move(hash_state), opt.get());
-}
-
+// AbslHashValue for hashing std::reference_wrapper 
+template <typename H, typename T> 
+typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue( 
+    H hash_state, std::reference_wrapper<T> opt) { 
+  return H::combine(std::move(hash_state), opt.get()); 
+} 
+ 
 // AbslHashValue for hashing y_absl::optional
 template <typename H, typename T>
 typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
@@ -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 = y_absl::base_internal::UnalignedLoad64(p);
-    uint64_t high_mem = y_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 = y_absl::base_internal::UnalignedLoad64(p); 
+    uint64_t high_mem = y_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 = y_absl::base_internal::UnalignedLoad32(p);
-    uint32_t high_mem = y_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 = y_absl::base_internal::UnalignedLoad32(p); 
+    uint32_t high_mem = y_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);
@@ -1060,15 +1060,15 @@ H PiecewiseCombiner::add_buffer(H state, const unsigned char* data,
     return state;
   }
 
-  // If the buffer is partially filled we need to complete the buffer
-  // and hash it.
-  if (position_ != 0) {
-    const size_t bytes_needed = PiecewiseChunkSize() - position_;
-    memcpy(buf_ + position_, data, bytes_needed);
-    state = H::combine_contiguous(std::move(state), buf_, PiecewiseChunkSize());
-    data += bytes_needed;
-    size -= bytes_needed;
-  }
+  // If the buffer is partially filled we need to complete the buffer 
+  // and hash it. 
+  if (position_ != 0) { 
+    const size_t bytes_needed = PiecewiseChunkSize() - position_; 
+    memcpy(buf_ + position_, data, bytes_needed); 
+    state = H::combine_contiguous(std::move(state), buf_, PiecewiseChunkSize()); 
+    data += bytes_needed; 
+    size -= bytes_needed; 
+  } 
 
   // Hash whatever chunks we can without copying
   while (size >= PiecewiseChunkSize()) {
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/low_level_hash.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/low_level_hash.cc
index 08b6dd85d4..d77a8efb58 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/low_level_hash.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_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 "y_absl/hash/internal/low_level_hash.h"
-
-#include "y_absl/base/internal/unaligned_access.h"
+ 
+#include "y_absl/base/internal/unaligned_access.h" 
 #include "y_absl/numeric/bits.h"
-#include "y_absl/numeric/int128.h"
-
-namespace y_absl {
-ABSL_NAMESPACE_BEGIN
-namespace hash_internal {
-
+#include "y_absl/numeric/int128.h" 
+ 
+namespace y_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.
-  y_absl::uint128 p = v0;
-  p *= v1;
-  return y_absl::Uint128Low64(p) ^ y_absl::Uint128High64(p);
+  y_absl::uint128 p = v0; 
+  p *= v1; 
+  return y_absl::Uint128Low64(p) ^ y_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 ^ y_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 = y_absl::base_internal::UnalignedLoad64(ptr);
-      uint64_t b = y_absl::base_internal::UnalignedLoad64(ptr + 8);
-      uint64_t c = y_absl::base_internal::UnalignedLoad64(ptr + 16);
-      uint64_t d = y_absl::base_internal::UnalignedLoad64(ptr + 24);
-      uint64_t e = y_absl::base_internal::UnalignedLoad64(ptr + 32);
-      uint64_t f = y_absl::base_internal::UnalignedLoad64(ptr + 40);
-      uint64_t g = y_absl::base_internal::UnalignedLoad64(ptr + 48);
-      uint64_t h = y_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 = y_absl::base_internal::UnalignedLoad64(ptr); 
+      uint64_t b = y_absl::base_internal::UnalignedLoad64(ptr + 8); 
+      uint64_t c = y_absl::base_internal::UnalignedLoad64(ptr + 16); 
+      uint64_t d = y_absl::base_internal::UnalignedLoad64(ptr + 24); 
+      uint64_t e = y_absl::base_internal::UnalignedLoad64(ptr + 32); 
+      uint64_t f = y_absl::base_internal::UnalignedLoad64(ptr + 40); 
+      uint64_t g = y_absl::base_internal::UnalignedLoad64(ptr + 48); 
+      uint64_t h = y_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 = y_absl::base_internal::UnalignedLoad64(ptr);
-    uint64_t b = y_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 = y_absl::base_internal::UnalignedLoad64(ptr); 
+    uint64_t b = y_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 = y_absl::base_internal::UnalignedLoad64(ptr);
-    b = y_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 = y_absl::base_internal::UnalignedLoad32(ptr);
-    b = y_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 = y_absl::base_internal::UnalignedLoad64(ptr); 
+    b = y_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 = y_absl::base_internal::UnalignedLoad32(ptr); 
+    b = y_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 y_absl
+} 
+ 
+}  // namespace hash_internal 
+ABSL_NAMESPACE_END 
+}  // namespace y_absl 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/low_level_hash.h b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/low_level_hash.h
index 4a71ab9418..a9cf012cc5 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/low_level_hash.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_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 "y_absl/base/config.h"
-
-namespace y_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 "y_absl/base/config.h" 
+ 
+namespace y_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 y_absl
-
+ 
+}  // namespace hash_internal 
+ABSL_NAMESPACE_END 
+}  // namespace y_absl 
+ 
 #endif  // ABSL_HASH_INTERNAL_LOW_LEVEL_HASH_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/ya.make
index 7f3aae3751..f2244ccce9 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/ya.make
@@ -1,32 +1,32 @@
-# Generated by devtools/yamaker.
-
-LIBRARY()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
-
-LICENSE(Apache-2.0)
-
-LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
-
-PEERDIR(
-    contrib/restricted/abseil-cpp-tstring/y_absl/base
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity
-    contrib/restricted/abseil-cpp-tstring/y_absl/numeric
-)
-
-ADDINCL(
-    GLOBAL contrib/restricted/abseil-cpp-tstring
-)
-
-NO_COMPILER_WARNINGS()
-
-SRCS(
+# Generated by devtools/yamaker. 
+ 
+LIBRARY() 
+ 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
+LICENSE(Apache-2.0) 
+ 
+LICENSE_TEXTS(.yandex_meta/licenses.list.txt) 
+ 
+PEERDIR( 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity 
+    contrib/restricted/abseil-cpp-tstring/y_absl/numeric 
+) 
+ 
+ADDINCL( 
+    GLOBAL contrib/restricted/abseil-cpp-tstring 
+) 
+ 
+NO_COMPILER_WARNINGS() 
+ 
+SRCS( 
     low_level_hash.cc
-)
-
-END()
+) 
+ 
+END() 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/ya.make
index 576811ee62..4502093ef7 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/ya.make
@@ -1,41 +1,41 @@
-# Generated by devtools/yamaker.
-
-LIBRARY()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
-
-LICENSE(Apache-2.0)
-
+# Generated by devtools/yamaker. 
+ 
+LIBRARY() 
+ 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
+LICENSE(Apache-2.0) 
+ 
 LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
 
-PEERDIR(
-    contrib/restricted/abseil-cpp-tstring/y_absl/base
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity
+PEERDIR( 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity 
     contrib/restricted/abseil-cpp-tstring/y_absl/city
     contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal
-    contrib/restricted/abseil-cpp-tstring/y_absl/numeric
-    contrib/restricted/abseil-cpp-tstring/y_absl/strings
+    contrib/restricted/abseil-cpp-tstring/y_absl/numeric 
+    contrib/restricted/abseil-cpp-tstring/y_absl/strings 
     contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_strings_internal
-    contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access
+    contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access 
     contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_variant_access
-    contrib/restricted/abseil-cpp-tstring/y_absl/types
+    contrib/restricted/abseil-cpp-tstring/y_absl/types 
     contrib/restricted/abseil-cpp-tstring/y_absl/types/internal
-)
-
-ADDINCL(
-    GLOBAL contrib/restricted/abseil-cpp-tstring
-)
-
-NO_COMPILER_WARNINGS()
-
-SRCS(
+) 
+ 
+ADDINCL( 
+    GLOBAL contrib/restricted/abseil-cpp-tstring 
+) 
+ 
+NO_COMPILER_WARNINGS() 
+ 
+SRCS( 
     internal/hash.cc
-)
-
-END()
+) 
+ 
+END() 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/memory/.yandex_meta/licenses.list.txt b/contrib/restricted/abseil-cpp-tstring/y_absl/memory/.yandex_meta/licenses.list.txt
index 7be6b42848..4335862815 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/memory/.yandex_meta/licenses.list.txt
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/memory/.yandex_meta/licenses.list.txt
@@ -1,16 +1,16 @@
-====================Apache-2.0====================
-// 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====================
-// Copyright 2017 The Abseil Authors.
+====================Apache-2.0==================== 
+// 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==================== 
+// Copyright 2017 The Abseil Authors. 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/memory/memory.h b/contrib/restricted/abseil-cpp-tstring/y_absl/memory/memory.h
index 134a614b33..f4f3f5a85d 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/memory/memory.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/memory/memory.h
@@ -420,8 +420,8 @@ struct pointer_traits<T*> {
 // A C++11 compatible implementation of C++17's std::allocator_traits.
 //
 #if __cplusplus >= 201703L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
-using std::allocator_traits;
-#else  // __cplusplus >= 201703L
+using std::allocator_traits; 
+#else  // __cplusplus >= 201703L 
 template <typename Alloc>
 struct allocator_traits {
   using allocator_type = Alloc;
@@ -611,7 +611,7 @@ struct allocator_traits {
     return a;
   }
 };
-#endif  // __cplusplus >= 201703L
+#endif  // __cplusplus >= 201703L 
 
 namespace memory_internal {
 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/memory/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/memory/ya.make
index 87b37c9e1c..9bef100886 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/memory/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/memory/ya.make
@@ -2,15 +2,15 @@
 
 LIBRARY()
 
-OWNER(
-    somov
-    g:cpp-contrib
-)
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
 
 LICENSE(Apache-2.0)
 
-LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
-
+LICENSE_TEXTS(.yandex_meta/licenses.list.txt) 
+ 
 PEERDIR(
     contrib/restricted/abseil-cpp-tstring/y_absl/meta
 )
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/meta/.yandex_meta/licenses.list.txt b/contrib/restricted/abseil-cpp-tstring/y_absl/meta/.yandex_meta/licenses.list.txt
index 7be6b42848..4335862815 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/meta/.yandex_meta/licenses.list.txt
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/meta/.yandex_meta/licenses.list.txt
@@ -1,16 +1,16 @@
-====================Apache-2.0====================
-// 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====================
-// Copyright 2017 The Abseil Authors.
+====================Apache-2.0==================== 
+// 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==================== 
+// Copyright 2017 The Abseil Authors. 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/meta/type_traits.h b/contrib/restricted/abseil-cpp-tstring/y_absl/meta/type_traits.h
index eb9649060b..662680ee7e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/meta/type_traits.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/meta/type_traits.h
@@ -227,7 +227,7 @@ using void_t = typename type_traits_internal::VoidTImpl<Ts...>::type;
 // This metafunction is designed to be a drop-in replacement for the C++17
 // `std::conjunction` metafunction.
 template <typename... Ts>
-struct conjunction : std::true_type {};
+struct conjunction : std::true_type {}; 
 
 template <typename T, typename... Ts>
 struct conjunction<T, Ts...>
@@ -246,7 +246,7 @@ struct conjunction<T> : T {};
 // This metafunction is designed to be a drop-in replacement for the C++17
 // `std::disjunction` metafunction.
 template <typename... Ts>
-struct disjunction : std::false_type {};
+struct disjunction : std::false_type {}; 
 
 template <typename T, typename... Ts>
 struct disjunction<T, Ts...> :
@@ -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-tstring/y_absl/meta/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/meta/ya.make
index 8e771a5b75..e3be22b279 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/meta/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/meta/ya.make
@@ -2,15 +2,15 @@
 
 LIBRARY()
 
-OWNER(
-    somov
-    g:cpp-contrib
-)
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
 
 LICENSE(Apache-2.0)
 
-LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
-
+LICENSE_TEXTS(.yandex_meta/licenses.list.txt) 
+ 
 PEERDIR(
     contrib/restricted/abseil-cpp-tstring/y_absl/base
 )
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/.yandex_meta/licenses.list.txt b/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/.yandex_meta/licenses.list.txt
index 3d70f7ab0e..c0fb99bcfc 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/.yandex_meta/licenses.list.txt
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/.yandex_meta/licenses.list.txt
@@ -1,38 +1,38 @@
-====================Apache-2.0====================
-// 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.
-
-
-====================Apache-2.0====================
-// 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====================
-// Copyright 2017 The Abseil Authors.
-
-
-====================COPYRIGHT====================
-// Copyright 2020 The Abseil Authors.
-
-
-====================COPYRIGHT====================
-// Copyright 2021 The Abseil Authors.
+====================Apache-2.0==================== 
+// 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. 
+ 
+ 
+====================Apache-2.0==================== 
+// 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==================== 
+// Copyright 2017 The Abseil Authors. 
+ 
+ 
+====================COPYRIGHT==================== 
+// Copyright 2020 The Abseil Authors. 
+ 
+ 
+====================COPYRIGHT==================== 
+// Copyright 2021 The Abseil Authors. 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/bits.h b/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/bits.h
index 92cb0c3a91..40f6e85f08 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/bits.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_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 "y_absl/base/attributes.h"
-#include "y_absl/base/config.h"
-#include "y_absl/numeric/internal/bits.h"
-
-namespace y_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 y_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 "y_absl/base/attributes.h" 
+#include "y_absl/base/config.h" 
+#include "y_absl/numeric/internal/bits.h" 
+ 
+namespace y_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 y_absl 
+ 
+#endif  // ABSL_NUMERIC_BITS_H_ 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128.cc
index 6172372d75..b1d350385e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128.cc
@@ -15,7 +15,7 @@
 #include "y_absl/numeric/int128.h"
 
 #include <stddef.h>
-
+ 
 #include <cassert>
 #include <iomanip>
 #include <ostream>  // NOLINT(readability/streams)
@@ -23,9 +23,9 @@
 #include <util/generic/string.h>
 #include <type_traits>
 
-#include "y_absl/base/optimization.h"
-#include "y_absl/numeric/bits.h"
-
+#include "y_absl/base/optimization.h" 
+#include "y_absl/numeric/bits.h" 
+ 
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
 
@@ -35,26 +35,26 @@ ABSL_DLL const uint128 kuint128max = MakeUint128(
 namespace {
 
 // Returns the 0-based position of the last set bit (i.e., most significant bit)
-// in the given uint128. The argument is not 0.
+// in the given uint128. The argument is not 0. 
 //
 // For example:
 //   Given: 5 (decimal) == 101 (binary)
 //   Returns: 2
-inline ABSL_ATTRIBUTE_ALWAYS_INLINE int Fls128(uint128 n) {
+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);
+    ABSL_INTERNAL_ASSUME(hi != 0); 
+    return 127 - countl_zero(hi); 
   }
-  const uint64_t low = Uint128Low64(n);
-  ABSL_INTERNAL_ASSUME(low != 0);
-  return 63 - countl_zero(low);
+  const uint64_t low = Uint128Low64(n); 
+  ABSL_INTERNAL_ASSUME(low != 0); 
+  return 63 - countl_zero(low); 
 }
 
 // Long division/modulo for uint128 implemented using the shift-subtract
 // division algorithm adapted from:
 // https://stackoverflow.com/questions/5386377/division-without-using
-inline void DivModImpl(uint128 dividend, uint128 divisor, uint128* quotient_ret,
-                       uint128* remainder_ret) {
+inline void DivModImpl(uint128 dividend, uint128 divisor, uint128* quotient_ret, 
+                       uint128* remainder_ret) { 
   assert(divisor != 0);
 
   if (divisor > dividend) {
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128.h b/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128.h
index b54d614ce9..d5b8ff3a66 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128.h
@@ -799,14 +799,14 @@ constexpr bool operator==(uint128 lhs, uint128 rhs) {
 constexpr bool operator!=(uint128 lhs, uint128 rhs) { return !(lhs == rhs); }
 
 constexpr bool operator<(uint128 lhs, uint128 rhs) {
-#ifdef ABSL_HAVE_INTRINSIC_INT128
-  return static_cast<unsigned __int128>(lhs) <
-         static_cast<unsigned __int128>(rhs);
-#else
+#ifdef ABSL_HAVE_INTRINSIC_INT128 
+  return static_cast<unsigned __int128>(lhs) < 
+         static_cast<unsigned __int128>(rhs); 
+#else 
   return (Uint128High64(lhs) == Uint128High64(rhs))
              ? (Uint128Low64(lhs) < Uint128Low64(rhs))
              : (Uint128High64(lhs) < Uint128High64(rhs));
-#endif
+#endif 
 }
 
 constexpr bool operator>(uint128 lhs, uint128 rhs) { return rhs < lhs; }
@@ -901,9 +901,9 @@ inline uint128& uint128::operator^=(uint128 other) {
 // Arithmetic operators.
 
 constexpr uint128 operator<<(uint128 lhs, int amount) {
-#ifdef ABSL_HAVE_INTRINSIC_INT128
-  return static_cast<unsigned __int128>(lhs) << amount;
-#else
+#ifdef ABSL_HAVE_INTRINSIC_INT128 
+  return static_cast<unsigned __int128>(lhs) << amount; 
+#else 
   // uint64_t shifts of >= 64 are undefined, so we will need some
   // special-casing.
   return amount >= 64 ? MakeUint128(Uint128Low64(lhs) << (amount - 64), 0)
@@ -911,13 +911,13 @@ constexpr uint128 operator<<(uint128 lhs, int amount) {
                        : MakeUint128((Uint128High64(lhs) << amount) |
                                          (Uint128Low64(lhs) >> (64 - amount)),
                                      Uint128Low64(lhs) << amount);
-#endif
+#endif 
 }
 
 constexpr uint128 operator>>(uint128 lhs, int amount) {
-#ifdef ABSL_HAVE_INTRINSIC_INT128
-  return static_cast<unsigned __int128>(lhs) >> amount;
-#else
+#ifdef ABSL_HAVE_INTRINSIC_INT128 
+  return static_cast<unsigned __int128>(lhs) >> amount; 
+#else 
   // uint64_t shifts of >= 64 are undefined, so we will need some
   // special-casing.
   return amount >= 64 ? MakeUint128(0, Uint128High64(lhs) >> (amount - 64))
@@ -925,7 +925,7 @@ constexpr uint128 operator>>(uint128 lhs, int amount) {
                        : MakeUint128(Uint128High64(lhs) >> amount,
                                      (Uint128Low64(lhs) >> amount) |
                                          (Uint128High64(lhs) << (64 - amount)));
-#endif
+#endif 
 }
 
 #if !defined(ABSL_HAVE_INTRINSIC_INT128)
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/internal/bits.h b/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/internal/bits.h
index 2a517399b0..da3d2a9eb6 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/internal/bits.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_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 "y_absl/base/attributes.h"
-#include "y_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 y_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 y_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 "y_absl/base/attributes.h" 
+#include "y_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 y_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 y_absl 
+ 
+#endif  // ABSL_NUMERIC_INTERNAL_BITS_H_ 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/internal/representation.h b/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/internal/representation.h
index 0761cf39bc..fdc4bf9c59 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/internal/representation.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_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 "y_absl/base/config.h"
-
-namespace y_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 y_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 "y_absl/base/config.h" 
+ 
+namespace y_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 y_absl 
+ 
+#endif  // ABSL_NUMERIC_INTERNAL_REPRESENTATION_H_ 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/ya.make
index 9f3280c39d..705b31d2e2 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/ya.make
@@ -2,15 +2,15 @@
 
 LIBRARY()
 
-OWNER(
-    somov
-    g:cpp-contrib
-)
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
 
 LICENSE(Apache-2.0)
 
-LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
-
+LICENSE_TEXTS(.yandex_meta/licenses.list.txt) 
+ 
 ADDINCL(
     GLOBAL contrib/restricted/abseil-cpp-tstring
 )
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/exponential_biased/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/exponential_biased/ya.make
index ddfe147041..234416d3c7 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/exponential_biased/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/exponential_biased/ya.make
@@ -2,13 +2,13 @@
 
 LIBRARY()
 
-WITHOUT_LICENSE_TEXTS()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
+WITHOUT_LICENSE_TEXTS() 
 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
 LICENSE(Apache-2.0)
 
 ADDINCL(
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/status/.yandex_meta/licenses.list.txt b/contrib/restricted/abseil-cpp-tstring/y_absl/status/.yandex_meta/licenses.list.txt
index 1c58023e4b..6d25aef463 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/status/.yandex_meta/licenses.list.txt
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/status/.yandex_meta/licenses.list.txt
@@ -1,20 +1,20 @@
-====================Apache-2.0====================
-// 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====================
-// Copyright 2019 The Abseil Authors.
-
-
-====================COPYRIGHT====================
-// Copyright 2020 The Abseil Authors.
+====================Apache-2.0==================== 
+// 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==================== 
+// Copyright 2019 The Abseil Authors. 
+ 
+ 
+====================COPYRIGHT==================== 
+// Copyright 2020 The Abseil Authors. 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/status/internal/status_internal.h b/contrib/restricted/abseil-cpp-tstring/y_absl/status/internal/status_internal.h
index 6754d7d518..28073afc48 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/status/internal/status_internal.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/status/internal/status_internal.h
@@ -1,69 +1,69 @@
-// Copyright 2019 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_STATUS_INTERNAL_STATUS_INTERNAL_H_
-#define ABSL_STATUS_INTERNAL_STATUS_INTERNAL_H_
-
-#include <util/generic/string.h>
-
-#include "y_absl/container/inlined_vector.h"
-#include "y_absl/strings/cord.h"
-
-#ifndef SWIG
-// Disabled for SWIG as it doesn't parse attributes correctly.
-namespace y_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 y_absl
-#endif  // !SWIG
-
-namespace y_absl {
-ABSL_NAMESPACE_BEGIN
-
-enum class StatusCode : int;
-
-namespace status_internal {
-
-// Container for status payloads.
-struct Payload {
-  TString type_url;
-  y_absl::Cord payload;
-};
-
-using Payloads = y_absl::InlinedVector<Payload, 1>;
-
-// Reference-counted representation of Status data.
-struct StatusRep {
+// Copyright 2019 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_STATUS_INTERNAL_STATUS_INTERNAL_H_ 
+#define ABSL_STATUS_INTERNAL_STATUS_INTERNAL_H_ 
+ 
+#include <util/generic/string.h> 
+ 
+#include "y_absl/container/inlined_vector.h" 
+#include "y_absl/strings/cord.h" 
+ 
+#ifndef SWIG 
+// Disabled for SWIG as it doesn't parse attributes correctly. 
+namespace y_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 y_absl 
+#endif  // !SWIG 
+ 
+namespace y_absl { 
+ABSL_NAMESPACE_BEGIN 
+ 
+enum class StatusCode : int; 
+ 
+namespace status_internal { 
+ 
+// Container for status payloads. 
+struct Payload { 
+  TString type_url; 
+  y_absl::Cord payload; 
+}; 
+ 
+using Payloads = y_absl::InlinedVector<Payload, 1>; 
+ 
+// Reference-counted representation of Status data. 
+struct StatusRep { 
   StatusRep(y_absl::StatusCode code_arg, y_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;
-  y_absl::StatusCode code;
-  TString message;
-  std::unique_ptr<status_internal::Payloads> payloads;
-};
-
-y_absl::StatusCode MapToLocalCode(int value);
-}  // namespace status_internal
-
-ABSL_NAMESPACE_END
-}  // namespace y_absl
-
-#endif  // ABSL_STATUS_INTERNAL_STATUS_INTERNAL_H_
+ 
+  std::atomic<int32_t> ref; 
+  y_absl::StatusCode code; 
+  TString message; 
+  std::unique_ptr<status_internal::Payloads> payloads; 
+}; 
+ 
+y_absl::StatusCode MapToLocalCode(int value); 
+}  // namespace status_internal 
+ 
+ABSL_NAMESPACE_END 
+}  // namespace y_absl 
+ 
+#endif  // ABSL_STATUS_INTERNAL_STATUS_INTERNAL_H_ 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/status/internal/statusor_internal.h b/contrib/restricted/abseil-cpp-tstring/y_absl/status/internal/statusor_internal.h
index c4d78e28d2..3c9f587e45 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/status/internal/statusor_internal.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/status/internal/statusor_internal.h
@@ -1,396 +1,396 @@
-// 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_STATUS_INTERNAL_STATUSOR_INTERNAL_H_
-#define ABSL_STATUS_INTERNAL_STATUSOR_INTERNAL_H_
-
-#include <type_traits>
-#include <utility>
-
-#include "y_absl/base/attributes.h"
-#include "y_absl/meta/type_traits.h"
-#include "y_absl/status/status.h"
-#include "y_absl/utility/utility.h"
-
-namespace y_absl {
-ABSL_NAMESPACE_BEGIN
-
-template <typename T>
-class ABSL_MUST_USE_RESULT StatusOr;
-
-namespace internal_statusor {
-
-// Detects whether `U` has conversion operator to `StatusOr<T>`, i.e. `operator
-// StatusOr<T>()`.
-template <typename T, typename U, typename = void>
-struct HasConversionOperatorToStatusOr : std::false_type {};
-
-template <typename T, typename U>
-void test(char (*)[sizeof(std::declval<U>().operator y_absl::StatusOr<T>())]);
-
-template <typename T, typename U>
-struct HasConversionOperatorToStatusOr<T, U, decltype(test<T, U>(0))>
-    : std::true_type {};
-
-// Detects whether `T` is constructible or convertible from `StatusOr<U>`.
-template <typename T, typename U>
-using IsConstructibleOrConvertibleFromStatusOr =
-    y_absl::disjunction<std::is_constructible<T, StatusOr<U>&>,
-                      std::is_constructible<T, const StatusOr<U>&>,
-                      std::is_constructible<T, StatusOr<U>&&>,
-                      std::is_constructible<T, const StatusOr<U>&&>,
-                      std::is_convertible<StatusOr<U>&, T>,
-                      std::is_convertible<const StatusOr<U>&, T>,
-                      std::is_convertible<StatusOr<U>&&, T>,
-                      std::is_convertible<const StatusOr<U>&&, T>>;
-
-// Detects whether `T` is constructible or convertible or assignable from
-// `StatusOr<U>`.
-template <typename T, typename U>
-using IsConstructibleOrConvertibleOrAssignableFromStatusOr =
-    y_absl::disjunction<IsConstructibleOrConvertibleFromStatusOr<T, U>,
-                      std::is_assignable<T&, StatusOr<U>&>,
-                      std::is_assignable<T&, const StatusOr<U>&>,
-                      std::is_assignable<T&, StatusOr<U>&&>,
-                      std::is_assignable<T&, const StatusOr<U>&&>>;
-
-// Detects whether direct initializing `StatusOr<T>` from `U` is ambiguous, i.e.
-// when `U` is `StatusOr<V>` and `T` is constructible or convertible from `V`.
-template <typename T, typename U>
-struct IsDirectInitializationAmbiguous
-    : public y_absl::conditional_t<
-          std::is_same<y_absl::remove_cv_t<y_absl::remove_reference_t<U>>,
-                       U>::value,
-          std::false_type,
-          IsDirectInitializationAmbiguous<
-              T, y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>> {};
-
-template <typename T, typename V>
-struct IsDirectInitializationAmbiguous<T, y_absl::StatusOr<V>>
-    : public IsConstructibleOrConvertibleFromStatusOr<T, V> {};
-
-// Checks against the constraints of the direction initialization, i.e. when
-// `StatusOr<T>::StatusOr(U&&)` should participate in overload resolution.
-template <typename T, typename U>
-using IsDirectInitializationValid = y_absl::disjunction<
-    // Short circuits if T is basically U.
-    std::is_same<T, y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>,
-    y_absl::negation<y_absl::disjunction<
-        std::is_same<y_absl::StatusOr<T>,
-                     y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>,
-        std::is_same<y_absl::Status,
-                     y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>,
-        std::is_same<y_absl::in_place_t,
-                     y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>,
-        IsDirectInitializationAmbiguous<T, U>>>>;
-
-// This trait detects whether `StatusOr<T>::operator=(U&&)` is ambiguous, which
-// is equivalent to whether all the following conditions are met:
-// 1. `U` is `StatusOr<V>`.
-// 2. `T` is constructible and assignable from `V`.
-// 3. `T` is constructible and assignable from `U` (i.e. `StatusOr<V>`).
-// For example, the following code is considered ambiguous:
-// (`T` is `bool`, `U` is `StatusOr<bool>`, `V` is `bool`)
-//   StatusOr<bool> s1 = true;  // s1.ok() && s1.ValueOrDie() == true
-//   StatusOr<bool> s2 = false;  // s2.ok() && s2.ValueOrDie() == false
-//   s1 = s2;  // ambiguous, `s1 = s2.ValueOrDie()` or `s1 = bool(s2)`?
-template <typename T, typename U>
-struct IsForwardingAssignmentAmbiguous
-    : public y_absl::conditional_t<
-          std::is_same<y_absl::remove_cv_t<y_absl::remove_reference_t<U>>,
-                       U>::value,
-          std::false_type,
-          IsForwardingAssignmentAmbiguous<
-              T, y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>> {};
-
-template <typename T, typename U>
-struct IsForwardingAssignmentAmbiguous<T, y_absl::StatusOr<U>>
-    : public IsConstructibleOrConvertibleOrAssignableFromStatusOr<T, U> {};
-
-// Checks against the constraints of the forwarding assignment, i.e. whether
-// `StatusOr<T>::operator(U&&)` should participate in overload resolution.
-template <typename T, typename U>
-using IsForwardingAssignmentValid = y_absl::disjunction<
-    // Short circuits if T is basically U.
-    std::is_same<T, y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>,
-    y_absl::negation<y_absl::disjunction<
-        std::is_same<y_absl::StatusOr<T>,
-                     y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>,
-        std::is_same<y_absl::Status,
-                     y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>,
-        std::is_same<y_absl::in_place_t,
-                     y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>,
-        IsForwardingAssignmentAmbiguous<T, U>>>>;
-
-class Helper {
- public:
-  // Move type-agnostic error handling to the .cc.
-  static void HandleInvalidStatusCtorArg(Status*);
-  ABSL_ATTRIBUTE_NORETURN static void Crash(const y_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) {
-  new (p) T(std::forward<Args>(args)...);
-}
-
-// Helper base class to hold the data and all operations.
-// We move all this to a base class to allow mixing with the appropriate
-// TraitsBase specialization.
-template <typename T>
-class StatusOrData {
-  template <typename U>
-  friend class StatusOrData;
-
- public:
-  StatusOrData() = delete;
-
-  StatusOrData(const StatusOrData& other) {
-    if (other.ok()) {
-      MakeValue(other.data_);
-      MakeStatus();
-    } else {
-      MakeStatus(other.status_);
-    }
-  }
-
-  StatusOrData(StatusOrData&& other) noexcept {
-    if (other.ok()) {
-      MakeValue(std::move(other.data_));
-      MakeStatus();
-    } else {
-      MakeStatus(std::move(other.status_));
-    }
-  }
-
-  template <typename U>
-  explicit StatusOrData(const StatusOrData<U>& other) {
-    if (other.ok()) {
-      MakeValue(other.data_);
-      MakeStatus();
-    } else {
-      MakeStatus(other.status_);
-    }
-  }
-
-  template <typename U>
-  explicit StatusOrData(StatusOrData<U>&& other) {
-    if (other.ok()) {
-      MakeValue(std::move(other.data_));
-      MakeStatus();
-    } else {
-      MakeStatus(std::move(other.status_));
-    }
-  }
-
-  template <typename... Args>
-  explicit StatusOrData(y_absl::in_place_t, Args&&... args)
-      : data_(std::forward<Args>(args)...) {
-    MakeStatus();
-  }
-
-  explicit StatusOrData(const T& value) : data_(value) {
-    MakeStatus();
-  }
-  explicit StatusOrData(T&& value) : data_(std::move(value)) {
-    MakeStatus();
-  }
-
-  template <typename U,
-            y_absl::enable_if_t<std::is_constructible<y_absl::Status, U&&>::value,
-                              int> = 0>
-  explicit StatusOrData(U&& v) : status_(std::forward<U>(v)) {
-    EnsureNotOk();
-  }
-
-  StatusOrData& operator=(const StatusOrData& other) {
-    if (this == &other) return *this;
-    if (other.ok())
-      Assign(other.data_);
-    else
-      AssignStatus(other.status_);
-    return *this;
-  }
-
-  StatusOrData& operator=(StatusOrData&& other) {
-    if (this == &other) return *this;
-    if (other.ok())
-      Assign(std::move(other.data_));
-    else
-      AssignStatus(std::move(other.status_));
-    return *this;
-  }
-
-  ~StatusOrData() {
-    if (ok()) {
-      status_.~Status();
-      data_.~T();
-    } else {
-      status_.~Status();
-    }
-  }
-
-  template <typename U>
-  void Assign(U&& value) {
-    if (ok()) {
-      data_ = std::forward<U>(value);
-    } else {
-      MakeValue(std::forward<U>(value));
-      status_ = OkStatus();
-    }
-  }
-
-  template <typename U>
-  void AssignStatus(U&& v) {
-    Clear();
-    status_ = static_cast<y_absl::Status>(std::forward<U>(v));
-    EnsureNotOk();
-  }
-
-  bool ok() const { return status_.ok(); }
-
- protected:
-  // status_ will always be active after the constructor.
-  // We make it a union to be able to initialize exactly how we need without
-  // waste.
-  // Eg. in the copy constructor we use the default constructor of Status in
-  // the ok() path to avoid an extra Ref call.
-  union {
-    Status status_;
-  };
-
-  // data_ is active iff status_.ok()==true
-  struct Dummy {};
-  union {
-    // When T is const, we need some non-const object we can cast to void* for
-    // the placement new. dummy_ is that object.
-    Dummy dummy_;
-    T data_;
-  };
-
-  void Clear() {
-    if (ok()) data_.~T();
-  }
-
-  void EnsureOk() const {
-    if (ABSL_PREDICT_FALSE(!ok())) Helper::Crash(status_);
-  }
-
-  void EnsureNotOk() {
-    if (ABSL_PREDICT_FALSE(ok())) Helper::HandleInvalidStatusCtorArg(&status_);
-  }
-
-  // Construct the value (ie. data_) through placement new with the passed
-  // argument.
-  template <typename... Arg>
-  void MakeValue(Arg&&... arg) {
-    internal_statusor::PlacementNew<T>(&dummy_, std::forward<Arg>(arg)...);
-  }
-
-  // Construct the status (ie. status_) through placement new with the passed
-  // argument.
-  template <typename... Args>
-  void MakeStatus(Args&&... args) {
-    internal_statusor::PlacementNew<Status>(&status_,
-                                            std::forward<Args>(args)...);
-  }
-};
-
-// Helper base classes to allow implicitly deleted constructors and assignment
-// operators in `StatusOr`. For example, `CopyCtorBase` will explicitly delete
-// the copy constructor when T is not copy constructible and `StatusOr` will
-// inherit that behavior implicitly.
-template <typename T, bool = std::is_copy_constructible<T>::value>
-struct CopyCtorBase {
-  CopyCtorBase() = default;
-  CopyCtorBase(const CopyCtorBase&) = default;
-  CopyCtorBase(CopyCtorBase&&) = default;
-  CopyCtorBase& operator=(const CopyCtorBase&) = default;
-  CopyCtorBase& operator=(CopyCtorBase&&) = default;
-};
-
-template <typename T>
-struct CopyCtorBase<T, false> {
-  CopyCtorBase() = default;
-  CopyCtorBase(const CopyCtorBase&) = delete;
-  CopyCtorBase(CopyCtorBase&&) = default;
-  CopyCtorBase& operator=(const CopyCtorBase&) = default;
-  CopyCtorBase& operator=(CopyCtorBase&&) = default;
-};
-
-template <typename T, bool = std::is_move_constructible<T>::value>
-struct MoveCtorBase {
-  MoveCtorBase() = default;
-  MoveCtorBase(const MoveCtorBase&) = default;
-  MoveCtorBase(MoveCtorBase&&) = default;
-  MoveCtorBase& operator=(const MoveCtorBase&) = default;
-  MoveCtorBase& operator=(MoveCtorBase&&) = default;
-};
-
-template <typename T>
-struct MoveCtorBase<T, false> {
-  MoveCtorBase() = default;
-  MoveCtorBase(const MoveCtorBase&) = default;
-  MoveCtorBase(MoveCtorBase&&) = delete;
-  MoveCtorBase& operator=(const MoveCtorBase&) = default;
-  MoveCtorBase& operator=(MoveCtorBase&&) = default;
-};
-
-template <typename T, bool = std::is_copy_constructible<T>::value&&
-                          std::is_copy_assignable<T>::value>
-struct CopyAssignBase {
-  CopyAssignBase() = default;
-  CopyAssignBase(const CopyAssignBase&) = default;
-  CopyAssignBase(CopyAssignBase&&) = default;
-  CopyAssignBase& operator=(const CopyAssignBase&) = default;
-  CopyAssignBase& operator=(CopyAssignBase&&) = default;
-};
-
-template <typename T>
-struct CopyAssignBase<T, false> {
-  CopyAssignBase() = default;
-  CopyAssignBase(const CopyAssignBase&) = default;
-  CopyAssignBase(CopyAssignBase&&) = default;
-  CopyAssignBase& operator=(const CopyAssignBase&) = delete;
-  CopyAssignBase& operator=(CopyAssignBase&&) = default;
-};
-
-template <typename T, bool = std::is_move_constructible<T>::value&&
-                          std::is_move_assignable<T>::value>
-struct MoveAssignBase {
-  MoveAssignBase() = default;
-  MoveAssignBase(const MoveAssignBase&) = default;
-  MoveAssignBase(MoveAssignBase&&) = default;
-  MoveAssignBase& operator=(const MoveAssignBase&) = default;
-  MoveAssignBase& operator=(MoveAssignBase&&) = default;
-};
-
-template <typename T>
-struct MoveAssignBase<T, false> {
-  MoveAssignBase() = default;
-  MoveAssignBase(const MoveAssignBase&) = default;
-  MoveAssignBase(MoveAssignBase&&) = default;
-  MoveAssignBase& operator=(const MoveAssignBase&) = default;
-  MoveAssignBase& operator=(MoveAssignBase&&) = delete;
-};
-
-ABSL_ATTRIBUTE_NORETURN void ThrowBadStatusOrAccess(y_absl::Status status);
-
-}  // namespace internal_statusor
-ABSL_NAMESPACE_END
-}  // namespace y_absl
-
-#endif  // ABSL_STATUS_INTERNAL_STATUSOR_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. 
+#ifndef ABSL_STATUS_INTERNAL_STATUSOR_INTERNAL_H_ 
+#define ABSL_STATUS_INTERNAL_STATUSOR_INTERNAL_H_ 
+ 
+#include <type_traits> 
+#include <utility> 
+ 
+#include "y_absl/base/attributes.h" 
+#include "y_absl/meta/type_traits.h" 
+#include "y_absl/status/status.h" 
+#include "y_absl/utility/utility.h" 
+ 
+namespace y_absl { 
+ABSL_NAMESPACE_BEGIN 
+ 
+template <typename T> 
+class ABSL_MUST_USE_RESULT StatusOr; 
+ 
+namespace internal_statusor { 
+ 
+// Detects whether `U` has conversion operator to `StatusOr<T>`, i.e. `operator 
+// StatusOr<T>()`. 
+template <typename T, typename U, typename = void> 
+struct HasConversionOperatorToStatusOr : std::false_type {}; 
+ 
+template <typename T, typename U> 
+void test(char (*)[sizeof(std::declval<U>().operator y_absl::StatusOr<T>())]); 
+ 
+template <typename T, typename U> 
+struct HasConversionOperatorToStatusOr<T, U, decltype(test<T, U>(0))> 
+    : std::true_type {}; 
+ 
+// Detects whether `T` is constructible or convertible from `StatusOr<U>`. 
+template <typename T, typename U> 
+using IsConstructibleOrConvertibleFromStatusOr = 
+    y_absl::disjunction<std::is_constructible<T, StatusOr<U>&>, 
+                      std::is_constructible<T, const StatusOr<U>&>, 
+                      std::is_constructible<T, StatusOr<U>&&>, 
+                      std::is_constructible<T, const StatusOr<U>&&>, 
+                      std::is_convertible<StatusOr<U>&, T>, 
+                      std::is_convertible<const StatusOr<U>&, T>, 
+                      std::is_convertible<StatusOr<U>&&, T>, 
+                      std::is_convertible<const StatusOr<U>&&, T>>; 
+ 
+// Detects whether `T` is constructible or convertible or assignable from 
+// `StatusOr<U>`. 
+template <typename T, typename U> 
+using IsConstructibleOrConvertibleOrAssignableFromStatusOr = 
+    y_absl::disjunction<IsConstructibleOrConvertibleFromStatusOr<T, U>, 
+                      std::is_assignable<T&, StatusOr<U>&>, 
+                      std::is_assignable<T&, const StatusOr<U>&>, 
+                      std::is_assignable<T&, StatusOr<U>&&>, 
+                      std::is_assignable<T&, const StatusOr<U>&&>>; 
+ 
+// Detects whether direct initializing `StatusOr<T>` from `U` is ambiguous, i.e. 
+// when `U` is `StatusOr<V>` and `T` is constructible or convertible from `V`. 
+template <typename T, typename U> 
+struct IsDirectInitializationAmbiguous 
+    : public y_absl::conditional_t< 
+          std::is_same<y_absl::remove_cv_t<y_absl::remove_reference_t<U>>, 
+                       U>::value, 
+          std::false_type, 
+          IsDirectInitializationAmbiguous< 
+              T, y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>> {}; 
+ 
+template <typename T, typename V> 
+struct IsDirectInitializationAmbiguous<T, y_absl::StatusOr<V>> 
+    : public IsConstructibleOrConvertibleFromStatusOr<T, V> {}; 
+ 
+// Checks against the constraints of the direction initialization, i.e. when 
+// `StatusOr<T>::StatusOr(U&&)` should participate in overload resolution. 
+template <typename T, typename U> 
+using IsDirectInitializationValid = y_absl::disjunction< 
+    // Short circuits if T is basically U. 
+    std::is_same<T, y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>, 
+    y_absl::negation<y_absl::disjunction< 
+        std::is_same<y_absl::StatusOr<T>, 
+                     y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>, 
+        std::is_same<y_absl::Status, 
+                     y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>, 
+        std::is_same<y_absl::in_place_t, 
+                     y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>, 
+        IsDirectInitializationAmbiguous<T, U>>>>; 
+ 
+// This trait detects whether `StatusOr<T>::operator=(U&&)` is ambiguous, which 
+// is equivalent to whether all the following conditions are met: 
+// 1. `U` is `StatusOr<V>`. 
+// 2. `T` is constructible and assignable from `V`. 
+// 3. `T` is constructible and assignable from `U` (i.e. `StatusOr<V>`). 
+// For example, the following code is considered ambiguous: 
+// (`T` is `bool`, `U` is `StatusOr<bool>`, `V` is `bool`) 
+//   StatusOr<bool> s1 = true;  // s1.ok() && s1.ValueOrDie() == true 
+//   StatusOr<bool> s2 = false;  // s2.ok() && s2.ValueOrDie() == false 
+//   s1 = s2;  // ambiguous, `s1 = s2.ValueOrDie()` or `s1 = bool(s2)`? 
+template <typename T, typename U> 
+struct IsForwardingAssignmentAmbiguous 
+    : public y_absl::conditional_t< 
+          std::is_same<y_absl::remove_cv_t<y_absl::remove_reference_t<U>>, 
+                       U>::value, 
+          std::false_type, 
+          IsForwardingAssignmentAmbiguous< 
+              T, y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>> {}; 
+ 
+template <typename T, typename U> 
+struct IsForwardingAssignmentAmbiguous<T, y_absl::StatusOr<U>> 
+    : public IsConstructibleOrConvertibleOrAssignableFromStatusOr<T, U> {}; 
+ 
+// Checks against the constraints of the forwarding assignment, i.e. whether 
+// `StatusOr<T>::operator(U&&)` should participate in overload resolution. 
+template <typename T, typename U> 
+using IsForwardingAssignmentValid = y_absl::disjunction< 
+    // Short circuits if T is basically U. 
+    std::is_same<T, y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>, 
+    y_absl::negation<y_absl::disjunction< 
+        std::is_same<y_absl::StatusOr<T>, 
+                     y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>, 
+        std::is_same<y_absl::Status, 
+                     y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>, 
+        std::is_same<y_absl::in_place_t, 
+                     y_absl::remove_cv_t<y_absl::remove_reference_t<U>>>, 
+        IsForwardingAssignmentAmbiguous<T, U>>>>; 
+ 
+class Helper { 
+ public: 
+  // Move type-agnostic error handling to the .cc. 
+  static void HandleInvalidStatusCtorArg(Status*); 
+  ABSL_ATTRIBUTE_NORETURN static void Crash(const y_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) { 
+  new (p) T(std::forward<Args>(args)...); 
+} 
+ 
+// Helper base class to hold the data and all operations. 
+// We move all this to a base class to allow mixing with the appropriate 
+// TraitsBase specialization. 
+template <typename T> 
+class StatusOrData { 
+  template <typename U> 
+  friend class StatusOrData; 
+ 
+ public: 
+  StatusOrData() = delete; 
+ 
+  StatusOrData(const StatusOrData& other) { 
+    if (other.ok()) { 
+      MakeValue(other.data_); 
+      MakeStatus(); 
+    } else { 
+      MakeStatus(other.status_); 
+    } 
+  } 
+ 
+  StatusOrData(StatusOrData&& other) noexcept { 
+    if (other.ok()) { 
+      MakeValue(std::move(other.data_)); 
+      MakeStatus(); 
+    } else { 
+      MakeStatus(std::move(other.status_)); 
+    } 
+  } 
+ 
+  template <typename U> 
+  explicit StatusOrData(const StatusOrData<U>& other) { 
+    if (other.ok()) { 
+      MakeValue(other.data_); 
+      MakeStatus(); 
+    } else { 
+      MakeStatus(other.status_); 
+    } 
+  } 
+ 
+  template <typename U> 
+  explicit StatusOrData(StatusOrData<U>&& other) { 
+    if (other.ok()) { 
+      MakeValue(std::move(other.data_)); 
+      MakeStatus(); 
+    } else { 
+      MakeStatus(std::move(other.status_)); 
+    } 
+  } 
+ 
+  template <typename... Args> 
+  explicit StatusOrData(y_absl::in_place_t, Args&&... args) 
+      : data_(std::forward<Args>(args)...) { 
+    MakeStatus(); 
+  } 
+ 
+  explicit StatusOrData(const T& value) : data_(value) { 
+    MakeStatus(); 
+  } 
+  explicit StatusOrData(T&& value) : data_(std::move(value)) { 
+    MakeStatus(); 
+  } 
+ 
+  template <typename U, 
+            y_absl::enable_if_t<std::is_constructible<y_absl::Status, U&&>::value, 
+                              int> = 0> 
+  explicit StatusOrData(U&& v) : status_(std::forward<U>(v)) { 
+    EnsureNotOk(); 
+  } 
+ 
+  StatusOrData& operator=(const StatusOrData& other) { 
+    if (this == &other) return *this; 
+    if (other.ok()) 
+      Assign(other.data_); 
+    else 
+      AssignStatus(other.status_); 
+    return *this; 
+  } 
+ 
+  StatusOrData& operator=(StatusOrData&& other) { 
+    if (this == &other) return *this; 
+    if (other.ok()) 
+      Assign(std::move(other.data_)); 
+    else 
+      AssignStatus(std::move(other.status_)); 
+    return *this; 
+  } 
+ 
+  ~StatusOrData() { 
+    if (ok()) { 
+      status_.~Status(); 
+      data_.~T(); 
+    } else { 
+      status_.~Status(); 
+    } 
+  } 
+ 
+  template <typename U> 
+  void Assign(U&& value) { 
+    if (ok()) { 
+      data_ = std::forward<U>(value); 
+    } else { 
+      MakeValue(std::forward<U>(value)); 
+      status_ = OkStatus(); 
+    } 
+  } 
+ 
+  template <typename U> 
+  void AssignStatus(U&& v) { 
+    Clear(); 
+    status_ = static_cast<y_absl::Status>(std::forward<U>(v)); 
+    EnsureNotOk(); 
+  } 
+ 
+  bool ok() const { return status_.ok(); } 
+ 
+ protected: 
+  // status_ will always be active after the constructor. 
+  // We make it a union to be able to initialize exactly how we need without 
+  // waste. 
+  // Eg. in the copy constructor we use the default constructor of Status in 
+  // the ok() path to avoid an extra Ref call. 
+  union { 
+    Status status_; 
+  }; 
+ 
+  // data_ is active iff status_.ok()==true 
+  struct Dummy {}; 
+  union { 
+    // When T is const, we need some non-const object we can cast to void* for 
+    // the placement new. dummy_ is that object. 
+    Dummy dummy_; 
+    T data_; 
+  }; 
+ 
+  void Clear() { 
+    if (ok()) data_.~T(); 
+  } 
+ 
+  void EnsureOk() const { 
+    if (ABSL_PREDICT_FALSE(!ok())) Helper::Crash(status_); 
+  } 
+ 
+  void EnsureNotOk() { 
+    if (ABSL_PREDICT_FALSE(ok())) Helper::HandleInvalidStatusCtorArg(&status_); 
+  } 
+ 
+  // Construct the value (ie. data_) through placement new with the passed 
+  // argument. 
+  template <typename... Arg> 
+  void MakeValue(Arg&&... arg) { 
+    internal_statusor::PlacementNew<T>(&dummy_, std::forward<Arg>(arg)...); 
+  } 
+ 
+  // Construct the status (ie. status_) through placement new with the passed 
+  // argument. 
+  template <typename... Args> 
+  void MakeStatus(Args&&... args) { 
+    internal_statusor::PlacementNew<Status>(&status_, 
+                                            std::forward<Args>(args)...); 
+  } 
+}; 
+ 
+// Helper base classes to allow implicitly deleted constructors and assignment 
+// operators in `StatusOr`. For example, `CopyCtorBase` will explicitly delete 
+// the copy constructor when T is not copy constructible and `StatusOr` will 
+// inherit that behavior implicitly. 
+template <typename T, bool = std::is_copy_constructible<T>::value> 
+struct CopyCtorBase { 
+  CopyCtorBase() = default; 
+  CopyCtorBase(const CopyCtorBase&) = default; 
+  CopyCtorBase(CopyCtorBase&&) = default; 
+  CopyCtorBase& operator=(const CopyCtorBase&) = default; 
+  CopyCtorBase& operator=(CopyCtorBase&&) = default; 
+}; 
+ 
+template <typename T> 
+struct CopyCtorBase<T, false> { 
+  CopyCtorBase() = default; 
+  CopyCtorBase(const CopyCtorBase&) = delete; 
+  CopyCtorBase(CopyCtorBase&&) = default; 
+  CopyCtorBase& operator=(const CopyCtorBase&) = default; 
+  CopyCtorBase& operator=(CopyCtorBase&&) = default; 
+}; 
+ 
+template <typename T, bool = std::is_move_constructible<T>::value> 
+struct MoveCtorBase { 
+  MoveCtorBase() = default; 
+  MoveCtorBase(const MoveCtorBase&) = default; 
+  MoveCtorBase(MoveCtorBase&&) = default; 
+  MoveCtorBase& operator=(const MoveCtorBase&) = default; 
+  MoveCtorBase& operator=(MoveCtorBase&&) = default; 
+}; 
+ 
+template <typename T> 
+struct MoveCtorBase<T, false> { 
+  MoveCtorBase() = default; 
+  MoveCtorBase(const MoveCtorBase&) = default; 
+  MoveCtorBase(MoveCtorBase&&) = delete; 
+  MoveCtorBase& operator=(const MoveCtorBase&) = default; 
+  MoveCtorBase& operator=(MoveCtorBase&&) = default; 
+}; 
+ 
+template <typename T, bool = std::is_copy_constructible<T>::value&& 
+                          std::is_copy_assignable<T>::value> 
+struct CopyAssignBase { 
+  CopyAssignBase() = default; 
+  CopyAssignBase(const CopyAssignBase&) = default; 
+  CopyAssignBase(CopyAssignBase&&) = default; 
+  CopyAssignBase& operator=(const CopyAssignBase&) = default; 
+  CopyAssignBase& operator=(CopyAssignBase&&) = default; 
+}; 
+ 
+template <typename T> 
+struct CopyAssignBase<T, false> { 
+  CopyAssignBase() = default; 
+  CopyAssignBase(const CopyAssignBase&) = default; 
+  CopyAssignBase(CopyAssignBase&&) = default; 
+  CopyAssignBase& operator=(const CopyAssignBase&) = delete; 
+  CopyAssignBase& operator=(CopyAssignBase&&) = default; 
+}; 
+ 
+template <typename T, bool = std::is_move_constructible<T>::value&& 
+                          std::is_move_assignable<T>::value> 
+struct MoveAssignBase { 
+  MoveAssignBase() = default; 
+  MoveAssignBase(const MoveAssignBase&) = default; 
+  MoveAssignBase(MoveAssignBase&&) = default; 
+  MoveAssignBase& operator=(const MoveAssignBase&) = default; 
+  MoveAssignBase& operator=(MoveAssignBase&&) = default; 
+}; 
+ 
+template <typename T> 
+struct MoveAssignBase<T, false> { 
+  MoveAssignBase() = default; 
+  MoveAssignBase(const MoveAssignBase&) = default; 
+  MoveAssignBase(MoveAssignBase&&) = default; 
+  MoveAssignBase& operator=(const MoveAssignBase&) = default; 
+  MoveAssignBase& operator=(MoveAssignBase&&) = delete; 
+}; 
+ 
+ABSL_ATTRIBUTE_NORETURN void ThrowBadStatusOrAccess(y_absl::Status status); 
+ 
+}  // namespace internal_statusor 
+ABSL_NAMESPACE_END 
+}  // namespace y_absl 
+ 
+#endif  // ABSL_STATUS_INTERNAL_STATUSOR_INTERNAL_H_ 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/status/status.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/status/status.cc
index 3b7fe28e08..f4747914bf 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/status/status.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/status/status.cc
@@ -78,7 +78,7 @@ static int FindPayloadIndexByUrl(const Payloads* payloads,
                                  y_absl::string_view type_url) {
   if (payloads == nullptr) return -1;
 
-  for (size_t i = 0; i < payloads->size(); ++i) {
+  for (size_t i = 0; i < payloads->size(); ++i) { 
     if ((*payloads)[i].type_url == type_url) return i;
   }
 
@@ -167,15 +167,15 @@ void Status::ForEachPayload(
     bool in_reverse =
         payloads->size() > 1 && reinterpret_cast<uintptr_t>(payloads) % 13 > 6;
 
-    for (size_t index = 0; index < payloads->size(); ++index) {
+    for (size_t index = 0; index < payloads->size(); ++index) { 
       const auto& elem =
           (*payloads)[in_reverse ? payloads->size() - 1 - index : index];
 
 #ifdef NDEBUG
       visitor(elem.type_url, elem.payload);
 #else
-      // In debug mode invalidate the type url to prevent users from relying on
-      // this string lifetime.
+      // In debug mode invalidate the type url to prevent users from relying on 
+      // this string lifetime. 
 
       // NOLINTNEXTLINE intentional extra conversion to force temporary.
       visitor(TString(elem.type_url), elem.payload);
@@ -283,27 +283,27 @@ bool Status::EqualsSlow(const y_absl::Status& a, const y_absl::Status& b) {
   return true;
 }
 
-TString Status::ToStringSlow(StatusToStringMode mode) const {
+TString Status::ToStringSlow(StatusToStringMode mode) const { 
   TString text;
   y_absl::StrAppend(&text, y_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([&](y_absl::string_view type_url,
-                             const y_absl::Cord& payload) {
-      y_absl::optional<TString> result;
-      if (printer) result = printer(type_url, payload);
-      y_absl::StrAppend(
-          &text, " [", type_url, "='",
-          result.has_value() ? *result : y_absl::CHexEscape(TString(payload)),
-          "']");
-    });
-  }
-
+  const bool with_payload = (mode & StatusToStringMode::kWithPayload) == 
+                      StatusToStringMode::kWithPayload; 
+ 
+  if (with_payload) { 
+    status_internal::StatusPayloadPrinter printer = 
+        status_internal::GetStatusPayloadPrinter(); 
+    this->ForEachPayload([&](y_absl::string_view type_url, 
+                             const y_absl::Cord& payload) { 
+      y_absl::optional<TString> result; 
+      if (printer) result = printer(type_url, payload); 
+      y_absl::StrAppend( 
+          &text, " [", type_url, "='", 
+          result.has_value() ? *result : y_absl::CHexEscape(TString(payload)), 
+          "']"); 
+    }); 
+  } 
+ 
   return text;
 }
 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/status/status.h b/contrib/restricted/abseil-cpp-tstring/y_absl/status/status.h
index fa461e9f76..0ea97ef92c 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/status/status.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/status/status.h
@@ -11,43 +11,43 @@
 // 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: status.h
-// -----------------------------------------------------------------------------
-//
-// This header file defines the Abseil `status` library, consisting of:
-//
-//   * An `y_absl::Status` class for holding error handling information
-//   * A set of canonical `y_absl::StatusCode` error codes, and associated
-//     utilities for generating and propagating status codes.
-//   * A set of helper functions for creating status codes and checking their
-//     values
-//
-// Within Google, `y_absl::Status` is the primary mechanism for gracefully
-// handling errors across API boundaries (and in particular across RPC
-// boundaries). Some of these errors may be recoverable, but others may not.
-// Most functions that can produce a recoverable error should be designed to
-// return an `y_absl::Status` (or `y_absl::StatusOr`).
-//
-// Example:
-//
-// y_absl::Status myFunction(y_absl::string_view fname, ...) {
-//   ...
-//   // encounter error
-//   if (error condition) {
-//     return y_absl::InvalidArgumentError("bad mode");
-//   }
-//   // else, return OK
-//   return y_absl::OkStatus();
-// }
-//
-// An `y_absl::Status` is designed to either return "OK" or one of a number of
-// different error codes, corresponding to typical error conditions.
-// In almost all cases, when using `y_absl::Status` you should use the canonical
-// error codes (of type `y_absl::StatusCode`) enumerated in this header file.
-// These canonical codes are understood across the codebase and will be
-// accepted across all API and RPC boundaries.
+// 
+// ----------------------------------------------------------------------------- 
+// File: status.h 
+// ----------------------------------------------------------------------------- 
+// 
+// This header file defines the Abseil `status` library, consisting of: 
+// 
+//   * An `y_absl::Status` class for holding error handling information 
+//   * A set of canonical `y_absl::StatusCode` error codes, and associated 
+//     utilities for generating and propagating status codes. 
+//   * A set of helper functions for creating status codes and checking their 
+//     values 
+// 
+// Within Google, `y_absl::Status` is the primary mechanism for gracefully 
+// handling errors across API boundaries (and in particular across RPC 
+// boundaries). Some of these errors may be recoverable, but others may not. 
+// Most functions that can produce a recoverable error should be designed to 
+// return an `y_absl::Status` (or `y_absl::StatusOr`). 
+// 
+// Example: 
+// 
+// y_absl::Status myFunction(y_absl::string_view fname, ...) { 
+//   ... 
+//   // encounter error 
+//   if (error condition) { 
+//     return y_absl::InvalidArgumentError("bad mode"); 
+//   } 
+//   // else, return OK 
+//   return y_absl::OkStatus(); 
+// } 
+// 
+// An `y_absl::Status` is designed to either return "OK" or one of a number of 
+// different error codes, corresponding to typical error conditions. 
+// In almost all cases, when using `y_absl::Status` you should use the canonical 
+// error codes (of type `y_absl::StatusCode`) enumerated in this header file. 
+// These canonical codes are understood across the codebase and will be 
+// accepted across all API and RPC boundaries. 
 #ifndef ABSL_STATUS_STATUS_H_
 #define ABSL_STATUS_STATUS_H_
 
@@ -56,539 +56,539 @@
 
 #include "y_absl/container/inlined_vector.h"
 #include "y_absl/functional/function_ref.h"
-#include "y_absl/status/internal/status_internal.h"
+#include "y_absl/status/internal/status_internal.h" 
 #include "y_absl/strings/cord.h"
-#include "y_absl/strings/string_view.h"
+#include "y_absl/strings/string_view.h" 
 #include "y_absl/types/optional.h"
 
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
 
-// y_absl::StatusCode
-//
-// An `y_absl::StatusCode` is an enumerated type indicating either no error ("OK")
-// or an error condition. In most cases, an `y_absl::Status` indicates a
-// recoverable error, and the purpose of signalling an error is to indicate what
-// action to take in response to that error. These error codes map to the proto
-// RPC error codes indicated in https://cloud.google.com/apis/design/errors.
-//
-// The errors listed below are the canonical errors associated with
-// `y_absl::Status` and are used throughout the codebase. As a result, these
-// error codes are somewhat generic.
-//
-// In general, try to return the most specific error that applies if more than
-// one error may pertain. For example, prefer `kOutOfRange` over
-// `kFailedPrecondition` if both codes apply. Similarly prefer `kNotFound` or
-// `kAlreadyExists` over `kFailedPrecondition`.
-//
+// y_absl::StatusCode 
+// 
+// An `y_absl::StatusCode` is an enumerated type indicating either no error ("OK") 
+// or an error condition. In most cases, an `y_absl::Status` indicates a 
+// recoverable error, and the purpose of signalling an error is to indicate what 
+// action to take in response to that error. These error codes map to the proto 
+// RPC error codes indicated in https://cloud.google.com/apis/design/errors. 
+// 
+// The errors listed below are the canonical errors associated with 
+// `y_absl::Status` and are used throughout the codebase. As a result, these 
+// error codes are somewhat generic. 
+// 
+// In general, try to return the most specific error that applies if more than 
+// one error may pertain. For example, prefer `kOutOfRange` over 
+// `kFailedPrecondition` if both codes apply. Similarly prefer `kNotFound` or 
+// `kAlreadyExists` over `kFailedPrecondition`. 
+// 
 // Because these errors may cross RPC boundaries, these codes are tied to the
-// `google.rpc.Code` definitions within
-// https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto
-// The string value of these RPC codes is denoted within each enum below.
-//
-// If your error handling code requires more context, you can attach payloads
-// to your status. See `y_absl::Status::SetPayload()` and
-// `y_absl::Status::GetPayload()` below.
+// `google.rpc.Code` definitions within 
+// https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto 
+// The string value of these RPC codes is denoted within each enum below. 
+// 
+// If your error handling code requires more context, you can attach payloads 
+// to your status. See `y_absl::Status::SetPayload()` and 
+// `y_absl::Status::GetPayload()` below. 
 enum class StatusCode : int {
-  // StatusCode::kOk
-  //
-  // kOK (gRPC code "OK") does not indicate an error; this value is returned on
-  // success. It is typical to check for this value before proceeding on any
-  // given call across an API or RPC boundary. To check this value, use the
-  // `y_absl::Status::ok()` member function rather than inspecting the raw code.
+  // StatusCode::kOk 
+  // 
+  // kOK (gRPC code "OK") does not indicate an error; this value is returned on 
+  // success. It is typical to check for this value before proceeding on any 
+  // given call across an API or RPC boundary. To check this value, use the 
+  // `y_absl::Status::ok()` member function rather than inspecting the raw code. 
   kOk = 0,
-
-  // StatusCode::kCancelled
-  //
-  // kCancelled (gRPC code "CANCELLED") indicates the operation was cancelled,
-  // typically by the caller.
+ 
+  // StatusCode::kCancelled 
+  // 
+  // kCancelled (gRPC code "CANCELLED") indicates the operation was cancelled, 
+  // typically by the caller. 
   kCancelled = 1,
-
-  // StatusCode::kUnknown
-  //
-  // kUnknown (gRPC code "UNKNOWN") indicates an unknown error occurred. In
-  // general, more specific errors should be raised, if possible. Errors raised
-  // by APIs that do not return enough error information may be converted to
-  // this error.
+ 
+  // StatusCode::kUnknown 
+  // 
+  // kUnknown (gRPC code "UNKNOWN") indicates an unknown error occurred. In 
+  // general, more specific errors should be raised, if possible. Errors raised 
+  // by APIs that do not return enough error information may be converted to 
+  // this error. 
   kUnknown = 2,
-
-  // StatusCode::kInvalidArgument
-  //
-  // kInvalidArgument (gRPC code "INVALID_ARGUMENT") indicates the caller
+ 
+  // StatusCode::kInvalidArgument 
+  // 
+  // kInvalidArgument (gRPC code "INVALID_ARGUMENT") indicates the caller 
   // specified an invalid argument, such as a malformed filename. Note that use
   // of such errors should be narrowly limited to indicate the invalid nature of
   // the arguments themselves. Errors with validly formed arguments that may
   // cause errors with the state of the receiving system should be denoted with
-  // `kFailedPrecondition` instead.
+  // `kFailedPrecondition` instead. 
   kInvalidArgument = 3,
-
-  // StatusCode::kDeadlineExceeded
-  //
-  // kDeadlineExceeded (gRPC code "DEADLINE_EXCEEDED") indicates a deadline
-  // expired before the operation could complete. For operations that may change
-  // state within a system, this error may be returned even if the operation has
-  // completed successfully. For example, a successful response from a server
-  // could have been delayed long enough for the deadline to expire.
+ 
+  // StatusCode::kDeadlineExceeded 
+  // 
+  // kDeadlineExceeded (gRPC code "DEADLINE_EXCEEDED") indicates a deadline 
+  // expired before the operation could complete. For operations that may change 
+  // state within a system, this error may be returned even if the operation has 
+  // completed successfully. For example, a successful response from a server 
+  // could have been delayed long enough for the deadline to expire. 
   kDeadlineExceeded = 4,
-
-  // StatusCode::kNotFound
-  //
-  // kNotFound (gRPC code "NOT_FOUND") indicates some requested entity (such as
-  // a file or directory) was not found.
-  //
-  // `kNotFound` is useful if a request should be denied for an entire class of
-  // users, such as during a gradual feature rollout or undocumented allow list.
+ 
+  // StatusCode::kNotFound 
+  // 
+  // kNotFound (gRPC code "NOT_FOUND") indicates some requested entity (such as 
+  // a file or directory) was not found. 
+  // 
+  // `kNotFound` is useful if a request should be denied for an entire class of 
+  // users, such as during a gradual feature rollout or undocumented allow list. 
   // If a request should be denied for specific sets of users, such as through
   // user-based access control, use `kPermissionDenied` instead.
   kNotFound = 5,
-
-  // StatusCode::kAlreadyExists
-  //
+ 
+  // StatusCode::kAlreadyExists 
+  // 
   // kAlreadyExists (gRPC code "ALREADY_EXISTS") indicates that the entity a
   // caller attempted to create (such as a file or directory) is already
   // present.
   kAlreadyExists = 6,
-
-  // StatusCode::kPermissionDenied
-  //
-  // kPermissionDenied (gRPC code "PERMISSION_DENIED") indicates that the caller
-  // does not have permission to execute the specified operation. Note that this
-  // error is different than an error due to an *un*authenticated user. This
-  // error code does not imply the request is valid or the requested entity
-  // exists or satisfies any other pre-conditions.
-  //
-  // `kPermissionDenied` must not be used for rejections caused by exhausting
-  // some resource. Instead, use `kResourceExhausted` for those errors.
-  // `kPermissionDenied` must not be used if the caller cannot be identified.
-  // Instead, use `kUnauthenticated` for those errors.
+ 
+  // StatusCode::kPermissionDenied 
+  // 
+  // kPermissionDenied (gRPC code "PERMISSION_DENIED") indicates that the caller 
+  // does not have permission to execute the specified operation. Note that this 
+  // error is different than an error due to an *un*authenticated user. This 
+  // error code does not imply the request is valid or the requested entity 
+  // exists or satisfies any other pre-conditions. 
+  // 
+  // `kPermissionDenied` must not be used for rejections caused by exhausting 
+  // some resource. Instead, use `kResourceExhausted` for those errors. 
+  // `kPermissionDenied` must not be used if the caller cannot be identified. 
+  // Instead, use `kUnauthenticated` for those errors. 
   kPermissionDenied = 7,
-
-  // StatusCode::kResourceExhausted
-  //
-  // kResourceExhausted (gRPC code "RESOURCE_EXHAUSTED") indicates some resource
-  // has been exhausted, perhaps a per-user quota, or perhaps the entire file
-  // system is out of space.
+ 
+  // StatusCode::kResourceExhausted 
+  // 
+  // kResourceExhausted (gRPC code "RESOURCE_EXHAUSTED") indicates some resource 
+  // has been exhausted, perhaps a per-user quota, or perhaps the entire file 
+  // system is out of space. 
   kResourceExhausted = 8,
-
-  // StatusCode::kFailedPrecondition
-  //
-  // kFailedPrecondition (gRPC code "FAILED_PRECONDITION") indicates that the
-  // operation was rejected because the system is not in a state required for
-  // the operation's execution. For example, a directory to be deleted may be
-  // non-empty, an "rmdir" operation is applied to a non-directory, etc.
-  //
-  // Some guidelines that may help a service implementer in deciding between
-  // `kFailedPrecondition`, `kAborted`, and `kUnavailable`:
-  //
-  //  (a) Use `kUnavailable` if the client can retry just the failing call.
-  //  (b) Use `kAborted` if the client should retry at a higher transaction
-  //      level (such as when a client-specified test-and-set fails, indicating
-  //      the client should restart a read-modify-write sequence).
-  //  (c) Use `kFailedPrecondition` if the client should not retry until
+ 
+  // StatusCode::kFailedPrecondition 
+  // 
+  // kFailedPrecondition (gRPC code "FAILED_PRECONDITION") indicates that the 
+  // operation was rejected because the system is not in a state required for 
+  // the operation's execution. For example, a directory to be deleted may be 
+  // non-empty, an "rmdir" operation is applied to a non-directory, etc. 
+  // 
+  // Some guidelines that may help a service implementer in deciding between 
+  // `kFailedPrecondition`, `kAborted`, and `kUnavailable`: 
+  // 
+  //  (a) Use `kUnavailable` if the client can retry just the failing call. 
+  //  (b) Use `kAborted` if the client should retry at a higher transaction 
+  //      level (such as when a client-specified test-and-set fails, indicating 
+  //      the client should restart a read-modify-write sequence). 
+  //  (c) Use `kFailedPrecondition` if the client should not retry until 
   //      the system state has been explicitly fixed. For example, if a "rmdir"
-  //      fails because the directory is non-empty, `kFailedPrecondition`
-  //      should be returned since the client should not retry unless
-  //      the files are deleted from the directory.
+  //      fails because the directory is non-empty, `kFailedPrecondition` 
+  //      should be returned since the client should not retry unless 
+  //      the files are deleted from the directory. 
   kFailedPrecondition = 9,
-
-  // StatusCode::kAborted
-  //
-  // kAborted (gRPC code "ABORTED") indicates the operation was aborted,
-  // typically due to a concurrency issue such as a sequencer check failure or a
-  // failed transaction.
-  //
-  // See the guidelines above for deciding between `kFailedPrecondition`,
-  // `kAborted`, and `kUnavailable`.
+ 
+  // StatusCode::kAborted 
+  // 
+  // kAborted (gRPC code "ABORTED") indicates the operation was aborted, 
+  // typically due to a concurrency issue such as a sequencer check failure or a 
+  // failed transaction. 
+  // 
+  // See the guidelines above for deciding between `kFailedPrecondition`, 
+  // `kAborted`, and `kUnavailable`. 
   kAborted = 10,
-
-  // StatusCode::kOutOfRange
-  //
-  // kOutOfRange (gRPC code "OUT_OF_RANGE") indicates the operation was
-  // attempted past the valid range, such as seeking or reading past an
-  // end-of-file.
-  //
-  // Unlike `kInvalidArgument`, this error indicates a problem that may
-  // be fixed if the system state changes. For example, a 32-bit file
-  // system will generate `kInvalidArgument` if asked to read at an
-  // offset that is not in the range [0,2^32-1], but it will generate
-  // `kOutOfRange` if asked to read from an offset past the current
-  // file size.
-  //
-  // There is a fair bit of overlap between `kFailedPrecondition` and
-  // `kOutOfRange`.  We recommend using `kOutOfRange` (the more specific
-  // error) when it applies so that callers who are iterating through
-  // a space can easily look for an `kOutOfRange` error to detect when
-  // they are done.
+ 
+  // StatusCode::kOutOfRange 
+  // 
+  // kOutOfRange (gRPC code "OUT_OF_RANGE") indicates the operation was 
+  // attempted past the valid range, such as seeking or reading past an 
+  // end-of-file. 
+  // 
+  // Unlike `kInvalidArgument`, this error indicates a problem that may 
+  // be fixed if the system state changes. For example, a 32-bit file 
+  // system will generate `kInvalidArgument` if asked to read at an 
+  // offset that is not in the range [0,2^32-1], but it will generate 
+  // `kOutOfRange` if asked to read from an offset past the current 
+  // file size. 
+  // 
+  // There is a fair bit of overlap between `kFailedPrecondition` and 
+  // `kOutOfRange`.  We recommend using `kOutOfRange` (the more specific 
+  // error) when it applies so that callers who are iterating through 
+  // a space can easily look for an `kOutOfRange` error to detect when 
+  // they are done. 
   kOutOfRange = 11,
-
-  // StatusCode::kUnimplemented
-  //
-  // kUnimplemented (gRPC code "UNIMPLEMENTED") indicates the operation is not
-  // implemented or supported in this service. In this case, the operation
-  // should not be re-attempted.
+ 
+  // StatusCode::kUnimplemented 
+  // 
+  // kUnimplemented (gRPC code "UNIMPLEMENTED") indicates the operation is not 
+  // implemented or supported in this service. In this case, the operation 
+  // should not be re-attempted. 
   kUnimplemented = 12,
-
-  // StatusCode::kInternal
-  //
-  // kInternal (gRPC code "INTERNAL") indicates an internal error has occurred
-  // and some invariants expected by the underlying system have not been
-  // satisfied. This error code is reserved for serious errors.
+ 
+  // StatusCode::kInternal 
+  // 
+  // kInternal (gRPC code "INTERNAL") indicates an internal error has occurred 
+  // and some invariants expected by the underlying system have not been 
+  // satisfied. This error code is reserved for serious errors. 
   kInternal = 13,
-
-  // StatusCode::kUnavailable
-  //
-  // kUnavailable (gRPC code "UNAVAILABLE") indicates the service is currently
-  // unavailable and that this is most likely a transient condition. An error
-  // such as this can be corrected by retrying with a backoff scheme. Note that
-  // it is not always safe to retry non-idempotent operations.
-  //
-  // See the guidelines above for deciding between `kFailedPrecondition`,
-  // `kAborted`, and `kUnavailable`.
+ 
+  // StatusCode::kUnavailable 
+  // 
+  // kUnavailable (gRPC code "UNAVAILABLE") indicates the service is currently 
+  // unavailable and that this is most likely a transient condition. An error 
+  // such as this can be corrected by retrying with a backoff scheme. Note that 
+  // it is not always safe to retry non-idempotent operations. 
+  // 
+  // See the guidelines above for deciding between `kFailedPrecondition`, 
+  // `kAborted`, and `kUnavailable`. 
   kUnavailable = 14,
-
-  // StatusCode::kDataLoss
-  //
-  // kDataLoss (gRPC code "DATA_LOSS") indicates that unrecoverable data loss or
-  // corruption has occurred. As this error is serious, proper alerting should
-  // be attached to errors such as this.
+ 
+  // StatusCode::kDataLoss 
+  // 
+  // kDataLoss (gRPC code "DATA_LOSS") indicates that unrecoverable data loss or 
+  // corruption has occurred. As this error is serious, proper alerting should 
+  // be attached to errors such as this. 
   kDataLoss = 15,
-
-  // StatusCode::kUnauthenticated
-  //
-  // kUnauthenticated (gRPC code "UNAUTHENTICATED") indicates that the request
-  // does not have valid authentication credentials for the operation. Correct
-  // the authentication and try again.
+ 
+  // StatusCode::kUnauthenticated 
+  // 
+  // kUnauthenticated (gRPC code "UNAUTHENTICATED") indicates that the request 
+  // does not have valid authentication credentials for the operation. Correct 
+  // the authentication and try again. 
   kUnauthenticated = 16,
-
-  // StatusCode::DoNotUseReservedForFutureExpansionUseDefaultInSwitchInstead_
-  //
-  // NOTE: this error code entry should not be used and you should not rely on
-  // its value, which may change.
-  //
-  // The purpose of this enumerated value is to force people who handle status
-  // codes with `switch()` statements to *not* simply enumerate all possible
-  // values, but instead provide a "default:" case. Providing such a default
-  // case ensures that code will compile when new codes are added.
+ 
+  // StatusCode::DoNotUseReservedForFutureExpansionUseDefaultInSwitchInstead_ 
+  // 
+  // NOTE: this error code entry should not be used and you should not rely on 
+  // its value, which may change. 
+  // 
+  // The purpose of this enumerated value is to force people who handle status 
+  // codes with `switch()` statements to *not* simply enumerate all possible 
+  // values, but instead provide a "default:" case. Providing such a default 
+  // case ensures that code will compile when new codes are added. 
   kDoNotUseReservedForFutureExpansionUseDefaultInSwitchInstead_ = 20
 };
 
-// StatusCodeToString()
-//
+// StatusCodeToString() 
+// 
 // Returns the name for the status code, or "" if it is an unknown value.
 TString StatusCodeToString(StatusCode code);
 
-// operator<<
-//
+// operator<< 
+// 
 // Streams StatusCodeToString(code) to `os`.
 std::ostream& operator<<(std::ostream& os, StatusCode code);
 
-// y_absl::StatusToStringMode
-//
-// An `y_absl::StatusToStringMode` is an enumerated type indicating how
+// y_absl::StatusToStringMode 
+// 
+// An `y_absl::StatusToStringMode` is an enumerated type indicating how 
 // `y_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,
 };
 
-// y_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;
-}
-
-// y_absl::Status
-//
-// The `y_absl::Status` class is generally used to gracefully handle errors
-// across API boundaries (and in particular across RPC boundaries). Some of
-// these errors may be recoverable, but others may not. Most
-// functions which can produce a recoverable error should be designed to return
-// either an `y_absl::Status` (or the similar `y_absl::StatusOr<T>`, which holds
-// either an object of type `T` or an error).
-//
-// API developers should construct their functions to return `y_absl::OkStatus()`
-// upon success, or an `y_absl::StatusCode` upon another type of error (e.g
-// an `y_absl::StatusCode::kInvalidArgument` error). The API provides convenience
+// y_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; 
+} 
+
+// y_absl::Status 
+// 
+// The `y_absl::Status` class is generally used to gracefully handle errors 
+// across API boundaries (and in particular across RPC boundaries). Some of 
+// these errors may be recoverable, but others may not. Most 
+// functions which can produce a recoverable error should be designed to return 
+// either an `y_absl::Status` (or the similar `y_absl::StatusOr<T>`, which holds 
+// either an object of type `T` or an error). 
+// 
+// API developers should construct their functions to return `y_absl::OkStatus()` 
+// upon success, or an `y_absl::StatusCode` upon another type of error (e.g 
+// an `y_absl::StatusCode::kInvalidArgument` error). The API provides convenience 
 // functions to construct each status code.
-//
-// Example:
-//
-// y_absl::Status myFunction(y_absl::string_view fname, ...) {
-//   ...
-//   // encounter error
-//   if (error condition) {
-//     // Construct an y_absl::StatusCode::kInvalidArgument error
-//     return y_absl::InvalidArgumentError("bad mode");
-//   }
-//   // else, return OK
-//   return y_absl::OkStatus();
-// }
-//
-// Users handling status error codes should prefer checking for an OK status
-// using the `ok()` member function. Handling multiple error codes may justify
-// use of switch statement, but only check for error codes you know how to
-// handle; do not try to exhaustively match against all canonical error codes.
-// Errors that cannot be handled should be logged and/or propagated for higher
-// levels to deal with. If you do use a switch statement, make sure that you
-// also provide a `default:` switch case, so that code does not break as other
-// canonical codes are added to the API.
-//
-// Example:
-//
-//   y_absl::Status result = DoSomething();
-//   if (!result.ok()) {
-//     LOG(ERROR) << result;
-//   }
-//
-//   // Provide a default if switching on multiple error codes
-//   switch (result.code()) {
-//     // The user hasn't authenticated. Ask them to reauth
-//     case y_absl::StatusCode::kUnauthenticated:
-//       DoReAuth();
-//       break;
-//     // The user does not have permission. Log an error.
-//     case y_absl::StatusCode::kPermissionDenied:
-//       LOG(ERROR) << result;
-//       break;
-//     // Propagate the error otherwise.
-//     default:
-//       return true;
-//   }
-//
-// An `y_absl::Status` can optionally include a payload with more information
-// about the error. Typically, this payload serves one of several purposes:
-//
-//   * It may provide more fine-grained semantic information about the error to
-//     facilitate actionable remedies.
-//   * It may provide human-readable contexual information that is more
-//     appropriate to display to an end user.
-//
-// Example:
-//
-//   y_absl::Status result = DoSomething();
-//   // Inform user to retry after 30 seconds
-//   // See more error details in googleapis/google/rpc/error_details.proto
-//   if (y_absl::IsResourceExhausted(result)) {
-//     google::rpc::RetryInfo info;
-//     info.retry_delay().seconds() = 30;
-//     // Payloads require a unique key (a URL to ensure no collisions with
-//     // other payloads), and an `y_absl::Cord` to hold the encoded data.
-//     y_absl::string_view url = "type.googleapis.com/google.rpc.RetryInfo";
-//     result.SetPayload(url, info.SerializeAsCord());
-//     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 {
- public:
-  // Constructors
-
-  // This default constructor creates an OK status with no message or payload.
-  // Avoid this constructor and prefer explicit construction of an OK status
-  // with `y_absl::OkStatus()`.
+// 
+// Example: 
+// 
+// y_absl::Status myFunction(y_absl::string_view fname, ...) { 
+//   ... 
+//   // encounter error 
+//   if (error condition) { 
+//     // Construct an y_absl::StatusCode::kInvalidArgument error 
+//     return y_absl::InvalidArgumentError("bad mode"); 
+//   } 
+//   // else, return OK 
+//   return y_absl::OkStatus(); 
+// } 
+// 
+// Users handling status error codes should prefer checking for an OK status 
+// using the `ok()` member function. Handling multiple error codes may justify 
+// use of switch statement, but only check for error codes you know how to 
+// handle; do not try to exhaustively match against all canonical error codes. 
+// Errors that cannot be handled should be logged and/or propagated for higher 
+// levels to deal with. If you do use a switch statement, make sure that you 
+// also provide a `default:` switch case, so that code does not break as other 
+// canonical codes are added to the API. 
+// 
+// Example: 
+// 
+//   y_absl::Status result = DoSomething(); 
+//   if (!result.ok()) { 
+//     LOG(ERROR) << result; 
+//   } 
+// 
+//   // Provide a default if switching on multiple error codes 
+//   switch (result.code()) { 
+//     // The user hasn't authenticated. Ask them to reauth 
+//     case y_absl::StatusCode::kUnauthenticated: 
+//       DoReAuth(); 
+//       break; 
+//     // The user does not have permission. Log an error. 
+//     case y_absl::StatusCode::kPermissionDenied: 
+//       LOG(ERROR) << result; 
+//       break; 
+//     // Propagate the error otherwise. 
+//     default: 
+//       return true; 
+//   } 
+// 
+// An `y_absl::Status` can optionally include a payload with more information 
+// about the error. Typically, this payload serves one of several purposes: 
+// 
+//   * It may provide more fine-grained semantic information about the error to 
+//     facilitate actionable remedies. 
+//   * It may provide human-readable contexual information that is more 
+//     appropriate to display to an end user. 
+// 
+// Example: 
+// 
+//   y_absl::Status result = DoSomething(); 
+//   // Inform user to retry after 30 seconds 
+//   // See more error details in googleapis/google/rpc/error_details.proto 
+//   if (y_absl::IsResourceExhausted(result)) { 
+//     google::rpc::RetryInfo info; 
+//     info.retry_delay().seconds() = 30; 
+//     // Payloads require a unique key (a URL to ensure no collisions with 
+//     // other payloads), and an `y_absl::Cord` to hold the encoded data. 
+//     y_absl::string_view url = "type.googleapis.com/google.rpc.RetryInfo"; 
+//     result.SetPayload(url, info.SerializeAsCord()); 
+//     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 { 
+ public: 
+  // Constructors 
+
+  // This default constructor creates an OK status with no message or payload. 
+  // Avoid this constructor and prefer explicit construction of an OK status 
+  // with `y_absl::OkStatus()`. 
   Status();
 
-  // Creates a status in the canonical error space with the specified
-  // `y_absl::StatusCode` and error message.  If `code == y_absl::StatusCode::kOk`,  // NOLINT
-  // `msg` is ignored and an object identical to an OK status is constructed.
+  // Creates a status in the canonical error space with the specified 
+  // `y_absl::StatusCode` and error message.  If `code == y_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(y_absl::StatusCode code, y_absl::string_view msg);
 
   Status(const Status&);
   Status& operator=(const Status& x);
 
-  // Move operators
-
+  // Move operators 
+ 
   // The moved-from state is valid but unspecified.
   Status(Status&&) noexcept;
   Status& operator=(Status&&);
 
   ~Status();
 
-  // Status::Update()
-  //
-  // Updates the existing status with `new_status` provided that `this->ok()`.
-  // If the existing status already contains a non-OK error, this update has no
-  // effect and preserves the current data. Note that this behavior may change
-  // in the future to augment a current non-ok status with additional
-  // information about `new_status`.
-  //
-  // `Update()` provides a convenient way of keeping track of the first error
-  // encountered.
-  //
-  // Example:
-  //   // Instead of "if (overall_status.ok()) overall_status = new_status"
+  // Status::Update() 
+  //
+  // Updates the existing status with `new_status` provided that `this->ok()`. 
+  // If the existing status already contains a non-OK error, this update has no 
+  // effect and preserves the current data. Note that this behavior may change 
+  // in the future to augment a current non-ok status with additional 
+  // information about `new_status`. 
+  // 
+  // `Update()` provides a convenient way of keeping track of the first error 
+  // encountered. 
+  // 
+  // Example: 
+  //   // Instead of "if (overall_status.ok()) overall_status = new_status" 
   //   overall_status.Update(new_status);
   //
   void Update(const Status& new_status);
   void Update(Status&& new_status);
 
-  // Status::ok()
-  //
-  // Returns `true` if `this->ok()`. Prefer checking for an OK status using this
-  // member function.
+  // Status::ok() 
+  // 
+  // Returns `true` if `this->ok()`. Prefer checking for an OK status using this 
+  // member function. 
   ABSL_MUST_USE_RESULT bool ok() const;
 
-  // Status::code()
-  //
-  // Returns the canonical error code of type `y_absl::StatusCode` of this status.
+  // Status::code() 
+  // 
+  // Returns the canonical error code of type `y_absl::StatusCode` of this status. 
   y_absl::StatusCode code() const;
 
-  // Status::raw_code()
-  //
-  // Returns a raw (canonical) error code corresponding to the enum value of
-  // `google.rpc.Code` definitions within
-  // https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto.
-  // These values could be out of the range of canonical `y_absl::StatusCode`
-  // enum values.
-  //
-  // NOTE: This function should only be called when converting to an associated
-  // wire format. Use `Status::code()` for error handling.
+  // Status::raw_code() 
+  // 
+  // Returns a raw (canonical) error code corresponding to the enum value of 
+  // `google.rpc.Code` definitions within 
+  // https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto. 
+  // These values could be out of the range of canonical `y_absl::StatusCode` 
+  // enum values. 
+  // 
+  // NOTE: This function should only be called when converting to an associated 
+  // wire format. Use `Status::code()` for error handling. 
   int raw_code() const;
 
-  // Status::message()
-  //
-  // Returns the error message associated with this error code, if available.
-  // Note that this message rarely describes the error code.  It is not unusual
-  // for the error message to be the empty string. As a result, prefer
+  // Status::message() 
+  // 
+  // Returns the error message associated with this error code, if available. 
+  // Note that this message rarely describes the error code.  It is not unusual 
+  // for the error message to be the empty string. As a result, prefer 
   // `operator<<` or `Status::ToString()` for debug logging.
   y_absl::string_view message() const;
 
   friend bool operator==(const Status&, const Status&);
   friend bool operator!=(const Status&, const Status&);
 
-  // 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.
-  //
-  // 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).
-  TString ToString(
+  // 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. 
+  // 
+  // 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). 
+  TString ToString( 
       StatusToStringMode mode = StatusToStringMode::kDefault) const;
 
-  // Status::IgnoreError()
-  //
+  // Status::IgnoreError() 
+  // 
   // Ignores any errors. This method does nothing except potentially suppress
   // complaints from any tools that are checking that errors are not dropped on
   // the floor.
   void IgnoreError() const;
 
-  // swap()
-  //
-  // Swap the contents of one status with another.
+  // swap() 
+  // 
+  // Swap the contents of one status with another. 
   friend void swap(Status& a, Status& b);
 
-  //----------------------------------------------------------------------------
-  // Payload Management APIs
-  //----------------------------------------------------------------------------
-
-  // A payload may be attached to a status to provide additional context to an
-  // error that may not be satisifed by an existing `y_absl::StatusCode`.
-  // Typically, this payload serves one of several purposes:
-  //
-  //   * It may provide more fine-grained semantic information about the error
-  //     to facilitate actionable remedies.
-  //   * It may provide human-readable contexual information that is more
-  //     appropriate to display to an end user.
-  //
-  // A payload consists of a [key,value] pair, where the key is a string
-  // referring to a unique "type URL" and the value is an object of type
-  // `y_absl::Cord` to hold the contextual data.
-  //
-  // The "type URL" should be unique and follow the format of a URL
-  // (https://en.wikipedia.org/wiki/URL) and, ideally, provide some
-  // documentation or schema on how to interpret its associated data. For
-  // example, the default type URL for a protobuf message type is
-  // "type.googleapis.com/packagename.messagename". Other custom wire formats
-  // should define the format of type URL in a similar practice so as to
-  // minimize the chance of conflict between type URLs.
-  // Users should ensure that the type URL can be mapped to a concrete
+  //---------------------------------------------------------------------------- 
+  // Payload Management APIs 
+  //---------------------------------------------------------------------------- 
+
+  // A payload may be attached to a status to provide additional context to an 
+  // error that may not be satisifed by an existing `y_absl::StatusCode`. 
+  // Typically, this payload serves one of several purposes: 
+  // 
+  //   * It may provide more fine-grained semantic information about the error 
+  //     to facilitate actionable remedies. 
+  //   * It may provide human-readable contexual information that is more 
+  //     appropriate to display to an end user. 
+  // 
+  // A payload consists of a [key,value] pair, where the key is a string 
+  // referring to a unique "type URL" and the value is an object of type 
+  // `y_absl::Cord` to hold the contextual data. 
+  // 
+  // The "type URL" should be unique and follow the format of a URL 
+  // (https://en.wikipedia.org/wiki/URL) and, ideally, provide some 
+  // documentation or schema on how to interpret its associated data. For 
+  // example, the default type URL for a protobuf message type is 
+  // "type.googleapis.com/packagename.messagename". Other custom wire formats 
+  // should define the format of type URL in a similar practice so as to 
+  // minimize the chance of conflict between type URLs. 
+  // Users should ensure that the type URL can be mapped to a concrete 
   // C++ type if they want to deserialize the payload and read it effectively.
-  //
-  // To attach a payload to a status object, call `Status::SetPayload()`,
-  // passing it the type URL and an `y_absl::Cord` of associated data. Similarly,
-  // to extract the payload from a status, call `Status::GetPayload()`. You
-  // may attach multiple payloads (with differing type URLs) to any given
-  // status object, provided that the status is currently exhibiting an error
-  // code (i.e. is not OK).
-
-  // Status::GetPayload()
-  //
-  // Gets the payload of a status given its unique `type_url` key, if present.
+  // 
+  // To attach a payload to a status object, call `Status::SetPayload()`, 
+  // passing it the type URL and an `y_absl::Cord` of associated data. Similarly, 
+  // to extract the payload from a status, call `Status::GetPayload()`. You 
+  // may attach multiple payloads (with differing type URLs) to any given 
+  // status object, provided that the status is currently exhibiting an error 
+  // code (i.e. is not OK). 
+
+  // Status::GetPayload() 
+  // 
+  // Gets the payload of a status given its unique `type_url` key, if present. 
   y_absl::optional<y_absl::Cord> GetPayload(y_absl::string_view type_url) const;
 
-  // Status::SetPayload()
-  //
-  // Sets the payload for a non-ok status using a `type_url` key, overwriting
-  // any existing payload for that `type_url`.
+  // Status::SetPayload() 
   //
-  // NOTE: This function does nothing if the Status is ok.
+  // Sets the payload for a non-ok status using a `type_url` key, overwriting 
+  // any existing payload for that `type_url`. 
+  // 
+  // NOTE: This function does nothing if the Status is ok. 
   void SetPayload(y_absl::string_view type_url, y_absl::Cord payload);
 
-  // Status::ErasePayload()
-  //
-  // Erases the payload corresponding to the `type_url` key.  Returns `true` if
+  // Status::ErasePayload() 
+  // 
+  // Erases the payload corresponding to the `type_url` key.  Returns `true` if 
   // the payload was present.
   bool ErasePayload(y_absl::string_view type_url);
 
-  // Status::ForEachPayload()
-  //
-  // Iterates over the stored payloads and calls the
-  // `visitor(type_key, payload)` callable for each one.
+  // Status::ForEachPayload() 
   //
-  // NOTE: The order of calls to `visitor()` is not specified and may change at
+  // Iterates over the stored payloads and calls the 
+  // `visitor(type_key, payload)` callable for each one. 
+  // 
+  // NOTE: The order of calls to `visitor()` is not specified and may change at 
   // any time.
   //
-  // NOTE: Any mutation on the same 'y_absl::Status' object during visitation is
+  // NOTE: Any mutation on the same 'y_absl::Status' object during visitation is 
   // forbidden and could result in undefined behavior.
   void ForEachPayload(
       y_absl::FunctionRef<void(y_absl::string_view, const y_absl::Cord&)> visitor)
@@ -613,9 +613,9 @@ class Status final {
   status_internal::Payloads* GetPayloads();
 
   // Takes ownership of payload.
-  static uintptr_t NewRep(
-      y_absl::StatusCode code, y_absl::string_view msg,
-      std::unique_ptr<status_internal::Payloads> payload);
+  static uintptr_t NewRep( 
+      y_absl::StatusCode code, y_absl::string_view msg, 
+      std::unique_ptr<status_internal::Payloads> payload); 
   static bool EqualsSlow(const y_absl::Status& a, const y_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);
 
-  TString ToStringSlow(StatusToStringMode mode) const;
+  TString ToStringSlow(StatusToStringMode mode) const; 
 
   // Status supports two different representations.
   //  - When the low bit is off it is an inlined representation.
@@ -657,93 +657,93 @@ class Status final {
   uintptr_t rep_;
 };
 
-// OkStatus()
-//
-// Returns an OK status, equivalent to a default constructed instance. Prefer
-// usage of `y_absl::OkStatus()` when constructing such an OK status.
+// OkStatus() 
+// 
+// Returns an OK status, equivalent to a default constructed instance. Prefer 
+// usage of `y_absl::OkStatus()` when constructing such an OK status. 
 Status OkStatus();
 
-// operator<<()
-//
+// operator<<() 
+// 
 // Prints a human-readable representation of `x` to `os`.
 std::ostream& operator<<(std::ostream& os, const Status& x);
 
-// IsAborted()
-// IsAlreadyExists()
-// IsCancelled()
-// IsDataLoss()
-// IsDeadlineExceeded()
-// IsFailedPrecondition()
-// IsInternal()
-// IsInvalidArgument()
-// IsNotFound()
-// IsOutOfRange()
-// IsPermissionDenied()
-// IsResourceExhausted()
-// IsUnauthenticated()
-// IsUnavailable()
-// IsUnimplemented()
-// IsUnknown()
-//
-// These convenience functions return `true` if a given status matches the
-// `y_absl::StatusCode` error code of its associated function.
-ABSL_MUST_USE_RESULT bool IsAborted(const Status& status);
-ABSL_MUST_USE_RESULT bool IsAlreadyExists(const Status& status);
-ABSL_MUST_USE_RESULT bool IsCancelled(const Status& status);
-ABSL_MUST_USE_RESULT bool IsDataLoss(const Status& status);
-ABSL_MUST_USE_RESULT bool IsDeadlineExceeded(const Status& status);
-ABSL_MUST_USE_RESULT bool IsFailedPrecondition(const Status& status);
-ABSL_MUST_USE_RESULT bool IsInternal(const Status& status);
-ABSL_MUST_USE_RESULT bool IsInvalidArgument(const Status& status);
-ABSL_MUST_USE_RESULT bool IsNotFound(const Status& status);
-ABSL_MUST_USE_RESULT bool IsOutOfRange(const Status& status);
-ABSL_MUST_USE_RESULT bool IsPermissionDenied(const Status& status);
-ABSL_MUST_USE_RESULT bool IsResourceExhausted(const Status& status);
-ABSL_MUST_USE_RESULT bool IsUnauthenticated(const Status& status);
-ABSL_MUST_USE_RESULT bool IsUnavailable(const Status& status);
-ABSL_MUST_USE_RESULT bool IsUnimplemented(const Status& status);
-ABSL_MUST_USE_RESULT bool IsUnknown(const Status& status);
-
-// AbortedError()
-// AlreadyExistsError()
-// CancelledError()
-// DataLossError()
-// DeadlineExceededError()
-// FailedPreconditionError()
-// InternalError()
-// InvalidArgumentError()
-// NotFoundError()
-// OutOfRangeError()
-// PermissionDeniedError()
-// ResourceExhaustedError()
-// UnauthenticatedError()
-// UnavailableError()
-// UnimplementedError()
-// UnknownError()
-//
-// These convenience functions create an `y_absl::Status` object with an error
-// code as indicated by the associated function name, using the error message
-// passed in `message`.
-Status AbortedError(y_absl::string_view message);
-Status AlreadyExistsError(y_absl::string_view message);
-Status CancelledError(y_absl::string_view message);
-Status DataLossError(y_absl::string_view message);
-Status DeadlineExceededError(y_absl::string_view message);
-Status FailedPreconditionError(y_absl::string_view message);
-Status InternalError(y_absl::string_view message);
-Status InvalidArgumentError(y_absl::string_view message);
-Status NotFoundError(y_absl::string_view message);
-Status OutOfRangeError(y_absl::string_view message);
-Status PermissionDeniedError(y_absl::string_view message);
-Status ResourceExhaustedError(y_absl::string_view message);
-Status UnauthenticatedError(y_absl::string_view message);
-Status UnavailableError(y_absl::string_view message);
-Status UnimplementedError(y_absl::string_view message);
-Status UnknownError(y_absl::string_view message);
-
-//------------------------------------------------------------------------------
+// IsAborted() 
+// IsAlreadyExists() 
+// IsCancelled() 
+// IsDataLoss() 
+// IsDeadlineExceeded() 
+// IsFailedPrecondition() 
+// IsInternal() 
+// IsInvalidArgument() 
+// IsNotFound() 
+// IsOutOfRange() 
+// IsPermissionDenied() 
+// IsResourceExhausted() 
+// IsUnauthenticated() 
+// IsUnavailable() 
+// IsUnimplemented() 
+// IsUnknown() 
+// 
+// These convenience functions return `true` if a given status matches the 
+// `y_absl::StatusCode` error code of its associated function. 
+ABSL_MUST_USE_RESULT bool IsAborted(const Status& status); 
+ABSL_MUST_USE_RESULT bool IsAlreadyExists(const Status& status); 
+ABSL_MUST_USE_RESULT bool IsCancelled(const Status& status); 
+ABSL_MUST_USE_RESULT bool IsDataLoss(const Status& status); 
+ABSL_MUST_USE_RESULT bool IsDeadlineExceeded(const Status& status); 
+ABSL_MUST_USE_RESULT bool IsFailedPrecondition(const Status& status); 
+ABSL_MUST_USE_RESULT bool IsInternal(const Status& status); 
+ABSL_MUST_USE_RESULT bool IsInvalidArgument(const Status& status); 
+ABSL_MUST_USE_RESULT bool IsNotFound(const Status& status); 
+ABSL_MUST_USE_RESULT bool IsOutOfRange(const Status& status); 
+ABSL_MUST_USE_RESULT bool IsPermissionDenied(const Status& status); 
+ABSL_MUST_USE_RESULT bool IsResourceExhausted(const Status& status); 
+ABSL_MUST_USE_RESULT bool IsUnauthenticated(const Status& status); 
+ABSL_MUST_USE_RESULT bool IsUnavailable(const Status& status); 
+ABSL_MUST_USE_RESULT bool IsUnimplemented(const Status& status); 
+ABSL_MUST_USE_RESULT bool IsUnknown(const Status& status); 
+ 
+// AbortedError() 
+// AlreadyExistsError() 
+// CancelledError() 
+// DataLossError() 
+// DeadlineExceededError() 
+// FailedPreconditionError() 
+// InternalError() 
+// InvalidArgumentError() 
+// NotFoundError() 
+// OutOfRangeError() 
+// PermissionDeniedError() 
+// ResourceExhaustedError() 
+// UnauthenticatedError() 
+// UnavailableError() 
+// UnimplementedError() 
+// UnknownError() 
+// 
+// These convenience functions create an `y_absl::Status` object with an error 
+// code as indicated by the associated function name, using the error message 
+// passed in `message`. 
+Status AbortedError(y_absl::string_view message); 
+Status AlreadyExistsError(y_absl::string_view message); 
+Status CancelledError(y_absl::string_view message); 
+Status DataLossError(y_absl::string_view message); 
+Status DeadlineExceededError(y_absl::string_view message); 
+Status FailedPreconditionError(y_absl::string_view message); 
+Status InternalError(y_absl::string_view message); 
+Status InvalidArgumentError(y_absl::string_view message); 
+Status NotFoundError(y_absl::string_view message); 
+Status OutOfRangeError(y_absl::string_view message); 
+Status PermissionDeniedError(y_absl::string_view message); 
+Status ResourceExhaustedError(y_absl::string_view message); 
+Status UnauthenticatedError(y_absl::string_view message); 
+Status UnavailableError(y_absl::string_view message); 
+Status UnimplementedError(y_absl::string_view message); 
+Status UnknownError(y_absl::string_view message); 
+ 
+//------------------------------------------------------------------------------ 
 // Implementation details follow
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------ 
 
 inline Status::Status() : rep_(CodeToInlinedRep(y_absl::StatusCode::kOk)) {}
 
@@ -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 TString Status::ToString(StatusToStringMode mode) const {
-  return ok() ? "OK" : ToStringSlow(mode);
+inline TString Status::ToString(StatusToStringMode mode) const { 
+  return ok() ? "OK" : ToStringSlow(mode); 
 }
 
 inline void Status::IgnoreError() const {
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/status/status_payload_printer.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/status/status_payload_printer.cc
index 6990ff6e8d..d22f50de8b 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/status/status_payload_printer.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/status/status_payload_printer.cc
@@ -16,21 +16,21 @@
 #include <atomic>
 
 #include "y_absl/base/attributes.h"
-#include "y_absl/base/internal/atomic_hook.h"
+#include "y_absl/base/internal/atomic_hook.h" 
 
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
 namespace status_internal {
 
-ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES
-static y_absl::base_internal::AtomicHook<StatusPayloadPrinter> storage;
+ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES 
+static y_absl::base_internal::AtomicHook<StatusPayloadPrinter> storage; 
 
 void SetStatusPayloadPrinter(StatusPayloadPrinter printer) {
-  storage.Store(printer);
+  storage.Store(printer); 
 }
 
 StatusPayloadPrinter GetStatusPayloadPrinter() {
-  return storage.Load();
+  return storage.Load(); 
 }
 
 }  // namespace status_internal
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor.cc
index 03e6d1cec4..ac881e65b5 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor.cc
@@ -1,32 +1,32 @@
-// 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 "y_absl/status/statusor.h"
-
-#include <cstdlib>
-#include <utility>
-
+// 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 "y_absl/status/statusor.h" 
+ 
+#include <cstdlib> 
+#include <utility> 
+ 
 #include "y_absl/base/call_once.h"
-#include "y_absl/base/internal/raw_logging.h"
-#include "y_absl/status/status.h"
-#include "y_absl/strings/str_cat.h"
-
-namespace y_absl {
-ABSL_NAMESPACE_BEGIN
-
-BadStatusOrAccess::BadStatusOrAccess(y_absl::Status status)
-    : status_(std::move(status)) {}
-
+#include "y_absl/base/internal/raw_logging.h" 
+#include "y_absl/status/status.h" 
+#include "y_absl/strings/str_cat.h" 
+ 
+namespace y_absl { 
+ABSL_NAMESPACE_BEGIN 
+ 
+BadStatusOrAccess::BadStatusOrAccess(y_absl::Status status) 
+    : status_(std::move(status)) {} 
+ 
 BadStatusOrAccess::BadStatusOrAccess(const BadStatusOrAccess& other)
     : status_(other.status_) {}
 
@@ -52,52 +52,52 @@ BadStatusOrAccess& BadStatusOrAccess::operator=(BadStatusOrAccess&& other) {
 BadStatusOrAccess::BadStatusOrAccess(BadStatusOrAccess&& other)
     : status_(std::move(other.status_)) {}
 
-const char* BadStatusOrAccess::what() const noexcept {
+const char* BadStatusOrAccess::what() const noexcept { 
   InitWhat();
   return what_.c_str();
-}
-
-const y_absl::Status& BadStatusOrAccess::status() const { return status_; }
-
+} 
+ 
+const y_absl::Status& BadStatusOrAccess::status() const { return status_; } 
+ 
 void BadStatusOrAccess::InitWhat() const {
   y_absl::call_once(init_what_, [this] {
     what_ = y_absl::StrCat("Bad StatusOr access: ", status_.ToString());
   });
 }
 
-namespace internal_statusor {
-
-void Helper::HandleInvalidStatusCtorArg(y_absl::Status* status) {
-  const char* kMessage =
-      "An OK status is not a valid constructor argument to StatusOr<T>";
-#ifdef NDEBUG
-  ABSL_INTERNAL_LOG(ERROR, kMessage);
-#else
-  ABSL_INTERNAL_LOG(FATAL, kMessage);
-#endif
-  // In optimized builds, we will fall back to InternalError.
-  *status = y_absl::InternalError(kMessage);
-}
-
-void Helper::Crash(const y_absl::Status& status) {
-  ABSL_INTERNAL_LOG(
-      FATAL,
-      y_absl::StrCat("Attempting to fetch value instead of handling error ",
-                   status.ToString()));
-}
-
-void ThrowBadStatusOrAccess(y_absl::Status status) {
-#ifdef ABSL_HAVE_EXCEPTIONS
-  throw y_absl::BadStatusOrAccess(std::move(status));
-#else
-  ABSL_INTERNAL_LOG(
-      FATAL,
-      y_absl::StrCat("Attempting to fetch value instead of handling error ",
-                   status.ToString()));
-  std::abort();
-#endif
-}
-
-}  // namespace internal_statusor
-ABSL_NAMESPACE_END
-}  // namespace y_absl
+namespace internal_statusor { 
+ 
+void Helper::HandleInvalidStatusCtorArg(y_absl::Status* status) { 
+  const char* kMessage = 
+      "An OK status is not a valid constructor argument to StatusOr<T>"; 
+#ifdef NDEBUG 
+  ABSL_INTERNAL_LOG(ERROR, kMessage); 
+#else 
+  ABSL_INTERNAL_LOG(FATAL, kMessage); 
+#endif 
+  // In optimized builds, we will fall back to InternalError. 
+  *status = y_absl::InternalError(kMessage); 
+} 
+ 
+void Helper::Crash(const y_absl::Status& status) { 
+  ABSL_INTERNAL_LOG( 
+      FATAL, 
+      y_absl::StrCat("Attempting to fetch value instead of handling error ", 
+                   status.ToString())); 
+} 
+ 
+void ThrowBadStatusOrAccess(y_absl::Status status) { 
+#ifdef ABSL_HAVE_EXCEPTIONS 
+  throw y_absl::BadStatusOrAccess(std::move(status)); 
+#else 
+  ABSL_INTERNAL_LOG( 
+      FATAL, 
+      y_absl::StrCat("Attempting to fetch value instead of handling error ", 
+                   status.ToString())); 
+  std::abort(); 
+#endif 
+} 
+ 
+}  // namespace internal_statusor 
+ABSL_NAMESPACE_END 
+}  // namespace y_absl 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor.h b/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor.h
index 23e1b8a6e4..4931a7a837 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor.h
@@ -1,770 +1,770 @@
-// 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: statusor.h
-// -----------------------------------------------------------------------------
-//
-// An `y_absl::StatusOr<T>` represents a union of an `y_absl::Status` object
-// and an object of type `T`. The `y_absl::StatusOr<T>` will either contain an
-// object of type `T` (indicating a successful operation), or an error (of type
-// `y_absl::Status`) explaining why such a value is not present.
-//
-// In general, check the success of an operation returning an
-// `y_absl::StatusOr<T>` like you would an `y_absl::Status` by using the `ok()`
-// member function.
-//
-// Example:
-//
-//   StatusOr<Foo> result = Calculation();
-//   if (result.ok()) {
-//     result->DoSomethingCool();
-//   } else {
-//     LOG(ERROR) << result.status();
-//   }
-#ifndef ABSL_STATUS_STATUSOR_H_
-#define ABSL_STATUS_STATUSOR_H_
-
-#include <exception>
-#include <initializer_list>
-#include <new>
-#include <util/generic/string.h>
-#include <type_traits>
-#include <utility>
-
-#include "y_absl/base/attributes.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: statusor.h 
+// ----------------------------------------------------------------------------- 
+// 
+// An `y_absl::StatusOr<T>` represents a union of an `y_absl::Status` object 
+// and an object of type `T`. The `y_absl::StatusOr<T>` will either contain an 
+// object of type `T` (indicating a successful operation), or an error (of type 
+// `y_absl::Status`) explaining why such a value is not present. 
+// 
+// In general, check the success of an operation returning an 
+// `y_absl::StatusOr<T>` like you would an `y_absl::Status` by using the `ok()` 
+// member function. 
+// 
+// Example: 
+// 
+//   StatusOr<Foo> result = Calculation(); 
+//   if (result.ok()) { 
+//     result->DoSomethingCool(); 
+//   } else { 
+//     LOG(ERROR) << result.status(); 
+//   } 
+#ifndef ABSL_STATUS_STATUSOR_H_ 
+#define ABSL_STATUS_STATUSOR_H_ 
+ 
+#include <exception> 
+#include <initializer_list> 
+#include <new> 
+#include <util/generic/string.h> 
+#include <type_traits> 
+#include <utility> 
+ 
+#include "y_absl/base/attributes.h" 
 #include "y_absl/base/call_once.h"
-#include "y_absl/meta/type_traits.h"
-#include "y_absl/status/internal/statusor_internal.h"
-#include "y_absl/status/status.h"
-#include "y_absl/types/variant.h"
-#include "y_absl/utility/utility.h"
-
-namespace y_absl {
-ABSL_NAMESPACE_BEGIN
-
-// BadStatusOrAccess
-//
-// This class defines the type of object to throw (if exceptions are enabled),
-// when accessing the value of an `y_absl::StatusOr<T>` object that does not
-// contain a value. This behavior is analogous to that of
-// `std::bad_optional_access` in the case of accessing an invalid
-// `std::optional` value.
-//
-// Example:
-//
-// try {
-//   y_absl::StatusOr<int> v = FetchInt();
-//   DoWork(v.value());  // Accessing value() when not "OK" may throw
-// } catch (y_absl::BadStatusOrAccess& ex) {
-//   LOG(ERROR) << ex.status();
-// }
-class BadStatusOrAccess : public std::exception {
- public:
-  explicit BadStatusOrAccess(y_absl::Status status);
+#include "y_absl/meta/type_traits.h" 
+#include "y_absl/status/internal/statusor_internal.h" 
+#include "y_absl/status/status.h" 
+#include "y_absl/types/variant.h" 
+#include "y_absl/utility/utility.h" 
+ 
+namespace y_absl { 
+ABSL_NAMESPACE_BEGIN 
+ 
+// BadStatusOrAccess 
+// 
+// This class defines the type of object to throw (if exceptions are enabled), 
+// when accessing the value of an `y_absl::StatusOr<T>` object that does not 
+// contain a value. This behavior is analogous to that of 
+// `std::bad_optional_access` in the case of accessing an invalid 
+// `std::optional` value. 
+// 
+// Example: 
+// 
+// try { 
+//   y_absl::StatusOr<int> v = FetchInt(); 
+//   DoWork(v.value());  // Accessing value() when not "OK" may throw 
+// } catch (y_absl::BadStatusOrAccess& ex) { 
+//   LOG(ERROR) << ex.status(); 
+// } 
+class BadStatusOrAccess : public std::exception { 
+ public: 
+  explicit BadStatusOrAccess(y_absl::Status status); 
   ~BadStatusOrAccess() override = default;
-
+ 
   BadStatusOrAccess(const BadStatusOrAccess& other);
   BadStatusOrAccess& operator=(const BadStatusOrAccess& other);
   BadStatusOrAccess(BadStatusOrAccess&& other);
   BadStatusOrAccess& operator=(BadStatusOrAccess&& other);
 
-  // BadStatusOrAccess::what()
-  //
-  // Returns the associated explanatory string of the `y_absl::StatusOr<T>`
+  // BadStatusOrAccess::what() 
+  // 
+  // Returns the associated explanatory string of the `y_absl::StatusOr<T>` 
   // object's error code. This function contains information about the failing
   // status, but its exact formatting may change and should not be depended on.
-  //
-  // The pointer of this string is guaranteed to be valid until any non-const
-  // function is invoked on the exception object.
-  const char* what() const noexcept override;
-
-  // BadStatusOrAccess::status()
-  //
-  // Returns the associated `y_absl::Status` of the `y_absl::StatusOr<T>` object's
-  // error.
-  const y_absl::Status& status() const;
-
- private:
+  // 
+  // The pointer of this string is guaranteed to be valid until any non-const 
+  // function is invoked on the exception object. 
+  const char* what() const noexcept override; 
+ 
+  // BadStatusOrAccess::status() 
+  // 
+  // Returns the associated `y_absl::Status` of the `y_absl::StatusOr<T>` object's 
+  // error. 
+  const y_absl::Status& status() const; 
+ 
+ private: 
   void InitWhat() const;
 
-  y_absl::Status status_;
+  y_absl::Status status_; 
   mutable y_absl::once_flag init_what_;
   mutable TString what_;
-};
-
-// Returned StatusOr objects may not be ignored.
-template <typename T>
-class ABSL_MUST_USE_RESULT StatusOr;
-
-// y_absl::StatusOr<T>
-//
-// The `y_absl::StatusOr<T>` class template is a union of an `y_absl::Status` object
-// and an object of type `T`. The `y_absl::StatusOr<T>` models an object that is
-// either a usable object, or an error (of type `y_absl::Status`) explaining why
-// such an object is not present. An `y_absl::StatusOr<T>` is typically the return
-// value of a function which may fail.
-//
-// An `y_absl::StatusOr<T>` can never hold an "OK" status (an
-// `y_absl::StatusCode::kOk` value); instead, the presence of an object of type
-// `T` indicates success. Instead of checking for a `kOk` value, use the
-// `y_absl::StatusOr<T>::ok()` member function. (It is for this reason, and code
-// readability, that using the `ok()` function is preferred for `y_absl::Status`
-// as well.)
-//
-// Example:
-//
-//   StatusOr<Foo> result = DoBigCalculationThatCouldFail();
-//   if (result.ok()) {
-//     result->DoSomethingCool();
-//   } else {
-//     LOG(ERROR) << result.status();
-//   }
-//
-// Accessing the object held by an `y_absl::StatusOr<T>` should be performed via
-// `operator*` or `operator->`, after a call to `ok()` confirms that the
-// `y_absl::StatusOr<T>` holds an object of type `T`:
-//
-// Example:
-//
-//   y_absl::StatusOr<int> i = GetCount();
-//   if (i.ok()) {
-//     updated_total += *i
-//   }
-//
-// NOTE: using `y_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.
-//
-// Example:
-//
-//   StatusOr<Foo> result = DoBigCalculationThatCouldFail();
-//   const Foo& foo = result.value();    // Crash/exception if no value present
-//   foo.DoSomethingCool();
-//
-// A `y_absl::StatusOr<T*>` can be constructed from a null pointer like any other
-// pointer value, and the result will be that `ok()` returns `true` and
-// `value()` returns `nullptr`. Checking the value of pointer in an
-// `y_absl::StatusOr<T>` generally requires a bit more care, to ensure both that a
-// value is present and that value is not null:
-//
-//  StatusOr<std::unique_ptr<Foo>> result = FooFactory::MakeNewFoo(arg);
-//  if (!result.ok()) {
-//    LOG(ERROR) << result.status();
-//  } else if (*result == nullptr) {
-//    LOG(ERROR) << "Unexpected null pointer";
-//  } else {
-//    (*result)->DoSomethingCool();
-//  }
-//
-// Example factory implementation returning StatusOr<T>:
-//
-//  StatusOr<Foo> FooFactory::MakeFoo(int arg) {
-//    if (arg <= 0) {
-//      return y_absl::Status(y_absl::StatusCode::kInvalidArgument,
-//                          "Arg must be positive");
-//    }
-//    return Foo(arg);
-//  }
-template <typename T>
-class StatusOr : private internal_statusor::StatusOrData<T>,
-                 private internal_statusor::CopyCtorBase<T>,
-                 private internal_statusor::MoveCtorBase<T>,
-                 private internal_statusor::CopyAssignBase<T>,
-                 private internal_statusor::MoveAssignBase<T> {
-  template <typename U>
-  friend class StatusOr;
-
-  typedef internal_statusor::StatusOrData<T> Base;
-
- public:
-  // StatusOr<T>::value_type
-  //
-  // This instance data provides a generic `value_type` member for use within
-  // generic programming. This usage is analogous to that of
-  // `optional::value_type` in the case of `std::optional`.
-  typedef T value_type;
-
-  // Constructors
-
-  // Constructs a new `y_absl::StatusOr` with an `y_absl::StatusCode::kUnknown`
-  // status. This constructor is marked 'explicit' to prevent usages in return
-  // values such as 'return {};', under the misconception that
-  // `y_absl::StatusOr<std::vector<int>>` will be initialized with an empty
-  // vector, instead of an `y_absl::StatusCode::kUnknown` error code.
-  explicit StatusOr();
-
-  // `StatusOr<T>` is copy constructible if `T` is copy constructible.
-  StatusOr(const StatusOr&) = default;
-  // `StatusOr<T>` is copy assignable if `T` is copy constructible and copy
-  // assignable.
-  StatusOr& operator=(const StatusOr&) = default;
-
-  // `StatusOr<T>` is move constructible if `T` is move constructible.
-  StatusOr(StatusOr&&) = default;
-  // `StatusOr<T>` is moveAssignable if `T` is move constructible and move
-  // assignable.
-  StatusOr& operator=(StatusOr&&) = default;
-
-  // Converting Constructors
-
-  // Constructs a new `y_absl::StatusOr<T>` from an `y_absl::StatusOr<U>`, when `T`
-  // is constructible from `U`. To avoid ambiguity, these constructors are
-  // disabled if `T` is also constructible from `StatusOr<U>.`. This constructor
-  // is explicit if and only if the corresponding construction of `T` from `U`
-  // is explicit. (This constructor inherits its explicitness from the
-  // underlying constructor.)
-  template <
-      typename U,
-      y_absl::enable_if_t<
-          y_absl::conjunction<
-              y_absl::negation<std::is_same<T, U>>,
-              std::is_constructible<T, const U&>,
-              std::is_convertible<const U&, T>,
-              y_absl::negation<
-                  internal_statusor::IsConstructibleOrConvertibleFromStatusOr<
-                      T, U>>>::value,
-          int> = 0>
-  StatusOr(const StatusOr<U>& other)  // NOLINT
-      : Base(static_cast<const typename StatusOr<U>::Base&>(other)) {}
-  template <
-      typename U,
-      y_absl::enable_if_t<
-          y_absl::conjunction<
-              y_absl::negation<std::is_same<T, U>>,
-              std::is_constructible<T, const U&>,
-              y_absl::negation<std::is_convertible<const U&, T>>,
-              y_absl::negation<
-                  internal_statusor::IsConstructibleOrConvertibleFromStatusOr<
-                      T, U>>>::value,
-          int> = 0>
-  explicit StatusOr(const StatusOr<U>& other)
-      : Base(static_cast<const typename StatusOr<U>::Base&>(other)) {}
-
-  template <
-      typename U,
-      y_absl::enable_if_t<
-          y_absl::conjunction<
-              y_absl::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>,
-              std::is_convertible<U&&, T>,
-              y_absl::negation<
-                  internal_statusor::IsConstructibleOrConvertibleFromStatusOr<
-                      T, U>>>::value,
-          int> = 0>
-  StatusOr(StatusOr<U>&& other)  // NOLINT
-      : Base(static_cast<typename StatusOr<U>::Base&&>(other)) {}
-  template <
-      typename U,
-      y_absl::enable_if_t<
-          y_absl::conjunction<
-              y_absl::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>,
-              y_absl::negation<std::is_convertible<U&&, T>>,
-              y_absl::negation<
-                  internal_statusor::IsConstructibleOrConvertibleFromStatusOr<
-                      T, U>>>::value,
-          int> = 0>
-  explicit StatusOr(StatusOr<U>&& other)
-      : Base(static_cast<typename StatusOr<U>::Base&&>(other)) {}
-
-  // Converting Assignment Operators
-
-  // Creates an `y_absl::StatusOr<T>` through assignment from an
-  // `y_absl::StatusOr<U>` when:
-  //
-  //   * Both `y_absl::StatusOr<T>` and `y_absl::StatusOr<U>` are OK by assigning
-  //     `U` to `T` directly.
-  //   * `y_absl::StatusOr<T>` is OK and `y_absl::StatusOr<U>` contains an error
-  //      code by destroying `y_absl::StatusOr<T>`'s value and assigning from
-  //      `y_absl::StatusOr<U>'
-  //   * `y_absl::StatusOr<T>` contains an error code and `y_absl::StatusOr<U>` is
-  //      OK by directly initializing `T` from `U`.
-  //   * Both `y_absl::StatusOr<T>` and `y_absl::StatusOr<U>` contain an error
-  //     code by assigning the `Status` in `y_absl::StatusOr<U>` to
-  //     `y_absl::StatusOr<T>`
-  //
-  // These overloads only apply if `y_absl::StatusOr<T>` is constructible and
-  // assignable from `y_absl::StatusOr<U>` and `StatusOr<T>` cannot be directly
-  // assigned from `StatusOr<U>`.
-  template <
-      typename U,
-      y_absl::enable_if_t<
-          y_absl::conjunction<
-              y_absl::negation<std::is_same<T, U>>,
-              std::is_constructible<T, const U&>,
-              std::is_assignable<T, const U&>,
-              y_absl::negation<
-                  internal_statusor::
-                      IsConstructibleOrConvertibleOrAssignableFromStatusOr<
-                          T, U>>>::value,
-          int> = 0>
-  StatusOr& operator=(const StatusOr<U>& other) {
-    this->Assign(other);
-    return *this;
-  }
-  template <
-      typename U,
-      y_absl::enable_if_t<
-          y_absl::conjunction<
-              y_absl::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>,
-              std::is_assignable<T, U&&>,
-              y_absl::negation<
-                  internal_statusor::
-                      IsConstructibleOrConvertibleOrAssignableFromStatusOr<
-                          T, U>>>::value,
-          int> = 0>
-  StatusOr& operator=(StatusOr<U>&& other) {
-    this->Assign(std::move(other));
-    return *this;
-  }
-
-  // Constructs a new `y_absl::StatusOr<T>` with a non-ok status. After calling
-  // this constructor, `this->ok()` will be `false` and calls to `value()` will
-  // crash, or produce an exception if exceptions are enabled.
-  //
-  // The constructor also takes any type `U` that is convertible to
-  // `y_absl::Status`. This constructor is explicit if an only if `U` is not of
-  // type `y_absl::Status` and the conversion from `U` to `Status` is explicit.
-  //
-  // REQUIRES: !Status(std::forward<U>(v)).ok(). This requirement is DCHECKed.
-  // In optimized builds, passing y_absl::OkStatus() here will have the effect
-  // of passing y_absl::StatusCode::kInternal as a fallback.
-  template <
-      typename U = y_absl::Status,
-      y_absl::enable_if_t<
-          y_absl::conjunction<
-              std::is_convertible<U&&, y_absl::Status>,
-              std::is_constructible<y_absl::Status, U&&>,
-              y_absl::negation<std::is_same<y_absl::decay_t<U>, y_absl::StatusOr<T>>>,
-              y_absl::negation<std::is_same<y_absl::decay_t<U>, T>>,
-              y_absl::negation<std::is_same<y_absl::decay_t<U>, y_absl::in_place_t>>,
-              y_absl::negation<internal_statusor::HasConversionOperatorToStatusOr<
-                  T, U&&>>>::value,
-          int> = 0>
-  StatusOr(U&& v) : Base(std::forward<U>(v)) {}
-
-  template <
-      typename U = y_absl::Status,
-      y_absl::enable_if_t<
-          y_absl::conjunction<
-              y_absl::negation<std::is_convertible<U&&, y_absl::Status>>,
-              std::is_constructible<y_absl::Status, U&&>,
-              y_absl::negation<std::is_same<y_absl::decay_t<U>, y_absl::StatusOr<T>>>,
-              y_absl::negation<std::is_same<y_absl::decay_t<U>, T>>,
-              y_absl::negation<std::is_same<y_absl::decay_t<U>, y_absl::in_place_t>>,
-              y_absl::negation<internal_statusor::HasConversionOperatorToStatusOr<
-                  T, U&&>>>::value,
-          int> = 0>
-  explicit StatusOr(U&& v) : Base(std::forward<U>(v)) {}
-
-  template <
-      typename U = y_absl::Status,
-      y_absl::enable_if_t<
-          y_absl::conjunction<
-              std::is_convertible<U&&, y_absl::Status>,
-              std::is_constructible<y_absl::Status, U&&>,
-              y_absl::negation<std::is_same<y_absl::decay_t<U>, y_absl::StatusOr<T>>>,
-              y_absl::negation<std::is_same<y_absl::decay_t<U>, T>>,
-              y_absl::negation<std::is_same<y_absl::decay_t<U>, y_absl::in_place_t>>,
-              y_absl::negation<internal_statusor::HasConversionOperatorToStatusOr<
-                  T, U&&>>>::value,
-          int> = 0>
-  StatusOr& operator=(U&& v) {
-    this->AssignStatus(std::forward<U>(v));
-    return *this;
-  }
-
-  // Perfect-forwarding value assignment operator.
-
-  // If `*this` contains a `T` value before the call, the contained value is
-  // assigned from `std::forward<U>(v)`; Otherwise, it is directly-initialized
-  // from `std::forward<U>(v)`.
-  // This function does not participate in overload unless:
-  // 1. `std::is_constructible_v<T, U>` is true,
-  // 2. `std::is_assignable_v<T&, U>` is true.
-  // 3. `std::is_same_v<StatusOr<T>, std::remove_cvref_t<U>>` is false.
-  // 4. Assigning `U` to `T` is not ambiguous:
-  //  If `U` is `StatusOr<V>` and `T` is constructible and assignable from
-  //  both `StatusOr<V>` and `V`, the assignment is considered bug-prone and
-  //  ambiguous thus will fail to compile. For example:
-  //    StatusOr<bool> s1 = true;  // s1.ok() && *s1 == true
-  //    StatusOr<bool> s2 = false;  // s2.ok() && *s2 == false
-  //    s1 = s2;  // ambiguous, `s1 = *s2` or `s1 = bool(s2)`?
-  template <
-      typename U = T,
-      typename = typename std::enable_if<y_absl::conjunction<
-          std::is_constructible<T, U&&>, std::is_assignable<T&, U&&>,
-          y_absl::disjunction<
-              std::is_same<y_absl::remove_cv_t<y_absl::remove_reference_t<U>>, T>,
-              y_absl::conjunction<
-                  y_absl::negation<std::is_convertible<U&&, y_absl::Status>>,
-                  y_absl::negation<internal_statusor::
-                                     HasConversionOperatorToStatusOr<T, U&&>>>>,
-          internal_statusor::IsForwardingAssignmentValid<T, U&&>>::value>::type>
-  StatusOr& operator=(U&& v) {
-    this->Assign(std::forward<U>(v));
-    return *this;
-  }
-
-  // Constructs the inner value `T` in-place using the provided args, using the
-  // `T(args...)` constructor.
-  template <typename... Args>
-  explicit StatusOr(y_absl::in_place_t, Args&&... args);
-  template <typename U, typename... Args>
-  explicit StatusOr(y_absl::in_place_t, std::initializer_list<U> ilist,
-                    Args&&... args);
-
-  // Constructs the inner value `T` in-place using the provided args, using the
-  // `T(U)` (direct-initialization) constructor. This constructor is only valid
-  // if `T` can be constructed from a `U`. Can accept move or copy constructors.
-  //
-  // This constructor is explicit if `U` is not convertible to `T`. To avoid
+}; 
+ 
+// Returned StatusOr objects may not be ignored. 
+template <typename T> 
+class ABSL_MUST_USE_RESULT StatusOr; 
+ 
+// y_absl::StatusOr<T> 
+// 
+// The `y_absl::StatusOr<T>` class template is a union of an `y_absl::Status` object 
+// and an object of type `T`. The `y_absl::StatusOr<T>` models an object that is 
+// either a usable object, or an error (of type `y_absl::Status`) explaining why 
+// such an object is not present. An `y_absl::StatusOr<T>` is typically the return 
+// value of a function which may fail. 
+// 
+// An `y_absl::StatusOr<T>` can never hold an "OK" status (an 
+// `y_absl::StatusCode::kOk` value); instead, the presence of an object of type 
+// `T` indicates success. Instead of checking for a `kOk` value, use the 
+// `y_absl::StatusOr<T>::ok()` member function. (It is for this reason, and code 
+// readability, that using the `ok()` function is preferred for `y_absl::Status` 
+// as well.) 
+// 
+// Example: 
+// 
+//   StatusOr<Foo> result = DoBigCalculationThatCouldFail(); 
+//   if (result.ok()) { 
+//     result->DoSomethingCool(); 
+//   } else { 
+//     LOG(ERROR) << result.status(); 
+//   } 
+// 
+// Accessing the object held by an `y_absl::StatusOr<T>` should be performed via 
+// `operator*` or `operator->`, after a call to `ok()` confirms that the 
+// `y_absl::StatusOr<T>` holds an object of type `T`: 
+// 
+// Example: 
+// 
+//   y_absl::StatusOr<int> i = GetCount(); 
+//   if (i.ok()) { 
+//     updated_total += *i 
+//   } 
+// 
+// NOTE: using `y_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. 
+// 
+// Example: 
+// 
+//   StatusOr<Foo> result = DoBigCalculationThatCouldFail(); 
+//   const Foo& foo = result.value();    // Crash/exception if no value present 
+//   foo.DoSomethingCool(); 
+// 
+// A `y_absl::StatusOr<T*>` can be constructed from a null pointer like any other 
+// pointer value, and the result will be that `ok()` returns `true` and 
+// `value()` returns `nullptr`. Checking the value of pointer in an 
+// `y_absl::StatusOr<T>` generally requires a bit more care, to ensure both that a 
+// value is present and that value is not null: 
+// 
+//  StatusOr<std::unique_ptr<Foo>> result = FooFactory::MakeNewFoo(arg); 
+//  if (!result.ok()) { 
+//    LOG(ERROR) << result.status(); 
+//  } else if (*result == nullptr) { 
+//    LOG(ERROR) << "Unexpected null pointer"; 
+//  } else { 
+//    (*result)->DoSomethingCool(); 
+//  } 
+// 
+// Example factory implementation returning StatusOr<T>: 
+// 
+//  StatusOr<Foo> FooFactory::MakeFoo(int arg) { 
+//    if (arg <= 0) { 
+//      return y_absl::Status(y_absl::StatusCode::kInvalidArgument, 
+//                          "Arg must be positive"); 
+//    } 
+//    return Foo(arg); 
+//  } 
+template <typename T> 
+class StatusOr : private internal_statusor::StatusOrData<T>, 
+                 private internal_statusor::CopyCtorBase<T>, 
+                 private internal_statusor::MoveCtorBase<T>, 
+                 private internal_statusor::CopyAssignBase<T>, 
+                 private internal_statusor::MoveAssignBase<T> { 
+  template <typename U> 
+  friend class StatusOr; 
+ 
+  typedef internal_statusor::StatusOrData<T> Base; 
+ 
+ public: 
+  // StatusOr<T>::value_type 
+  // 
+  // This instance data provides a generic `value_type` member for use within 
+  // generic programming. This usage is analogous to that of 
+  // `optional::value_type` in the case of `std::optional`. 
+  typedef T value_type; 
+ 
+  // Constructors 
+ 
+  // Constructs a new `y_absl::StatusOr` with an `y_absl::StatusCode::kUnknown` 
+  // status. This constructor is marked 'explicit' to prevent usages in return 
+  // values such as 'return {};', under the misconception that 
+  // `y_absl::StatusOr<std::vector<int>>` will be initialized with an empty 
+  // vector, instead of an `y_absl::StatusCode::kUnknown` error code. 
+  explicit StatusOr(); 
+ 
+  // `StatusOr<T>` is copy constructible if `T` is copy constructible. 
+  StatusOr(const StatusOr&) = default; 
+  // `StatusOr<T>` is copy assignable if `T` is copy constructible and copy 
+  // assignable. 
+  StatusOr& operator=(const StatusOr&) = default; 
+ 
+  // `StatusOr<T>` is move constructible if `T` is move constructible. 
+  StatusOr(StatusOr&&) = default; 
+  // `StatusOr<T>` is moveAssignable if `T` is move constructible and move 
+  // assignable. 
+  StatusOr& operator=(StatusOr&&) = default; 
+ 
+  // Converting Constructors 
+ 
+  // Constructs a new `y_absl::StatusOr<T>` from an `y_absl::StatusOr<U>`, when `T` 
+  // is constructible from `U`. To avoid ambiguity, these constructors are 
+  // disabled if `T` is also constructible from `StatusOr<U>.`. This constructor 
+  // is explicit if and only if the corresponding construction of `T` from `U` 
+  // is explicit. (This constructor inherits its explicitness from the 
+  // underlying constructor.) 
+  template < 
+      typename U, 
+      y_absl::enable_if_t< 
+          y_absl::conjunction< 
+              y_absl::negation<std::is_same<T, U>>, 
+              std::is_constructible<T, const U&>, 
+              std::is_convertible<const U&, T>, 
+              y_absl::negation< 
+                  internal_statusor::IsConstructibleOrConvertibleFromStatusOr< 
+                      T, U>>>::value, 
+          int> = 0> 
+  StatusOr(const StatusOr<U>& other)  // NOLINT 
+      : Base(static_cast<const typename StatusOr<U>::Base&>(other)) {} 
+  template < 
+      typename U, 
+      y_absl::enable_if_t< 
+          y_absl::conjunction< 
+              y_absl::negation<std::is_same<T, U>>, 
+              std::is_constructible<T, const U&>, 
+              y_absl::negation<std::is_convertible<const U&, T>>, 
+              y_absl::negation< 
+                  internal_statusor::IsConstructibleOrConvertibleFromStatusOr< 
+                      T, U>>>::value, 
+          int> = 0> 
+  explicit StatusOr(const StatusOr<U>& other) 
+      : Base(static_cast<const typename StatusOr<U>::Base&>(other)) {} 
+ 
+  template < 
+      typename U, 
+      y_absl::enable_if_t< 
+          y_absl::conjunction< 
+              y_absl::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>, 
+              std::is_convertible<U&&, T>, 
+              y_absl::negation< 
+                  internal_statusor::IsConstructibleOrConvertibleFromStatusOr< 
+                      T, U>>>::value, 
+          int> = 0> 
+  StatusOr(StatusOr<U>&& other)  // NOLINT 
+      : Base(static_cast<typename StatusOr<U>::Base&&>(other)) {} 
+  template < 
+      typename U, 
+      y_absl::enable_if_t< 
+          y_absl::conjunction< 
+              y_absl::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>, 
+              y_absl::negation<std::is_convertible<U&&, T>>, 
+              y_absl::negation< 
+                  internal_statusor::IsConstructibleOrConvertibleFromStatusOr< 
+                      T, U>>>::value, 
+          int> = 0> 
+  explicit StatusOr(StatusOr<U>&& other) 
+      : Base(static_cast<typename StatusOr<U>::Base&&>(other)) {} 
+ 
+  // Converting Assignment Operators 
+ 
+  // Creates an `y_absl::StatusOr<T>` through assignment from an 
+  // `y_absl::StatusOr<U>` when: 
+  // 
+  //   * Both `y_absl::StatusOr<T>` and `y_absl::StatusOr<U>` are OK by assigning 
+  //     `U` to `T` directly. 
+  //   * `y_absl::StatusOr<T>` is OK and `y_absl::StatusOr<U>` contains an error 
+  //      code by destroying `y_absl::StatusOr<T>`'s value and assigning from 
+  //      `y_absl::StatusOr<U>' 
+  //   * `y_absl::StatusOr<T>` contains an error code and `y_absl::StatusOr<U>` is 
+  //      OK by directly initializing `T` from `U`. 
+  //   * Both `y_absl::StatusOr<T>` and `y_absl::StatusOr<U>` contain an error 
+  //     code by assigning the `Status` in `y_absl::StatusOr<U>` to 
+  //     `y_absl::StatusOr<T>` 
+  // 
+  // These overloads only apply if `y_absl::StatusOr<T>` is constructible and 
+  // assignable from `y_absl::StatusOr<U>` and `StatusOr<T>` cannot be directly 
+  // assigned from `StatusOr<U>`. 
+  template < 
+      typename U, 
+      y_absl::enable_if_t< 
+          y_absl::conjunction< 
+              y_absl::negation<std::is_same<T, U>>, 
+              std::is_constructible<T, const U&>, 
+              std::is_assignable<T, const U&>, 
+              y_absl::negation< 
+                  internal_statusor:: 
+                      IsConstructibleOrConvertibleOrAssignableFromStatusOr< 
+                          T, U>>>::value, 
+          int> = 0> 
+  StatusOr& operator=(const StatusOr<U>& other) { 
+    this->Assign(other); 
+    return *this; 
+  } 
+  template < 
+      typename U, 
+      y_absl::enable_if_t< 
+          y_absl::conjunction< 
+              y_absl::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>, 
+              std::is_assignable<T, U&&>, 
+              y_absl::negation< 
+                  internal_statusor:: 
+                      IsConstructibleOrConvertibleOrAssignableFromStatusOr< 
+                          T, U>>>::value, 
+          int> = 0> 
+  StatusOr& operator=(StatusOr<U>&& other) { 
+    this->Assign(std::move(other)); 
+    return *this; 
+  } 
+ 
+  // Constructs a new `y_absl::StatusOr<T>` with a non-ok status. After calling 
+  // this constructor, `this->ok()` will be `false` and calls to `value()` will 
+  // crash, or produce an exception if exceptions are enabled. 
+  // 
+  // The constructor also takes any type `U` that is convertible to 
+  // `y_absl::Status`. This constructor is explicit if an only if `U` is not of 
+  // type `y_absl::Status` and the conversion from `U` to `Status` is explicit. 
+  // 
+  // REQUIRES: !Status(std::forward<U>(v)).ok(). This requirement is DCHECKed. 
+  // In optimized builds, passing y_absl::OkStatus() here will have the effect 
+  // of passing y_absl::StatusCode::kInternal as a fallback. 
+  template < 
+      typename U = y_absl::Status, 
+      y_absl::enable_if_t< 
+          y_absl::conjunction< 
+              std::is_convertible<U&&, y_absl::Status>, 
+              std::is_constructible<y_absl::Status, U&&>, 
+              y_absl::negation<std::is_same<y_absl::decay_t<U>, y_absl::StatusOr<T>>>, 
+              y_absl::negation<std::is_same<y_absl::decay_t<U>, T>>, 
+              y_absl::negation<std::is_same<y_absl::decay_t<U>, y_absl::in_place_t>>, 
+              y_absl::negation<internal_statusor::HasConversionOperatorToStatusOr< 
+                  T, U&&>>>::value, 
+          int> = 0> 
+  StatusOr(U&& v) : Base(std::forward<U>(v)) {} 
+ 
+  template < 
+      typename U = y_absl::Status, 
+      y_absl::enable_if_t< 
+          y_absl::conjunction< 
+              y_absl::negation<std::is_convertible<U&&, y_absl::Status>>, 
+              std::is_constructible<y_absl::Status, U&&>, 
+              y_absl::negation<std::is_same<y_absl::decay_t<U>, y_absl::StatusOr<T>>>, 
+              y_absl::negation<std::is_same<y_absl::decay_t<U>, T>>, 
+              y_absl::negation<std::is_same<y_absl::decay_t<U>, y_absl::in_place_t>>, 
+              y_absl::negation<internal_statusor::HasConversionOperatorToStatusOr< 
+                  T, U&&>>>::value, 
+          int> = 0> 
+  explicit StatusOr(U&& v) : Base(std::forward<U>(v)) {} 
+ 
+  template < 
+      typename U = y_absl::Status, 
+      y_absl::enable_if_t< 
+          y_absl::conjunction< 
+              std::is_convertible<U&&, y_absl::Status>, 
+              std::is_constructible<y_absl::Status, U&&>, 
+              y_absl::negation<std::is_same<y_absl::decay_t<U>, y_absl::StatusOr<T>>>, 
+              y_absl::negation<std::is_same<y_absl::decay_t<U>, T>>, 
+              y_absl::negation<std::is_same<y_absl::decay_t<U>, y_absl::in_place_t>>, 
+              y_absl::negation<internal_statusor::HasConversionOperatorToStatusOr< 
+                  T, U&&>>>::value, 
+          int> = 0> 
+  StatusOr& operator=(U&& v) { 
+    this->AssignStatus(std::forward<U>(v)); 
+    return *this; 
+  } 
+ 
+  // Perfect-forwarding value assignment operator. 
+ 
+  // If `*this` contains a `T` value before the call, the contained value is 
+  // assigned from `std::forward<U>(v)`; Otherwise, it is directly-initialized 
+  // from `std::forward<U>(v)`. 
+  // This function does not participate in overload unless: 
+  // 1. `std::is_constructible_v<T, U>` is true, 
+  // 2. `std::is_assignable_v<T&, U>` is true. 
+  // 3. `std::is_same_v<StatusOr<T>, std::remove_cvref_t<U>>` is false. 
+  // 4. Assigning `U` to `T` is not ambiguous: 
+  //  If `U` is `StatusOr<V>` and `T` is constructible and assignable from 
+  //  both `StatusOr<V>` and `V`, the assignment is considered bug-prone and 
+  //  ambiguous thus will fail to compile. For example: 
+  //    StatusOr<bool> s1 = true;  // s1.ok() && *s1 == true 
+  //    StatusOr<bool> s2 = false;  // s2.ok() && *s2 == false 
+  //    s1 = s2;  // ambiguous, `s1 = *s2` or `s1 = bool(s2)`? 
+  template < 
+      typename U = T, 
+      typename = typename std::enable_if<y_absl::conjunction< 
+          std::is_constructible<T, U&&>, std::is_assignable<T&, U&&>, 
+          y_absl::disjunction< 
+              std::is_same<y_absl::remove_cv_t<y_absl::remove_reference_t<U>>, T>, 
+              y_absl::conjunction< 
+                  y_absl::negation<std::is_convertible<U&&, y_absl::Status>>, 
+                  y_absl::negation<internal_statusor:: 
+                                     HasConversionOperatorToStatusOr<T, U&&>>>>, 
+          internal_statusor::IsForwardingAssignmentValid<T, U&&>>::value>::type> 
+  StatusOr& operator=(U&& v) { 
+    this->Assign(std::forward<U>(v)); 
+    return *this; 
+  } 
+ 
+  // Constructs the inner value `T` in-place using the provided args, using the 
+  // `T(args...)` constructor. 
+  template <typename... Args> 
+  explicit StatusOr(y_absl::in_place_t, Args&&... args); 
+  template <typename U, typename... Args> 
+  explicit StatusOr(y_absl::in_place_t, std::initializer_list<U> ilist, 
+                    Args&&... args); 
+ 
+  // Constructs the inner value `T` in-place using the provided args, using the 
+  // `T(U)` (direct-initialization) constructor. This constructor is only valid 
+  // if `T` can be constructed from a `U`. Can accept move or copy constructors. 
+  // 
+  // This constructor is explicit if `U` is not convertible to `T`. To avoid 
   // ambiguity, this constructor is disabled if `U` is a `StatusOr<J>`, where
   // `J` is convertible to `T`.
-  template <
-      typename U = T,
-      y_absl::enable_if_t<
-          y_absl::conjunction<
-              internal_statusor::IsDirectInitializationValid<T, U&&>,
-              std::is_constructible<T, U&&>, std::is_convertible<U&&, T>,
-              y_absl::disjunction<
-                  std::is_same<y_absl::remove_cv_t<y_absl::remove_reference_t<U>>,
-                               T>,
-                  y_absl::conjunction<
-                      y_absl::negation<std::is_convertible<U&&, y_absl::Status>>,
-                      y_absl::negation<
-                          internal_statusor::HasConversionOperatorToStatusOr<
-                              T, U&&>>>>>::value,
-          int> = 0>
-  StatusOr(U&& u)  // NOLINT
+  template < 
+      typename U = T, 
+      y_absl::enable_if_t< 
+          y_absl::conjunction< 
+              internal_statusor::IsDirectInitializationValid<T, U&&>, 
+              std::is_constructible<T, U&&>, std::is_convertible<U&&, T>, 
+              y_absl::disjunction< 
+                  std::is_same<y_absl::remove_cv_t<y_absl::remove_reference_t<U>>, 
+                               T>, 
+                  y_absl::conjunction< 
+                      y_absl::negation<std::is_convertible<U&&, y_absl::Status>>, 
+                      y_absl::negation< 
+                          internal_statusor::HasConversionOperatorToStatusOr< 
+                              T, U&&>>>>>::value, 
+          int> = 0> 
+  StatusOr(U&& u)  // NOLINT 
       : StatusOr(y_absl::in_place, std::forward<U>(u)) {}
-
-  template <
-      typename U = T,
-      y_absl::enable_if_t<
-          y_absl::conjunction<
-              internal_statusor::IsDirectInitializationValid<T, U&&>,
-              y_absl::disjunction<
-                  std::is_same<y_absl::remove_cv_t<y_absl::remove_reference_t<U>>,
-                               T>,
-                  y_absl::conjunction<
-                      y_absl::negation<std::is_constructible<y_absl::Status, U&&>>,
-                      y_absl::negation<
-                          internal_statusor::HasConversionOperatorToStatusOr<
-                              T, U&&>>>>,
-              std::is_constructible<T, U&&>,
-              y_absl::negation<std::is_convertible<U&&, T>>>::value,
-          int> = 0>
-  explicit StatusOr(U&& u)  // NOLINT
+ 
+  template < 
+      typename U = T, 
+      y_absl::enable_if_t< 
+          y_absl::conjunction< 
+              internal_statusor::IsDirectInitializationValid<T, U&&>, 
+              y_absl::disjunction< 
+                  std::is_same<y_absl::remove_cv_t<y_absl::remove_reference_t<U>>, 
+                               T>, 
+                  y_absl::conjunction< 
+                      y_absl::negation<std::is_constructible<y_absl::Status, U&&>>, 
+                      y_absl::negation< 
+                          internal_statusor::HasConversionOperatorToStatusOr< 
+                              T, U&&>>>>, 
+              std::is_constructible<T, U&&>, 
+              y_absl::negation<std::is_convertible<U&&, T>>>::value, 
+          int> = 0> 
+  explicit StatusOr(U&& u)  // NOLINT 
       : StatusOr(y_absl::in_place, std::forward<U>(u)) {}
-
-  // StatusOr<T>::ok()
-  //
-  // Returns whether or not this `y_absl::StatusOr<T>` holds a `T` value. This
-  // member function is analagous to `y_absl::Status::ok()` and should be used
-  // similarly to check the status of return values.
-  //
-  // Example:
-  //
-  // StatusOr<Foo> result = DoBigCalculationThatCouldFail();
-  // if (result.ok()) {
-  //    // Handle result
-  // else {
-  //    // Handle error
-  // }
-  ABSL_MUST_USE_RESULT bool ok() const { return this->status_.ok(); }
-
-  // StatusOr<T>::status()
-  //
-  // Returns a reference to the current `y_absl::Status` contained within the
-  // `y_absl::StatusOr<T>`. If `y_absl::StatusOr<T>` contains a `T`, then this
-  // function returns `y_absl::OkStatus()`.
+ 
+  // StatusOr<T>::ok() 
+  // 
+  // Returns whether or not this `y_absl::StatusOr<T>` holds a `T` value. This 
+  // member function is analagous to `y_absl::Status::ok()` and should be used 
+  // similarly to check the status of return values. 
+  // 
+  // Example: 
+  // 
+  // StatusOr<Foo> result = DoBigCalculationThatCouldFail(); 
+  // if (result.ok()) { 
+  //    // Handle result 
+  // else { 
+  //    // Handle error 
+  // } 
+  ABSL_MUST_USE_RESULT bool ok() const { return this->status_.ok(); } 
+ 
+  // StatusOr<T>::status() 
+  // 
+  // Returns a reference to the current `y_absl::Status` contained within the 
+  // `y_absl::StatusOr<T>`. If `y_absl::StatusOr<T>` contains a `T`, then this 
+  // function returns `y_absl::OkStatus()`. 
   const Status& status() const&;
-  Status status() &&;
-
-  // StatusOr<T>::value()
-  //
-  // Returns a reference to the held value if `this->ok()`. Otherwise, throws
-  // `y_absl::BadStatusOrAccess` if exceptions are enabled, or is guaranteed to
-  // terminate the process if exceptions are disabled.
-  //
-  // If you have already checked the status using `this->ok()`, you probably
-  // want to use `operator*()` or `operator->()` to access the value instead of
-  // `value`.
-  //
-  // Note: for value types that are cheap to copy, prefer simple code:
-  //
-  //   T value = statusor.value();
-  //
-  // Otherwise, if the value type is expensive to copy, but can be left
-  // in the StatusOr, simply assign to a reference:
-  //
-  //   T& value = statusor.value();  // or `const T&`
-  //
-  // Otherwise, if the value type supports an efficient move, it can be
-  // used as follows:
-  //
-  //   T value = std::move(statusor).value();
-  //
-  // The `std::move` on statusor instead of on the whole expression enables
-  // warnings about possible uses of the statusor object after the move.
+  Status status() &&; 
+ 
+  // StatusOr<T>::value() 
+  // 
+  // Returns a reference to the held value if `this->ok()`. Otherwise, throws 
+  // `y_absl::BadStatusOrAccess` if exceptions are enabled, or is guaranteed to 
+  // terminate the process if exceptions are disabled. 
+  // 
+  // If you have already checked the status using `this->ok()`, you probably 
+  // want to use `operator*()` or `operator->()` to access the value instead of 
+  // `value`. 
+  // 
+  // Note: for value types that are cheap to copy, prefer simple code: 
+  // 
+  //   T value = statusor.value(); 
+  // 
+  // Otherwise, if the value type is expensive to copy, but can be left 
+  // in the StatusOr, simply assign to a reference: 
+  // 
+  //   T& value = statusor.value();  // or `const T&` 
+  // 
+  // Otherwise, if the value type supports an efficient move, it can be 
+  // used as follows: 
+  // 
+  //   T value = std::move(statusor).value(); 
+  // 
+  // The `std::move` on statusor instead of on the whole expression enables 
+  // warnings about possible uses of the statusor object after the move. 
   const T& value() const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
   T& value() & ABSL_ATTRIBUTE_LIFETIME_BOUND;
   const T&& value() const&& ABSL_ATTRIBUTE_LIFETIME_BOUND;
   T&& value() && ABSL_ATTRIBUTE_LIFETIME_BOUND;
-
-  // StatusOr<T>:: operator*()
-  //
-  // Returns a reference to the current value.
-  //
-  // REQUIRES: `this->ok() == true`, otherwise the behavior is undefined.
-  //
-  // Use `this->ok()` to verify that there is a current value within the
-  // `y_absl::StatusOr<T>`. Alternatively, see the `value()` member function for a
-  // similar API that guarantees crashing or throwing an exception if there is
-  // no current value.
+ 
+  // StatusOr<T>:: operator*() 
+  // 
+  // Returns a reference to the current value. 
+  // 
+  // REQUIRES: `this->ok() == true`, otherwise the behavior is undefined. 
+  // 
+  // Use `this->ok()` to verify that there is a current value within the 
+  // `y_absl::StatusOr<T>`. Alternatively, see the `value()` member function for a 
+  // similar API that guarantees crashing or throwing an exception if there is 
+  // no current value. 
   const T& operator*() const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
   T& operator*() & ABSL_ATTRIBUTE_LIFETIME_BOUND;
   const T&& operator*() const&& ABSL_ATTRIBUTE_LIFETIME_BOUND;
   T&& operator*() && ABSL_ATTRIBUTE_LIFETIME_BOUND;
-
-  // StatusOr<T>::operator->()
-  //
-  // Returns a pointer to the current value.
-  //
-  // REQUIRES: `this->ok() == true`, otherwise the behavior is undefined.
-  //
-  // Use `this->ok()` to verify that there is a current value.
+ 
+  // StatusOr<T>::operator->() 
+  // 
+  // Returns a pointer to the current value. 
+  // 
+  // REQUIRES: `this->ok() == true`, otherwise the behavior is undefined. 
+  // 
+  // Use `this->ok()` to verify that there is a current value. 
   const T* operator->() const ABSL_ATTRIBUTE_LIFETIME_BOUND;
   T* operator->() ABSL_ATTRIBUTE_LIFETIME_BOUND;
-
-  // StatusOr<T>::value_or()
-  //
-  // 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
-  // if necessary. If the value type supports an efficient move, it can be used
-  // as follows:
-  //
-  //   T value = std::move(statusor).value_or(def);
-  //
-  // Unlike with `value`, calling `std::move()` on the result of `value_or` will
-  // still trigger a copy.
-  template <typename U>
-  T value_or(U&& default_value) const&;
-  template <typename U>
-  T value_or(U&& default_value) &&;
-
-  // StatusOr<T>::IgnoreError()
-  //
-  // Ignores any errors. This method does nothing except potentially suppress
-  // complaints from any tools that are checking that errors are not dropped on
-  // the floor.
-  void IgnoreError() const;
-
-  // StatusOr<T>::emplace()
-  //
-  // Reconstructs the inner value T in-place using the provided args, using the
-  // T(args...) constructor. Returns reference to the reconstructed `T`.
-  template <typename... Args>
-  T& emplace(Args&&... args) {
-    if (ok()) {
-      this->Clear();
-      this->MakeValue(std::forward<Args>(args)...);
-    } else {
-      this->MakeValue(std::forward<Args>(args)...);
-      this->status_ = y_absl::OkStatus();
-    }
-    return this->data_;
-  }
-
-  template <
-      typename U, typename... Args,
-      y_absl::enable_if_t<
-          std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value,
-          int> = 0>
-  T& emplace(std::initializer_list<U> ilist, Args&&... args) {
-    if (ok()) {
-      this->Clear();
-      this->MakeValue(ilist, std::forward<Args>(args)...);
-    } else {
-      this->MakeValue(ilist, std::forward<Args>(args)...);
-      this->status_ = y_absl::OkStatus();
-    }
-    return this->data_;
-  }
-
- private:
-  using internal_statusor::StatusOrData<T>::Assign;
-  template <typename U>
-  void Assign(const y_absl::StatusOr<U>& other);
-  template <typename U>
-  void Assign(y_absl::StatusOr<U>&& other);
-};
-
-// operator==()
-//
-// This operator checks the equality of two `y_absl::StatusOr<T>` objects.
-template <typename T>
-bool operator==(const StatusOr<T>& lhs, const StatusOr<T>& rhs) {
-  if (lhs.ok() && rhs.ok()) return *lhs == *rhs;
-  return lhs.status() == rhs.status();
-}
-
-// operator!=()
-//
-// This operator checks the inequality of two `y_absl::StatusOr<T>` objects.
-template <typename T>
-bool operator!=(const StatusOr<T>& lhs, const StatusOr<T>& rhs) {
-  return !(lhs == rhs);
-}
-
-//------------------------------------------------------------------------------
-// Implementation details for StatusOr<T>
-//------------------------------------------------------------------------------
-
-// TODO(sbenza): avoid the string here completely.
-template <typename T>
-StatusOr<T>::StatusOr() : Base(Status(y_absl::StatusCode::kUnknown, "")) {}
-
-template <typename T>
-template <typename U>
-inline void StatusOr<T>::Assign(const StatusOr<U>& other) {
-  if (other.ok()) {
-    this->Assign(*other);
-  } else {
-    this->AssignStatus(other.status());
-  }
-}
-
-template <typename T>
-template <typename U>
-inline void StatusOr<T>::Assign(StatusOr<U>&& other) {
-  if (other.ok()) {
-    this->Assign(*std::move(other));
-  } else {
-    this->AssignStatus(std::move(other).status());
-  }
-}
-template <typename T>
-template <typename... Args>
-StatusOr<T>::StatusOr(y_absl::in_place_t, Args&&... args)
-    : Base(y_absl::in_place, std::forward<Args>(args)...) {}
-
-template <typename T>
-template <typename U, typename... Args>
-StatusOr<T>::StatusOr(y_absl::in_place_t, std::initializer_list<U> ilist,
-                      Args&&... args)
-    : Base(y_absl::in_place, ilist, std::forward<Args>(args)...) {}
-
-template <typename T>
+ 
+  // StatusOr<T>::value_or() 
+  // 
+  // 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 
+  // if necessary. If the value type supports an efficient move, it can be used 
+  // as follows: 
+  // 
+  //   T value = std::move(statusor).value_or(def); 
+  // 
+  // Unlike with `value`, calling `std::move()` on the result of `value_or` will 
+  // still trigger a copy. 
+  template <typename U> 
+  T value_or(U&& default_value) const&; 
+  template <typename U> 
+  T value_or(U&& default_value) &&; 
+ 
+  // StatusOr<T>::IgnoreError() 
+  // 
+  // Ignores any errors. This method does nothing except potentially suppress 
+  // complaints from any tools that are checking that errors are not dropped on 
+  // the floor. 
+  void IgnoreError() const; 
+ 
+  // StatusOr<T>::emplace() 
+  // 
+  // Reconstructs the inner value T in-place using the provided args, using the 
+  // T(args...) constructor. Returns reference to the reconstructed `T`. 
+  template <typename... Args> 
+  T& emplace(Args&&... args) { 
+    if (ok()) { 
+      this->Clear(); 
+      this->MakeValue(std::forward<Args>(args)...); 
+    } else { 
+      this->MakeValue(std::forward<Args>(args)...); 
+      this->status_ = y_absl::OkStatus(); 
+    } 
+    return this->data_; 
+  } 
+ 
+  template < 
+      typename U, typename... Args, 
+      y_absl::enable_if_t< 
+          std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value, 
+          int> = 0> 
+  T& emplace(std::initializer_list<U> ilist, Args&&... args) { 
+    if (ok()) { 
+      this->Clear(); 
+      this->MakeValue(ilist, std::forward<Args>(args)...); 
+    } else { 
+      this->MakeValue(ilist, std::forward<Args>(args)...); 
+      this->status_ = y_absl::OkStatus(); 
+    } 
+    return this->data_; 
+  } 
+ 
+ private: 
+  using internal_statusor::StatusOrData<T>::Assign; 
+  template <typename U> 
+  void Assign(const y_absl::StatusOr<U>& other); 
+  template <typename U> 
+  void Assign(y_absl::StatusOr<U>&& other); 
+}; 
+ 
+// operator==() 
+// 
+// This operator checks the equality of two `y_absl::StatusOr<T>` objects. 
+template <typename T> 
+bool operator==(const StatusOr<T>& lhs, const StatusOr<T>& rhs) { 
+  if (lhs.ok() && rhs.ok()) return *lhs == *rhs; 
+  return lhs.status() == rhs.status(); 
+} 
+ 
+// operator!=() 
+// 
+// This operator checks the inequality of two `y_absl::StatusOr<T>` objects. 
+template <typename T> 
+bool operator!=(const StatusOr<T>& lhs, const StatusOr<T>& rhs) { 
+  return !(lhs == rhs); 
+} 
+ 
+//------------------------------------------------------------------------------ 
+// Implementation details for StatusOr<T> 
+//------------------------------------------------------------------------------ 
+ 
+// TODO(sbenza): avoid the string here completely. 
+template <typename T> 
+StatusOr<T>::StatusOr() : Base(Status(y_absl::StatusCode::kUnknown, "")) {} 
+ 
+template <typename T> 
+template <typename U> 
+inline void StatusOr<T>::Assign(const StatusOr<U>& other) { 
+  if (other.ok()) { 
+    this->Assign(*other); 
+  } else { 
+    this->AssignStatus(other.status()); 
+  } 
+} 
+ 
+template <typename T> 
+template <typename U> 
+inline void StatusOr<T>::Assign(StatusOr<U>&& other) { 
+  if (other.ok()) { 
+    this->Assign(*std::move(other)); 
+  } else { 
+    this->AssignStatus(std::move(other).status()); 
+  } 
+} 
+template <typename T> 
+template <typename... Args> 
+StatusOr<T>::StatusOr(y_absl::in_place_t, Args&&... args) 
+    : Base(y_absl::in_place, std::forward<Args>(args)...) {} 
+ 
+template <typename T> 
+template <typename U, typename... Args> 
+StatusOr<T>::StatusOr(y_absl::in_place_t, std::initializer_list<U> ilist, 
+                      Args&&... args) 
+    : Base(y_absl::in_place, ilist, std::forward<Args>(args)...) {} 
+ 
+template <typename T> 
 const Status& StatusOr<T>::status() const& {
   return this->status_;
 }
-template <typename T>
-Status StatusOr<T>::status() && {
-  return ok() ? OkStatus() : std::move(this->status_);
-}
-
-template <typename T>
-const T& StatusOr<T>::value() const& {
-  if (!this->ok()) internal_statusor::ThrowBadStatusOrAccess(this->status_);
-  return this->data_;
-}
-
-template <typename T>
-T& StatusOr<T>::value() & {
-  if (!this->ok()) internal_statusor::ThrowBadStatusOrAccess(this->status_);
-  return this->data_;
-}
-
-template <typename T>
-const T&& StatusOr<T>::value() const&& {
-  if (!this->ok()) {
-    internal_statusor::ThrowBadStatusOrAccess(std::move(this->status_));
-  }
-  return std::move(this->data_);
-}
-
-template <typename T>
-T&& StatusOr<T>::value() && {
-  if (!this->ok()) {
-    internal_statusor::ThrowBadStatusOrAccess(std::move(this->status_));
-  }
-  return std::move(this->data_);
-}
-
-template <typename T>
-const T& StatusOr<T>::operator*() const& {
-  this->EnsureOk();
-  return this->data_;
-}
-
-template <typename T>
-T& StatusOr<T>::operator*() & {
-  this->EnsureOk();
-  return this->data_;
-}
-
-template <typename T>
-const T&& StatusOr<T>::operator*() const&& {
-  this->EnsureOk();
-  return std::move(this->data_);
-}
-
-template <typename T>
-T&& StatusOr<T>::operator*() && {
-  this->EnsureOk();
-  return std::move(this->data_);
-}
-
-template <typename T>
-const T* StatusOr<T>::operator->() const {
-  this->EnsureOk();
-  return &this->data_;
-}
-
-template <typename T>
-T* StatusOr<T>::operator->() {
-  this->EnsureOk();
-  return &this->data_;
-}
-
-template <typename T>
-template <typename U>
-T StatusOr<T>::value_or(U&& default_value) const& {
-  if (ok()) {
-    return this->data_;
-  }
-  return std::forward<U>(default_value);
-}
-
-template <typename T>
-template <typename U>
-T StatusOr<T>::value_or(U&& default_value) && {
-  if (ok()) {
-    return std::move(this->data_);
-  }
-  return std::forward<U>(default_value);
-}
-
-template <typename T>
-void StatusOr<T>::IgnoreError() const {
-  // no-op
-}
-
-ABSL_NAMESPACE_END
-}  // namespace y_absl
-
-#endif  // ABSL_STATUS_STATUSOR_H_
+template <typename T> 
+Status StatusOr<T>::status() && { 
+  return ok() ? OkStatus() : std::move(this->status_); 
+} 
+ 
+template <typename T> 
+const T& StatusOr<T>::value() const& { 
+  if (!this->ok()) internal_statusor::ThrowBadStatusOrAccess(this->status_); 
+  return this->data_; 
+} 
+ 
+template <typename T> 
+T& StatusOr<T>::value() & { 
+  if (!this->ok()) internal_statusor::ThrowBadStatusOrAccess(this->status_); 
+  return this->data_; 
+} 
+ 
+template <typename T> 
+const T&& StatusOr<T>::value() const&& { 
+  if (!this->ok()) { 
+    internal_statusor::ThrowBadStatusOrAccess(std::move(this->status_)); 
+  } 
+  return std::move(this->data_); 
+} 
+ 
+template <typename T> 
+T&& StatusOr<T>::value() && { 
+  if (!this->ok()) { 
+    internal_statusor::ThrowBadStatusOrAccess(std::move(this->status_)); 
+  } 
+  return std::move(this->data_); 
+} 
+ 
+template <typename T> 
+const T& StatusOr<T>::operator*() const& { 
+  this->EnsureOk(); 
+  return this->data_; 
+} 
+ 
+template <typename T> 
+T& StatusOr<T>::operator*() & { 
+  this->EnsureOk(); 
+  return this->data_; 
+} 
+ 
+template <typename T> 
+const T&& StatusOr<T>::operator*() const&& { 
+  this->EnsureOk(); 
+  return std::move(this->data_); 
+} 
+ 
+template <typename T> 
+T&& StatusOr<T>::operator*() && { 
+  this->EnsureOk(); 
+  return std::move(this->data_); 
+} 
+ 
+template <typename T> 
+const T* StatusOr<T>::operator->() const { 
+  this->EnsureOk(); 
+  return &this->data_; 
+} 
+ 
+template <typename T> 
+T* StatusOr<T>::operator->() { 
+  this->EnsureOk(); 
+  return &this->data_; 
+} 
+ 
+template <typename T> 
+template <typename U> 
+T StatusOr<T>::value_or(U&& default_value) const& { 
+  if (ok()) { 
+    return this->data_; 
+  } 
+  return std::forward<U>(default_value); 
+} 
+ 
+template <typename T> 
+template <typename U> 
+T StatusOr<T>::value_or(U&& default_value) && { 
+  if (ok()) { 
+    return std::move(this->data_); 
+  } 
+  return std::forward<U>(default_value); 
+} 
+ 
+template <typename T> 
+void StatusOr<T>::IgnoreError() const { 
+  // no-op 
+} 
+ 
+ABSL_NAMESPACE_END 
+}  // namespace y_absl 
+ 
+#endif  // ABSL_STATUS_STATUSOR_H_ 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor/ya.make
index a29c7ae5b3..0574972151 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor/ya.make
@@ -1,31 +1,31 @@
-# Generated by devtools/yamaker.
-
-LIBRARY()
-
-WITHOUT_LICENSE_TEXTS()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
-
-LICENSE(Apache-2.0)
-
-PEERDIR(
-    contrib/restricted/abseil-cpp-tstring/y_absl/base
+# Generated by devtools/yamaker. 
+ 
+LIBRARY() 
+ 
+WITHOUT_LICENSE_TEXTS() 
+ 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
+LICENSE(Apache-2.0) 
+ 
+PEERDIR( 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base 
     contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity 
     contrib/restricted/abseil-cpp-tstring/y_absl/debugging
     contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace
     contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize
     contrib/restricted/abseil-cpp-tstring/y_absl/demangle
-    contrib/restricted/abseil-cpp-tstring/y_absl/numeric
+    contrib/restricted/abseil-cpp-tstring/y_absl/numeric 
     contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/exponential_biased
     contrib/restricted/abseil-cpp-tstring/y_absl/status
-    contrib/restricted/abseil-cpp-tstring/y_absl/strings
+    contrib/restricted/abseil-cpp-tstring/y_absl/strings 
     contrib/restricted/abseil-cpp-tstring/y_absl/strings/cord
     contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_cord_internal
     contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_strings_internal
@@ -38,20 +38,20 @@ PEERDIR(
     contrib/restricted/abseil-cpp-tstring/y_absl/time
     contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time
     contrib/restricted/abseil-cpp-tstring/y_absl/time/time_zone
-    contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access
+    contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access 
     contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_variant_access
-)
-
-ADDINCL(
-    GLOBAL contrib/restricted/abseil-cpp-tstring
-)
-
-NO_COMPILER_WARNINGS()
-
+) 
+ 
+ADDINCL( 
+    GLOBAL contrib/restricted/abseil-cpp-tstring 
+) 
+ 
+NO_COMPILER_WARNINGS() 
+ 
 SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/status)
-
-SRCS(
+ 
+SRCS( 
     statusor.cc
-)
-
-END()
+) 
+ 
+END() 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/status/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/status/ya.make
index 9414dfc26b..ceb84a219e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/status/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/status/ya.make
@@ -2,15 +2,15 @@
 
 LIBRARY()
 
-OWNER(
-    somov
-    g:cpp-contrib
-)
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
 
 LICENSE(Apache-2.0)
 
-LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
-
+LICENSE_TEXTS(.yandex_meta/licenses.list.txt) 
+ 
 PEERDIR(
     contrib/restricted/abseil-cpp-tstring/y_absl/base
     contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/.yandex_meta/licenses.list.txt b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/.yandex_meta/licenses.list.txt
index 9d8552c68c..bd499f8070 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/.yandex_meta/licenses.list.txt
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/.yandex_meta/licenses.list.txt
@@ -1,46 +1,46 @@
-====================Apache-2.0====================
-// 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.
-
-
-====================Apache-2.0====================
-// 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====================
-// Copyright 2017 The Abseil Authors.
-
-
-====================COPYRIGHT====================
-// Copyright 2018 The Abseil Authors.
-
-
-====================COPYRIGHT====================
+====================Apache-2.0==================== 
+// 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. 
+ 
+ 
+====================Apache-2.0==================== 
+// 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==================== 
+// Copyright 2017 The Abseil Authors. 
+ 
+ 
+====================COPYRIGHT==================== 
+// Copyright 2018 The Abseil Authors. 
+ 
+ 
+====================COPYRIGHT==================== 
 // Copyright 2019 The Abseil Authors.
 
 
 ====================COPYRIGHT====================
-// Copyright 2020 The Abseil Authors.
-
-
-====================COPYRIGHT====================
-// Copyright 2021 The Abseil Authors.
+// Copyright 2020 The Abseil Authors. 
+ 
+ 
+====================COPYRIGHT==================== 
+// Copyright 2021 The Abseil Authors. 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/charconv.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/charconv.cc
index 9515ca24dd..865ed0dfeb 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/charconv.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/charconv.cc
@@ -20,7 +20,7 @@
 #include <cstring>
 
 #include "y_absl/base/casts.h"
-#include "y_absl/numeric/bits.h"
+#include "y_absl/numeric/bits.h" 
 #include "y_absl/numeric/int128.h"
 #include "y_absl/strings/internal/charconv_bigint.h"
 #include "y_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;
@@ -619,10 +619,10 @@ from_chars_result FromCharsImpl(const char* first, const char* last,
       // Either we failed to parse a hex float after the "0x", or we read
       // "0xinf" or "0xnan" which we don't want to match.
       //
-      // However, a string that begins with "0x" also begins with "0", which
+      // However, a string that begins with "0x" also begins with "0", which 
       // is normally a valid match for the number zero.  So we want these
       // strings to match zero unless fmt_flags is `scientific`.  (This flag
-      // means an exponent is required, which the string "0" does not have.)
+      // means an exponent is required, which the string "0" does not have.) 
       if (fmt_flags == chars_format::scientific) {
         result.ec = std::errc::invalid_argument;
       } else {
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/cord.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/cord.cc
index 0de4ea1b3c..c37f2c3400 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/cord.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/cord.cc
@@ -15,12 +15,12 @@
 #include "y_absl/strings/cord.h"
 
 #include <algorithm>
-#include <atomic>
+#include <atomic> 
 #include <cstddef>
 #include <cstdio>
 #include <cstdlib>
 #include <iomanip>
-#include <iostream>
+#include <iostream> 
 #include <limits>
 #include <ostream>
 #include <sstream>
@@ -30,14 +30,14 @@
 
 #include "y_absl/base/casts.h"
 #include "y_absl/base/internal/raw_logging.h"
-#include "y_absl/base/macros.h"
+#include "y_absl/base/macros.h" 
 #include "y_absl/base/port.h"
 #include "y_absl/container/fixed_array.h"
 #include "y_absl/container/inlined_vector.h"
 #include "y_absl/strings/escaping.h"
 #include "y_absl/strings/internal/cord_internal.h"
 #include "y_absl/strings/internal/cord_rep_btree.h"
-#include "y_absl/strings/internal/cord_rep_flat.h"
+#include "y_absl/strings/internal/cord_rep_flat.h" 
 #include "y_absl/strings/internal/cordz_statistics.h"
 #include "y_absl/strings/internal/cordz_update_scope.h"
 #include "y_absl/strings/internal/cordz_update_tracker.h"
@@ -54,15 +54,15 @@ using ::y_absl::cord_internal::CordRep;
 using ::y_absl::cord_internal::CordRepBtree;
 using ::y_absl::cord_internal::CordRepConcat;
 using ::y_absl::cord_internal::CordRepExternal;
-using ::y_absl::cord_internal::CordRepFlat;
+using ::y_absl::cord_internal::CordRepFlat; 
 using ::y_absl::cord_internal::CordRepSubstring;
 using ::y_absl::cord_internal::CordzUpdateTracker;
 using ::y_absl::cord_internal::InlineData;
 using ::y_absl::cord_internal::kMaxFlatLength;
-using ::y_absl::cord_internal::kMinFlatLength;
+using ::y_absl::cord_internal::kMinFlatLength; 
 
-using ::y_absl::cord_internal::kInlinedVectorSize;
-using ::y_absl::cord_internal::kMaxBytesToCopy;
+using ::y_absl::cord_internal::kInlinedVectorSize; 
+using ::y_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);
@@ -77,18 +77,18 @@ static_assert(Fibonacci(63) == 6557470319842,
 // The root node depth is allowed to become twice as large to reduce rebalancing
 // for larger strings (see IsRootBalanced).
 static constexpr uint64_t min_length[] = {
-    Fibonacci(2),          Fibonacci(3),  Fibonacci(4),  Fibonacci(5),
-    Fibonacci(6),          Fibonacci(7),  Fibonacci(8),  Fibonacci(9),
-    Fibonacci(10),         Fibonacci(11), Fibonacci(12), Fibonacci(13),
-    Fibonacci(14),         Fibonacci(15), Fibonacci(16), Fibonacci(17),
-    Fibonacci(18),         Fibonacci(19), Fibonacci(20), Fibonacci(21),
-    Fibonacci(22),         Fibonacci(23), Fibonacci(24), Fibonacci(25),
-    Fibonacci(26),         Fibonacci(27), Fibonacci(28), Fibonacci(29),
-    Fibonacci(30),         Fibonacci(31), Fibonacci(32), Fibonacci(33),
-    Fibonacci(34),         Fibonacci(35), Fibonacci(36), Fibonacci(37),
-    Fibonacci(38),         Fibonacci(39), Fibonacci(40), Fibonacci(41),
-    Fibonacci(42),         Fibonacci(43), Fibonacci(44), Fibonacci(45),
-    Fibonacci(46),         Fibonacci(47),
+    Fibonacci(2),          Fibonacci(3),  Fibonacci(4),  Fibonacci(5), 
+    Fibonacci(6),          Fibonacci(7),  Fibonacci(8),  Fibonacci(9), 
+    Fibonacci(10),         Fibonacci(11), Fibonacci(12), Fibonacci(13), 
+    Fibonacci(14),         Fibonacci(15), Fibonacci(16), Fibonacci(17), 
+    Fibonacci(18),         Fibonacci(19), Fibonacci(20), Fibonacci(21), 
+    Fibonacci(22),         Fibonacci(23), Fibonacci(24), Fibonacci(25), 
+    Fibonacci(26),         Fibonacci(27), Fibonacci(28), Fibonacci(29), 
+    Fibonacci(30),         Fibonacci(31), Fibonacci(32), Fibonacci(33), 
+    Fibonacci(34),         Fibonacci(35), Fibonacci(36), Fibonacci(37), 
+    Fibonacci(38),         Fibonacci(39), Fibonacci(40), Fibonacci(41), 
+    Fibonacci(42),         Fibonacci(43), Fibonacci(44), Fibonacci(45), 
+    Fibonacci(46),         Fibonacci(47), 
     0xffffffffffffffffull,  // Avoid overflow
 };
 
@@ -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);
-  }
+  } 
   y_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;
@@ -248,12 +248,12 @@ static CordRep* NewTree(const char* data, size_t length, size_t alloc_hint) {
 
 namespace cord_internal {
 
-void InitializeCordRepExternal(y_absl::string_view data, CordRepExternal* rep) {
+void InitializeCordRepExternal(y_absl::string_view data, CordRepExternal* rep) { 
   assert(!data.empty());
   rep->length = data.size();
   rep->tag = EXTERNAL;
   rep->base = data.data();
-  VerifyTree(rep);
+  VerifyTree(rep); 
 }
 
 }  // namespace cord_internal
@@ -261,7 +261,7 @@ void InitializeCordRepExternal(y_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();
@@ -306,35 +306,35 @@ static CordRep* CordRepFromString(TString&& src) {
 // --------------------------------------------------------------------
 // Cord::InlineRep functions
 
-constexpr unsigned char Cord::InlineRep::kMaxInline;
+constexpr unsigned char Cord::InlineRep::kMaxInline; 
 
 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();
+  ResetToEmpty(); 
+  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());
@@ -405,7 +405,7 @@ void Cord::InlineRep::PrependTreeToTree(CordRep* tree,
 }
 
 void Cord::InlineRep::PrependTree(CordRep* tree, MethodIdentifier method) {
-  assert(tree != nullptr);
+  assert(tree != nullptr); 
   if (data_.is_tree()) {
     PrependTreeToTree(tree, method);
   } else {
@@ -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()); 
   }
 }
 
@@ -588,18 +588,18 @@ Cord::Cord(y_absl::string_view src, MethodIdentifier method)
   }
 }
 
-template <typename T, Cord::EnableIfString<T>>
+template <typename T, Cord::EnableIfString<T>> 
 Cord::Cord(T&& src) : contents_(InlineData::kDefaultInit) {
   if (src.size() <= InlineRep::kMaxInline) {
     contents_.set_data(src.data(), src.size(), true);
-  } else {
+  } else { 
     CordRep* rep = CordRepFromString(std::forward<T>(src));
     contents_.EmplaceTree(rep, CordzUpdateTracker::kConstructorString);
-  }
-}
-
-template Cord::Cord(TString&& src);
-
+  } 
+} 
+ 
+template Cord::Cord(TString&& src); 
+ 
 // The destruction code is separate so that the compiler can determine
 // that it does not need to call the destructor on a moved-from Cord.
 void Cord::DestroyCordSlow() {
@@ -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(TString&& src) {
@@ -658,12 +658,12 @@ Cord& Cord::operator=(y_absl::string_view src) {
     }
     contents_.SetTree(NewTree(data, length, 0), scope);
     CordRep::Unref(tree);
-  } else {
+  } else { 
     contents_.EmplaceTree(NewTree(data, length, 0), method);
-  }
-  return *this;
-}
-
+  } 
+  return *this; 
+} 
+ 
 // TODO(sanjay): Move to Cord::InlineRep section of file.  For now,
 // we keep it here to make diffs easier.
 void Cord::InlineRep::AppendArray(y_absl::string_view src,
@@ -680,15 +680,15 @@ void Cord::InlineRep::AppendArray(y_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(y_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);
 }
@@ -794,22 +794,22 @@ void Cord::Append(Cord&& src) {
   AppendImpl(std::move(src));
 }
 
-template <typename T, Cord::EnableIfString<T>>
-void Cord::Append(T&& src) {
-  if (src.size() <= kMaxBytesToCopy) {
-    Append(y_absl::string_view(src));
-  } else {
+template <typename T, Cord::EnableIfString<T>> 
+void Cord::Append(T&& src) { 
+  if (src.size() <= kMaxBytesToCopy) { 
+    Append(y_absl::string_view(src)); 
+  } else { 
     CordRep* rep = CordRepFromString(std::forward<T>(src));
     contents_.AppendTree(rep, CordzUpdateTracker::kAppendString);
-  }
-}
-
-template void Cord::Append(TString&& src);
-
+  } 
+} 
+ 
+template void Cord::Append(TString&& 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,37 +821,37 @@ void Cord::Prepend(const Cord& src) {
 
 void Cord::PrependArray(y_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);
-}
-
-template <typename T, Cord::EnableIfString<T>>
-inline void Cord::Prepend(T&& src) {
-  if (src.size() <= kMaxBytesToCopy) {
-    Prepend(y_absl::string_view(src));
+} 
+ 
+template <typename T, Cord::EnableIfString<T>> 
+inline void Cord::Prepend(T&& src) { 
+  if (src.size() <= kMaxBytesToCopy) { 
+    Prepend(y_absl::string_view(src)); 
   } else {
     CordRep* rep = CordRepFromString(std::forward<T>(src));
     contents_.PrependTree(rep, CordzUpdateTracker::kPrependString);
   }
 }
 
-template void Cord::Prepend(TString&& src);
-
+template void Cord::Prepend(TString&& 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); 
   y_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); 
   y_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);
@@ -1135,7 +1135,7 @@ class CordForest {
   void AddNode(CordRep* node) {
     CordRep* sum = nullptr;
 
-    // Collect together everything with which we will merge with node
+    // Collect together everything with which we will merge with node 
     int i = 0;
     for (; node->length > min_length[i + 1]; ++i) {
       auto& tree_at_i = trees_[i];
@@ -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 y_absl::string_view Cord::InlineRep::FindFlatStartPiece() const {
-  if (!is_tree()) {
-    return y_absl::string_view(data_.as_chars(), data_.inline_size());
+  if (!is_tree()) { 
+    return y_absl::string_view(data_.as_chars(), data_.inline_size()); 
   }
 
   CordRep* node = tree();
   if (node->IsFlat()) {
-    return y_absl::string_view(node->flat()->Data(), node->length);
+    return y_absl::string_view(node->flat()->Data(), node->length); 
   }
 
   if (node->IsExternal()) {
@@ -1272,8 +1272,8 @@ inline y_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 y_absl::string_view Cord::InlineRep::FindFlatStartPiece() const {
   }
 
   if (node->IsFlat()) {
-    return y_absl::string_view(node->flat()->Data() + offset, length);
+    return y_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;
   }
 
@@ -1510,8 +1510,8 @@ Cord::ChunkIterator& Cord::ChunkIterator::AdvanceStack() {
 }
 
 Cord Cord::ChunkIterator::AdvanceAndReadBytes(size_t n) {
-  ABSL_HARDENING_ASSERT(bytes_remaining_ >= n &&
-                        "Attempted to iterate past `end()`");
+  ABSL_HARDENING_ASSERT(bytes_remaining_ >= n && 
+                        "Attempted to iterate past `end()`"); 
   Cord subcord;
   auto constexpr method = CordzUpdateTracker::kCordReader;
 
@@ -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_ = y_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.
@@ -1712,7 +1712,7 @@ void Cord::ChunkIterator::AdvanceBytesSlowPath(size_t n) {
 }
 
 char Cord::operator[](size_t i) const {
-  ABSL_HARDENING_ASSERT(i < size());
+  ABSL_HARDENING_ASSERT(i < size()); 
   size_t offset = i;
   const CordRep* rep = contents_.tree();
   if (rep == nullptr) {
@@ -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 @@ y_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 @@ y_absl::string_view Cord::FlattenSlowPath() {
 /* static */ bool Cord::GetFlatAux(CordRep* rep, y_absl::string_view* fragment) {
   assert(rep != nullptr);
   if (rep->IsFlat()) {
-    *fragment = y_absl::string_view(rep->flat()->Data(), rep->length);
+    *fragment = y_absl::string_view(rep->flat()->Data(), rep->length); 
     return true;
   } else if (rep->IsExternal()) {
     *fragment = y_absl::string_view(rep->external()->base, rep->length);
@@ -1789,8 +1789,8 @@ y_absl::string_view Cord::FlattenSlowPath() {
   } else if (rep->IsSubstring()) {
     CordRep* child = rep->substring()->child;
     if (child->IsFlat()) {
-      *fragment = y_absl::string_view(
-          child->flat()->Data() + rep->substring()->start, rep->length);
+      *fragment = y_absl::string_view( 
+          child->flat()->Data() + rep->substring()->start, rep->length); 
       return true;
     } else if (child->IsExternal()) {
       *fragment = y_absl::string_view(
@@ -1808,14 +1808,14 @@ y_absl::string_view Cord::FlattenSlowPath() {
     y_absl::cord_internal::CordRep* rep,
     y_absl::FunctionRef<void(y_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 @@ y_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;
   y_absl::InlinedVector<CordRep*, kInlinedVectorSize> stack;
   y_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 << y_absl::CEscape(TString(rep->flat()->Data(), rep->length));
+          *os << y_absl::CEscape(TString(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, y_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-tstring/y_absl/strings/cord.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/cord.h
index 62359e0cf8..2bce9ffccf 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/cord.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/cord.h
@@ -12,51 +12,51 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
-// -----------------------------------------------------------------------------
-// File: cord.h
-// -----------------------------------------------------------------------------
-//
-// This file defines the `y_absl::Cord` data structure and operations on that data
-// structure. A Cord is a string-like sequence of characters optimized for
-// specific use cases. Unlike a `TString`, which stores an array of
-// contiguous characters, Cord data is stored in a structure consisting of
-// separate, reference-counted "chunks." (Currently, this implementation is a
-// tree structure, though that implementation may change.)
-//
-// 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
-// `TString`, 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.
-//
-// A Cord provides some benefit over `TString` under the following (albeit
-// narrow) circumstances:
-//
-//   * Cord data is designed to grow and shrink over a Cord's lifetime. Cord
-//     provides efficient insertions and deletions at the start and end of the
-//     character sequences, avoiding copies in those cases. Static data should
-//     generally be stored as strings.
-//   * External memory consisting of string-like data can be directly added to
-//     a Cord without requiring copies or allocations.
-//   * Cord data may be shared and copied cheaply. Cord provides a copy-on-write
-//     implementation and cheap sub-Cord operations. Copying a Cord is an O(1)
-//     operation.
-//
-// As a consequence to the above, Cord data is generally large. Small data
-// should generally use strings, as construction of a Cord requires some
-// overhead. Small Cords (<= 15 bytes) are represented inline, but most small
-// Cords are expected to grow over their lifetimes.
-//
-// Note that because a Cord is made up of separate chunked data, random access
-// to character data within a Cord is slower than within a `TString`.
-//
-// Thread Safety
-//
+// ----------------------------------------------------------------------------- 
+// File: cord.h 
+// ----------------------------------------------------------------------------- 
+// 
+// This file defines the `y_absl::Cord` data structure and operations on that data 
+// structure. A Cord is a string-like sequence of characters optimized for 
+// specific use cases. Unlike a `TString`, which stores an array of 
+// contiguous characters, Cord data is stored in a structure consisting of 
+// separate, reference-counted "chunks." (Currently, this implementation is a 
+// tree structure, though that implementation may change.) 
+// 
+// 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 
+// `TString`, 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. 
+// 
+// A Cord provides some benefit over `TString` under the following (albeit 
+// narrow) circumstances: 
+// 
+//   * Cord data is designed to grow and shrink over a Cord's lifetime. Cord 
+//     provides efficient insertions and deletions at the start and end of the 
+//     character sequences, avoiding copies in those cases. Static data should 
+//     generally be stored as strings. 
+//   * External memory consisting of string-like data can be directly added to 
+//     a Cord without requiring copies or allocations. 
+//   * Cord data may be shared and copied cheaply. Cord provides a copy-on-write 
+//     implementation and cheap sub-Cord operations. Copying a Cord is an O(1) 
+//     operation. 
+// 
+// As a consequence to the above, Cord data is generally large. Small data 
+// should generally use strings, as construction of a Cord requires some 
+// overhead. Small Cords (<= 15 bytes) are represented inline, but most small 
+// Cords are expected to grow over their lifetimes. 
+// 
+// Note that because a Cord is made up of separate chunked data, random access 
+// to character data within a Cord is slower than within a `TString`. 
+// 
+// Thread Safety 
+// 
 // Cord has the same thread-safety properties as many other types like
 // TString, std::vector<>, int, etc -- it is thread-compatible. In
-// particular, if threads do not call non-const methods, then it is safe to call
-// const methods without synchronization. Copying a Cord produces a new instance
-// that can be used concurrently with the original in arbitrary ways.
+// particular, if threads do not call non-const methods, then it is safe to call 
+// const methods without synchronization. Copying a Cord produces a new instance 
+// that can be used concurrently with the original in arbitrary ways. 
 
 #ifndef ABSL_STRINGS_CORD_H_
 #define ABSL_STRINGS_CORD_H_
@@ -65,10 +65,10 @@
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
-#include <iosfwd>
+#include <iosfwd> 
 #include <iterator>
 #include <util/generic/string.h>
-#include <type_traits>
+#include <type_traits> 
 
 #include "y_absl/base/config.h"
 #include "y_absl/base/internal/endian.h"
@@ -81,16 +81,16 @@
 #include "y_absl/strings/internal/cord_internal.h"
 #include "y_absl/strings/internal/cord_rep_btree.h"
 #include "y_absl/strings/internal/cord_rep_btree_reader.h"
-#include "y_absl/strings/internal/cord_rep_ring.h"
+#include "y_absl/strings/internal/cord_rep_ring.h" 
 #include "y_absl/strings/internal/cordz_functions.h"
 #include "y_absl/strings/internal/cordz_info.h"
 #include "y_absl/strings/internal/cordz_statistics.h"
 #include "y_absl/strings/internal/cordz_update_scope.h"
 #include "y_absl/strings/internal/cordz_update_tracker.h"
 #include "y_absl/strings/internal/resize_uninitialized.h"
-#include "y_absl/strings/internal/string_constant.h"
+#include "y_absl/strings/internal/string_constant.h" 
 #include "y_absl/strings/string_view.h"
-#include "y_absl/types/optional.h"
+#include "y_absl/types/optional.h" 
 
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
@@ -100,34 +100,34 @@ template <typename Releaser>
 Cord MakeCordFromExternal(y_absl::string_view, Releaser&&);
 void CopyCordToString(const Cord& src, TString* dst);
 
-// Cord
-//
-// A Cord is a sequence of characters, designed to be more efficient than a
-// `TString` in certain circumstances: namely, large string data that needs
-// to change over its lifetime or shared, especially when such data is shared
-// across API boundaries.
-//
-// A Cord stores its character data in a structure that allows efficient prepend
-// and append operations. This makes a Cord useful for large string data sent
-// over in a wire format that may need to be prepended or appended at some point
-// during the data exchange (e.g. HTTP, protocol buffers). For example, a
-// Cord is useful for storing an HTTP request, and prepending an HTTP header to
-// such a request.
-//
-// Cords should not be used for storing general string data, however. They
-// require overhead to construct and are slower than strings for random access.
-//
-// The Cord API provides the following common API operations:
-//
-// * Create or assign Cords out of existing string data, memory, or other Cords
-// * Append and prepend data to an existing Cord
-// * Create new Sub-Cords from existing Cord data
-// * Swap Cord data and compare Cord equality
-// * Write out Cord data by constructing a `TString`
-//
-// Additionally, the API provides iterator utilities to iterate through Cord
-// data via chunks or character bytes.
-//
+// Cord 
+// 
+// A Cord is a sequence of characters, designed to be more efficient than a 
+// `TString` in certain circumstances: namely, large string data that needs 
+// to change over its lifetime or shared, especially when such data is shared 
+// across API boundaries. 
+// 
+// A Cord stores its character data in a structure that allows efficient prepend 
+// and append operations. This makes a Cord useful for large string data sent 
+// over in a wire format that may need to be prepended or appended at some point 
+// during the data exchange (e.g. HTTP, protocol buffers). For example, a 
+// Cord is useful for storing an HTTP request, and prepending an HTTP header to 
+// such a request. 
+// 
+// Cords should not be used for storing general string data, however. They 
+// require overhead to construct and are slower than strings for random access. 
+// 
+// The Cord API provides the following common API operations: 
+// 
+// * Create or assign Cords out of existing string data, memory, or other Cords 
+// * Append and prepend data to an existing Cord 
+// * Create new Sub-Cords from existing Cord data 
+// * Swap Cord data and compare Cord equality 
+// * Write out Cord data by constructing a `TString` 
+// 
+// Additionally, the API provides iterator utilities to iterate through Cord 
+// data via chunks or character bytes. 
+// 
 class Cord {
  private:
   template <typename T>
@@ -135,54 +135,54 @@ class Cord {
       y_absl::enable_if_t<std::is_same<T, TString>::value, int>;
 
  public:
-  // Cord::Cord() Constructors.
+  // Cord::Cord() Constructors. 
 
-  // Creates an empty Cord.
+  // Creates an empty Cord. 
   constexpr Cord() noexcept;
 
-  // Creates a Cord from an existing Cord. Cord is copyable and efficiently
-  // movable. The moved-from state is valid but unspecified.
+  // Creates a Cord from an existing Cord. Cord is copyable and efficiently 
+  // movable. The moved-from state is valid but unspecified. 
   Cord(const Cord& src);
   Cord(Cord&& src) noexcept;
   Cord& operator=(const Cord& x);
   Cord& operator=(Cord&& x) noexcept;
 
-  // Creates a Cord from a `src` string. This constructor is marked explicit to
-  // prevent implicit Cord constructions from arguments convertible to an
-  // `y_absl::string_view`.
+  // Creates a Cord from a `src` string. This constructor is marked explicit to 
+  // prevent implicit Cord constructions from arguments convertible to an 
+  // `y_absl::string_view`. 
   explicit Cord(y_absl::string_view src);
   Cord& operator=(y_absl::string_view src);
 
-  // Creates a Cord from a `TString&&` rvalue. These constructors are
-  // templated to avoid ambiguities for types that are convertible to both
-  // `y_absl::string_view` and `TString`, such as `const char*`.
+  // Creates a Cord from a `TString&&` rvalue. These constructors are 
+  // templated to avoid ambiguities for types that are convertible to both 
+  // `y_absl::string_view` and `TString`, such as `const char*`. 
   template <typename T, EnableIfString<T> = 0>
-  explicit Cord(T&& src);
+  explicit Cord(T&& src); 
   template <typename T, EnableIfString<T> = 0>
   Cord& operator=(T&& src);
 
-  // Cord::~Cord()
-  //
-  // Destructs the Cord.
+  // Cord::~Cord() 
+  // 
+  // Destructs the Cord. 
   ~Cord() {
     if (contents_.is_tree()) DestroyCordSlow();
   }
 
-  // MakeCordFromExternal()
-  //
-  // Creates a Cord that takes ownership of external string memory. The
-  // contents of `data` are not copied to the Cord; instead, the external
-  // memory is added to the Cord and reference-counted. This data may not be
-  // changed for the life of the Cord, though it may be prepended or appended
-  // to.
-  //
-  // `MakeCordFromExternal()` takes a callable "releaser" that is invoked when
-  // the reference count for `data` reaches zero. As noted above, this data must
-  // remain live until the releaser is invoked. The callable releaser also must:
-  //
-  //   * be move constructible
-  //   * support `void operator()(y_absl::string_view) const` or `void operator()`
-  //
+  // MakeCordFromExternal() 
+  //
+  // Creates a Cord that takes ownership of external string memory. The 
+  // contents of `data` are not copied to the Cord; instead, the external 
+  // memory is added to the Cord and reference-counted. This data may not be 
+  // changed for the life of the Cord, though it may be prepended or appended 
+  // to. 
+  //
+  // `MakeCordFromExternal()` takes a callable "releaser" that is invoked when 
+  // the reference count for `data` reaches zero. As noted above, this data must 
+  // remain live until the releaser is invoked. The callable releaser also must: 
+  // 
+  //   * be move constructible 
+  //   * support `void operator()(y_absl::string_view) const` or `void operator()` 
+  // 
   // Example:
   //
   // Cord MakeCord(BlockPool* pool) {
@@ -190,13 +190,13 @@ class Cord {
   //   FillBlock(block);
   //   return y_absl::MakeCordFromExternal(
   //       block->ToStringView(),
-  //       [pool, block](y_absl::string_view v) {
-  //         pool->FreeBlock(block, v);
+  //       [pool, block](y_absl::string_view v) { 
+  //         pool->FreeBlock(block, v); 
   //       });
   // }
   //
-  // WARNING: Because a Cord can be reference-counted, it's likely a bug if your
-  // releaser doesn't do anything. For example, consider the following:
+  // WARNING: Because a Cord can be reference-counted, it's likely a bug if your 
+  // releaser doesn't do anything. For example, consider the following: 
   //
   // void Foo(const char* buffer, int len) {
   //   auto c = y_absl::MakeCordFromExternal(y_absl::string_view(buffer, len),
@@ -210,107 +210,107 @@ class Cord {
   template <typename Releaser>
   friend Cord MakeCordFromExternal(y_absl::string_view data, Releaser&& releaser);
 
-  // Cord::Clear()
-  //
-  // Releases the Cord data. Any nodes that share data with other Cords, if
-  // applicable, will have their reference counts reduced by 1.
+  // Cord::Clear() 
+  // 
+  // Releases the Cord data. Any nodes that share data with other Cords, if 
+  // applicable, will have their reference counts reduced by 1. 
   void Clear();
 
-  // Cord::Append()
-  //
-  // Appends data to the Cord, which may come from another Cord or other string
-  // data.
+  // Cord::Append() 
+  // 
+  // Appends data to the Cord, which may come from another Cord or other string 
+  // data. 
   void Append(const Cord& src);
   void Append(Cord&& src);
   void Append(y_absl::string_view src);
   template <typename T, EnableIfString<T> = 0>
   void Append(T&& src);
 
-  // Cord::Prepend()
-  //
-  // Prepends data to the Cord, which may come from another Cord or other string
-  // data.
+  // Cord::Prepend() 
+  // 
+  // Prepends data to the Cord, which may come from another Cord or other string 
+  // data. 
   void Prepend(const Cord& src);
   void Prepend(y_absl::string_view src);
   template <typename T, EnableIfString<T> = 0>
   void Prepend(T&& src);
 
-  // Cord::RemovePrefix()
-  //
-  // Removes the first `n` bytes of a Cord.
+  // Cord::RemovePrefix() 
+  // 
+  // Removes the first `n` bytes of a Cord. 
   void RemovePrefix(size_t n);
   void RemoveSuffix(size_t n);
 
-  // Cord::Subcord()
-  //
-  // Returns a new Cord representing the subrange [pos, pos + new_size) of
+  // Cord::Subcord() 
+  // 
+  // Returns a new Cord representing the subrange [pos, pos + new_size) of 
   // *this. If pos >= size(), the result is empty(). If
   // (pos + new_size) >= size(), the result is the subrange [pos, size()).
   Cord Subcord(size_t pos, size_t new_size) const;
 
-  // Cord::swap()
-  //
-  // Swaps the contents of the Cord with `other`.
-  void swap(Cord& other) noexcept;
+  // Cord::swap() 
+  // 
+  // Swaps the contents of the Cord with `other`. 
+  void swap(Cord& other) noexcept; 
 
-  // swap()
-  //
-  // Swaps the contents of two Cords.
+  // swap() 
+  // 
+  // Swaps the contents of two Cords. 
   friend void swap(Cord& x, Cord& y) noexcept { x.swap(y); }
 
-  // Cord::size()
-  //
-  // Returns the size of the Cord.
+  // Cord::size() 
+  // 
+  // Returns the size of the Cord. 
   size_t size() const;
-
-  // Cord::empty()
-  //
-  // Determines whether the given Cord is empty, returning `true` is so.
+ 
+  // Cord::empty() 
+  // 
+  // Determines whether the given Cord is empty, returning `true` is so. 
   bool empty() const;
 
-  // Cord::EstimatedMemoryUsage()
-  //
-  // Returns the *approximate* number of bytes held in full or in part by this
-  // Cord (which may not remain the same between invocations).  Note that Cords
-  // that share memory could each be "charged" independently for the same shared
-  // memory.
+  // Cord::EstimatedMemoryUsage() 
+  // 
+  // Returns the *approximate* number of bytes held in full or in part by this 
+  // Cord (which may not remain the same between invocations).  Note that Cords 
+  // that share memory could each be "charged" independently for the same shared 
+  // memory. 
   size_t EstimatedMemoryUsage() const;
 
-  // Cord::Compare()
-  //
-  // Compares 'this' Cord with rhs. This function and its relatives treat Cords
-  // as sequences of unsigned bytes. The comparison is a straightforward
-  // lexicographic comparison. `Cord::Compare()` returns values as follows:
-  //
+  // Cord::Compare() 
+  // 
+  // Compares 'this' Cord with rhs. This function and its relatives treat Cords 
+  // as sequences of unsigned bytes. The comparison is a straightforward 
+  // lexicographic comparison. `Cord::Compare()` returns values as follows: 
+  // 
   //   -1  'this' Cord is smaller
   //    0  two Cords are equal
   //    1  'this' Cord is larger
   int Compare(y_absl::string_view rhs) const;
   int Compare(const Cord& rhs) const;
 
-  // Cord::StartsWith()
-  //
-  // Determines whether the Cord starts with the passed string data `rhs`.
+  // Cord::StartsWith() 
+  // 
+  // Determines whether the Cord starts with the passed string data `rhs`. 
   bool StartsWith(const Cord& rhs) const;
   bool StartsWith(y_absl::string_view rhs) const;
-
-  // Cord::EndsWith()
-  //
-  // Determines whether the Cord ends with the passed string data `rhs`.
+ 
+  // Cord::EndsWith() 
+  // 
+  // Determines whether the Cord ends with the passed string data `rhs`. 
   bool EndsWith(y_absl::string_view rhs) const;
   bool EndsWith(const Cord& rhs) const;
 
-  // Cord::operator TString()
-  //
-  // Converts a Cord into a `TString()`. This operator is marked explicit to
-  // prevent unintended Cord usage in functions that take a string.
+  // Cord::operator TString() 
+  // 
+  // Converts a Cord into a `TString()`. This operator is marked explicit to 
+  // prevent unintended Cord usage in functions that take a string. 
   explicit operator TString() const;
 
-  // CopyCordToString()
+  // CopyCordToString() 
   //
-  // Copies the contents of a `src` Cord into a `*dst` string.
-  //
-  // This function optimizes the case of reusing the destination string since it
+  // Copies the contents of a `src` Cord into a `*dst` string. 
+  // 
+  // This function optimizes the case of reusing the destination string since it 
   // can reuse previously allocated capacity. However, this function does not
   // guarantee that pointers previously returned by `dst->data()` remain valid
   // even if `*dst` had enough capacity to hold `src`. If `*dst` is a new
@@ -319,32 +319,32 @@ class Cord {
 
   class CharIterator;
 
-  //----------------------------------------------------------------------------
-  // Cord::ChunkIterator
-  //----------------------------------------------------------------------------
-  //
-  // A `Cord::ChunkIterator` allows iteration over the constituent chunks of its
-  // Cord. Such iteration allows you to perform non-const operatons on the data
-  // of a Cord without modifying it.
-  //
-  // Generally, you do not instantiate a `Cord::ChunkIterator` directly;
-  // instead, you create one implicitly through use of the `Cord::Chunks()`
-  // member function.
-  //
-  // The `Cord::ChunkIterator` has the following properties:
-  //
-  //   * The iterator is invalidated after any non-const operation on the
-  //     Cord object over which it iterates.
+  //---------------------------------------------------------------------------- 
+  // Cord::ChunkIterator 
+  //---------------------------------------------------------------------------- 
+  //
+  // A `Cord::ChunkIterator` allows iteration over the constituent chunks of its 
+  // Cord. Such iteration allows you to perform non-const operatons on the data 
+  // of a Cord without modifying it. 
+  // 
+  // Generally, you do not instantiate a `Cord::ChunkIterator` directly; 
+  // instead, you create one implicitly through use of the `Cord::Chunks()` 
+  // member function. 
+  // 
+  // The `Cord::ChunkIterator` has the following properties: 
+  // 
+  //   * The iterator is invalidated after any non-const operation on the 
+  //     Cord object over which it iterates. 
   //   * The `string_view` returned by dereferencing a valid, non-`end()`
   //     iterator is guaranteed to be non-empty.
-  //   * Two `ChunkIterator` objects can be compared equal if and only if they
-  //     remain valid and iterate over the same Cord.
-  //   * The iterator in this case is a proxy iterator; the `string_view`
-  //     returned by the iterator does not live inside the Cord, and its
-  //     lifetime is limited to the lifetime of the iterator itself. To help
-  //     prevent lifetime issues, `ChunkIterator::reference` is not a true
-  //     reference type and is equivalent to `value_type`.
-  //   * The iterator keeps state that can grow for Cords that contain many
+  //   * Two `ChunkIterator` objects can be compared equal if and only if they 
+  //     remain valid and iterate over the same Cord. 
+  //   * The iterator in this case is a proxy iterator; the `string_view` 
+  //     returned by the iterator does not live inside the Cord, and its 
+  //     lifetime is limited to the lifetime of the iterator itself. To help 
+  //     prevent lifetime issues, `ChunkIterator::reference` is not a true 
+  //     reference type and is equivalent to `value_type`. 
+  //   * The iterator keeps state that can grow for Cords that contain many 
   //     nodes and are imbalanced due to sharing. Prefer to pass this type by
   //     const reference instead of by value.
   class ChunkIterator {
@@ -368,38 +368,38 @@ class Cord {
     friend class CharIterator;
 
    private:
-    using CordRep = y_absl::cord_internal::CordRep;
+    using CordRep = y_absl::cord_internal::CordRep; 
     using CordRepBtree = y_absl::cord_internal::CordRepBtree;
     using CordRepBtreeReader = y_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 = y_absl::InlinedVector<y_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 = y_absl::InlinedVector<y_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,21 +413,21 @@ class Cord {
     y_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()
-  //
+  // Cord::ChunkIterator::chunk_begin() 
+  // 
   // Returns an iterator to the first chunk of the `Cord`.
   //
-  // Generally, prefer using `Cord::Chunks()` within a range-based for loop for
-  // iterating over the chunks of a Cord. This method may be useful for getting
-  // a `ChunkIterator` where range-based for-loops are not useful.
+  // Generally, prefer using `Cord::Chunks()` within a range-based for loop for 
+  // iterating over the chunks of a Cord. This method may be useful for getting 
+  // a `ChunkIterator` where range-based for-loops are not useful. 
   //
   // Example:
   //
@@ -436,28 +436,28 @@ class Cord {
   //     return std::find(c.chunk_begin(), c.chunk_end(), s);
   //   }
   ChunkIterator chunk_begin() const;
-
-  // Cord::ChunkItertator::chunk_end()
-  //
+ 
+  // Cord::ChunkItertator::chunk_end() 
+  // 
   // Returns an iterator one increment past the last chunk of the `Cord`.
-  //
-  // Generally, prefer using `Cord::Chunks()` within a range-based for loop for
-  // iterating over the chunks of a Cord. This method may be useful for getting
-  // a `ChunkIterator` where range-based for-loops may not be available.
+  // 
+  // Generally, prefer using `Cord::Chunks()` within a range-based for loop for 
+  // iterating over the chunks of a Cord. This method may be useful for getting 
+  // a `ChunkIterator` where range-based for-loops may not be available. 
   ChunkIterator chunk_end() const;
 
-  //----------------------------------------------------------------------------
-  // Cord::ChunkIterator::ChunkRange
-  //----------------------------------------------------------------------------
-  //
-  // `ChunkRange` is a helper class for iterating over the chunks of the `Cord`,
-  // producing an iterator which can be used within a range-based for loop.
-  // Construction of a `ChunkRange` will return an iterator pointing to the
-  // first chunk of the Cord. Generally, do not construct a `ChunkRange`
-  // directly; instead, prefer to use the `Cord::Chunks()` method.
-  //
-  // Implementation note: `ChunkRange` is simply a convenience wrapper over
-  // `Cord::chunk_begin()` and `Cord::chunk_end()`.
+  //---------------------------------------------------------------------------- 
+  // Cord::ChunkIterator::ChunkRange 
+  //---------------------------------------------------------------------------- 
+  //
+  // `ChunkRange` is a helper class for iterating over the chunks of the `Cord`, 
+  // producing an iterator which can be used within a range-based for loop. 
+  // Construction of a `ChunkRange` will return an iterator pointing to the 
+  // first chunk of the Cord. Generally, do not construct a `ChunkRange` 
+  // directly; instead, prefer to use the `Cord::Chunks()` method. 
+  // 
+  // Implementation note: `ChunkRange` is simply a convenience wrapper over 
+  // `Cord::chunk_begin()` and `Cord::chunk_end()`. 
   class ChunkRange {
    public:
     // Fulfill minimum c++ container requirements [container.requirements]
@@ -479,12 +479,12 @@ class Cord {
     const Cord* cord_;
   };
 
-  // Cord::Chunks()
-  //
-  // Returns a `Cord::ChunkIterator::ChunkRange` for iterating over the chunks
-  // of a `Cord` with a range-based for-loop. For most iteration tasks on a
-  // Cord, use `Cord::Chunks()` to retrieve this iterator.
+  // Cord::Chunks() 
   //
+  // Returns a `Cord::ChunkIterator::ChunkRange` for iterating over the chunks 
+  // of a `Cord` with a range-based for-loop. For most iteration tasks on a 
+  // Cord, use `Cord::Chunks()` to retrieve this iterator. 
+  // 
   // Example:
   //
   //   void ProcessChunks(const Cord& cord) {
@@ -500,30 +500,30 @@ class Cord {
   //   }
   ChunkRange Chunks() const;
 
-  //----------------------------------------------------------------------------
-  // Cord::CharIterator
-  //----------------------------------------------------------------------------
-  //
-  // A `Cord::CharIterator` allows iteration over the constituent characters of
-  // a `Cord`.
-  //
-  // Generally, you do not instantiate a `Cord::CharIterator` directly; instead,
-  // you create one implicitly through use of the `Cord::Chars()` member
-  // function.
-  //
-  // A `Cord::CharIterator` has the following properties:
-  //
-  //   * The iterator is invalidated after any non-const operation on the
-  //     Cord object over which it iterates.
-  //   * Two `CharIterator` objects can be compared equal if and only if they
-  //     remain valid and iterate over the same Cord.
-  //   * The iterator keeps state that can grow for Cords that contain many
+  //---------------------------------------------------------------------------- 
+  // Cord::CharIterator 
+  //---------------------------------------------------------------------------- 
+  //
+  // A `Cord::CharIterator` allows iteration over the constituent characters of 
+  // a `Cord`. 
+  // 
+  // Generally, you do not instantiate a `Cord::CharIterator` directly; instead, 
+  // you create one implicitly through use of the `Cord::Chars()` member 
+  // function. 
+  // 
+  // A `Cord::CharIterator` has the following properties: 
+  // 
+  //   * The iterator is invalidated after any non-const operation on the 
+  //     Cord object over which it iterates. 
+  //   * Two `CharIterator` objects can be compared equal if and only if they 
+  //     remain valid and iterate over the same Cord. 
+  //   * The iterator keeps state that can grow for Cords that contain many 
   //     nodes and are imbalanced due to sharing. Prefer to pass this type by
   //     const reference instead of by value.
-  //   * This type cannot act as a forward iterator because a `Cord` can reuse
-  //     sections of memory. This fact violates the requirement for forward
-  //     iterators to compare equal if dereferencing them returns the same
-  //     object.
+  //   * This type cannot act as a forward iterator because a `Cord` can reuse 
+  //     sections of memory. This fact violates the requirement for forward 
+  //     iterators to compare equal if dereferencing them returns the same 
+  //     object. 
   class CharIterator {
    public:
     using iterator_category = std::input_iterator_tag;
@@ -549,56 +549,56 @@ class Cord {
     ChunkIterator chunk_iterator_;
   };
 
-  // Cord::CharIterator::AdvanceAndRead()
+  // Cord::CharIterator::AdvanceAndRead() 
   //
-  // Advances the `Cord::CharIterator` by `n_bytes` and returns the bytes
-  // advanced as a separate `Cord`. `n_bytes` must be less than or equal to the
-  // number of bytes within the Cord; otherwise, behavior is undefined. It is
-  // valid to pass `char_end()` and `0`.
+  // Advances the `Cord::CharIterator` by `n_bytes` and returns the bytes 
+  // advanced as a separate `Cord`. `n_bytes` must be less than or equal to the 
+  // number of bytes within the Cord; otherwise, behavior is undefined. It is 
+  // valid to pass `char_end()` and `0`. 
   static Cord AdvanceAndRead(CharIterator* it, size_t n_bytes);
 
-  // Cord::CharIterator::Advance()
+  // Cord::CharIterator::Advance() 
   //
-  // Advances the `Cord::CharIterator` by `n_bytes`. `n_bytes` must be less than
-  // or equal to the number of bytes remaining within the Cord; otherwise,
-  // behavior is undefined. It is valid to pass `char_end()` and `0`.
+  // Advances the `Cord::CharIterator` by `n_bytes`. `n_bytes` must be less than 
+  // or equal to the number of bytes remaining within the Cord; otherwise, 
+  // behavior is undefined. It is valid to pass `char_end()` and `0`. 
   static void Advance(CharIterator* it, size_t n_bytes);
 
-  // Cord::CharIterator::ChunkRemaining()
-  //
+  // Cord::CharIterator::ChunkRemaining() 
+  // 
   // Returns the longest contiguous view starting at the iterator's position.
   //
   // `it` must be dereferenceable.
   static y_absl::string_view ChunkRemaining(const CharIterator& it);
 
-  // Cord::CharIterator::char_begin()
-  //
+  // Cord::CharIterator::char_begin() 
+  // 
   // Returns an iterator to the first character of the `Cord`.
-  //
-  // Generally, prefer using `Cord::Chars()` within a range-based for loop for
-  // iterating over the chunks of a Cord. This method may be useful for getting
-  // a `CharIterator` where range-based for-loops may not be available.
+  // 
+  // Generally, prefer using `Cord::Chars()` within a range-based for loop for 
+  // iterating over the chunks of a Cord. This method may be useful for getting 
+  // a `CharIterator` where range-based for-loops may not be available. 
   CharIterator char_begin() const;
-
-  // Cord::CharIterator::char_end()
-  //
+ 
+  // Cord::CharIterator::char_end() 
+  // 
   // Returns an iterator to one past the last character of the `Cord`.
-  //
-  // Generally, prefer using `Cord::Chars()` within a range-based for loop for
-  // iterating over the chunks of a Cord. This method may be useful for getting
-  // a `CharIterator` where range-based for-loops are not useful.
+  // 
+  // Generally, prefer using `Cord::Chars()` within a range-based for loop for 
+  // iterating over the chunks of a Cord. This method may be useful for getting 
+  // a `CharIterator` where range-based for-loops are not useful. 
   CharIterator char_end() const;
 
-  // Cord::CharIterator::CharRange
-  //
-  // `CharRange` is a helper class for iterating over the characters of a
-  // producing an iterator which can be used within a range-based for loop.
-  // Construction of a `CharRange` will return an iterator pointing to the first
-  // character of the Cord. Generally, do not construct a `CharRange` directly;
-  // instead, prefer to use the `Cord::Chars()` method show below.
+  // Cord::CharIterator::CharRange 
   //
-  // Implementation note: `CharRange` is simply a convenience wrapper over
-  // `Cord::char_begin()` and `Cord::char_end()`.
+  // `CharRange` is a helper class for iterating over the characters of a 
+  // producing an iterator which can be used within a range-based for loop. 
+  // Construction of a `CharRange` will return an iterator pointing to the first 
+  // character of the Cord. Generally, do not construct a `CharRange` directly; 
+  // instead, prefer to use the `Cord::Chars()` method show below. 
+  // 
+  // Implementation note: `CharRange` is simply a convenience wrapper over 
+  // `Cord::char_begin()` and `Cord::char_end()`. 
   class CharRange {
    public:
     // Fulfill minimum c++ container requirements [container.requirements]
@@ -620,12 +620,12 @@ class Cord {
     const Cord* cord_;
   };
 
-  // Cord::CharIterator::Chars()
-  //
-  // Returns a `Cord::CharIterator` for iterating over the characters of a
-  // `Cord` with a range-based for-loop. For most character-based iteration
-  // tasks on a Cord, use `Cord::Chars()` to retrieve this iterator.
+  // Cord::CharIterator::Chars() 
   //
+  // Returns a `Cord::CharIterator` for iterating over the characters of a 
+  // `Cord` with a range-based for-loop. For most character-based iteration 
+  // tasks on a Cord, use `Cord::Chars()` to retrieve this iterator. 
+  // 
   // Example:
   //
   //   void ProcessCord(const Cord& cord) {
@@ -641,53 +641,53 @@ class Cord {
   //   }
   CharRange Chars() const;
 
-  // Cord::operator[]
-  //
-  // Gets the "i"th character of the Cord and returns it, provided that
-  // 0 <= i < Cord.size().
-  //
-  // NOTE: This routine is reasonably efficient. It is roughly
-  // logarithmic based on the number of chunks that make up the cord. Still,
+  // Cord::operator[] 
+  // 
+  // Gets the "i"th character of the Cord and returns it, provided that 
+  // 0 <= i < Cord.size(). 
+  // 
+  // NOTE: This routine is reasonably efficient. It is roughly 
+  // logarithmic based on the number of chunks that make up the cord. Still, 
   // if you need to iterate over the contents of a cord, you should
-  // use a CharIterator/ChunkIterator rather than call operator[] or Get()
-  // repeatedly in a loop.
+  // use a CharIterator/ChunkIterator rather than call operator[] or Get() 
+  // repeatedly in a loop. 
   char operator[](size_t i) const;
 
-  // Cord::TryFlat()
-  //
-  // If this cord's representation is a single flat array, returns a
-  // string_view referencing that array.  Otherwise returns nullopt.
-  y_absl::optional<y_absl::string_view> TryFlat() const;
-
-  // Cord::Flatten()
-  //
+  // Cord::TryFlat() 
+  // 
+  // If this cord's representation is a single flat array, returns a 
+  // string_view referencing that array.  Otherwise returns nullopt. 
+  y_absl::optional<y_absl::string_view> TryFlat() const; 
+ 
+  // Cord::Flatten() 
+  // 
   // Flattens the cord into a single array and returns a view of the data.
   //
   // If the cord was already flat, the contents are not modified.
   y_absl::string_view Flatten();
 
-  // Supports y_absl::Cord as a sink object for y_absl::Format().
-  friend void AbslFormatFlush(y_absl::Cord* cord, y_absl::string_view part) {
-    cord->Append(part);
-  }
-
-  template <typename H>
-  friend H AbslHashValue(H hash_state, const y_absl::Cord& c) {
-    y_absl::optional<y_absl::string_view> maybe_flat = c.TryFlat();
-    if (maybe_flat.has_value()) {
-      return H::combine(std::move(hash_state), *maybe_flat);
-    }
-    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 y_absl::strings_internal::MakeStringConstant, which is
-  // also an internal API.
-  template <typename T>
-  explicit constexpr Cord(strings_internal::StringConstant<T>);
-
+  // Supports y_absl::Cord as a sink object for y_absl::Format(). 
+  friend void AbslFormatFlush(y_absl::Cord* cord, y_absl::string_view part) { 
+    cord->Append(part); 
+  } 
+ 
+  template <typename H> 
+  friend H AbslHashValue(H hash_state, const y_absl::Cord& c) { 
+    y_absl::optional<y_absl::string_view> maybe_flat = c.TryFlat(); 
+    if (maybe_flat.has_value()) { 
+      return H::combine(std::move(hash_state), *maybe_flat); 
+    } 
+    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 y_absl::strings_internal::MakeStringConstant, which is 
+  // also an internal API. 
+  template <typename T> 
+  explicit constexpr Cord(strings_internal::StringConstant<T>); 
+ 
  private:
   using CordRep = y_absl::cord_internal::CordRep;
   using CordRepFlat = y_absl::cord_internal::CordRepFlat;
@@ -707,7 +707,7 @@ class Cord {
 
   friend const CordzInfo* GetCordzInfoForTesting(const Cord& cord);
 
-  // Calls the provided function once for each cord chunk, in order.  Unlike
+  // Calls the provided function once for each cord chunk, in order.  Unlike 
   // Chunks(), this API will not allocate memory.
   void ForEachChunk(y_absl::FunctionRef<void(y_absl::string_view)>) const;
 
@@ -719,21 +719,21 @@ class Cord {
   // class so that we can isolate the bulk of cord.cc from changes
   // to the representation.
   //
-  // InlineRep holds either a tree pointer, or an array of kMaxInline bytes.
+  // InlineRep holds either a tree pointer, or an array of kMaxInline bytes. 
   class InlineRep {
    public:
-    static constexpr unsigned char kMaxInline = cord_internal::kMaxInline;
+    static constexpr unsigned char kMaxInline = cord_internal::kMaxInline; 
     static_assert(kMaxInline >= sizeof(y_absl::cord_internal::CordRep*), "");
 
-    constexpr InlineRep() : data_() {}
+    constexpr InlineRep() : data_() {} 
     explicit InlineRep(InlineData::DefaultInitType init) : data_(init) {}
     InlineRep(const InlineRep& src);
     InlineRep(InlineRep&& src);
     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,10 +743,10 @@ class Cord {
     char* set_data(size_t n);          // Write data to the result
     // Returns nullptr if holding bytes
     y_absl::cord_internal::CordRep* tree() const;
-    y_absl::cord_internal::CordRep* as_tree() const;
+    y_absl::cord_internal::CordRep* as_tree() const; 
     // Returns non-null iff was holding a pointer
     y_absl::cord_internal::CordRep* clear();
-    // Converts to pointer if necessary.
+    // Converts to pointer if necessary. 
     void reduce_size(size_t n);    // REQUIRES: holding data
     void remove_prefix(size_t n);  // REQUIRES: holding data
     void AppendArray(y_absl::string_view src, MethodIdentifier method);
@@ -795,16 +795,16 @@ class Cord {
     void GetAppendRegion(char** region, size_t* size, size_t length);
 
     bool IsSame(const InlineRep& other) const {
-      return memcmp(&data_, &other.data_, sizeof(data_)) == 0;
+      return memcmp(&data_, &other.data_, sizeof(data_)) == 0; 
     }
     int BitwiseCompare(const InlineRep& other) const {
       uint64_t x, y;
-      // Use memcpy to avoid aliasing issues.
-      memcpy(&x, &data_, sizeof(x));
-      memcpy(&y, &other.data_, sizeof(y));
+      // Use memcpy to avoid aliasing issues. 
+      memcpy(&x, &data_, sizeof(x)); 
+      memcpy(&y, &other.data_, sizeof(y)); 
       if (x == y) {
-        memcpy(&x, reinterpret_cast<const char*>(&data_) + 8, sizeof(x));
-        memcpy(&y, reinterpret_cast<const char*>(&other.data_) + 8, sizeof(y));
+        memcpy(&x, reinterpret_cast<const char*>(&data_) + 8, sizeof(x)); 
+        memcpy(&y, reinterpret_cast<const char*>(&other.data_) + 8, sizeof(y)); 
         if (x == y) return 0;
       }
       return y_absl::big_endian::FromHost64(x) < y_absl::big_endian::FromHost64(y)
@@ -813,38 +813,38 @@ class Cord {
     }
     void CopyTo(TString* dst) const {
       // memcpy is much faster when operating on a known size. On most supported
-      // platforms, the small string optimization is large enough that resizing
+      // platforms, the small string optimization is large enough that resizing 
       // to 15 bytes does not cause a memory allocation.
       y_absl::strings_internal::STLStringResizeUninitialized(dst,
                                                            sizeof(data_) - 1);
-      memcpy(&(*dst)[0], &data_, sizeof(data_) - 1);
+      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.
-    y_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. 
+    y_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;
 
@@ -852,23 +852,23 @@ class Cord {
     // Unrefs the tree and stops profiling.
     void UnrefTree();
 
-    void ResetToEmpty() { data_ = {}; }
-
-    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_;
+    void ResetToEmpty() { data_ = {}; } 
+ 
+    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_; 
   };
   InlineRep contents_;
 
-  // Helper for MemoryUsage().
+  // Helper for MemoryUsage(). 
   static size_t MemoryUsageAux(const y_absl::cord_internal::CordRep* rep);
 
-  // Helper for GetFlat() and TryFlat().
+  // Helper for GetFlat() and TryFlat(). 
   static bool GetFlatAux(y_absl::cord_internal::CordRep* rep,
                          y_absl::string_view* fragment);
 
-  // Helper for ForEachChunk().
+  // Helper for ForEachChunk(). 
   static void ForEachChunkAux(
       y_absl::cord_internal::CordRep* rep,
       y_absl::FunctionRef<void(y_absl::string_view)> callback);
@@ -897,10 +897,10 @@ class Cord {
   y_absl::cord_internal::CordRep* TakeRep() const&;
   y_absl::cord_internal::CordRep* TakeRep() &&;
 
-  // Helper for Append().
+  // Helper for Append(). 
   template <typename C>
   void AppendImpl(C&& src);
-
+ 
   // Prepends the provided data to this instance. `method` contains the public
   // API method for this action which is tracked for Cordz sampling purposes.
   void PrependArray(y_absl::string_view src, MethodIdentifier method);
@@ -909,16 +909,16 @@ class Cord {
   // Requires src.length() > kMaxBytesToCopy.
   Cord& AssignLargeString(TString&& src);
 
-  // Helper for AbslHashValue().
-  template <typename H>
-  H HashFragmented(H hash_state) const {
-    typename H::AbslInternalPiecewiseCombiner combiner;
-    ForEachChunk([&combiner, &hash_state](y_absl::string_view chunk) {
-      hash_state = combiner.add_buffer(std::move(hash_state), chunk.data(),
-                                       chunk.size());
-    });
-    return H::combine(combiner.finalize(std::move(hash_state)), size());
-  }
+  // Helper for AbslHashValue(). 
+  template <typename H> 
+  H HashFragmented(H hash_state) const { 
+    typename H::AbslInternalPiecewiseCombiner combiner; 
+    ForEachChunk([&combiner, &hash_state](y_absl::string_view chunk) { 
+      hash_state = combiner.add_buffer(std::move(hash_state), chunk.data(), 
+                                       chunk.size()); 
+    }); 
+    return H::combine(combiner.finalize(std::move(hash_state)), size()); 
+  } 
 };
 
 ABSL_NAMESPACE_END
@@ -975,9 +975,9 @@ inline void SmallMemmove(char* dst, const char* src, size_t n,
   }
 }
 
-// Does non-template-specific `CordRepExternal` initialization.
+// Does non-template-specific `CordRepExternal` initialization. 
 // Expects `data` to be non-empty.
-void InitializeCordRepExternal(y_absl::string_view data, CordRepExternal* rep);
+void InitializeCordRepExternal(y_absl::string_view data, CordRepExternal* rep); 
 
 // Creates a new `CordRep` that owns `data` and `releaser` and returns a pointer
 // to it, or `nullptr` if `data` was empty.
@@ -987,15 +987,15 @@ CordRep* NewExternalRep(y_absl::string_view data, Releaser&& releaser) {
   using ReleaserType = y_absl::decay_t<Releaser>;
   if (data.empty()) {
     // Never create empty external nodes.
-    InvokeReleaser(Rank0{}, ReleaserType(std::forward<Releaser>(releaser)),
-                   data);
+    InvokeReleaser(Rank0{}, ReleaserType(std::forward<Releaser>(releaser)), 
+                   data); 
     return nullptr;
   }
 
-  CordRepExternal* rep = new CordRepExternalImpl<ReleaserType>(
-      std::forward<Releaser>(releaser), 0);
-  InitializeCordRepExternal(data, rep);
-  return rep;
+  CordRepExternal* rep = new CordRepExternalImpl<ReleaserType>( 
+      std::forward<Releaser>(releaser), 0); 
+  InitializeCordRepExternal(data, rep); 
+  return rep; 
 }
 
 // Overload for function reference types that dispatches using a function
@@ -1019,21 +1019,21 @@ Cord MakeCordFromExternal(y_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_) {
-  src.ResetToEmpty();
+  src.ResetToEmpty(); 
 }
 
 inline Cord::InlineRep& Cord::InlineRep::operator=(const Cord::InlineRep& src) {
@@ -1041,7 +1041,7 @@ inline Cord::InlineRep& Cord::InlineRep::operator=(const Cord::InlineRep& src) {
     return *this;
   }
   if (!is_tree() && !src.is_tree()) {
-    data_ = src.data_;
+    data_ = src.data_; 
     return *this;
   }
   AssignSlow(src);
@@ -1053,8 +1053,8 @@ inline Cord::InlineRep& Cord::InlineRep::operator=(
   if (is_tree()) {
     UnrefTree();
   }
-  data_ = src.data_;
-  src.ResetToEmpty();
+  data_ = src.data_; 
+  src.ResetToEmpty(); 
   return *this;
 }
 
@@ -1062,30 +1062,30 @@ inline void Cord::InlineRep::Swap(Cord::InlineRep* rhs) {
   if (rhs == this) {
     return;
   }
-  std::swap(data_, rhs->data_);
+  std::swap(data_, rhs->data_); 
 }
 
 inline const char* Cord::InlineRep::data() const {
-  return is_tree() ? nullptr : data_.as_chars();
-}
-
-inline y_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 y_absl::cord_internal::CordRep* Cord::InlineRep::as_tree() const { 
+  assert(data_.is_tree()); 
+  return data_.as_tree(); 
+} 
+ 
 inline y_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(
@@ -1144,16 +1144,16 @@ inline y_absl::cord_internal::CordRep* Cord::InlineRep::clear() {
   if (is_tree()) {
     CordzInfo::MaybeUntrackCord(cordz_info());
   }
-  y_absl::cord_internal::CordRep* result = tree();
-  ResetToEmpty();
+  y_absl::cord_internal::CordRep* result = tree(); 
+  ResetToEmpty(); 
   return result;
 }
 
 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(y_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,20 +1185,20 @@ 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 {
-  contents_.Swap(&other.contents_);
-}
-
+inline void Cord::swap(Cord& other) noexcept { 
+  contents_.Swap(&other.contents_); 
+} 
+ 
 inline Cord& Cord::operator=(Cord&& x) noexcept {
   contents_ = std::move(x.contents_);
   return *this;
 }
 
-extern template Cord::Cord(TString&& src);
+extern template Cord::Cord(TString&& src); 
 
 inline size_t Cord::size() const {
   // Length is 1st field in str.rep_
@@ -1215,18 +1215,18 @@ inline size_t Cord::EstimatedMemoryUsage() const {
   return result;
 }
 
-inline y_absl::optional<y_absl::string_view> Cord::TryFlat() const {
-  y_absl::cord_internal::CordRep* rep = contents_.tree();
-  if (rep == nullptr) {
-    return y_absl::string_view(contents_.data(), contents_.size());
-  }
-  y_absl::string_view fragment;
-  if (GetFlatAux(rep, &fragment)) {
-    return fragment;
-  }
-  return y_absl::nullopt;
-}
-
+inline y_absl::optional<y_absl::string_view> Cord::TryFlat() const { 
+  y_absl::cord_internal::CordRep* rep = contents_.tree(); 
+  if (rep == nullptr) { 
+    return y_absl::string_view(contents_.data(), contents_.size()); 
+  } 
+  y_absl::string_view fragment; 
+  if (GetFlatAux(rep, &fragment)) { 
+    return fragment; 
+  } 
+  return y_absl::nullopt; 
+} 
+ 
 inline y_absl::string_view Cord::Flatten() {
   y_absl::cord_internal::CordRep* rep = contents_.tree();
   if (rep == nullptr) {
@@ -1248,8 +1248,8 @@ inline void Cord::Prepend(y_absl::string_view src) {
   PrependArray(src, CordzUpdateTracker::kPrependString);
 }
 
-extern template void Cord::Append(TString&& src);
-extern template void Cord::Prepend(TString&& src);
+extern template void Cord::Append(TString&& src); 
+extern template void Cord::Prepend(TString&& src); 
 
 inline int Cord::Compare(const Cord& rhs) const {
   if (!contents_.is_tree() && !rhs.contents_.is_tree()) {
@@ -1273,64 +1273,64 @@ inline bool Cord::StartsWith(y_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_ =
-        y_absl::string_view(cord->contents_.data(), bytes_remaining_);
+    current_chunk_ = 
+        y_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++();
@@ -1346,12 +1346,12 @@ inline bool Cord::ChunkIterator::operator!=(const ChunkIterator& other) const {
 }
 
 inline Cord::ChunkIterator::reference Cord::ChunkIterator::operator*() const {
-  ABSL_HARDENING_ASSERT(bytes_remaining_ != 0);
+  ABSL_HARDENING_ASSERT(bytes_remaining_ != 0); 
   return current_chunk_;
 }
 
 inline Cord::ChunkIterator::pointer Cord::ChunkIterator::operator->() const {
-  ABSL_HARDENING_ASSERT(bytes_remaining_ != 0);
+  ABSL_HARDENING_ASSERT(bytes_remaining_ != 0); 
   return &current_chunk_;
 }
 
@@ -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-tstring/y_absl/strings/cord/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/cord/ya.make
index 8f3ec1f20f..eae61fde3f 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/cord/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/cord/ya.make
@@ -1,30 +1,30 @@
-# Generated by devtools/yamaker.
-
-LIBRARY()
-
-WITHOUT_LICENSE_TEXTS()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
-
-LICENSE(Apache-2.0)
-
-PEERDIR(
-    contrib/restricted/abseil-cpp-tstring/y_absl/base
+# Generated by devtools/yamaker. 
+ 
+LIBRARY() 
+ 
+WITHOUT_LICENSE_TEXTS() 
+ 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
+LICENSE(Apache-2.0) 
+ 
+PEERDIR( 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base 
     contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity 
     contrib/restricted/abseil-cpp-tstring/y_absl/debugging
     contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace
     contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize
     contrib/restricted/abseil-cpp-tstring/y_absl/demangle
-    contrib/restricted/abseil-cpp-tstring/y_absl/numeric
+    contrib/restricted/abseil-cpp-tstring/y_absl/numeric 
     contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/exponential_biased
-    contrib/restricted/abseil-cpp-tstring/y_absl/strings
+    contrib/restricted/abseil-cpp-tstring/y_absl/strings 
     contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_cord_internal
     contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_strings_internal
     contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_functions
@@ -35,24 +35,24 @@ PEERDIR(
     contrib/restricted/abseil-cpp-tstring/y_absl/time
     contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time
     contrib/restricted/abseil-cpp-tstring/y_absl/time/time_zone
-    contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access
-    contrib/restricted/abseil-cpp-tstring/y_absl/algorithm
-    contrib/restricted/abseil-cpp-tstring/y_absl/container
-    contrib/restricted/abseil-cpp-tstring/y_absl/functional
-    contrib/restricted/abseil-cpp-tstring/y_absl/types
-    contrib/restricted/abseil-cpp-tstring/y_absl/utility
-)
-
-ADDINCL(
-    GLOBAL contrib/restricted/abseil-cpp-tstring
-)
-
-NO_COMPILER_WARNINGS()
-
-SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/strings)
-
-SRCS(
-    cord.cc
-)
-
-END()
+    contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access 
+    contrib/restricted/abseil-cpp-tstring/y_absl/algorithm 
+    contrib/restricted/abseil-cpp-tstring/y_absl/container 
+    contrib/restricted/abseil-cpp-tstring/y_absl/functional 
+    contrib/restricted/abseil-cpp-tstring/y_absl/types 
+    contrib/restricted/abseil-cpp-tstring/y_absl/utility 
+) 
+ 
+ADDINCL( 
+    GLOBAL contrib/restricted/abseil-cpp-tstring 
+) 
+ 
+NO_COMPILER_WARNINGS() 
+ 
+SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/strings) 
+ 
+SRCS( 
+    cord.cc 
+) 
+ 
+END() 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/escaping.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/escaping.cc
index 8c82740608..b347786a02 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/escaping.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/escaping.cc
@@ -137,7 +137,7 @@ bool CUnescapeInternal(y_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(y_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(y_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(y_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;
           }
@@ -450,7 +450,7 @@ bool Base64UnescapeInternal(const char* src_param, size_t szsrc, char* dest,
 
   // The GET_INPUT macro gets the next input character, skipping
   // over any whitespace, and stopping when we reach the end of the
-  // string or when we read any non-data character.  The arguments are
+  // string or when we read any non-data character.  The arguments are 
   // an arbitrary identifier (used as a label for goto) and the number
   // of data bytes that must remain in the input to avoid aborting the
   // loop.
@@ -473,18 +473,18 @@ bool Base64UnescapeInternal(const char* src_param, size_t szsrc, char* dest,
   if (dest) {
     // This loop consumes 4 input bytes and produces 3 output bytes
     // per iteration.  We can't know at the start that there is enough
-    // data left in the string for a full iteration, so the loop may
+    // data left in the string for a full iteration, so the loop may 
     // break out in the middle; if so 'state' will be set to the
     // number of input bytes read.
 
     while (szsrc >= 4) {
       // We'll start by optimistically assuming that the next four
-      // bytes of the string (src[0..3]) are four good data bytes
+      // bytes of the string (src[0..3]) are four good data bytes 
       // (that is, no nulls, whitespace, padding chars, or illegal
       // chars).  We need to test src[0..2] for nulls individually
       // before constructing temp to preserve the property that we
-      // never read past a null in the string (no matter how long
-      // szsrc claims the string is).
+      // never read past a null in the string (no matter how long 
+      // szsrc claims the string is). 
 
       if (!src[0] || !src[1] || !src[2] ||
           ((temp = ((unsigned(unbase64[src[0]]) << 18) |
@@ -509,7 +509,7 @@ bool Base64UnescapeInternal(const char* src_param, size_t szsrc, char* dest,
         temp = (temp << 6) | decode;
       } else {
         // We really did have four good data bytes, so advance four
-        // characters in the string.
+        // characters in the string. 
 
         szsrc -= 4;
         src += 4;
@@ -644,7 +644,7 @@ bool Base64UnescapeInternal(const char* src_param, size_t szsrc, char* dest,
                    state);
   }
 
-  // The remainder of the string should be all whitespace, mixed with
+  // The remainder of the string should be all whitespace, mixed with 
   // exactly 0 equals signs, or exactly 'expected_equals' equals
   // signs.  (Always accepting 0 equals signs is an Abseil extension
   // not covered in the RFC, as is accepting dot as the pad character.)
@@ -771,7 +771,7 @@ constexpr char kWebSafeBase64Chars[] =
 template <typename String>
 bool Base64UnescapeInternal(const char* src, size_t slen, String* dest,
                             const signed char* unbase64) {
-  // Determine the size of the output string.  Base64 encodes every 3 bytes into
+  // Determine the size of the output string.  Base64 encodes every 3 bytes into 
   // 4 characters.  any leftover chars are added directly for good measure.
   // This is documented in the base64 RFC: http://tools.ietf.org/html/rfc3548
   const size_t dest_len = 3 * (slen / 4) + (slen % 4);
@@ -779,7 +779,7 @@ bool Base64UnescapeInternal(const char* src, size_t slen, String* dest,
   strings_internal::STLStringResizeUninitialized(dest, dest_len);
 
   // We are getting the destination buffer by getting the beginning of the
-  // string and converting it into a char *.
+  // string and converting it into a char *. 
   size_t len;
   const bool ok =
       Base64UnescapeInternal(src, slen, &(*dest)[0], dest_len, unbase64, &len);
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_cord_internal/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_cord_internal/ya.make
index 42b7b6cd5e..5b0a4c0695 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_cord_internal/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_cord_internal/ya.make
@@ -1,42 +1,42 @@
-# Generated by devtools/yamaker.
-
-LIBRARY()
-
-WITHOUT_LICENSE_TEXTS()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
-
-LICENSE(Apache-2.0)
-
-PEERDIR(
-    contrib/restricted/abseil-cpp-tstring/y_absl/base
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity
-    contrib/restricted/abseil-cpp-tstring/y_absl/numeric
-    contrib/restricted/abseil-cpp-tstring/y_absl/strings
+# Generated by devtools/yamaker. 
+ 
+LIBRARY() 
+ 
+WITHOUT_LICENSE_TEXTS() 
+ 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
+LICENSE(Apache-2.0) 
+ 
+PEERDIR( 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity 
+    contrib/restricted/abseil-cpp-tstring/y_absl/numeric 
+    contrib/restricted/abseil-cpp-tstring/y_absl/strings 
     contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_strings_internal
-)
-
-ADDINCL(
-    GLOBAL contrib/restricted/abseil-cpp-tstring
-)
-
-NO_COMPILER_WARNINGS()
-
+) 
+ 
+ADDINCL( 
+    GLOBAL contrib/restricted/abseil-cpp-tstring 
+) 
+ 
+NO_COMPILER_WARNINGS() 
+ 
 SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal)
-
-SRCS(
+ 
+SRCS( 
     cord_internal.cc
     cord_rep_btree.cc
     cord_rep_btree_navigator.cc
     cord_rep_btree_reader.cc
     cord_rep_consume.cc
     cord_rep_ring.cc
-)
-
-END()
+) 
+ 
+END() 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_strings_internal/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_strings_internal/ya.make
index 4e57fc75f6..f1c30b2590 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_strings_internal/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_strings_internal/ya.make
@@ -4,17 +4,17 @@ LIBRARY()
 
 WITHOUT_LICENSE_TEXTS()
 
-OWNER(
-    somov
-    g:cpp-contrib
-)
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
 
 LICENSE(Apache-2.0)
 
 PEERDIR(
-    contrib/restricted/abseil-cpp-tstring/y_absl/base
+    contrib/restricted/abseil-cpp-tstring/y_absl/base 
     contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait 
     contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity
 )
 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/char_map.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/char_map.h
index 25428e304c..873125a571 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/char_map.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/char_map.h
@@ -72,7 +72,7 @@ class Charmap {
                    CharMaskForWord(x, 2), CharMaskForWord(x, 3));
   }
 
-  // Containing all the chars in the C-string 's'.
+  // Containing all the chars in the C-string 's'. 
   // Note that this is expensively recursive because of the C++11 constexpr
   // formulation. Use only in constexpr initializers.
   static constexpr Charmap FromString(const char* s) {
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.cc
index 72a4fa188b..2b6742a64e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.cc
@@ -208,7 +208,7 @@ int BigUnsigned<max_words>::ReadDigits(const char* begin, const char* end,
     ++dropped_digits;
   }
   if (begin < end && *std::prev(end) == '.') {
-    // If the string ends in '.', either before or after dropping zeroes, then
+    // If the string ends in '.', either before or after dropping zeroes, then 
     // drop the decimal point and look for more digits to drop.
     dropped_digits = 0;
     --end;
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.h
index a77aab14dd..75df41a2e1 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.h
@@ -66,7 +66,7 @@ class BigUnsigned {
                static_cast<uint32_t>(v >> 32)} {}
 
   // Constructs a BigUnsigned from the given string_view containing a decimal
-  // value.  If the input string is not a decimal integer, constructs a 0
+  // value.  If the input string is not a decimal integer, constructs a 0 
   // instead.
   explicit BigUnsigned(y_absl::string_view sv) : size_(0), words_{} {
     // Check for valid input, returning a 0 otherwise.  This is reasonable
@@ -210,7 +210,7 @@ class BigUnsigned {
     return words_[index];
   }
 
-  // Returns this integer as a decimal string.  This is not used in the decimal-
+  // Returns this integer as a decimal string.  This is not used in the decimal- 
   // to-binary conversion; it is intended to aid in testing.
   TString ToString() const;
 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_parse.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_parse.cc
index f0f78eb68c..cf92a22d56 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_parse.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_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
@@ -302,7 +302,7 @@ bool ParseInfinityOrNan(const char* begin, const char* end,
   switch (*begin) {
     case 'i':
     case 'I': {
-      // An infinity string consists of the characters "inf" or "infinity",
+      // An infinity string consists of the characters "inf" or "infinity", 
       // case insensitive.
       if (strings_internal::memcasecmp(begin + 1, "nf", 2) != 0) {
         return false;
@@ -326,7 +326,7 @@ bool ParseInfinityOrNan(const char* begin, const char* end,
       }
       out->type = strings_internal::FloatType::kNan;
       out->end = begin + 3;
-      // NaN is allowed to be followed by a parenthesized string, consisting of
+      // NaN is allowed to be followed by a parenthesized string, consisting of 
       // only the characters [a-zA-Z0-9_].  Match that if it's present.
       begin += 3;
       if (begin < end && *begin == '(') {
@@ -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-tstring/y_absl/strings/internal/cord_internal.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_internal.cc
index 6fc39985d8..d32e638883 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_internal.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_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 "y_absl/strings/internal/cord_internal.h"
-
-#include <atomic>
-#include <cassert>
-#include <memory>
-
-#include "y_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 "y_absl/strings/internal/cord_internal.h" 
+ 
+#include <atomic> 
+#include <cassert> 
+#include <memory> 
+ 
+#include "y_absl/container/inlined_vector.h" 
 #include "y_absl/strings/internal/cord_rep_btree.h"
-#include "y_absl/strings/internal/cord_rep_flat.h"
-#include "y_absl/strings/internal/cord_rep_ring.h"
-
-namespace y_absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
+#include "y_absl/strings/internal/cord_rep_flat.h" 
+#include "y_absl/strings/internal/cord_rep_ring.h" 
+ 
+namespace y_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);
-
-  y_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); 
+ 
+  y_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 y_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 y_absl 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_internal.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_internal.h
index 82f5ac7b81..02b215f61f 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_internal.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_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,11 +21,11 @@
 #include <cstdint>
 #include <type_traits>
 
-#include "y_absl/base/config.h"
-#include "y_absl/base/internal/endian.h"
-#include "y_absl/base/internal/invoke.h"
-#include "y_absl/base/optimization.h"
-#include "y_absl/container/internal/compressed_tuple.h"
+#include "y_absl/base/config.h" 
+#include "y_absl/base/internal/endian.h" 
+#include "y_absl/base/internal/invoke.h" 
+#include "y_absl/base/optimization.h" 
+#include "y_absl/container/internal/compressed_tuple.h" 
 #include "y_absl/meta/type_traits.h"
 #include "y_absl/strings/string_view.h"
 
@@ -33,19 +33,19 @@ namespace y_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 y_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 y_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,30 +189,30 @@ 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,
+// Various representations that we allow 
+enum CordRepKind { 
+  CONCAT = 0, 
   SUBSTRING = 1,
   BTREE = 2,
-  RING = 3,
+  RING = 3, 
   EXTERNAL = 4,
-
-  // We have different tags for different sized flat arrays,
+ 
+  // 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
-};
-
+}; 
+ 
 // There are various locations where we want to check if some rep is a 'plain'
 // data edge, i.e. an external or flat rep. By having FLAT == EXTERNAL + 1, we
 // can perform this check in a single branch as 'tag >= EXTERNAL'
@@ -225,13 +225,13 @@ 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;
+  size_t length; 
   RefcountAndFlags refcount;
   // If tag < FLAT, it represents CordRepKind and indicates the type of node.
   // Otherwise, the node type is CordRepFlat and the tag is the encoded size.
@@ -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 {
@@ -296,151 +296,151 @@ struct CordRepSubstring : public CordRep {
   CordRep* child;
 };
 
-// Type for function pointer that will invoke the releaser function and also
-// delete the `CordRepExternalImpl` corresponding to the passed in
-// `CordRepExternal`.
-using ExternalReleaserInvoker = void (*)(CordRepExternal*);
+// Type for function pointer that will invoke the releaser function and also 
+// delete the `CordRepExternalImpl` corresponding to the passed in 
+// `CordRepExternal`. 
+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(y_absl::string_view str)
+struct CordRepExternal : public CordRep { 
+  CordRepExternal() = default; 
+  explicit constexpr CordRepExternal(y_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 {};
-struct Rank0 : Rank1 {};
-
-template <typename Releaser, typename = ::y_absl::base_internal::invoke_result_t<
-                                 Releaser, y_absl::string_view>>
-void InvokeReleaser(Rank0, Releaser&& releaser, y_absl::string_view data) {
-  ::y_absl::base_internal::invoke(std::forward<Releaser>(releaser), data);
-}
-
-template <typename Releaser,
-          typename = ::y_absl::base_internal::invoke_result_t<Releaser>>
-void InvokeReleaser(Rank1, Releaser&& releaser, y_absl::string_view) {
-  ::y_absl::base_internal::invoke(std::forward<Releaser>(releaser));
-}
-
-// We use CompressedTuple so that we can benefit from EBCO.
-template <typename Releaser>
-struct CordRepExternalImpl
-    : public CordRepExternal,
-      public ::y_absl::container_internal::CompressedTuple<Releaser> {
-  // The extra int arg is so that we can avoid interfering with copy/move
-  // constructors while still benefitting from perfect forwarding.
-  template <typename T>
-  CordRepExternalImpl(T&& releaser, int)
-      : CordRepExternalImpl::CompressedTuple(std::forward<T>(releaser)) {
-    this->releaser_invoker = &Release;
-  }
-
-  ~CordRepExternalImpl() {
-    InvokeReleaser(Rank0{}, std::move(this->template get<0>()),
-                   y_absl::string_view(base, length));
-  }
-
-  static void Release(CordRepExternal* rep) {
-    delete static_cast<CordRepExternalImpl*>(rep);
-  }
-};
-
-inline void CordRepExternal::Delete(CordRep* rep) {
+struct Rank1 {}; 
+struct Rank0 : Rank1 {}; 
+
+template <typename Releaser, typename = ::y_absl::base_internal::invoke_result_t< 
+                                 Releaser, y_absl::string_view>> 
+void InvokeReleaser(Rank0, Releaser&& releaser, y_absl::string_view data) { 
+  ::y_absl::base_internal::invoke(std::forward<Releaser>(releaser), data); 
+} 
+ 
+template <typename Releaser, 
+          typename = ::y_absl::base_internal::invoke_result_t<Releaser>> 
+void InvokeReleaser(Rank1, Releaser&& releaser, y_absl::string_view) { 
+  ::y_absl::base_internal::invoke(std::forward<Releaser>(releaser)); 
+} 
+ 
+// We use CompressedTuple so that we can benefit from EBCO. 
+template <typename Releaser> 
+struct CordRepExternalImpl 
+    : public CordRepExternal, 
+      public ::y_absl::container_internal::CompressedTuple<Releaser> { 
+  // The extra int arg is so that we can avoid interfering with copy/move 
+  // constructors while still benefitting from perfect forwarding. 
+  template <typename T> 
+  CordRepExternalImpl(T&& releaser, int) 
+      : CordRepExternalImpl::CompressedTuple(std::forward<T>(releaser)) { 
+    this->releaser_invoker = &Release; 
+  } 
+ 
+  ~CordRepExternalImpl() { 
+    InvokeReleaser(Rank0{}, std::move(this->template get<0>()), 
+                   y_absl::string_view(base, length)); 
+  } 
+ 
+  static void Release(CordRepExternal* rep) { 
+    delete static_cast<CordRepExternalImpl*>(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);
-
-enum {
-  kMaxInline = 15,
-};
-
-constexpr char GetOrNull(y_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:
+  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(y_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(y_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(y_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>(y_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 = y_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(y_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 {
-      y_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>(y_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 = y_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(y_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 { 
+      y_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_;
-  };
-};
-
-static_assert(sizeof(InlineData) == kMaxInline + 1, "");
-
-inline CordRepConcat* CordRep::concat() {
+    char as_chars_[kMaxInline + 1]; 
+    AsTree as_tree_; 
+  }; 
+}; 
+ 
+static_assert(sizeof(InlineData) == kMaxInline + 1, ""); 
+ 
+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 y_absl
 #endif  // ABSL_STRINGS_INTERNAL_CORD_INTERNAL_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_flat.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_flat.h
index 976613031c..5557022553 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_flat.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_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 "y_absl/strings/internal/cord_internal.h"
-
-namespace y_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 "y_absl/strings/internal/cord_internal.h" 
+ 
+namespace y_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 y_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 y_absl 
+ 
+#endif  // ABSL_STRINGS_INTERNAL_CORD_REP_FLAT_H_ 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_ring.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_ring.cc
index 06c7e75bd8..97dff05363 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_ring.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_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 "y_absl/strings/internal/cord_rep_ring.h"
-
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <iostream>
-#include <limits>
-#include <memory>
-#include <util/generic/string.h>
-
-#include "y_absl/base/internal/raw_logging.h"
-#include "y_absl/base/internal/throw_delegate.h"
-#include "y_absl/base/macros.h"
-#include "y_absl/container/inlined_vector.h"
-#include "y_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 "y_absl/strings/internal/cord_rep_ring.h" 
+ 
+#include <cassert> 
+#include <cstddef> 
+#include <cstdint> 
+#include <iostream> 
+#include <limits> 
+#include <memory> 
+#include <util/generic/string.h> 
+ 
+#include "y_absl/base/internal/raw_logging.h" 
+#include "y_absl/base/internal/throw_delegate.h" 
+#include "y_absl/base/macros.h" 
+#include "y_absl/container/inlined_vector.h" 
+#include "y_absl/strings/internal/cord_internal.h" 
 #include "y_absl/strings/internal/cord_rep_consume.h"
-#include "y_absl/strings/internal/cord_rep_flat.h"
-
-namespace y_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 "y_absl/strings/internal/cord_rep_flat.h" 
+ 
+namespace y_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, y_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, y_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, y_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, y_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 y_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 y_absl 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_ring.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_ring.h
index 5f9784d8da..a6a4890ab4 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_ring.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_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 "y_absl/container/internal/layout.h"
-#include "y_absl/strings/internal/cord_internal.h"
-#include "y_absl/strings/internal/cord_rep_flat.h"
-
-namespace y_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 "y_absl/container/internal/layout.h" 
+#include "y_absl/strings/internal/cord_internal.h" 
+#include "y_absl/strings/internal/cord_rep_flat.h" 
+ 
+namespace y_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, y_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`
-  y_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` 
+  y_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 y_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 y_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(y_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 y_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 y_absl 
+ 
+#endif  // ABSL_STRINGS_INTERNAL_CORD_REP_RING_H_ 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_ring_reader.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_ring_reader.h
index 3f64d04fae..98ea8c170a 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_ring_reader.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_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 "y_absl/strings/internal/cord_internal.h"
-#include "y_absl/strings/internal/cord_rep_ring.h"
-#include "y_absl/strings/string_view.h"
-
-namespace y_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 "y_absl/strings/internal/cord_internal.h" 
+#include "y_absl/strings/internal/cord_rep_ring.h" 
+#include "y_absl/strings/string_view.h" 
+ 
+namespace y_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.
-  y_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.
-  y_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()`
-  y_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 y_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. 
+  y_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. 
+  y_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()` 
+  y_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 y_absl 
+ 
+#endif  // ABSL_STRINGS_INTERNAL_CORD_REP_RING_READER_H_ 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_functions/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_functions/ya.make
index 06e99346da..d2522532e2 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_functions/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_functions/ya.make
@@ -2,13 +2,13 @@
 
 LIBRARY()
 
-WITHOUT_LICENSE_TEXTS()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
+WITHOUT_LICENSE_TEXTS() 
 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
 LICENSE(Apache-2.0)
 
 PEERDIR(
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_handle/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_handle/ya.make
index e181217139..0220a75bd1 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_handle/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_handle/ya.make
@@ -1,47 +1,47 @@
-# Generated by devtools/yamaker.
-
-LIBRARY()
-
-WITHOUT_LICENSE_TEXTS()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
-
-LICENSE(Apache-2.0)
-
-PEERDIR(
-    contrib/restricted/abseil-cpp-tstring/y_absl/base
+# Generated by devtools/yamaker. 
+ 
+LIBRARY() 
+ 
+WITHOUT_LICENSE_TEXTS() 
+ 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
+LICENSE(Apache-2.0) 
+ 
+PEERDIR( 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base 
     contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity 
     contrib/restricted/abseil-cpp-tstring/y_absl/debugging
     contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace
     contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize
     contrib/restricted/abseil-cpp-tstring/y_absl/demangle
-    contrib/restricted/abseil-cpp-tstring/y_absl/numeric
-    contrib/restricted/abseil-cpp-tstring/y_absl/strings
+    contrib/restricted/abseil-cpp-tstring/y_absl/numeric 
+    contrib/restricted/abseil-cpp-tstring/y_absl/strings 
     contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_strings_internal
     contrib/restricted/abseil-cpp-tstring/y_absl/synchronization
     contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal
     contrib/restricted/abseil-cpp-tstring/y_absl/time
     contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time
     contrib/restricted/abseil-cpp-tstring/y_absl/time/time_zone
-)
-
-ADDINCL(
-    GLOBAL contrib/restricted/abseil-cpp-tstring
-)
-
-NO_COMPILER_WARNINGS()
-
+) 
+ 
+ADDINCL( 
+    GLOBAL contrib/restricted/abseil-cpp-tstring 
+) 
+ 
+NO_COMPILER_WARNINGS() 
+ 
 SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal)
-
-SRCS(
+ 
+SRCS( 
     cordz_handle.cc
-)
-
-END()
+) 
+ 
+END() 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_info/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_info/ya.make
index 930eaa8b05..4d749dc50b 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_info/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_info/ya.make
@@ -1,30 +1,30 @@
-# Generated by devtools/yamaker.
-
-LIBRARY()
-
-WITHOUT_LICENSE_TEXTS()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
-
-LICENSE(Apache-2.0)
-
-PEERDIR(
-    contrib/restricted/abseil-cpp-tstring/y_absl/base
+# Generated by devtools/yamaker. 
+ 
+LIBRARY() 
+ 
+WITHOUT_LICENSE_TEXTS() 
+ 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
+LICENSE(Apache-2.0) 
+ 
+PEERDIR( 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base 
     contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity 
     contrib/restricted/abseil-cpp-tstring/y_absl/debugging
     contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace
     contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize
     contrib/restricted/abseil-cpp-tstring/y_absl/demangle
-    contrib/restricted/abseil-cpp-tstring/y_absl/numeric
+    contrib/restricted/abseil-cpp-tstring/y_absl/numeric 
     contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/exponential_biased
-    contrib/restricted/abseil-cpp-tstring/y_absl/strings
+    contrib/restricted/abseil-cpp-tstring/y_absl/strings 
     contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_cord_internal
     contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_strings_internal
     contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_functions
@@ -34,18 +34,18 @@ PEERDIR(
     contrib/restricted/abseil-cpp-tstring/y_absl/time
     contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time
     contrib/restricted/abseil-cpp-tstring/y_absl/time/time_zone
-)
-
-ADDINCL(
-    GLOBAL contrib/restricted/abseil-cpp-tstring
-)
-
-NO_COMPILER_WARNINGS()
-
+) 
+ 
+ADDINCL( 
+    GLOBAL contrib/restricted/abseil-cpp-tstring 
+) 
+ 
+NO_COMPILER_WARNINGS() 
+ 
 SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal)
-
-SRCS(
+ 
+SRCS( 
     cordz_info.cc
-)
-
-END()
+) 
+ 
+END() 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/numbers_test_common.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/numbers_test_common.h
index 12aec3ac11..022633ac82 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/numbers_test_common.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/numbers_test_common.h
@@ -170,7 +170,7 @@ inline const std::array<uint64_test_case, 34>& strtouint64_test_cases() {
 
       {"0x1234", true, 16, 0x1234},
 
-      // Base-10 string version.
+      // Base-10 string version. 
       {"1234", true, 0, 1234},
       {nullptr, false, 0, 0},
   }};
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/.yandex_meta/licenses.list.txt b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/.yandex_meta/licenses.list.txt
index 33d60b3d2b..95cff783b8 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/.yandex_meta/licenses.list.txt
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/.yandex_meta/licenses.list.txt
@@ -1,20 +1,20 @@
-====================Apache-2.0====================
-// 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====================
-// Copyright 2017 The Abseil Authors.
-
-
-====================COPYRIGHT====================
-// Copyright 2020 The Abseil Authors.
+====================Apache-2.0==================== 
+// 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==================== 
+// Copyright 2017 The Abseil Authors. 
+ 
+ 
+====================COPYRIGHT==================== 
+// Copyright 2020 The Abseil Authors. 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.cc
index 8d5c3b61ac..dbd80e7052 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.cc
@@ -1,18 +1,18 @@
-// 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. 
+ 
+// 
 // POSIX spec:
 //   http://pubs.opengroup.org/onlinepubs/009695399/functions/fprintf.html
 //
@@ -26,7 +26,7 @@
 
 #include "y_absl/base/port.h"
 #include "y_absl/strings/internal/str_format/float_conversion.h"
-#include "y_absl/strings/numbers.h"
+#include "y_absl/strings/numbers.h" 
 
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
@@ -61,179 +61,179 @@ struct IsSigned<y_absl::int128> : std::true_type {};
 template <>
 struct IsSigned<y_absl::uint128> : std::false_type {};
 
-// Integral digit printer.
-// Call one of the PrintAs* routines after construction once.
-// Use with_neg_and_zero/without_neg_or_zero/is_negative to access the results.
-class IntDigits {
+// Integral digit printer. 
+// Call one of the PrintAs* routines after construction once. 
+// Use with_neg_and_zero/without_neg_or_zero/is_negative to access the results. 
+class IntDigits { 
  public:
-  // Print the unsigned integer as octal.
-  // Supports unsigned integral types and uint128.
+  // Print the unsigned integer as octal. 
+  // Supports unsigned integral types and uint128. 
   template <typename T>
-  void PrintAsOct(T v) {
-    static_assert(!IsSigned<T>::value, "");
-    char *p = storage_ + sizeof(storage_);
-    do {
-      *--p = static_cast<char>('0' + (static_cast<size_t>(v) & 7));
-      v >>= 3;
-    } while (v);
-    start_ = p;
-    size_ = storage_ + sizeof(storage_) - p;
-  }
-
-  // Print the signed or unsigned integer as decimal.
-  // Supports all integral types.
-  template <typename T>
-  void PrintAsDec(T v) {
-    static_assert(std::is_integral<T>::value, "");
-    start_ = storage_;
-    size_ = numbers_internal::FastIntToBuffer(v, storage_) - storage_;
-  }
-
-  void PrintAsDec(int128 v) {
-    auto u = static_cast<uint128>(v);
-    bool add_neg = false;
-    if (v < 0) {
-      add_neg = true;
-      u = uint128{} - u;
+  void PrintAsOct(T v) { 
+    static_assert(!IsSigned<T>::value, ""); 
+    char *p = storage_ + sizeof(storage_); 
+    do { 
+      *--p = static_cast<char>('0' + (static_cast<size_t>(v) & 7)); 
+      v >>= 3; 
+    } while (v); 
+    start_ = p; 
+    size_ = storage_ + sizeof(storage_) - p; 
+  } 
+ 
+  // Print the signed or unsigned integer as decimal. 
+  // Supports all integral types. 
+  template <typename T> 
+  void PrintAsDec(T v) { 
+    static_assert(std::is_integral<T>::value, ""); 
+    start_ = storage_; 
+    size_ = numbers_internal::FastIntToBuffer(v, storage_) - storage_; 
+  } 
+ 
+  void PrintAsDec(int128 v) { 
+    auto u = static_cast<uint128>(v); 
+    bool add_neg = false; 
+    if (v < 0) { 
+      add_neg = true; 
+      u = uint128{} - u; 
     }
-    PrintAsDec(u, add_neg);
+    PrintAsDec(u, add_neg); 
   }
 
-  void PrintAsDec(uint128 v, bool add_neg = false) {
-    // This function can be sped up if needed. We can call FastIntToBuffer
-    // twice, or fix FastIntToBuffer to support uint128.
-    char *p = storage_ + sizeof(storage_);
-    do {
-      p -= 2;
-      numbers_internal::PutTwoDigits(static_cast<size_t>(v % 100), p);
-      v /= 100;
-    } while (v);
-    if (p[0] == '0') {
-      // We printed one too many hexits.
-      ++p;
-    }
-    if (add_neg) {
-      *--p = '-';
-    }
-    size_ = storage_ + sizeof(storage_) - p;
-    start_ = p;
+  void PrintAsDec(uint128 v, bool add_neg = false) { 
+    // This function can be sped up if needed. We can call FastIntToBuffer 
+    // twice, or fix FastIntToBuffer to support uint128. 
+    char *p = storage_ + sizeof(storage_); 
+    do { 
+      p -= 2; 
+      numbers_internal::PutTwoDigits(static_cast<size_t>(v % 100), p); 
+      v /= 100; 
+    } while (v); 
+    if (p[0] == '0') { 
+      // We printed one too many hexits. 
+      ++p; 
+    } 
+    if (add_neg) { 
+      *--p = '-'; 
+    } 
+    size_ = storage_ + sizeof(storage_) - p; 
+    start_ = p; 
   }
 
-  // Print the unsigned integer as hex using lowercase.
-  // Supports unsigned integral types and uint128.
+  // Print the unsigned integer as hex using lowercase. 
+  // Supports unsigned integral types and uint128. 
   template <typename T>
-  void PrintAsHexLower(T v) {
-    static_assert(!IsSigned<T>::value, "");
-    char *p = storage_ + sizeof(storage_);
-
-    do {
-      p -= 2;
-      constexpr const char* table = numbers_internal::kHexTable;
-      std::memcpy(p, table + 2 * (static_cast<size_t>(v) & 0xFF), 2);
-      if (sizeof(T) == 1) break;
-      v >>= 8;
-    } while (v);
-    if (p[0] == '0') {
-      // We printed one too many digits.
-      ++p;
+  void PrintAsHexLower(T v) { 
+    static_assert(!IsSigned<T>::value, ""); 
+    char *p = storage_ + sizeof(storage_); 
+ 
+    do { 
+      p -= 2; 
+      constexpr const char* table = numbers_internal::kHexTable; 
+      std::memcpy(p, table + 2 * (static_cast<size_t>(v) & 0xFF), 2); 
+      if (sizeof(T) == 1) break; 
+      v >>= 8; 
+    } while (v); 
+    if (p[0] == '0') { 
+      // We printed one too many digits. 
+      ++p; 
     }
-    start_ = p;
-    size_ = storage_ + sizeof(storage_) - p;
-  }
+    start_ = p; 
+    size_ = storage_ + sizeof(storage_) - p; 
+  } 
 
-  // Print the unsigned integer as hex using uppercase.
-  // Supports unsigned integral types and uint128.
+  // Print the unsigned integer as hex using uppercase. 
+  // Supports unsigned integral types and uint128. 
   template <typename T>
-  void PrintAsHexUpper(T v) {
-    static_assert(!IsSigned<T>::value, "");
-    char *p = storage_ + sizeof(storage_);
-
-    // kHexTable is only lowercase, so do it manually for uppercase.
-    do {
-      *--p = "0123456789ABCDEF"[static_cast<size_t>(v) & 15];
-      v >>= 4;
-    } while (v);
-    start_ = p;
-    size_ = storage_ + sizeof(storage_) - p;
+  void PrintAsHexUpper(T v) { 
+    static_assert(!IsSigned<T>::value, ""); 
+    char *p = storage_ + sizeof(storage_); 
+ 
+    // kHexTable is only lowercase, so do it manually for uppercase. 
+    do { 
+      *--p = "0123456789ABCDEF"[static_cast<size_t>(v) & 15]; 
+      v >>= 4; 
+    } while (v); 
+    start_ = p; 
+    size_ = storage_ + sizeof(storage_) - p; 
   }
 
-  // The printed value including the '-' sign if available.
-  // For inputs of value `0`, this will return "0"
-  string_view with_neg_and_zero() const { return {start_, size_}; }
-
-  // The printed value not including the '-' sign.
-  // For inputs of value `0`, this will return "".
-  string_view without_neg_or_zero() const {
-    static_assert('-' < '0', "The check below verifies both.");
-    size_t advance = start_[0] <= '0' ? 1 : 0;
-    return {start_ + advance, size_ - advance};
+  // The printed value including the '-' sign if available. 
+  // For inputs of value `0`, this will return "0" 
+  string_view with_neg_and_zero() const { return {start_, size_}; } 
+ 
+  // The printed value not including the '-' sign. 
+  // For inputs of value `0`, this will return "". 
+  string_view without_neg_or_zero() const { 
+    static_assert('-' < '0', "The check below verifies both."); 
+    size_t advance = start_[0] <= '0' ? 1 : 0; 
+    return {start_ + advance, size_ - advance}; 
   }
 
-  bool is_negative() const { return start_[0] == '-'; }
+  bool is_negative() const { return start_[0] == '-'; } 
 
- private:
-  const char *start_;
-  size_t size_;
-  // Max size: 128 bit value as octal -> 43 digits, plus sign char
-  char storage_[128 / 3 + 1 + 1];
+ private: 
+  const char *start_; 
+  size_t size_; 
+  // Max size: 128 bit value as octal -> 43 digits, plus sign char 
+  char storage_[128 / 3 + 1 + 1]; 
 };
 
 // Note: 'o' conversions do not have a base indicator, it's just that
 // the '#' flag is specified to modify the precision for 'o' conversions.
-string_view BaseIndicator(const IntDigits &as_digits,
-                          const FormatConversionSpecImpl conv) {
-  // always show 0x for %p.
-  bool alt = conv.has_alt_flag() ||
-             conv.conversion_char() == FormatConversionCharInternal::p;
-  bool hex = (conv.conversion_char() == FormatConversionCharInternal::x ||
-              conv.conversion_char() == FormatConversionCharInternal::X ||
-              conv.conversion_char() == FormatConversionCharInternal::p);
+string_view BaseIndicator(const IntDigits &as_digits, 
+                          const FormatConversionSpecImpl conv) { 
+  // always show 0x for %p. 
+  bool alt = conv.has_alt_flag() || 
+             conv.conversion_char() == FormatConversionCharInternal::p; 
+  bool hex = (conv.conversion_char() == FormatConversionCharInternal::x || 
+              conv.conversion_char() == FormatConversionCharInternal::X || 
+              conv.conversion_char() == FormatConversionCharInternal::p); 
   // From the POSIX description of '#' flag:
   //   "For x or X conversion specifiers, a non-zero result shall have
   //   0x (or 0X) prefixed to it."
-  if (alt && hex && !as_digits.without_neg_or_zero().empty()) {
-    return conv.conversion_char() == FormatConversionCharInternal::X ? "0X"
-                                                                     : "0x";
+  if (alt && hex && !as_digits.without_neg_or_zero().empty()) { 
+    return conv.conversion_char() == FormatConversionCharInternal::X ? "0X" 
+                                                                     : "0x"; 
   }
   return {};
 }
 
-string_view SignColumn(bool neg, const FormatConversionSpecImpl conv) {
-  if (conv.conversion_char() == FormatConversionCharInternal::d ||
-      conv.conversion_char() == FormatConversionCharInternal::i) {
+string_view SignColumn(bool neg, const FormatConversionSpecImpl conv) { 
+  if (conv.conversion_char() == FormatConversionCharInternal::d || 
+      conv.conversion_char() == FormatConversionCharInternal::i) { 
     if (neg) return "-";
-    if (conv.has_show_pos_flag()) return "+";
-    if (conv.has_sign_col_flag()) return " ";
+    if (conv.has_show_pos_flag()) return "+"; 
+    if (conv.has_sign_col_flag()) return " "; 
   }
   return {};
 }
 
-bool ConvertCharImpl(unsigned char v, const FormatConversionSpecImpl conv,
+bool ConvertCharImpl(unsigned char v, const FormatConversionSpecImpl conv, 
                      FormatSinkImpl *sink) {
   size_t fill = 0;
   if (conv.width() >= 0) fill = conv.width();
   ReducePadding(1, &fill);
-  if (!conv.has_left_flag()) sink->Append(fill, ' ');
+  if (!conv.has_left_flag()) sink->Append(fill, ' '); 
   sink->Append(1, v);
-  if (conv.has_left_flag()) sink->Append(fill, ' ');
+  if (conv.has_left_flag()) sink->Append(fill, ' '); 
   return true;
 }
 
-bool ConvertIntImplInnerSlow(const IntDigits &as_digits,
-                             const FormatConversionSpecImpl conv,
-                             FormatSinkImpl *sink) {
+bool ConvertIntImplInnerSlow(const IntDigits &as_digits, 
+                             const FormatConversionSpecImpl conv, 
+                             FormatSinkImpl *sink) { 
   // Print as a sequence of Substrings:
   //   [left_spaces][sign][base_indicator][zeroes][formatted][right_spaces]
   size_t fill = 0;
   if (conv.width() >= 0) fill = conv.width();
 
-  string_view formatted = as_digits.without_neg_or_zero();
+  string_view formatted = as_digits.without_neg_or_zero(); 
   ReducePadding(formatted, &fill);
 
-  string_view sign = SignColumn(as_digits.is_negative(), conv);
+  string_view sign = SignColumn(as_digits.is_negative(), conv); 
   ReducePadding(sign, &fill);
 
-  string_view base_indicator = BaseIndicator(as_digits, conv);
+  string_view base_indicator = BaseIndicator(as_digits, conv); 
   ReducePadding(base_indicator, &fill);
 
   int precision = conv.precision();
@@ -241,8 +241,8 @@ bool ConvertIntImplInnerSlow(const IntDigits &as_digits,
   if (!precision_specified)
     precision = 1;
 
-  if (conv.has_alt_flag() &&
-      conv.conversion_char() == FormatConversionCharInternal::o) {
+  if (conv.has_alt_flag() && 
+      conv.conversion_char() == FormatConversionCharInternal::o) { 
     // From POSIX description of the '#' (alt) flag:
     //   "For o conversion, it increases the precision (if necessary) to
     //   force the first digit of the result to be zero."
@@ -255,13 +255,13 @@ bool ConvertIntImplInnerSlow(const IntDigits &as_digits,
   size_t num_zeroes = Excess(formatted.size(), precision);
   ReducePadding(num_zeroes, &fill);
 
-  size_t num_left_spaces = !conv.has_left_flag() ? fill : 0;
-  size_t num_right_spaces = conv.has_left_flag() ? fill : 0;
+  size_t num_left_spaces = !conv.has_left_flag() ? fill : 0; 
+  size_t num_right_spaces = conv.has_left_flag() ? fill : 0; 
 
   // From POSIX description of the '0' (zero) flag:
   //   "For d, i, o, u, x, and X conversion specifiers, if a precision
   //   is specified, the '0' flag is ignored."
-  if (!precision_specified && conv.has_zero_flag()) {
+  if (!precision_specified && conv.has_zero_flag()) { 
     num_zeroes += num_left_spaces;
     num_left_spaces = 0;
   }
@@ -276,97 +276,97 @@ bool ConvertIntImplInnerSlow(const IntDigits &as_digits,
 }
 
 template <typename T>
-bool ConvertIntArg(T v, const FormatConversionSpecImpl conv,
-                   FormatSinkImpl *sink) {
-  using U = typename MakeUnsigned<T>::type;
-  IntDigits as_digits;
-
-  // This odd casting is due to a bug in -Wswitch behavior in gcc49 which causes
-  // it to complain about a switch/case type mismatch, even though both are
-  // FormatConverionChar.  Likely this is because at this point
-  // FormatConversionChar is declared, but not defined.
-  switch (static_cast<uint8_t>(conv.conversion_char())) {
-    case static_cast<uint8_t>(FormatConversionCharInternal::c):
-      return ConvertCharImpl(static_cast<unsigned char>(v), conv, sink);
-
-    case static_cast<uint8_t>(FormatConversionCharInternal::o):
-      as_digits.PrintAsOct(static_cast<U>(v));
-      break;
-
-    case static_cast<uint8_t>(FormatConversionCharInternal::x):
-      as_digits.PrintAsHexLower(static_cast<U>(v));
-      break;
-    case static_cast<uint8_t>(FormatConversionCharInternal::X):
-      as_digits.PrintAsHexUpper(static_cast<U>(v));
-      break;
-
-    case static_cast<uint8_t>(FormatConversionCharInternal::u):
-      as_digits.PrintAsDec(static_cast<U>(v));
-      break;
-
-    case static_cast<uint8_t>(FormatConversionCharInternal::d):
-    case static_cast<uint8_t>(FormatConversionCharInternal::i):
-      as_digits.PrintAsDec(v);
-      break;
-
-    case static_cast<uint8_t>(FormatConversionCharInternal::a):
-    case static_cast<uint8_t>(FormatConversionCharInternal::e):
-    case static_cast<uint8_t>(FormatConversionCharInternal::f):
-    case static_cast<uint8_t>(FormatConversionCharInternal::g):
-    case static_cast<uint8_t>(FormatConversionCharInternal::A):
-    case static_cast<uint8_t>(FormatConversionCharInternal::E):
-    case static_cast<uint8_t>(FormatConversionCharInternal::F):
-    case static_cast<uint8_t>(FormatConversionCharInternal::G):
-      return ConvertFloatImpl(static_cast<double>(v), conv, sink);
-
-    default:
-       ABSL_INTERNAL_ASSUME(false);
+bool ConvertIntArg(T v, const FormatConversionSpecImpl conv, 
+                   FormatSinkImpl *sink) { 
+  using U = typename MakeUnsigned<T>::type; 
+  IntDigits as_digits; 
+ 
+  // This odd casting is due to a bug in -Wswitch behavior in gcc49 which causes 
+  // it to complain about a switch/case type mismatch, even though both are 
+  // FormatConverionChar.  Likely this is because at this point 
+  // FormatConversionChar is declared, but not defined. 
+  switch (static_cast<uint8_t>(conv.conversion_char())) { 
+    case static_cast<uint8_t>(FormatConversionCharInternal::c): 
+      return ConvertCharImpl(static_cast<unsigned char>(v), conv, sink); 
+ 
+    case static_cast<uint8_t>(FormatConversionCharInternal::o): 
+      as_digits.PrintAsOct(static_cast<U>(v)); 
+      break; 
+ 
+    case static_cast<uint8_t>(FormatConversionCharInternal::x): 
+      as_digits.PrintAsHexLower(static_cast<U>(v)); 
+      break; 
+    case static_cast<uint8_t>(FormatConversionCharInternal::X): 
+      as_digits.PrintAsHexUpper(static_cast<U>(v)); 
+      break; 
+ 
+    case static_cast<uint8_t>(FormatConversionCharInternal::u): 
+      as_digits.PrintAsDec(static_cast<U>(v)); 
+      break; 
+ 
+    case static_cast<uint8_t>(FormatConversionCharInternal::d): 
+    case static_cast<uint8_t>(FormatConversionCharInternal::i): 
+      as_digits.PrintAsDec(v); 
+      break; 
+ 
+    case static_cast<uint8_t>(FormatConversionCharInternal::a): 
+    case static_cast<uint8_t>(FormatConversionCharInternal::e): 
+    case static_cast<uint8_t>(FormatConversionCharInternal::f): 
+    case static_cast<uint8_t>(FormatConversionCharInternal::g): 
+    case static_cast<uint8_t>(FormatConversionCharInternal::A): 
+    case static_cast<uint8_t>(FormatConversionCharInternal::E): 
+    case static_cast<uint8_t>(FormatConversionCharInternal::F): 
+    case static_cast<uint8_t>(FormatConversionCharInternal::G): 
+      return ConvertFloatImpl(static_cast<double>(v), conv, sink); 
+ 
+    default: 
+       ABSL_INTERNAL_ASSUME(false); 
   }
 
-  if (conv.is_basic()) {
-    sink->Append(as_digits.with_neg_and_zero());
-    return true;
+  if (conv.is_basic()) { 
+    sink->Append(as_digits.with_neg_and_zero()); 
+    return true; 
   }
-  return ConvertIntImplInnerSlow(as_digits, conv, sink);
+  return ConvertIntImplInnerSlow(as_digits, conv, sink); 
 }
 
 template <typename T>
-bool ConvertFloatArg(T v, const FormatConversionSpecImpl conv,
-                     FormatSinkImpl *sink) {
-  return FormatConversionCharIsFloat(conv.conversion_char()) &&
+bool ConvertFloatArg(T v, const FormatConversionSpecImpl conv, 
+                     FormatSinkImpl *sink) { 
+  return FormatConversionCharIsFloat(conv.conversion_char()) && 
          ConvertFloatImpl(v, conv, sink);
 }
 
-inline bool ConvertStringArg(string_view v, const FormatConversionSpecImpl conv,
+inline bool ConvertStringArg(string_view v, const FormatConversionSpecImpl conv, 
                              FormatSinkImpl *sink) {
-  if (conv.is_basic()) {
+  if (conv.is_basic()) { 
     sink->Append(v);
     return true;
   }
   return sink->PutPaddedString(v, conv.width(), conv.precision(),
-                               conv.has_left_flag());
+                               conv.has_left_flag()); 
 }
 
 }  // namespace
 
 // ==================== Strings ====================
-StringConvertResult FormatConvertImpl(const TString &v,
-                                      const FormatConversionSpecImpl conv,
-                                      FormatSinkImpl *sink) {
+StringConvertResult FormatConvertImpl(const TString &v, 
+                                      const FormatConversionSpecImpl conv, 
+                                      FormatSinkImpl *sink) { 
   return {ConvertStringArg(v, conv, sink)};
 }
 
-StringConvertResult FormatConvertImpl(string_view v,
-                                      const FormatConversionSpecImpl conv,
-                                      FormatSinkImpl *sink) {
+StringConvertResult FormatConvertImpl(string_view v, 
+                                      const FormatConversionSpecImpl conv, 
+                                      FormatSinkImpl *sink) { 
   return {ConvertStringArg(v, conv, sink)};
 }
 
-ArgConvertResult<FormatConversionCharSetUnion(
-    FormatConversionCharSetInternal::s, FormatConversionCharSetInternal::p)>
-FormatConvertImpl(const char *v, const FormatConversionSpecImpl conv,
-                  FormatSinkImpl *sink) {
-  if (conv.conversion_char() == FormatConversionCharInternal::p)
+ArgConvertResult<FormatConversionCharSetUnion( 
+    FormatConversionCharSetInternal::s, FormatConversionCharSetInternal::p)> 
+FormatConvertImpl(const char *v, const FormatConversionSpecImpl conv, 
+                  FormatSinkImpl *sink) { 
+  if (conv.conversion_char() == FormatConversionCharInternal::p) 
     return {FormatConvertImpl(VoidPtr(v), conv, sink).value};
   size_t len;
   if (v == nullptr) {
@@ -381,99 +381,99 @@ FormatConvertImpl(const char *v, const FormatConversionSpecImpl conv,
 }
 
 // ==================== Raw pointers ====================
-ArgConvertResult<FormatConversionCharSetInternal::p> FormatConvertImpl(
-    VoidPtr v, const FormatConversionSpecImpl conv, FormatSinkImpl *sink) {
+ArgConvertResult<FormatConversionCharSetInternal::p> FormatConvertImpl( 
+    VoidPtr v, const FormatConversionSpecImpl conv, FormatSinkImpl *sink) { 
   if (!v.value) {
     sink->Append("(nil)");
     return {true};
   }
-  IntDigits as_digits;
-  as_digits.PrintAsHexLower(v.value);
-  return {ConvertIntImplInnerSlow(as_digits, conv, sink)};
+  IntDigits as_digits; 
+  as_digits.PrintAsHexLower(v.value); 
+  return {ConvertIntImplInnerSlow(as_digits, conv, sink)}; 
 }
 
 // ==================== Floats ====================
-FloatingConvertResult FormatConvertImpl(float v,
-                                        const FormatConversionSpecImpl conv,
+FloatingConvertResult FormatConvertImpl(float v, 
+                                        const FormatConversionSpecImpl conv, 
                                         FormatSinkImpl *sink) {
   return {ConvertFloatArg(v, conv, sink)};
 }
-FloatingConvertResult FormatConvertImpl(double v,
-                                        const FormatConversionSpecImpl conv,
+FloatingConvertResult FormatConvertImpl(double v, 
+                                        const FormatConversionSpecImpl conv, 
                                         FormatSinkImpl *sink) {
   return {ConvertFloatArg(v, conv, sink)};
 }
 FloatingConvertResult FormatConvertImpl(long double v,
-                                        const FormatConversionSpecImpl conv,
+                                        const FormatConversionSpecImpl conv, 
                                         FormatSinkImpl *sink) {
   return {ConvertFloatArg(v, conv, sink)};
 }
 
 // ==================== Chars ====================
-IntegralConvertResult FormatConvertImpl(char v,
-                                        const FormatConversionSpecImpl conv,
+IntegralConvertResult FormatConvertImpl(char v, 
+                                        const FormatConversionSpecImpl conv, 
                                         FormatSinkImpl *sink) {
   return {ConvertIntArg(v, conv, sink)};
 }
 IntegralConvertResult FormatConvertImpl(signed char v,
-                                        const FormatConversionSpecImpl conv,
+                                        const FormatConversionSpecImpl conv, 
                                         FormatSinkImpl *sink) {
   return {ConvertIntArg(v, conv, sink)};
 }
 IntegralConvertResult FormatConvertImpl(unsigned char v,
-                                        const FormatConversionSpecImpl conv,
+                                        const FormatConversionSpecImpl conv, 
                                         FormatSinkImpl *sink) {
   return {ConvertIntArg(v, conv, sink)};
 }
 
 // ==================== Ints ====================
 IntegralConvertResult FormatConvertImpl(short v,  // NOLINT
-                                        const FormatConversionSpecImpl conv,
+                                        const FormatConversionSpecImpl conv, 
                                         FormatSinkImpl *sink) {
   return {ConvertIntArg(v, conv, sink)};
 }
 IntegralConvertResult FormatConvertImpl(unsigned short v,  // NOLINT
-                                        const FormatConversionSpecImpl conv,
+                                        const FormatConversionSpecImpl conv, 
                                         FormatSinkImpl *sink) {
   return {ConvertIntArg(v, conv, sink)};
 }
-IntegralConvertResult FormatConvertImpl(int v,
-                                        const FormatConversionSpecImpl conv,
+IntegralConvertResult FormatConvertImpl(int v, 
+                                        const FormatConversionSpecImpl conv, 
                                         FormatSinkImpl *sink) {
   return {ConvertIntArg(v, conv, sink)};
 }
-IntegralConvertResult FormatConvertImpl(unsigned v,
-                                        const FormatConversionSpecImpl conv,
+IntegralConvertResult FormatConvertImpl(unsigned v, 
+                                        const FormatConversionSpecImpl conv, 
                                         FormatSinkImpl *sink) {
   return {ConvertIntArg(v, conv, sink)};
 }
 IntegralConvertResult FormatConvertImpl(long v,  // NOLINT
-                                        const FormatConversionSpecImpl conv,
+                                        const FormatConversionSpecImpl conv, 
                                         FormatSinkImpl *sink) {
   return {ConvertIntArg(v, conv, sink)};
 }
 IntegralConvertResult FormatConvertImpl(unsigned long v,  // NOLINT
-                                        const FormatConversionSpecImpl conv,
+                                        const FormatConversionSpecImpl conv, 
                                         FormatSinkImpl *sink) {
   return {ConvertIntArg(v, conv, sink)};
 }
 IntegralConvertResult FormatConvertImpl(long long v,  // NOLINT
-                                        const FormatConversionSpecImpl conv,
+                                        const FormatConversionSpecImpl conv, 
                                         FormatSinkImpl *sink) {
   return {ConvertIntArg(v, conv, sink)};
 }
 IntegralConvertResult FormatConvertImpl(unsigned long long v,  // NOLINT
-                                        const FormatConversionSpecImpl conv,
+                                        const FormatConversionSpecImpl conv, 
                                         FormatSinkImpl *sink) {
   return {ConvertIntArg(v, conv, sink)};
 }
 IntegralConvertResult FormatConvertImpl(y_absl::int128 v,
-                                        const FormatConversionSpecImpl conv,
+                                        const FormatConversionSpecImpl conv, 
                                         FormatSinkImpl *sink) {
   return {ConvertIntArg(v, conv, sink)};
 }
 IntegralConvertResult FormatConvertImpl(y_absl::uint128 v,
-                                        const FormatConversionSpecImpl conv,
+                                        const FormatConversionSpecImpl conv, 
                                         FormatSinkImpl *sink) {
   return {ConvertIntArg(v, conv, sink)};
 }
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.h
index 59b7bcc727..fee261cbe3 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.h
@@ -1,17 +1,17 @@
-// 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. 
+ 
 #ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_ARG_H_
 #define ABSL_STRINGS_INTERNAL_STR_FORMAT_ARG_H_
 
@@ -24,7 +24,7 @@
 #include <memory>
 #include <sstream>
 #include <util/generic/string.h>
-#include <util/stream/str.h>
+#include <util/stream/str.h> 
 #include <type_traits>
 
 #include "y_absl/base/port.h"
@@ -40,52 +40,52 @@ class Cord;
 class FormatCountCapture;
 class FormatSink;
 
-template <y_absl::FormatConversionCharSet C>
-struct FormatConvertResult;
-class FormatConversionSpec;
-
+template <y_absl::FormatConversionCharSet C> 
+struct FormatConvertResult; 
+class FormatConversionSpec; 
+ 
 namespace str_format_internal {
 
 template <typename T, typename = void>
 struct HasUserDefinedConvert : std::false_type {};
 
 template <typename T>
-struct HasUserDefinedConvert<T, void_t<decltype(AbslFormatConvert(
-                                    std::declval<const T&>(),
-                                    std::declval<const FormatConversionSpec&>(),
-                                    std::declval<FormatSink*>()))>>
-    : std::true_type {};
-
-void AbslFormatConvert();  // Stops the lexical name lookup
-template <typename T>
-auto FormatConvertImpl(const T& v, FormatConversionSpecImpl conv,
-                       FormatSinkImpl* sink)
-    -> decltype(AbslFormatConvert(v,
-                                  std::declval<const FormatConversionSpec&>(),
-                                  std::declval<FormatSink*>())) {
-  using FormatConversionSpecT =
-      y_absl::enable_if_t<sizeof(const T& (*)()) != 0, FormatConversionSpec>;
-  using FormatSinkT =
-      y_absl::enable_if_t<sizeof(const T& (*)()) != 0, FormatSink>;
-  auto fcs = conv.Wrap<FormatConversionSpecT>();
-  auto fs = sink->Wrap<FormatSinkT>();
-  return AbslFormatConvert(v, fcs, &fs);
-}
+struct HasUserDefinedConvert<T, void_t<decltype(AbslFormatConvert( 
+                                    std::declval<const T&>(), 
+                                    std::declval<const FormatConversionSpec&>(), 
+                                    std::declval<FormatSink*>()))>> 
+    : std::true_type {}; 
 
+void AbslFormatConvert();  // Stops the lexical name lookup 
 template <typename T>
+auto FormatConvertImpl(const T& v, FormatConversionSpecImpl conv, 
+                       FormatSinkImpl* sink) 
+    -> decltype(AbslFormatConvert(v, 
+                                  std::declval<const FormatConversionSpec&>(), 
+                                  std::declval<FormatSink*>())) { 
+  using FormatConversionSpecT = 
+      y_absl::enable_if_t<sizeof(const T& (*)()) != 0, FormatConversionSpec>; 
+  using FormatSinkT = 
+      y_absl::enable_if_t<sizeof(const T& (*)()) != 0, FormatSink>; 
+  auto fcs = conv.Wrap<FormatConversionSpecT>(); 
+  auto fs = sink->Wrap<FormatSinkT>(); 
+  return AbslFormatConvert(v, fcs, &fs); 
+} 
+ 
+template <typename T> 
 class StreamedWrapper;
 
 // If 'v' can be converted (in the printf sense) according to 'conv',
 // then convert it, appending to `sink` and return `true`.
 // Otherwise fail and return `false`.
 
-// AbslFormatConvert(v, conv, sink) is intended to be found by ADL on 'v'
-// as an extension mechanism. These FormatConvertImpl functions are the default
-// implementations.
-// The ADL search is augmented via the 'Sink*' parameter, which also
-// serves as a disambiguator to reject possible unintended 'AbslFormatConvert'
-// functions in the namespaces associated with 'v'.
-
+// AbslFormatConvert(v, conv, sink) is intended to be found by ADL on 'v' 
+// as an extension mechanism. These FormatConvertImpl functions are the default 
+// implementations. 
+// The ADL search is augmented via the 'Sink*' parameter, which also 
+// serves as a disambiguator to reject possible unintended 'AbslFormatConvert' 
+// functions in the namespaces associated with 'v'. 
+ 
 // Raw pointers.
 struct VoidPtr {
   VoidPtr() = default;
@@ -96,33 +96,33 @@ struct VoidPtr {
   uintptr_t value;
 };
 
-template <FormatConversionCharSet C>
-struct ArgConvertResult {
-  bool value;
-};
-
-template <FormatConversionCharSet C>
-constexpr FormatConversionCharSet ExtractCharSet(FormatConvertResult<C>) {
-  return C;
-}
-
-template <FormatConversionCharSet C>
-constexpr FormatConversionCharSet ExtractCharSet(ArgConvertResult<C>) {
-  return C;
-}
-
-using StringConvertResult =
-    ArgConvertResult<FormatConversionCharSetInternal::s>;
-ArgConvertResult<FormatConversionCharSetInternal::p> FormatConvertImpl(
-    VoidPtr v, FormatConversionSpecImpl conv, FormatSinkImpl* sink);
-
+template <FormatConversionCharSet C> 
+struct ArgConvertResult { 
+  bool value; 
+}; 
+ 
+template <FormatConversionCharSet C> 
+constexpr FormatConversionCharSet ExtractCharSet(FormatConvertResult<C>) { 
+  return C; 
+} 
+ 
+template <FormatConversionCharSet C> 
+constexpr FormatConversionCharSet ExtractCharSet(ArgConvertResult<C>) { 
+  return C; 
+} 
+ 
+using StringConvertResult = 
+    ArgConvertResult<FormatConversionCharSetInternal::s>; 
+ArgConvertResult<FormatConversionCharSetInternal::p> FormatConvertImpl( 
+    VoidPtr v, FormatConversionSpecImpl conv, FormatSinkImpl* sink); 
+ 
 // Strings.
-StringConvertResult FormatConvertImpl(const TString& v,
-                                      FormatConversionSpecImpl conv,
-                                      FormatSinkImpl* sink);
-StringConvertResult FormatConvertImpl(string_view v,
-                                      FormatConversionSpecImpl conv,
-                                      FormatSinkImpl* sink);
+StringConvertResult FormatConvertImpl(const TString& v, 
+                                      FormatConversionSpecImpl conv, 
+                                      FormatSinkImpl* sink); 
+StringConvertResult FormatConvertImpl(string_view v, 
+                                      FormatConversionSpecImpl conv, 
+                                      FormatSinkImpl* sink); 
 #if defined(ABSL_HAVE_STD_STRING_VIEW) && !defined(ABSL_USES_STD_STRING_VIEW)
 inline StringConvertResult FormatConvertImpl(std::string_view v,
                                              FormatConversionSpecImpl conv,
@@ -131,17 +131,17 @@ inline StringConvertResult FormatConvertImpl(std::string_view v,
 }
 #endif  // ABSL_HAVE_STD_STRING_VIEW && !ABSL_USES_STD_STRING_VIEW
 
-ArgConvertResult<FormatConversionCharSetUnion(
-    FormatConversionCharSetInternal::s, FormatConversionCharSetInternal::p)>
-FormatConvertImpl(const char* v, const FormatConversionSpecImpl conv,
-                  FormatSinkImpl* sink);
-
-template <class AbslCord, typename std::enable_if<std::is_same<
-                              AbslCord, y_absl::Cord>::value>::type* = nullptr>
-StringConvertResult FormatConvertImpl(const AbslCord& value,
-                                      FormatConversionSpecImpl conv,
-                                      FormatSinkImpl* sink) {
-  bool is_left = conv.has_left_flag();
+ArgConvertResult<FormatConversionCharSetUnion( 
+    FormatConversionCharSetInternal::s, FormatConversionCharSetInternal::p)> 
+FormatConvertImpl(const char* v, const FormatConversionSpecImpl conv, 
+                  FormatSinkImpl* sink); 
+
+template <class AbslCord, typename std::enable_if<std::is_same< 
+                              AbslCord, y_absl::Cord>::value>::type* = nullptr> 
+StringConvertResult FormatConvertImpl(const AbslCord& value, 
+                                      FormatConversionSpecImpl conv, 
+                                      FormatSinkImpl* sink) { 
+  bool is_left = conv.has_left_flag(); 
   size_t space_remaining = 0;
 
   int width = conv.width();
@@ -174,63 +174,63 @@ StringConvertResult FormatConvertImpl(const AbslCord& value,
   return {true};
 }
 
-using IntegralConvertResult = ArgConvertResult<FormatConversionCharSetUnion(
-    FormatConversionCharSetInternal::c,
-    FormatConversionCharSetInternal::kNumeric,
-    FormatConversionCharSetInternal::kStar)>;
-using FloatingConvertResult =
-    ArgConvertResult<FormatConversionCharSetInternal::kFloating>;
+using IntegralConvertResult = ArgConvertResult<FormatConversionCharSetUnion( 
+    FormatConversionCharSetInternal::c, 
+    FormatConversionCharSetInternal::kNumeric, 
+    FormatConversionCharSetInternal::kStar)>; 
+using FloatingConvertResult = 
+    ArgConvertResult<FormatConversionCharSetInternal::kFloating>; 
 
 // Floats.
-FloatingConvertResult FormatConvertImpl(float v, FormatConversionSpecImpl conv,
+FloatingConvertResult FormatConvertImpl(float v, FormatConversionSpecImpl conv, 
                                         FormatSinkImpl* sink);
-FloatingConvertResult FormatConvertImpl(double v, FormatConversionSpecImpl conv,
+FloatingConvertResult FormatConvertImpl(double v, FormatConversionSpecImpl conv, 
                                         FormatSinkImpl* sink);
-FloatingConvertResult FormatConvertImpl(long double v,
-                                        FormatConversionSpecImpl conv,
+FloatingConvertResult FormatConvertImpl(long double v, 
+                                        FormatConversionSpecImpl conv, 
                                         FormatSinkImpl* sink);
 
 // Chars.
-IntegralConvertResult FormatConvertImpl(char v, FormatConversionSpecImpl conv,
+IntegralConvertResult FormatConvertImpl(char v, FormatConversionSpecImpl conv, 
                                         FormatSinkImpl* sink);
-IntegralConvertResult FormatConvertImpl(signed char v,
-                                        FormatConversionSpecImpl conv,
+IntegralConvertResult FormatConvertImpl(signed char v, 
+                                        FormatConversionSpecImpl conv, 
                                         FormatSinkImpl* sink);
-IntegralConvertResult FormatConvertImpl(unsigned char v,
-                                        FormatConversionSpecImpl conv,
+IntegralConvertResult FormatConvertImpl(unsigned char v, 
+                                        FormatConversionSpecImpl conv, 
                                         FormatSinkImpl* sink);
 
 // Ints.
 IntegralConvertResult FormatConvertImpl(short v,  // NOLINT
-                                        FormatConversionSpecImpl conv,
+                                        FormatConversionSpecImpl conv, 
                                         FormatSinkImpl* sink);
 IntegralConvertResult FormatConvertImpl(unsigned short v,  // NOLINT
-                                        FormatConversionSpecImpl conv,
+                                        FormatConversionSpecImpl conv, 
                                         FormatSinkImpl* sink);
-IntegralConvertResult FormatConvertImpl(int v, FormatConversionSpecImpl conv,
+IntegralConvertResult FormatConvertImpl(int v, FormatConversionSpecImpl conv, 
                                         FormatSinkImpl* sink);
-IntegralConvertResult FormatConvertImpl(unsigned v,
-                                        FormatConversionSpecImpl conv,
+IntegralConvertResult FormatConvertImpl(unsigned v, 
+                                        FormatConversionSpecImpl conv, 
                                         FormatSinkImpl* sink);
 IntegralConvertResult FormatConvertImpl(long v,  // NOLINT
-                                        FormatConversionSpecImpl conv,
+                                        FormatConversionSpecImpl conv, 
                                         FormatSinkImpl* sink);
 IntegralConvertResult FormatConvertImpl(unsigned long v,  // NOLINT
-                                        FormatConversionSpecImpl conv,
+                                        FormatConversionSpecImpl conv, 
                                         FormatSinkImpl* sink);
 IntegralConvertResult FormatConvertImpl(long long v,  // NOLINT
-                                        FormatConversionSpecImpl conv,
+                                        FormatConversionSpecImpl conv, 
                                         FormatSinkImpl* sink);
 IntegralConvertResult FormatConvertImpl(unsigned long long v,  // NOLINT
-                                        FormatConversionSpecImpl conv,
+                                        FormatConversionSpecImpl conv, 
                                         FormatSinkImpl* sink);
-IntegralConvertResult FormatConvertImpl(int128 v, FormatConversionSpecImpl conv,
+IntegralConvertResult FormatConvertImpl(int128 v, FormatConversionSpecImpl conv, 
                                         FormatSinkImpl* sink);
-IntegralConvertResult FormatConvertImpl(uint128 v,
-                                        FormatConversionSpecImpl conv,
+IntegralConvertResult FormatConvertImpl(uint128 v, 
+                                        FormatConversionSpecImpl conv, 
                                         FormatSinkImpl* sink);
 template <typename T, enable_if_t<std::is_same<T, bool>::value, int> = 0>
-IntegralConvertResult FormatConvertImpl(T v, FormatConversionSpecImpl conv,
+IntegralConvertResult FormatConvertImpl(T v, FormatConversionSpecImpl conv, 
                                         FormatSinkImpl* sink) {
   return FormatConvertImpl(static_cast<int>(v), conv, sink);
 }
@@ -241,41 +241,41 @@ template <typename T>
 typename std::enable_if<std::is_enum<T>::value &&
                             !HasUserDefinedConvert<T>::value,
                         IntegralConvertResult>::type
-FormatConvertImpl(T v, FormatConversionSpecImpl conv, FormatSinkImpl* sink);
+FormatConvertImpl(T v, FormatConversionSpecImpl conv, FormatSinkImpl* sink); 
 
 template <typename T>
-StringConvertResult FormatConvertImpl(const StreamedWrapper<T>& v,
-                                      FormatConversionSpecImpl conv,
-                                      FormatSinkImpl* out) {
-  TString buf;
-  TStringOutput oss(buf);
+StringConvertResult FormatConvertImpl(const StreamedWrapper<T>& v, 
+                                      FormatConversionSpecImpl conv, 
+                                      FormatSinkImpl* out) { 
+  TString buf; 
+  TStringOutput oss(buf); 
   oss << v.v_;
-  if (!buf) return {false};
-  return str_format_internal::FormatConvertImpl(buf, conv, out);
+  if (!buf) return {false}; 
+  return str_format_internal::FormatConvertImpl(buf, conv, out); 
 }
 
 // Use templates and dependent types to delay evaluation of the function
 // until after FormatCountCapture is fully defined.
 struct FormatCountCaptureHelper {
   template <class T = int>
-  static ArgConvertResult<FormatConversionCharSetInternal::n> ConvertHelper(
-      const FormatCountCapture& v, FormatConversionSpecImpl conv,
-      FormatSinkImpl* sink) {
+  static ArgConvertResult<FormatConversionCharSetInternal::n> ConvertHelper( 
+      const FormatCountCapture& v, FormatConversionSpecImpl conv, 
+      FormatSinkImpl* sink) { 
     const y_absl::enable_if_t<sizeof(T) != 0, FormatCountCapture>& v2 = v;
 
-    if (conv.conversion_char() !=
-        str_format_internal::FormatConversionCharInternal::n) {
-      return {false};
-    }
+    if (conv.conversion_char() != 
+        str_format_internal::FormatConversionCharInternal::n) { 
+      return {false}; 
+    } 
     *v2.p_ = static_cast<int>(sink->size());
     return {true};
   }
 };
 
 template <class T = int>
-ArgConvertResult<FormatConversionCharSetInternal::n> FormatConvertImpl(
-    const FormatCountCapture& v, FormatConversionSpecImpl conv,
-    FormatSinkImpl* sink) {
+ArgConvertResult<FormatConversionCharSetInternal::n> FormatConvertImpl( 
+    const FormatCountCapture& v, FormatConversionSpecImpl conv, 
+    FormatSinkImpl* sink) { 
   return FormatCountCaptureHelper::ConvertHelper(v, conv, sink);
 }
 
@@ -284,13 +284,13 @@ ArgConvertResult<FormatConversionCharSetInternal::n> FormatConvertImpl(
 struct FormatArgImplFriend {
   template <typename Arg>
   static bool ToInt(Arg arg, int* out) {
-    // A value initialized FormatConversionSpecImpl has a `none` conv, which
-    // tells the dispatcher to run the `int` conversion.
+    // A value initialized FormatConversionSpecImpl has a `none` conv, which 
+    // tells the dispatcher to run the `int` conversion. 
     return arg.dispatcher_(arg.data_, {}, out);
   }
 
   template <typename Arg>
-  static bool Convert(Arg arg, FormatConversionSpecImpl conv,
+  static bool Convert(Arg arg, FormatConversionSpecImpl conv, 
                       FormatSinkImpl* out) {
     return arg.dispatcher_(arg.data_, conv, out);
   }
@@ -301,15 +301,15 @@ struct FormatArgImplFriend {
   }
 };
 
-template <typename Arg>
-constexpr FormatConversionCharSet ArgumentToConv() {
-  return y_absl::str_format_internal::ExtractCharSet(
-      decltype(str_format_internal::FormatConvertImpl(
-          std::declval<const Arg&>(),
-          std::declval<const FormatConversionSpecImpl&>(),
-          std::declval<FormatSinkImpl*>())){});
-}
-
+template <typename Arg> 
+constexpr FormatConversionCharSet ArgumentToConv() { 
+  return y_absl::str_format_internal::ExtractCharSet( 
+      decltype(str_format_internal::FormatConvertImpl( 
+          std::declval<const Arg&>(), 
+          std::declval<const FormatConversionSpecImpl&>(), 
+          std::declval<FormatSinkImpl*>())){}); 
+} 
+ 
 // A type-erased handle to a format argument.
 class FormatArgImpl {
  private:
@@ -323,7 +323,7 @@ class FormatArgImpl {
     char buf[kInlinedSpace];
   };
 
-  using Dispatcher = bool (*)(Data, FormatConversionSpecImpl, void* out);
+  using Dispatcher = bool (*)(Data, FormatConversionSpecImpl, void* out); 
 
   template <typename T>
   struct store_by_value
@@ -465,20 +465,20 @@ class FormatArgImpl {
   }
 
   template <typename T>
-  static bool Dispatch(Data arg, FormatConversionSpecImpl spec, void* out) {
+  static bool Dispatch(Data arg, FormatConversionSpecImpl spec, void* out) { 
     // A `none` conv indicates that we want the `int` conversion.
-    if (ABSL_PREDICT_FALSE(spec.conversion_char() ==
-                           FormatConversionCharInternal::kNone)) {
+    if (ABSL_PREDICT_FALSE(spec.conversion_char() == 
+                           FormatConversionCharInternal::kNone)) { 
       return ToInt<T>(arg, static_cast<int*>(out), std::is_integral<T>(),
                       std::is_enum<T>());
     }
-    if (ABSL_PREDICT_FALSE(!Contains(ArgumentToConv<T>(),
-                                     spec.conversion_char()))) {
-      return false;
-    }
+    if (ABSL_PREDICT_FALSE(!Contains(ArgumentToConv<T>(), 
+                                     spec.conversion_char()))) { 
+      return false; 
+    } 
     return str_format_internal::FormatConvertImpl(
-               Manager<T>::Value(arg), spec,
-               static_cast<FormatSinkImpl*>(out))
+               Manager<T>::Value(arg), spec, 
+               static_cast<FormatSinkImpl*>(out)) 
         .value;
   }
 
@@ -486,9 +486,9 @@ class FormatArgImpl {
   Dispatcher dispatcher_;
 };
 
-#define ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(T, E)                     \
-  E template bool FormatArgImpl::Dispatch<T>(Data, FormatConversionSpecImpl, \
-                                             void*)
+#define ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(T, E)                     \ 
+  E template bool FormatArgImpl::Dispatch<T>(Data, FormatConversionSpecImpl, \ 
+                                             void*) 
 
 #define ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_(...)                   \
   ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(str_format_internal::VoidPtr,     \
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/bind.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/bind.cc
index 211ce25dea..5a62088bff 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/bind.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/bind.cc
@@ -1,17 +1,17 @@
-// 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 "y_absl/strings/internal/str_format/bind.h"
 
 #include <cerrno>
@@ -160,7 +160,7 @@ class SummarizingConverter {
        << FormatConversionSpecImplFriend::FlagsToString(bound);
     if (bound.width() >= 0) ss << bound.width();
     if (bound.precision() >= 0) ss << "." << bound.precision();
-    ss << bound.conversion_char() << "}";
+    ss << bound.conversion_char() << "}"; 
     Append(ss.str());
     return true;
   }
@@ -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-tstring/y_absl/strings/internal/str_format/bind.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/bind.h
index 3966610710..f0e73a6db2 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/bind.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/bind.h
@@ -1,17 +1,17 @@
-// 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. 
+ 
 #ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_BIND_H_
 #define ABSL_STRINGS_INTERNAL_STR_FORMAT_BIND_H_
 
@@ -33,7 +33,7 @@ class UntypedFormatSpec;
 
 namespace str_format_internal {
 
-class BoundConversion : public FormatConversionSpecImpl {
+class BoundConversion : public FormatConversionSpecImpl { 
  public:
   const FormatArgImpl* arg() const { return arg_; }
   void set_arg(const FormatArgImpl* a) { arg_ = a; }
@@ -74,7 +74,7 @@ class UntypedFormatSpecImpl {
   size_t size_;
 };
 
-template <typename T, FormatConversionCharSet...>
+template <typename T, FormatConversionCharSet...> 
 struct MakeDependent {
   using type = T;
 };
@@ -82,7 +82,7 @@ struct MakeDependent {
 // Implicitly convertible from `const char*`, `string_view`, and the
 // `ExtendedParsedFormat` type. This abstraction allows all format functions to
 // operate on any without providing too many overloads.
-template <FormatConversionCharSet... Args>
+template <FormatConversionCharSet... Args> 
 class FormatSpecTemplate
     : public MakeDependent<UntypedFormatSpec, Args...>::type {
   using Base = typename MakeDependent<UntypedFormatSpec, Args...>::type;
@@ -90,11 +90,11 @@ class FormatSpecTemplate
  public:
 #ifdef ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
 
-  // Honeypot overload for when the string is not constexpr.
+  // Honeypot overload for when the string is not constexpr. 
   // We use the 'unavailable' attribute to give a better compiler error than
   // just 'method is deleted'.
   FormatSpecTemplate(...)  // NOLINT
-      __attribute__((unavailable("Format string is not constexpr.")));
+      __attribute__((unavailable("Format string is not constexpr."))); 
 
   // Honeypot overload for when the format is constexpr and invalid.
   // We use the 'unavailable' attribute to give a better compiler error than
@@ -119,11 +119,11 @@ class FormatSpecTemplate
 
   // Good format overload.
   FormatSpecTemplate(const char* s)  // NOLINT
-      __attribute__((enable_if(ValidFormatImpl<Args...>(s), "bad format trap")))
+      __attribute__((enable_if(ValidFormatImpl<Args...>(s), "bad format trap"))) 
       : Base(s) {}
 
   FormatSpecTemplate(string_view s)  // NOLINT
-      __attribute__((enable_if(ValidFormatImpl<Args...>(s), "bad format trap")))
+      __attribute__((enable_if(ValidFormatImpl<Args...>(s), "bad format trap"))) 
       : Base(s) {}
 
 #else  // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
@@ -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) {}
 };
@@ -204,9 +204,9 @@ class StreamedWrapper {
 
  private:
   template <typename S>
-  friend ArgConvertResult<FormatConversionCharSetInternal::s> FormatConvertImpl(
-      const StreamedWrapper<S>& v, FormatConversionSpecImpl conv,
-      FormatSinkImpl* out);
+  friend ArgConvertResult<FormatConversionCharSetInternal::s> FormatConvertImpl( 
+      const StreamedWrapper<S>& v, FormatConversionSpecImpl conv, 
+      FormatSinkImpl* out); 
   const T& v_;
 };
 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/checker.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/checker.h
index 7c530d2507..ba3b3d02f3 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/checker.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/checker.h
@@ -1,17 +1,17 @@
-// 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. 
+ 
 #ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_CHECKER_H_
 #define ABSL_STRINGS_INTERNAL_STR_FORMAT_CHECKER_H_
 
@@ -46,14 +46,14 @@ constexpr bool ContainsChar(const char* chars, char c) {
 
 // A constexpr compatible list of Convs.
 struct ConvList {
-  const FormatConversionCharSet* array;
+  const FormatConversionCharSet* array; 
   int count;
 
   // We do the bound check here to avoid having to do it on the callers.
-  // Returning an empty FormatConversionCharSet has the same effect as
-  // short circuiting because it will never match any conversion.
-  constexpr FormatConversionCharSet operator[](int i) const {
-    return i < count ? array[i] : FormatConversionCharSet{};
+  // Returning an empty FormatConversionCharSet has the same effect as 
+  // short circuiting because it will never match any conversion. 
+  constexpr FormatConversionCharSet operator[](int i) const { 
+    return i < count ? array[i] : FormatConversionCharSet{}; 
   }
 
   constexpr ConvList without_front() const {
@@ -64,7 +64,7 @@ struct ConvList {
 template <size_t count>
 struct ConvListT {
   // Make sure the array has size > 0.
-  FormatConversionCharSet list[count ? count : 1];
+  FormatConversionCharSet list[count ? count : 1]; 
 };
 
 constexpr char GetChar(string_view str, size_t index) {
@@ -317,7 +317,7 @@ class FormatParser {
   ConvList args_;
 };
 
-template <FormatConversionCharSet... C>
+template <FormatConversionCharSet... C> 
 constexpr bool ValidFormatImpl(string_view format) {
   return FormatParser(format,
                       {ConvListT<sizeof...(C)>{{C...}}.list, sizeof...(C)})
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.cc
index f2a4169ae7..13c452cb8e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.cc
@@ -33,40 +33,40 @@ TString FlagsToString(Flags v) {
   return s;
 }
 
-#define ABSL_INTERNAL_X_VAL(id) \
-  constexpr y_absl::FormatConversionChar FormatConversionCharInternal::id;
-ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL, )
-#undef ABSL_INTERNAL_X_VAL
-// NOLINTNEXTLINE(readability-redundant-declaration)
-constexpr y_absl::FormatConversionChar FormatConversionCharInternal::kNone;
-
-#define ABSL_INTERNAL_CHAR_SET_CASE(c) \
-  constexpr FormatConversionCharSet FormatConversionCharSetInternal::c;
-ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_CHAR_SET_CASE, )
-#undef ABSL_INTERNAL_CHAR_SET_CASE
-
-// NOLINTNEXTLINE(readability-redundant-declaration)
-constexpr FormatConversionCharSet FormatConversionCharSetInternal::kStar;
-// NOLINTNEXTLINE(readability-redundant-declaration)
-constexpr FormatConversionCharSet FormatConversionCharSetInternal::kIntegral;
-// NOLINTNEXTLINE(readability-redundant-declaration)
-constexpr FormatConversionCharSet FormatConversionCharSetInternal::kFloating;
-// NOLINTNEXTLINE(readability-redundant-declaration)
-constexpr FormatConversionCharSet FormatConversionCharSetInternal::kNumeric;
-// NOLINTNEXTLINE(readability-redundant-declaration)
-constexpr FormatConversionCharSet FormatConversionCharSetInternal::kPointer;
-
-bool FormatSinkImpl::PutPaddedString(string_view value, int width,
-                                     int precision, bool left) {
+#define ABSL_INTERNAL_X_VAL(id) \ 
+  constexpr y_absl::FormatConversionChar FormatConversionCharInternal::id; 
+ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL, ) 
+#undef ABSL_INTERNAL_X_VAL 
+// NOLINTNEXTLINE(readability-redundant-declaration) 
+constexpr y_absl::FormatConversionChar FormatConversionCharInternal::kNone; 
+ 
+#define ABSL_INTERNAL_CHAR_SET_CASE(c) \ 
+  constexpr FormatConversionCharSet FormatConversionCharSetInternal::c; 
+ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_CHAR_SET_CASE, ) 
+#undef ABSL_INTERNAL_CHAR_SET_CASE 
+ 
+// NOLINTNEXTLINE(readability-redundant-declaration) 
+constexpr FormatConversionCharSet FormatConversionCharSetInternal::kStar; 
+// NOLINTNEXTLINE(readability-redundant-declaration) 
+constexpr FormatConversionCharSet FormatConversionCharSetInternal::kIntegral; 
+// NOLINTNEXTLINE(readability-redundant-declaration) 
+constexpr FormatConversionCharSet FormatConversionCharSetInternal::kFloating; 
+// NOLINTNEXTLINE(readability-redundant-declaration) 
+constexpr FormatConversionCharSet FormatConversionCharSetInternal::kNumeric; 
+// NOLINTNEXTLINE(readability-redundant-declaration) 
+constexpr FormatConversionCharSet FormatConversionCharSetInternal::kPointer; 
+ 
+bool FormatSinkImpl::PutPaddedString(string_view value, int width, 
+                                     int precision, bool left) { 
   size_t space_remaining = 0;
-  if (width >= 0) space_remaining = width;
-  size_t n = value.size();
-  if (precision >= 0) n = std::min(n, static_cast<size_t>(precision));
-  string_view shown(value.data(), n);
+  if (width >= 0) space_remaining = width; 
+  size_t n = value.size(); 
+  if (precision >= 0) n = std::min(n, static_cast<size_t>(precision)); 
+  string_view shown(value.data(), n); 
   space_remaining = Excess(shown.size(), space_remaining);
-  if (!left) Append(space_remaining, ' ');
+  if (!left) Append(space_remaining, ' '); 
   Append(shown);
-  if (left) Append(space_remaining, ' ');
+  if (left) Append(space_remaining, ' '); 
   return true;
 }
 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.h
index e5de5cb6a1..1548d56578 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.h
@@ -24,16 +24,16 @@
 
 #include "y_absl/base/config.h"
 #include "y_absl/base/port.h"
-#include "y_absl/meta/type_traits.h"
+#include "y_absl/meta/type_traits.h" 
 #include "y_absl/strings/internal/str_format/output.h"
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-
-enum class FormatConversionChar : uint8_t;
-enum class FormatConversionCharSet : uint64_t;
-
+ 
+enum class FormatConversionChar : uint8_t; 
+enum class FormatConversionCharSet : uint64_t; 
+ 
 namespace str_format_internal {
 
 class FormatRawSinkImpl {
@@ -107,7 +107,7 @@ class FormatSinkImpl {
   size_t size() const { return size_; }
 
   // Put 'v' to 'sink' with specified width, precision, and left flag.
-  bool PutPaddedString(string_view v, int width, int precision, bool left);
+  bool PutPaddedString(string_view v, int width, int precision, bool left); 
 
   template <typename T>
   T Wrap() {
@@ -158,7 +158,7 @@ inline std::ostream& operator<<(std::ostream& os, Flags v) {
 // clang-format off
 #define ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(X_VAL, X_SEP) \
   /* text */ \
-  X_VAL(c) X_SEP X_VAL(s) X_SEP \
+  X_VAL(c) X_SEP X_VAL(s) X_SEP \ 
   /* ints */ \
   X_VAL(d) X_SEP X_VAL(i) X_SEP X_VAL(o) X_SEP \
   X_VAL(u) X_SEP X_VAL(x) X_SEP X_VAL(X) X_SEP \
@@ -167,39 +167,39 @@ inline std::ostream& operator<<(std::ostream& os, Flags v) {
   X_VAL(g) X_SEP X_VAL(G) X_SEP X_VAL(a) X_SEP X_VAL(A) X_SEP \
   /* misc */ \
   X_VAL(n) X_SEP X_VAL(p)
-// clang-format on
-
-// This type should not be referenced, it exists only to provide labels
-// internally that match the values declared in FormatConversionChar in
-// str_format.h. This is meant to allow internal libraries to use the same
-// declared interface type as the public interface
-// (y_absl::StrFormatConversionChar) while keeping the definition in a public
-// header.
-// Internal libraries should use the form
-// `FormatConversionCharInternal::c`, `FormatConversionCharInternal::kNone` for
-// comparisons.  Use in switch statements is not recommended due to a bug in how
-// gcc 4.9 -Wswitch handles declared but undefined enums.
-struct FormatConversionCharInternal {
-  FormatConversionCharInternal() = delete;
-
- private:
-  // clang-format off
-  enum class Enum : uint8_t {
-    c, s,                    // text
+// clang-format on 
+
+// This type should not be referenced, it exists only to provide labels 
+// internally that match the values declared in FormatConversionChar in 
+// str_format.h. This is meant to allow internal libraries to use the same 
+// declared interface type as the public interface 
+// (y_absl::StrFormatConversionChar) while keeping the definition in a public 
+// header. 
+// Internal libraries should use the form 
+// `FormatConversionCharInternal::c`, `FormatConversionCharInternal::kNone` for 
+// comparisons.  Use in switch statements is not recommended due to a bug in how 
+// gcc 4.9 -Wswitch handles declared but undefined enums. 
+struct FormatConversionCharInternal { 
+  FormatConversionCharInternal() = delete; 
+ 
+ private: 
+  // clang-format off 
+  enum class Enum : uint8_t { 
+    c, s,                    // text 
     d, i, o, u, x, X,        // int
     f, F, e, E, g, G, a, A,  // float
     n, p,                    // misc
-    kNone
-  };
-  // clang-format on
- public:
-#define ABSL_INTERNAL_X_VAL(id)              \
-  static constexpr FormatConversionChar id = \
-      static_cast<FormatConversionChar>(Enum::id);
-  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL, )
-#undef ABSL_INTERNAL_X_VAL
-  static constexpr FormatConversionChar kNone =
-      static_cast<FormatConversionChar>(Enum::kNone);
+    kNone 
+  }; 
+  // clang-format on 
+ public: 
+#define ABSL_INTERNAL_X_VAL(id)              \ 
+  static constexpr FormatConversionChar id = \ 
+      static_cast<FormatConversionChar>(Enum::id); 
+  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL, ) 
+#undef ABSL_INTERNAL_X_VAL 
+  static constexpr FormatConversionChar kNone = 
+      static_cast<FormatConversionChar>(Enum::kNone); 
 };
 // clang-format on
 
@@ -207,54 +207,54 @@ inline FormatConversionChar FormatConversionCharFromChar(char c) {
   switch (c) {
 #define ABSL_INTERNAL_X_VAL(id) \
   case #id[0]:                  \
-    return FormatConversionCharInternal::id;
+    return FormatConversionCharInternal::id; 
     ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL, )
 #undef ABSL_INTERNAL_X_VAL
   }
-  return FormatConversionCharInternal::kNone;
+  return FormatConversionCharInternal::kNone; 
 }
 
 inline bool FormatConversionCharIsUpper(FormatConversionChar c) {
-  if (c == FormatConversionCharInternal::X ||
-      c == FormatConversionCharInternal::F ||
-      c == FormatConversionCharInternal::E ||
-      c == FormatConversionCharInternal::G ||
-      c == FormatConversionCharInternal::A) {
-    return true;
-  } else {
-    return false;
+  if (c == FormatConversionCharInternal::X || 
+      c == FormatConversionCharInternal::F || 
+      c == FormatConversionCharInternal::E || 
+      c == FormatConversionCharInternal::G || 
+      c == FormatConversionCharInternal::A) { 
+    return true; 
+  } else { 
+    return false; 
   }
 }
 
 inline bool FormatConversionCharIsFloat(FormatConversionChar c) {
-  if (c == FormatConversionCharInternal::a ||
-      c == FormatConversionCharInternal::e ||
-      c == FormatConversionCharInternal::f ||
-      c == FormatConversionCharInternal::g ||
-      c == FormatConversionCharInternal::A ||
-      c == FormatConversionCharInternal::E ||
-      c == FormatConversionCharInternal::F ||
-      c == FormatConversionCharInternal::G) {
-    return true;
-  } else {
-    return false;
+  if (c == FormatConversionCharInternal::a || 
+      c == FormatConversionCharInternal::e || 
+      c == FormatConversionCharInternal::f || 
+      c == FormatConversionCharInternal::g || 
+      c == FormatConversionCharInternal::A || 
+      c == FormatConversionCharInternal::E || 
+      c == FormatConversionCharInternal::F || 
+      c == FormatConversionCharInternal::G) { 
+    return true; 
+  } else { 
+    return false; 
   }
 }
 
 inline char FormatConversionCharToChar(FormatConversionChar c) {
-  if (c == FormatConversionCharInternal::kNone) {
-    return '\0';
-
-#define ABSL_INTERNAL_X_VAL(e)                       \
-  } else if (c == FormatConversionCharInternal::e) { \
+  if (c == FormatConversionCharInternal::kNone) { 
+    return '\0'; 
+ 
+#define ABSL_INTERNAL_X_VAL(e)                       \ 
+  } else if (c == FormatConversionCharInternal::e) { \ 
     return #e[0];
 #define ABSL_INTERNAL_X_SEP
-  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL,
-                                         ABSL_INTERNAL_X_SEP)
-  } else {
-    return '\0';
-  }
-
+  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL, 
+                                         ABSL_INTERNAL_X_SEP) 
+  } else { 
+    return '\0'; 
+  } 
+ 
 #undef ABSL_INTERNAL_X_VAL
 #undef ABSL_INTERNAL_X_SEP
 }
@@ -268,7 +268,7 @@ inline std::ostream& operator<<(std::ostream& os, FormatConversionChar v) {
 
 struct FormatConversionSpecImplFriend;
 
-class FormatConversionSpecImpl {
+class FormatConversionSpecImpl { 
  public:
   // Width and precison are not specified, no flags are set.
   bool is_basic() const { return flags_ == Flags::kBasic; }
@@ -285,7 +285,7 @@ class FormatConversionSpecImpl {
   FormatConversionChar conversion_char() const {
     // Keep this field first in the struct . It generates better code when
     // accessing it when ConversionSpec is passed by value in registers.
-    static_assert(offsetof(FormatConversionSpecImpl, conv_) == 0, "");
+    static_assert(offsetof(FormatConversionSpecImpl, conv_) == 0, ""); 
     return conv_;
   }
 
@@ -296,65 +296,65 @@ class FormatConversionSpecImpl {
   // negative value.
   int precision() const { return precision_; }
 
-  template <typename T>
-  T Wrap() {
-    return T(*this);
-  }
+  template <typename T> 
+  T Wrap() { 
+    return T(*this); 
+  } 
 
  private:
   friend struct str_format_internal::FormatConversionSpecImplFriend;
-  FormatConversionChar conv_ = FormatConversionCharInternal::kNone;
+  FormatConversionChar conv_ = FormatConversionCharInternal::kNone; 
   Flags flags_;
   int width_;
   int precision_;
 };
 
 struct FormatConversionSpecImplFriend final {
-  static void SetFlags(Flags f, FormatConversionSpecImpl* conv) {
+  static void SetFlags(Flags f, FormatConversionSpecImpl* conv) { 
     conv->flags_ = f;
   }
   static void SetConversionChar(FormatConversionChar c,
-                                FormatConversionSpecImpl* conv) {
+                                FormatConversionSpecImpl* conv) { 
     conv->conv_ = c;
   }
-  static void SetWidth(int w, FormatConversionSpecImpl* conv) {
-    conv->width_ = w;
-  }
-  static void SetPrecision(int p, FormatConversionSpecImpl* conv) {
+  static void SetWidth(int w, FormatConversionSpecImpl* conv) { 
+    conv->width_ = w; 
+  } 
+  static void SetPrecision(int p, FormatConversionSpecImpl* conv) { 
     conv->precision_ = p;
   }
-  static TString FlagsToString(const FormatConversionSpecImpl& spec) {
+  static TString FlagsToString(const FormatConversionSpecImpl& spec) { 
     return str_format_internal::FlagsToString(spec.flags_);
   }
 };
 
-// Type safe OR operator.
-// We need this for two reasons:
-//  1. operator| on enums makes them decay to integers and the result is an
-//     integer. We need the result to stay as an enum.
-//  2. We use "enum class" which would not work even if we accepted the decay.
-constexpr FormatConversionCharSet FormatConversionCharSetUnion(
-    FormatConversionCharSet a) {
-  return a;
-}
-
-template <typename... CharSet>
-constexpr FormatConversionCharSet FormatConversionCharSetUnion(
-    FormatConversionCharSet a, CharSet... rest) {
-  return static_cast<FormatConversionCharSet>(
-      static_cast<uint64_t>(a) |
-      static_cast<uint64_t>(FormatConversionCharSetUnion(rest...)));
-}
-
-constexpr uint64_t FormatConversionCharToConvInt(FormatConversionChar c) {
-  return uint64_t{1} << (1 + static_cast<uint8_t>(c));
-}
-
-constexpr uint64_t FormatConversionCharToConvInt(char conv) {
+// Type safe OR operator. 
+// We need this for two reasons: 
+//  1. operator| on enums makes them decay to integers and the result is an 
+//     integer. We need the result to stay as an enum. 
+//  2. We use "enum class" which would not work even if we accepted the decay. 
+constexpr FormatConversionCharSet FormatConversionCharSetUnion( 
+    FormatConversionCharSet a) { 
+  return a; 
+} 
+ 
+template <typename... CharSet> 
+constexpr FormatConversionCharSet FormatConversionCharSetUnion( 
+    FormatConversionCharSet a, CharSet... rest) { 
+  return static_cast<FormatConversionCharSet>( 
+      static_cast<uint64_t>(a) | 
+      static_cast<uint64_t>(FormatConversionCharSetUnion(rest...))); 
+} 
+ 
+constexpr uint64_t FormatConversionCharToConvInt(FormatConversionChar c) { 
+  return uint64_t{1} << (1 + static_cast<uint8_t>(c)); 
+} 
+ 
+constexpr uint64_t FormatConversionCharToConvInt(char conv) { 
   return
-#define ABSL_INTERNAL_CHAR_SET_CASE(c)                                 \
-  conv == #c[0]                                                        \
-      ? FormatConversionCharToConvInt(FormatConversionCharInternal::c) \
+#define ABSL_INTERNAL_CHAR_SET_CASE(c)                                 \ 
+  conv == #c[0]                                                        \ 
+      ? FormatConversionCharToConvInt(FormatConversionCharInternal::c) \ 
       :
       ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_CHAR_SET_CASE, )
 #undef ABSL_INTERNAL_CHAR_SET_CASE
@@ -363,29 +363,29 @@ constexpr uint64_t FormatConversionCharToConvInt(char conv) {
           : 0;
 }
 
-constexpr FormatConversionCharSet FormatConversionCharToConvValue(char conv) {
-  return static_cast<FormatConversionCharSet>(
-      FormatConversionCharToConvInt(conv));
-}
-
-struct FormatConversionCharSetInternal {
-#define ABSL_INTERNAL_CHAR_SET_CASE(c)         \
-  static constexpr FormatConversionCharSet c = \
-      FormatConversionCharToConvValue(#c[0]);
+constexpr FormatConversionCharSet FormatConversionCharToConvValue(char conv) { 
+  return static_cast<FormatConversionCharSet>( 
+      FormatConversionCharToConvInt(conv)); 
+} 
+ 
+struct FormatConversionCharSetInternal { 
+#define ABSL_INTERNAL_CHAR_SET_CASE(c)         \ 
+  static constexpr FormatConversionCharSet c = \ 
+      FormatConversionCharToConvValue(#c[0]); 
   ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_CHAR_SET_CASE, )
 #undef ABSL_INTERNAL_CHAR_SET_CASE
 
   // Used for width/precision '*' specification.
-  static constexpr FormatConversionCharSet kStar =
-      FormatConversionCharToConvValue('*');
-
-  static constexpr FormatConversionCharSet kIntegral =
-      FormatConversionCharSetUnion(d, i, u, o, x, X);
-  static constexpr FormatConversionCharSet kFloating =
-      FormatConversionCharSetUnion(a, e, f, g, A, E, F, G);
-  static constexpr FormatConversionCharSet kNumeric =
-      FormatConversionCharSetUnion(kIntegral, kFloating);
-  static constexpr FormatConversionCharSet kPointer = p;
+  static constexpr FormatConversionCharSet kStar = 
+      FormatConversionCharToConvValue('*'); 
+
+  static constexpr FormatConversionCharSet kIntegral = 
+      FormatConversionCharSetUnion(d, i, u, o, x, X); 
+  static constexpr FormatConversionCharSet kFloating = 
+      FormatConversionCharSetUnion(a, e, f, g, A, E, F, G); 
+  static constexpr FormatConversionCharSet kNumeric = 
+      FormatConversionCharSetUnion(kIntegral, kFloating); 
+  static constexpr FormatConversionCharSet kPointer = p; 
 };
 
 // Type safe OR operator.
@@ -395,29 +395,29 @@ struct FormatConversionCharSetInternal {
 //  2. We use "enum class" which would not work even if we accepted the decay.
 constexpr FormatConversionCharSet operator|(FormatConversionCharSet a,
                                             FormatConversionCharSet b) {
-  return FormatConversionCharSetUnion(a, b);
-}
-
-// Overloaded conversion functions to support y_absl::ParsedFormat.
-// Get a conversion with a single character in it.
-constexpr FormatConversionCharSet ToFormatConversionCharSet(char c) {
-  return static_cast<FormatConversionCharSet>(
-      FormatConversionCharToConvValue(c));
+  return FormatConversionCharSetUnion(a, b); 
 }
 
+// Overloaded conversion functions to support y_absl::ParsedFormat. 
 // Get a conversion with a single character in it.
-constexpr FormatConversionCharSet ToFormatConversionCharSet(
-    FormatConversionCharSet c) {
-  return c;
+constexpr FormatConversionCharSet ToFormatConversionCharSet(char c) { 
+  return static_cast<FormatConversionCharSet>( 
+      FormatConversionCharToConvValue(c)); 
 }
 
-template <typename T>
-void ToFormatConversionCharSet(T) = delete;
-
+// Get a conversion with a single character in it. 
+constexpr FormatConversionCharSet ToFormatConversionCharSet( 
+    FormatConversionCharSet c) { 
+  return c; 
+} 
+ 
+template <typename T> 
+void ToFormatConversionCharSet(T) = delete; 
+ 
 // Checks whether `c` exists in `set`.
 constexpr bool Contains(FormatConversionCharSet set, char c) {
-  return (static_cast<uint64_t>(set) &
-          static_cast<uint64_t>(FormatConversionCharToConvValue(c))) != 0;
+  return (static_cast<uint64_t>(set) & 
+          static_cast<uint64_t>(FormatConversionCharToConvValue(c))) != 0; 
 }
 
 // Checks whether all the characters in `c` are contained in `set`
@@ -427,10 +427,10 @@ constexpr bool Contains(FormatConversionCharSet set,
          static_cast<uint64_t>(c);
 }
 
-// Checks whether all the characters in `c` are contained in `set`
-constexpr bool Contains(FormatConversionCharSet set, FormatConversionChar c) {
-  return (static_cast<uint64_t>(set) & FormatConversionCharToConvInt(c)) != 0;
-}
+// Checks whether all the characters in `c` are contained in `set` 
+constexpr bool Contains(FormatConversionCharSet set, FormatConversionChar c) { 
+  return (static_cast<uint64_t>(set) & FormatConversionCharToConvInt(c)) != 0; 
+} 
 
 // Return capacity - used, clipped to a minimum of 0.
 inline size_t Excess(size_t used, size_t capacity) {
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.cc
index c49062538d..af48a71cde 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.cc
@@ -1,38 +1,38 @@
-// 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 "y_absl/strings/internal/str_format/float_conversion.h"
 
 #include <string.h>
-
+ 
 #include <algorithm>
 #include <cassert>
 #include <cmath>
-#include <limits>
+#include <limits> 
 #include <util/generic/string.h>
 
-#include "y_absl/base/attributes.h"
+#include "y_absl/base/attributes.h" 
 #include "y_absl/base/config.h"
-#include "y_absl/base/optimization.h"
-#include "y_absl/functional/function_ref.h"
-#include "y_absl/meta/type_traits.h"
-#include "y_absl/numeric/bits.h"
-#include "y_absl/numeric/int128.h"
-#include "y_absl/numeric/internal/representation.h"
-#include "y_absl/strings/numbers.h"
-#include "y_absl/types/optional.h"
-#include "y_absl/types/span.h"
+#include "y_absl/base/optimization.h" 
+#include "y_absl/functional/function_ref.h" 
+#include "y_absl/meta/type_traits.h" 
+#include "y_absl/numeric/bits.h" 
+#include "y_absl/numeric/int128.h" 
+#include "y_absl/numeric/internal/representation.h" 
+#include "y_absl/strings/numbers.h" 
+#include "y_absl/types/optional.h" 
+#include "y_absl/types/span.h" 
 
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
@@ -40,905 +40,905 @@ namespace str_format_internal {
 
 namespace {
 
-using ::y_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
-// array and call the provided callback with said memory.
-// It will allocate memory in increments of 512 bytes. We could allocate the
-// largest needed unconditionally, but that is more than we need in most of
-// cases. This way we use less stack in the common cases.
-class StackArray {
-  using Func = y_absl::FunctionRef<void(y_absl::Span<uint32_t>)>;
-  static constexpr size_t kStep = 512 / sizeof(uint32_t);
-  // 5 steps is 2560 bytes, which is enough to hold a long double with the
-  // largest/smallest exponents.
-  // The operations below will static_assert their particular maximum.
-  static constexpr size_t kNumSteps = 5;
-
-  // We do not want this function to be inlined.
-  // Otherwise the caller will allocate the stack space unnecessarily for all
-  // the variants even though it only calls one.
-  template <size_t steps>
-  ABSL_ATTRIBUTE_NOINLINE static void RunWithCapacityImpl(Func f) {
-    uint32_t values[steps * kStep]{};
-    f(y_absl::MakeSpan(values));
-  }
-
- public:
-  static constexpr size_t kMaxCapacity = kStep * kNumSteps;
-
-  static void RunWithCapacity(size_t capacity, Func f) {
-    assert(capacity <= kMaxCapacity);
-    const size_t step = (capacity + kStep - 1) / kStep;
-    assert(step <= kNumSteps);
-    switch (step) {
-      case 1:
-        return RunWithCapacityImpl<1>(f);
-      case 2:
-        return RunWithCapacityImpl<2>(f);
-      case 3:
-        return RunWithCapacityImpl<3>(f);
-      case 4:
-        return RunWithCapacityImpl<4>(f);
-      case 5:
-        return RunWithCapacityImpl<5>(f);
-    }
-
-    assert(false && "Invalid capacity");
-  }
-};
-
-// Calculates `10 * (*v) + carry` and stores the result in `*v` and returns
-// the carry.
-template <typename Int>
-inline Int MultiplyBy10WithCarry(Int *v, Int carry) {
-  using BiggerInt = y_absl::conditional_t<sizeof(Int) == 4, uint64_t, uint128>;
-  BiggerInt tmp = 10 * static_cast<BiggerInt>(*v) + carry;
-  *v = static_cast<Int>(tmp);
-  return static_cast<Int>(tmp >> (sizeof(Int) * 8));
-}
-
-// Calculates `(2^64 * carry + *v) / 10`.
-// Stores the quotient in `*v` and returns the remainder.
-// Requires: `0 <= carry <= 9`
-inline uint64_t DivideBy10WithCarry(uint64_t *v, uint64_t carry) {
-  constexpr uint64_t divisor = 10;
-  // 2^64 / divisor = chunk_quotient + chunk_remainder / divisor
-  constexpr uint64_t chunk_quotient = (uint64_t{1} << 63) / (divisor / 2);
-  constexpr uint64_t chunk_remainder = uint64_t{} - chunk_quotient * divisor;
-
-  const uint64_t mod = *v % divisor;
-  const uint64_t next_carry = chunk_remainder * carry + mod;
-  *v = *v / divisor + carry * chunk_quotient + next_carry / divisor;
-  return next_carry % divisor;
-}
-
-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`.
-class BinaryToDecimal {
-  static constexpr int ChunksNeeded(int exp) {
-    // We will left shift a uint128 by `exp` bits, so we need `128+exp` total
-    // bits. Round up to 32.
-    // See constructor for details about adding `10%` to the value.
-    return (128 + exp + 31) / 32 * 11 / 10;
-  }
-
- public:
-  // Run the conversion for `v * 2^exp` and call `f(binary_to_decimal)`.
-  // This function will allocate enough stack space to perform the conversion.
-  static void RunConversion(uint128 v, int exp,
-                            y_absl::FunctionRef<void(BinaryToDecimal)> f) {
-    assert(exp > 0);
-    assert(exp <= std::numeric_limits<MaxFloatType>::max_exponent);
-    static_assert(
-        static_cast<int>(StackArray::kMaxCapacity) >=
-            ChunksNeeded(std::numeric_limits<MaxFloatType>::max_exponent),
-        "");
-
-    StackArray::RunWithCapacity(
-        ChunksNeeded(exp),
-        [=](y_absl::Span<uint32_t> input) { f(BinaryToDecimal(input, v, exp)); });
-  }
-
-  int TotalDigits() const {
-    return static_cast<int>((decimal_end_ - decimal_start_) * kDigitsPerChunk +
-                            CurrentDigits().size());
-  }
-
-  // See the current block of digits.
-  y_absl::string_view CurrentDigits() const {
-    return y_absl::string_view(digits_ + kDigitsPerChunk - size_, size_);
-  }
-
-  // Advance the current view of digits.
-  // Returns `false` when no more digits are available.
-  bool AdvanceDigits() {
-    if (decimal_start_ >= decimal_end_) return false;
-
-    uint32_t w = data_[decimal_start_++];
-    for (size_ = 0; size_ < kDigitsPerChunk; w /= 10) {
-      digits_[kDigitsPerChunk - ++size_] = w % 10 + '0';
-    }
-    return true;
-  }
-
- private:
-  BinaryToDecimal(y_absl::Span<uint32_t> data, uint128 v, int exp) : data_(data) {
-    // We need to print the digits directly into the sink object without
-    // buffering them all first. To do this we need two things:
-    // - to know the total number of digits to do padding when necessary
-    // - to generate the decimal digits from the left.
-    //
-    // In order to do this, we do a two pass conversion.
-    // On the first pass we convert the binary representation of the value into
-    // a decimal representation in which each uint32_t chunk holds up to 9
-    // decimal digits.  In the second pass we take each decimal-holding-uint32_t
-    // value and generate the ascii decimal digits into `digits_`.
-    //
-    // The binary and decimal representations actually share the same memory
-    // region. As we go converting the chunks from binary to decimal we free
-    // them up and reuse them for the decimal representation. One caveat is that
-    // the decimal representation is around 7% less efficient in space than the
-    // binary one. We allocate an extra 10% memory to account for this. See
-    // ChunksNeeded for this calculation.
-    int chunk_index = exp / 32;
-    decimal_start_ = decimal_end_ = ChunksNeeded(exp);
-    const int offset = exp % 32;
-    // Left shift v by exp bits.
-    data_[chunk_index] = static_cast<uint32_t>(v << offset);
-    for (v >>= (32 - offset); v; v >>= 32)
-      data_[++chunk_index] = static_cast<uint32_t>(v);
-
-    while (chunk_index >= 0) {
-      // While we have more than one chunk available, go in steps of 1e9.
-      // `data_[chunk_index]` holds the highest non-zero binary chunk, so keep
-      // the variable updated.
-      uint32_t carry = 0;
-      for (int i = chunk_index; i >= 0; --i) {
-        uint64_t tmp = uint64_t{data_[i]} + (uint64_t{carry} << 32);
-        data_[i] = static_cast<uint32_t>(tmp / uint64_t{1000000000});
-        carry = static_cast<uint32_t>(tmp % uint64_t{1000000000});
-      }
-
-      // If the highest chunk is now empty, remove it from view.
-      if (data_[chunk_index] == 0) --chunk_index;
-
-      --decimal_start_;
-      assert(decimal_start_ != chunk_index);
-      data_[decimal_start_] = carry;
-    }
-
-    // Fill the first set of digits. The first chunk might not be complete, so
-    // handle differently.
-    for (uint32_t first = data_[decimal_start_++]; first != 0; first /= 10) {
-      digits_[kDigitsPerChunk - ++size_] = first % 10 + '0';
-    }
-  }
-
- private:
-  static constexpr int kDigitsPerChunk = 9;
-
-  int decimal_start_;
-  int decimal_end_;
-
-  char digits_[kDigitsPerChunk];
-  int size_ = 0;
-
-  y_absl::Span<uint32_t> data_;
-};
-
-// 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`.
-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, y_absl::FunctionRef<void(FractionalDigitGenerator)> f) {
-    using Limits = std::numeric_limits<MaxFloatType>;
-    assert(-exp < 0);
-    assert(-exp >= Limits::min_exponent - 128);
-    static_assert(StackArray::kMaxCapacity >=
-                      (Limits::digits + 128 - Limits::min_exponent + 31) / 32,
-                  "");
-    StackArray::RunWithCapacity((Limits::digits + exp + 31) / 32,
-                                [=](y_absl::Span<uint32_t> input) {
-                                  f(FractionalDigitGenerator(input, v, exp));
-                                });
-  }
-
-  // Returns true if there are any more non-zero digits left.
-  bool HasMoreDigits() const { return next_digit_ != 0 || chunk_index_ >= 0; }
-
-  // Returns true if the remainder digits are greater than 5000...
-  bool IsGreaterThanHalf() const {
-    return next_digit_ > 5 || (next_digit_ == 5 && chunk_index_ >= 0);
-  }
-  // Returns true if the remainder digits are exactly 5000...
-  bool IsExactlyHalf() const { return next_digit_ == 5 && chunk_index_ < 0; }
-
-  struct Digits {
-    int digit_before_nine;
-    int num_nines;
-  };
-
-  // Get the next set of digits.
-  // They are composed by a non-9 digit followed by a runs of zero or more 9s.
-  Digits GetDigits() {
-    Digits digits{next_digit_, 0};
-
-    next_digit_ = GetOneDigit();
-    while (next_digit_ == 9) {
-      ++digits.num_nines;
-      next_digit_ = GetOneDigit();
-    }
-
-    return digits;
-  }
-
- private:
-  // Return the next digit.
-  int GetOneDigit() {
-    if (chunk_index_ < 0) return 0;
-
-    uint32_t carry = 0;
-    for (int i = chunk_index_; i >= 0; --i) {
-      carry = MultiplyBy10WithCarry(&data_[i], carry);
-    }
-    // If the lowest chunk is now empty, remove it from view.
-    if (data_[chunk_index_] == 0) --chunk_index_;
-    return carry;
-  }
-
-  FractionalDigitGenerator(y_absl::Span<uint32_t> data, uint128 v, int exp)
-      : chunk_index_(exp / 32), data_(data) {
-    const int offset = exp % 32;
-    // Right shift `v` by `exp` bits.
-    data_[chunk_index_] = static_cast<uint32_t>(v << (32 - offset));
-    v >>= offset;
-    // Make sure we don't overflow the data. We already calculated that
-    // non-zero bits fit, so we might not have space for leading zero bits.
-    for (int pos = chunk_index_; v; v >>= 32)
-      data_[--pos] = static_cast<uint32_t>(v);
-
-    // Fill next_digit_, as GetDigits expects it to be populated always.
-    next_digit_ = GetOneDigit();
-  }
-
-  int next_digit_;
-  int chunk_index_;
-  y_absl::Span<uint32_t> data_;
-};
-
-// Count the number of leading zero bits.
-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);
-}
-
-// Round up the text digits starting at `p`.
-// The buffer must have an extra digit that is known to not need rounding.
-// This is done below by having an extra '0' digit on the left.
-void RoundUp(char *p) {
-  while (*p == '9' || *p == '.') {
-    if (*p == '9') *p = '0';
-    --p;
-  }
-  ++*p;
-}
-
-// Check the previous digit and round up or down to follow the round-to-even
-// policy.
-void RoundToEven(char *p) {
-  if (*p == '.') --p;
-  if (*p % 2 == 1) RoundUp(p);
-}
-
-// Simple integral decimal digit printing for values that fit in 64-bits.
-// Returns the pointer to the last written digit.
-char *PrintIntegralDigitsFromRightFast(uint64_t v, char *p) {
-  do {
-    *--p = DivideBy10WithCarry(&v, 0) + '0';
-  } while (v != 0);
-  return p;
-}
-
-// Simple integral decimal digit printing for values that fit in 128-bits.
-// Returns the pointer to the last written digit.
-char *PrintIntegralDigitsFromRightFast(uint128 v, char *p) {
-  auto high = static_cast<uint64_t>(v >> 64);
-  auto low = static_cast<uint64_t>(v);
-
-  while (high != 0) {
-    uint64_t carry = DivideBy10WithCarry(&high, 0);
-    carry = DivideBy10WithCarry(&low, carry);
-    *--p = carry + '0';
-  }
-  return PrintIntegralDigitsFromRightFast(low, p);
-}
-
-// Simple fractional decimal digit printing for values that fir in 64-bits after
-// shifting.
-// Performs rounding if necessary to fit within `precision`.
-// Returns the pointer to one after the last character written.
-char *PrintFractionalDigitsFast(uint64_t v, char *start, int exp,
-                                int precision) {
-  char *p = start;
-  v <<= (64 - exp);
-  while (precision > 0) {
-    if (!v) return p;
-    *p++ = MultiplyBy10WithCarry(&v, uint64_t{0}) + '0';
-    --precision;
-  }
-
-  // We need to round.
-  if (v < 0x8000000000000000) {
-    // We round down, so nothing to do.
-  } else if (v > 0x8000000000000000) {
-    // We round up.
-    RoundUp(p - 1);
-  } else {
-    RoundToEven(p - 1);
-  }
-
-  assert(precision == 0);
-  // Precision can only be zero here.
-  return p;
-}
-
-// Simple fractional decimal digit printing for values that fir in 128-bits
-// after shifting.
-// Performs rounding if necessary to fit within `precision`.
-// Returns the pointer to one after the last character written.
-char *PrintFractionalDigitsFast(uint128 v, char *start, int exp,
-                                int precision) {
-  char *p = start;
-  v <<= (128 - exp);
-  auto high = static_cast<uint64_t>(v >> 64);
-  auto low = static_cast<uint64_t>(v);
-
-  // While we have digits to print and `low` is not empty, do the long
-  // multiplication.
-  while (precision > 0 && low != 0) {
-    uint64_t carry = MultiplyBy10WithCarry(&low, uint64_t{0});
-    carry = MultiplyBy10WithCarry(&high, carry);
-
-    *p++ = carry + '0';
-    --precision;
-  }
-
-  // Now `low` is empty, so use a faster approach for the rest of the digits.
-  // This block is pretty much the same as the main loop for the 64-bit case
-  // above.
-  while (precision > 0) {
-    if (!high) return p;
-    *p++ = MultiplyBy10WithCarry(&high, uint64_t{0}) + '0';
-    --precision;
-  }
-
-  // We need to round.
-  if (high < 0x8000000000000000) {
-    // We round down, so nothing to do.
-  } else if (high > 0x8000000000000000 || low != 0) {
-    // We round up.
-    RoundUp(p - 1);
-  } else {
-    RoundToEven(p - 1);
-  }
-
-  assert(precision == 0);
-  // Precision can only be zero here.
-  return p;
-}
-
-struct FormatState {
-  char sign_char;
-  int precision;
-  const FormatConversionSpecImpl &conv;
-  FormatSinkImpl *sink;
-
-  // In `alt` mode (flag #) we keep the `.` even if there are no fractional
-  // digits. In non-alt mode, we strip it.
-  bool ShouldPrintDot() const { return precision != 0 || conv.has_alt_flag(); }
-};
-
-struct Padding {
-  int left_spaces;
-  int zeros;
-  int right_spaces;
-};
-
-Padding ExtraWidthToPadding(size_t total_size, const FormatState &state) {
-  if (state.conv.width() < 0 ||
-      static_cast<size_t>(state.conv.width()) <= total_size) {
-    return {0, 0, 0};
-  }
-  int missing_chars = state.conv.width() - total_size;
-  if (state.conv.has_left_flag()) {
-    return {0, 0, missing_chars};
-  } else if (state.conv.has_zero_flag()) {
-    return {0, missing_chars, 0};
-  } else {
-    return {missing_chars, 0, 0};
-  }
-}
-
-void FinalPrint(const FormatState &state, y_absl::string_view data,
-                int padding_offset, int trailing_zeros,
-                y_absl::string_view data_postfix) {
-  if (state.conv.width() < 0) {
-    // No width specified. Fast-path.
-    if (state.sign_char != '\0') state.sink->Append(1, state.sign_char);
-    state.sink->Append(data);
-    state.sink->Append(trailing_zeros, '0');
-    state.sink->Append(data_postfix);
-    return;
-  }
-
-  auto padding = ExtraWidthToPadding((state.sign_char != '\0' ? 1 : 0) +
-                                         data.size() + data_postfix.size() +
-                                         static_cast<size_t>(trailing_zeros),
-                                     state);
-
-  state.sink->Append(padding.left_spaces, ' ');
-  if (state.sign_char != '\0') state.sink->Append(1, state.sign_char);
-  // Padding in general needs to be inserted somewhere in the middle of `data`.
-  state.sink->Append(data.substr(0, padding_offset));
-  state.sink->Append(padding.zeros, '0');
-  state.sink->Append(data.substr(padding_offset));
-  state.sink->Append(trailing_zeros, '0');
-  state.sink->Append(data_postfix);
-  state.sink->Append(padding.right_spaces, ' ');
-}
-
-// Fastpath %f formatter for when the shifted value fits in a simple integral
-// type.
-// Prints `v*2^exp` with the options from `state`.
-template <typename Int>
-void FormatFFast(Int v, int exp, const FormatState &state) {
-  constexpr int input_bits = sizeof(Int) * 8;
-
-  static constexpr size_t integral_size =
-      /* in case we need to round up an extra digit */ 1 +
-      /* decimal digits for uint128 */ 40 + 1;
-  char buffer[integral_size + /* . */ 1 + /* max digits uint128 */ 128];
-  buffer[integral_size] = '.';
-  char *const integral_digits_end = buffer + integral_size;
-  char *integral_digits_start;
-  char *const fractional_digits_start = buffer + integral_size + 1;
-  char *fractional_digits_end = fractional_digits_start;
-
-  if (exp >= 0) {
-    const int total_bits = input_bits - LeadingZeros(v) + exp;
-    integral_digits_start =
-        total_bits <= 64
-            ? PrintIntegralDigitsFromRightFast(static_cast<uint64_t>(v) << exp,
-                                               integral_digits_end)
-            : PrintIntegralDigitsFromRightFast(static_cast<uint128>(v) << exp,
-                                               integral_digits_end);
-  } else {
-    exp = -exp;
-
-    integral_digits_start = PrintIntegralDigitsFromRightFast(
-        exp < input_bits ? v >> exp : 0, integral_digits_end);
-    // PrintFractionalDigits may pull a carried 1 all the way up through the
-    // integral portion.
-    integral_digits_start[-1] = '0';
-
-    fractional_digits_end =
-        exp <= 64 ? PrintFractionalDigitsFast(v, fractional_digits_start, exp,
-                                              state.precision)
-                  : PrintFractionalDigitsFast(static_cast<uint128>(v),
-                                              fractional_digits_start, exp,
-                                              state.precision);
-    // There was a carry, so include the first digit too.
-    if (integral_digits_start[-1] != '0') --integral_digits_start;
-  }
-
-  size_t size = fractional_digits_end - integral_digits_start;
-
-  // In `alt` mode (flag #) we keep the `.` even if there are no fractional
-  // digits. In non-alt mode, we strip it.
-  if (!state.ShouldPrintDot()) --size;
-  FinalPrint(state, y_absl::string_view(integral_digits_start, size),
-             /*padding_offset=*/0,
-             static_cast<int>(state.precision - (fractional_digits_end -
-                                                 fractional_digits_start)),
-             /*data_postfix=*/"");
-}
-
-// Slow %f formatter for when the shifted value does not fit in a uint128, and
-// `exp > 0`.
-// Prints `v*2^exp` with the options from `state`.
-// This one is guaranteed to not have fractional digits, so we don't have to
-// worry about anything after the `.`.
-void FormatFPositiveExpSlow(uint128 v, int exp, const FormatState &state) {
-  BinaryToDecimal::RunConversion(v, exp, [&](BinaryToDecimal btd) {
-    const size_t total_digits =
-        btd.TotalDigits() +
-        (state.ShouldPrintDot() ? static_cast<size_t>(state.precision) + 1 : 0);
-
-    const auto padding = ExtraWidthToPadding(
-        total_digits + (state.sign_char != '\0' ? 1 : 0), state);
-
-    state.sink->Append(padding.left_spaces, ' ');
-    if (state.sign_char != '\0') state.sink->Append(1, state.sign_char);
-    state.sink->Append(padding.zeros, '0');
-
-    do {
-      state.sink->Append(btd.CurrentDigits());
-    } while (btd.AdvanceDigits());
-
-    if (state.ShouldPrintDot()) state.sink->Append(1, '.');
-    state.sink->Append(state.precision, '0');
-    state.sink->Append(padding.right_spaces, ' ');
-  });
-}
-
-// Slow %f formatter for when the shifted value does not fit in a uint128, and
-// `exp < 0`.
-// Prints `v*2^exp` with the options from `state`.
-// This one is guaranteed to be < 1.0, so we don't have to worry about integral
-// digits.
-void FormatFNegativeExpSlow(uint128 v, int exp, const FormatState &state) {
-  const size_t total_digits =
-      /* 0 */ 1 +
-      (state.ShouldPrintDot() ? static_cast<size_t>(state.precision) + 1 : 0);
-  auto padding =
-      ExtraWidthToPadding(total_digits + (state.sign_char ? 1 : 0), state);
-  padding.zeros += 1;
-  state.sink->Append(padding.left_spaces, ' ');
-  if (state.sign_char != '\0') state.sink->Append(1, state.sign_char);
-  state.sink->Append(padding.zeros, '0');
-
-  if (state.ShouldPrintDot()) state.sink->Append(1, '.');
-
-  // Print digits
-  int digits_to_go = state.precision;
-
-  FractionalDigitGenerator::RunConversion(
-      v, exp, [&](FractionalDigitGenerator digit_gen) {
-        // There are no digits to print here.
-        if (state.precision == 0) return;
-
-        // We go one digit at a time, while keeping track of runs of nines.
-        // The runs of nines are used to perform rounding when necessary.
-
-        while (digits_to_go > 0 && digit_gen.HasMoreDigits()) {
-          auto digits = digit_gen.GetDigits();
-
-          // Now we have a digit and a run of nines.
-          // See if we can print them all.
-          if (digits.num_nines + 1 < digits_to_go) {
-            // We don't have to round yet, so print them.
-            state.sink->Append(1, digits.digit_before_nine + '0');
-            state.sink->Append(digits.num_nines, '9');
-            digits_to_go -= digits.num_nines + 1;
-
-          } else {
-            // We can't print all the nines, see where we have to truncate.
-
-            bool round_up = false;
-            if (digits.num_nines + 1 > digits_to_go) {
-              // We round up at a nine. No need to print them.
-              round_up = true;
-            } else {
-              // We can fit all the nines, but truncate just after it.
-              if (digit_gen.IsGreaterThanHalf()) {
-                round_up = true;
-              } else if (digit_gen.IsExactlyHalf()) {
-                // Round to even
-                round_up =
-                    digits.num_nines != 0 || digits.digit_before_nine % 2 == 1;
-              }
-            }
-
-            if (round_up) {
-              state.sink->Append(1, digits.digit_before_nine + '1');
-              --digits_to_go;
-              // The rest will be zeros.
-            } else {
-              state.sink->Append(1, digits.digit_before_nine + '0');
-              state.sink->Append(digits_to_go - 1, '9');
-              digits_to_go = 0;
-            }
-            return;
-          }
-        }
-      });
-
-  state.sink->Append(digits_to_go, '0');
-  state.sink->Append(padding.right_spaces, ' ');
-}
-
-template <typename Int>
-void FormatF(Int mantissa, int exp, const FormatState &state) {
-  if (exp >= 0) {
-    const int total_bits = sizeof(Int) * 8 - LeadingZeros(mantissa) + exp;
-
-    // Fallback to the slow stack-based approach if we can't do it in a 64 or
-    // 128 bit state.
-    if (ABSL_PREDICT_FALSE(total_bits > 128)) {
-      return FormatFPositiveExpSlow(mantissa, exp, state);
-    }
-  } else {
-    // Fallback to the slow stack-based approach if we can't do it in a 64 or
-    // 128 bit state.
-    if (ABSL_PREDICT_FALSE(exp < -128)) {
-      return FormatFNegativeExpSlow(mantissa, -exp, state);
-    }
-  }
-  return FormatFFast(mantissa, exp, state);
-}
-
-// Grab the group of four bits (nibble) from `n`. E.g., nibble 1 corresponds to
-// bits 4-7.
-template <typename Int>
-uint8_t GetNibble(Int n, int nibble_index) {
-  constexpr Int mask_low_nibble = Int{0xf};
-  int shift = nibble_index * 4;
-  n &= mask_low_nibble << shift;
-  return static_cast<uint8_t>((n >> shift) & 0xf);
-}
-
-// Add one to the given nibble, applying carry to higher nibbles. Returns true
-// if overflow, false otherwise.
-template <typename Int>
-bool IncrementNibble(int nibble_index, Int *n) {
-  constexpr int kShift = sizeof(Int) * 8 - 1;
-  constexpr int kNumNibbles = sizeof(Int) * 8 / 4;
-  Int before = *n >> kShift;
-  // Here we essentially want to take the number 1 and move it into the requsted
-  // nibble, then add it to *n to effectively increment the nibble. However,
-  // ASan will complain if we try to shift the 1 beyond the limits of the Int,
-  // i.e., if the nibble_index is out of range. So therefore we check for this
-  // and if we are out of range we just add 0 which leaves *n unchanged, which
-  // seems like the reasonable thing to do in that case.
-  *n += ((nibble_index >= kNumNibbles) ? 0 : (Int{1} << (nibble_index * 4)));
-  Int after = *n >> kShift;
-  return (before && !after) || (nibble_index >= kNumNibbles);
-}
-
-// Return a mask with 1's in the given nibble and all lower nibbles.
-template <typename Int>
-Int MaskUpToNibbleInclusive(int nibble_index) {
-  constexpr int kNumNibbles = sizeof(Int) * 8 / 4;
-  static const Int ones = ~Int{0};
-  return ones >> std::max(0, 4 * (kNumNibbles - nibble_index - 1));
-}
-
-// Return a mask with 1's below the given nibble.
-template <typename Int>
-Int MaskUpToNibbleExclusive(int nibble_index) {
-  return nibble_index <= 0 ? 0 : MaskUpToNibbleInclusive<Int>(nibble_index - 1);
-}
-
-template <typename Int>
-Int MoveToNibble(uint8_t nibble, int nibble_index) {
-  return Int{nibble} << (4 * nibble_index);
-}
-
-// Given mantissa size, find optimal # of mantissa bits to put in initial digit.
-//
-// In the hex representation we keep a single hex digit to the left of the dot.
-// However, the question as to how many bits of the mantissa should be put into
-// that hex digit in theory is arbitrary, but in practice it is optimal to
-// choose based on the size of the mantissa. E.g., for a `double`, there are 53
-// mantissa bits, so that means that we should put 1 bit to the left of the dot,
-// thereby leaving 52 bits to the right, which is evenly divisible by four and
-// thus all fractional digits represent actual precision. For a `long double`,
-// on the other hand, there are 64 bits of mantissa, thus we can use all four
-// bits for the initial hex digit and still have a number left over (60) that is
-// a multiple of four. Once again, the goal is to have all fractional digits
-// represent real precision.
-template <typename Float>
-constexpr int HexFloatLeadingDigitSizeInBits() {
-  return std::numeric_limits<Float>::digits % 4 > 0
-             ? std::numeric_limits<Float>::digits % 4
-             : 4;
-}
-
-// This function captures the rounding behavior of glibc for hex float
-// representations. E.g. when rounding 0x1.ab800000 to a precision of .2
-// ("%.2a") glibc will round up because it rounds toward the even number (since
-// 0xb is an odd number, it will round up to 0xc). However, when rounding at a
-// point that is not followed by 800000..., it disregards the parity and rounds
-// up if > 8 and rounds down if < 8.
-template <typename Int>
-bool HexFloatNeedsRoundUp(Int mantissa, int final_nibble_displayed,
-                          uint8_t leading) {
-  // If the last nibble (hex digit) to be displayed is the lowest on in the
-  // mantissa then that means that we don't have any further nibbles to inform
-  // rounding, so don't round.
-  if (final_nibble_displayed <= 0) {
-    return false;
-  }
-  int rounding_nibble_idx = final_nibble_displayed - 1;
-  constexpr int kTotalNibbles = sizeof(Int) * 8 / 4;
-  assert(final_nibble_displayed <= kTotalNibbles);
-  Int mantissa_up_to_rounding_nibble_inclusive =
-      mantissa & MaskUpToNibbleInclusive<Int>(rounding_nibble_idx);
-  Int eight = MoveToNibble<Int>(8, rounding_nibble_idx);
-  if (mantissa_up_to_rounding_nibble_inclusive != eight) {
-    return mantissa_up_to_rounding_nibble_inclusive > eight;
-  }
-  // Nibble in question == 8.
-  uint8_t round_if_odd = (final_nibble_displayed == kTotalNibbles)
-                             ? leading
-                             : GetNibble(mantissa, final_nibble_displayed);
-  return round_if_odd % 2 == 1;
-}
-
-// Stores values associated with a Float type needed by the FormatA
-// implementation in order to avoid templatizing that function by the Float
-// type.
-struct HexFloatTypeParams {
-  template <typename Float>
-  explicit HexFloatTypeParams(Float)
-      : min_exponent(std::numeric_limits<Float>::min_exponent - 1),
-        leading_digit_size_bits(HexFloatLeadingDigitSizeInBits<Float>()) {
-    assert(leading_digit_size_bits >= 1 && leading_digit_size_bits <= 4);
-  }
-
-  int min_exponent;
-  int leading_digit_size_bits;
-};
-
-// Hex Float Rounding. First check if we need to round; if so, then we do that
-// by manipulating (incrementing) the mantissa, that way we can later print the
-// mantissa digits by iterating through them in the same way regardless of
-// whether a rounding happened.
-template <typename Int>
-void FormatARound(bool precision_specified, const FormatState &state,
-                  uint8_t *leading, Int *mantissa, int *exp) {
-  constexpr int kTotalNibbles = sizeof(Int) * 8 / 4;
-  // Index of the last nibble that we could display given precision.
-  int final_nibble_displayed =
-      precision_specified ? std::max(0, (kTotalNibbles - state.precision)) : 0;
-  if (HexFloatNeedsRoundUp(*mantissa, final_nibble_displayed, *leading)) {
-    // Need to round up.
-    bool overflow = IncrementNibble(final_nibble_displayed, mantissa);
-    *leading += (overflow ? 1 : 0);
-    if (ABSL_PREDICT_FALSE(*leading > 15)) {
-      // We have overflowed the leading digit. This would mean that we would
-      // need two hex digits to the left of the dot, which is not allowed. So
-      // adjust the mantissa and exponent so that the result is always 1.0eXXX.
-      *leading = 1;
-      *mantissa = 0;
-      *exp += 4;
-    }
-  }
-  // Now that we have handled a possible round-up we can go ahead and zero out
-  // all the nibbles of the mantissa that we won't need.
-  if (precision_specified) {
-    *mantissa &= ~MaskUpToNibbleExclusive<Int>(final_nibble_displayed);
-  }
-}
-
-template <typename Int>
-void FormatANormalize(const HexFloatTypeParams float_traits, uint8_t *leading,
-                      Int *mantissa, int *exp) {
-  constexpr int kIntBits = sizeof(Int) * 8;
-  static const Int kHighIntBit = Int{1} << (kIntBits - 1);
-  const int kLeadDigitBitsCount = float_traits.leading_digit_size_bits;
-  // Normalize mantissa so that highest bit set is in MSB position, unless we
-  // get interrupted by the exponent threshold.
-  while (*mantissa && !(*mantissa & kHighIntBit)) {
-    if (ABSL_PREDICT_FALSE(*exp - 1 < float_traits.min_exponent)) {
-      *mantissa >>= (float_traits.min_exponent - *exp);
-      *exp = float_traits.min_exponent;
-      return;
-    }
-    *mantissa <<= 1;
-    --*exp;
-  }
-  // Extract bits for leading digit then shift them away leaving the
-  // fractional part.
-  *leading =
-      static_cast<uint8_t>(*mantissa >> (kIntBits - kLeadDigitBitsCount));
-  *exp -= (*mantissa != 0) ? kLeadDigitBitsCount : *exp;
-  *mantissa <<= kLeadDigitBitsCount;
-}
-
-template <typename Int>
-void FormatA(const HexFloatTypeParams float_traits, Int mantissa, int exp,
-             bool uppercase, const FormatState &state) {
-  // Int properties.
-  constexpr int kIntBits = sizeof(Int) * 8;
-  constexpr int kTotalNibbles = sizeof(Int) * 8 / 4;
-  // Did the user specify a precision explicitly?
-  const bool precision_specified = state.conv.precision() >= 0;
-
-  // ========== Normalize/Denormalize ==========
-  exp += kIntBits;  // make all digits fractional digits.
-  // This holds the (up to four) bits of leading digit, i.e., the '1' in the
-  // number 0x1.e6fp+2. It's always > 0 unless number is zero or denormal.
-  uint8_t leading = 0;
-  FormatANormalize(float_traits, &leading, &mantissa, &exp);
-
-  // =============== Rounding ==================
-  // Check if we need to round; if so, then we do that by manipulating
-  // (incrementing) the mantissa before beginning to print characters.
-  FormatARound(precision_specified, state, &leading, &mantissa, &exp);
-
-  // ============= Format Result ===============
-  // 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)
-  char digits_buffer[kBufSizeForHexFloatRepr];
-  char *digits_iter = digits_buffer;
-  const char *const digits =
-      static_cast<const char *>("0123456789ABCDEF0123456789abcdef") +
-      (uppercase ? 0 : 16);
-
-  // =============== Hex Prefix ================
-  *digits_iter++ = '0';
-  *digits_iter++ = uppercase ? 'X' : 'x';
-
-  // ========== Non-Fractional Digit ===========
-  *digits_iter++ = digits[leading];
-
-  // ================== Dot ====================
-  // There are three reasons we might need a dot. Keep in mind that, at this
-  // point, the mantissa holds only the fractional part.
-  if ((precision_specified && state.precision > 0) ||
-      (!precision_specified && mantissa > 0) || state.conv.has_alt_flag()) {
-    *digits_iter++ = '.';
-  }
-
-  // ============ Fractional Digits ============
-  int digits_emitted = 0;
-  while (mantissa > 0) {
-    *digits_iter++ = digits[GetNibble(mantissa, kTotalNibbles - 1)];
-    mantissa <<= 4;
-    ++digits_emitted;
-  }
-  int trailing_zeros =
-      precision_specified ? state.precision - digits_emitted : 0;
-  assert(trailing_zeros >= 0);
-  auto digits_result = string_view(digits_buffer, digits_iter - digits_buffer);
-
-  // =============== Exponent ==================
-  constexpr size_t kBufSizeForExpDecRepr =
-      numbers_internal::kFastToBufferSize  // requred for FastIntToBuffer
-      + 1                                  // 'p' or 'P'
-      + 1;                                 // '+' or '-'
-  char exp_buffer[kBufSizeForExpDecRepr];
-  exp_buffer[0] = uppercase ? 'P' : 'p';
-  exp_buffer[1] = exp >= 0 ? '+' : '-';
-  numbers_internal::FastIntToBuffer(exp < 0 ? -exp : exp, exp_buffer + 2);
-
-  // ============ Assemble Result ==============
-  FinalPrint(state,           //
-             digits_result,   // 0xN.NNN...
-             2,               // offset in `data` to start padding if needed.
-             trailing_zeros,  // num remaining mantissa padding zeros
-             exp_buffer);     // exponent
-}
-
-char *CopyStringTo(y_absl::string_view v, char *out) {
+using ::y_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 
+// array and call the provided callback with said memory. 
+// It will allocate memory in increments of 512 bytes. We could allocate the 
+// largest needed unconditionally, but that is more than we need in most of 
+// cases. This way we use less stack in the common cases. 
+class StackArray { 
+  using Func = y_absl::FunctionRef<void(y_absl::Span<uint32_t>)>; 
+  static constexpr size_t kStep = 512 / sizeof(uint32_t); 
+  // 5 steps is 2560 bytes, which is enough to hold a long double with the 
+  // largest/smallest exponents. 
+  // The operations below will static_assert their particular maximum. 
+  static constexpr size_t kNumSteps = 5; 
+ 
+  // We do not want this function to be inlined. 
+  // Otherwise the caller will allocate the stack space unnecessarily for all 
+  // the variants even though it only calls one. 
+  template <size_t steps> 
+  ABSL_ATTRIBUTE_NOINLINE static void RunWithCapacityImpl(Func f) { 
+    uint32_t values[steps * kStep]{}; 
+    f(y_absl::MakeSpan(values)); 
+  } 
+ 
+ public: 
+  static constexpr size_t kMaxCapacity = kStep * kNumSteps; 
+ 
+  static void RunWithCapacity(size_t capacity, Func f) { 
+    assert(capacity <= kMaxCapacity); 
+    const size_t step = (capacity + kStep - 1) / kStep; 
+    assert(step <= kNumSteps); 
+    switch (step) { 
+      case 1: 
+        return RunWithCapacityImpl<1>(f); 
+      case 2: 
+        return RunWithCapacityImpl<2>(f); 
+      case 3: 
+        return RunWithCapacityImpl<3>(f); 
+      case 4: 
+        return RunWithCapacityImpl<4>(f); 
+      case 5: 
+        return RunWithCapacityImpl<5>(f); 
+    } 
+ 
+    assert(false && "Invalid capacity"); 
+  } 
+}; 
+ 
+// Calculates `10 * (*v) + carry` and stores the result in `*v` and returns 
+// the carry. 
+template <typename Int> 
+inline Int MultiplyBy10WithCarry(Int *v, Int carry) { 
+  using BiggerInt = y_absl::conditional_t<sizeof(Int) == 4, uint64_t, uint128>; 
+  BiggerInt tmp = 10 * static_cast<BiggerInt>(*v) + carry; 
+  *v = static_cast<Int>(tmp); 
+  return static_cast<Int>(tmp >> (sizeof(Int) * 8)); 
+} 
+ 
+// Calculates `(2^64 * carry + *v) / 10`. 
+// Stores the quotient in `*v` and returns the remainder. 
+// Requires: `0 <= carry <= 9` 
+inline uint64_t DivideBy10WithCarry(uint64_t *v, uint64_t carry) { 
+  constexpr uint64_t divisor = 10; 
+  // 2^64 / divisor = chunk_quotient + chunk_remainder / divisor 
+  constexpr uint64_t chunk_quotient = (uint64_t{1} << 63) / (divisor / 2); 
+  constexpr uint64_t chunk_remainder = uint64_t{} - chunk_quotient * divisor; 
+ 
+  const uint64_t mod = *v % divisor; 
+  const uint64_t next_carry = chunk_remainder * carry + mod; 
+  *v = *v / divisor + carry * chunk_quotient + next_carry / divisor; 
+  return next_carry % divisor; 
+} 
+ 
+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`. 
+class BinaryToDecimal { 
+  static constexpr int ChunksNeeded(int exp) { 
+    // We will left shift a uint128 by `exp` bits, so we need `128+exp` total 
+    // bits. Round up to 32. 
+    // See constructor for details about adding `10%` to the value. 
+    return (128 + exp + 31) / 32 * 11 / 10; 
+  } 
+ 
+ public: 
+  // Run the conversion for `v * 2^exp` and call `f(binary_to_decimal)`. 
+  // This function will allocate enough stack space to perform the conversion. 
+  static void RunConversion(uint128 v, int exp, 
+                            y_absl::FunctionRef<void(BinaryToDecimal)> f) { 
+    assert(exp > 0); 
+    assert(exp <= std::numeric_limits<MaxFloatType>::max_exponent); 
+    static_assert( 
+        static_cast<int>(StackArray::kMaxCapacity) >= 
+            ChunksNeeded(std::numeric_limits<MaxFloatType>::max_exponent), 
+        ""); 
+ 
+    StackArray::RunWithCapacity( 
+        ChunksNeeded(exp), 
+        [=](y_absl::Span<uint32_t> input) { f(BinaryToDecimal(input, v, exp)); }); 
+  } 
+ 
+  int TotalDigits() const { 
+    return static_cast<int>((decimal_end_ - decimal_start_) * kDigitsPerChunk + 
+                            CurrentDigits().size()); 
+  } 
+ 
+  // See the current block of digits. 
+  y_absl::string_view CurrentDigits() const { 
+    return y_absl::string_view(digits_ + kDigitsPerChunk - size_, size_); 
+  } 
+ 
+  // Advance the current view of digits. 
+  // Returns `false` when no more digits are available. 
+  bool AdvanceDigits() { 
+    if (decimal_start_ >= decimal_end_) return false; 
+ 
+    uint32_t w = data_[decimal_start_++]; 
+    for (size_ = 0; size_ < kDigitsPerChunk; w /= 10) { 
+      digits_[kDigitsPerChunk - ++size_] = w % 10 + '0'; 
+    } 
+    return true; 
+  } 
+ 
+ private: 
+  BinaryToDecimal(y_absl::Span<uint32_t> data, uint128 v, int exp) : data_(data) { 
+    // We need to print the digits directly into the sink object without 
+    // buffering them all first. To do this we need two things: 
+    // - to know the total number of digits to do padding when necessary 
+    // - to generate the decimal digits from the left. 
+    // 
+    // In order to do this, we do a two pass conversion. 
+    // On the first pass we convert the binary representation of the value into 
+    // a decimal representation in which each uint32_t chunk holds up to 9 
+    // decimal digits.  In the second pass we take each decimal-holding-uint32_t 
+    // value and generate the ascii decimal digits into `digits_`. 
+    // 
+    // The binary and decimal representations actually share the same memory 
+    // region. As we go converting the chunks from binary to decimal we free 
+    // them up and reuse them for the decimal representation. One caveat is that 
+    // the decimal representation is around 7% less efficient in space than the 
+    // binary one. We allocate an extra 10% memory to account for this. See 
+    // ChunksNeeded for this calculation. 
+    int chunk_index = exp / 32; 
+    decimal_start_ = decimal_end_ = ChunksNeeded(exp); 
+    const int offset = exp % 32; 
+    // Left shift v by exp bits. 
+    data_[chunk_index] = static_cast<uint32_t>(v << offset); 
+    for (v >>= (32 - offset); v; v >>= 32) 
+      data_[++chunk_index] = static_cast<uint32_t>(v); 
+ 
+    while (chunk_index >= 0) { 
+      // While we have more than one chunk available, go in steps of 1e9. 
+      // `data_[chunk_index]` holds the highest non-zero binary chunk, so keep 
+      // the variable updated. 
+      uint32_t carry = 0; 
+      for (int i = chunk_index; i >= 0; --i) { 
+        uint64_t tmp = uint64_t{data_[i]} + (uint64_t{carry} << 32); 
+        data_[i] = static_cast<uint32_t>(tmp / uint64_t{1000000000}); 
+        carry = static_cast<uint32_t>(tmp % uint64_t{1000000000}); 
+      } 
+ 
+      // If the highest chunk is now empty, remove it from view. 
+      if (data_[chunk_index] == 0) --chunk_index; 
+ 
+      --decimal_start_; 
+      assert(decimal_start_ != chunk_index); 
+      data_[decimal_start_] = carry; 
+    } 
+ 
+    // Fill the first set of digits. The first chunk might not be complete, so 
+    // handle differently. 
+    for (uint32_t first = data_[decimal_start_++]; first != 0; first /= 10) { 
+      digits_[kDigitsPerChunk - ++size_] = first % 10 + '0'; 
+    } 
+  } 
+ 
+ private: 
+  static constexpr int kDigitsPerChunk = 9; 
+ 
+  int decimal_start_; 
+  int decimal_end_; 
+ 
+  char digits_[kDigitsPerChunk]; 
+  int size_ = 0; 
+ 
+  y_absl::Span<uint32_t> data_; 
+}; 
+ 
+// 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`. 
+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, y_absl::FunctionRef<void(FractionalDigitGenerator)> f) { 
+    using Limits = std::numeric_limits<MaxFloatType>; 
+    assert(-exp < 0); 
+    assert(-exp >= Limits::min_exponent - 128); 
+    static_assert(StackArray::kMaxCapacity >= 
+                      (Limits::digits + 128 - Limits::min_exponent + 31) / 32, 
+                  ""); 
+    StackArray::RunWithCapacity((Limits::digits + exp + 31) / 32, 
+                                [=](y_absl::Span<uint32_t> input) { 
+                                  f(FractionalDigitGenerator(input, v, exp)); 
+                                }); 
+  } 
+ 
+  // Returns true if there are any more non-zero digits left. 
+  bool HasMoreDigits() const { return next_digit_ != 0 || chunk_index_ >= 0; } 
+ 
+  // Returns true if the remainder digits are greater than 5000... 
+  bool IsGreaterThanHalf() const { 
+    return next_digit_ > 5 || (next_digit_ == 5 && chunk_index_ >= 0); 
+  } 
+  // Returns true if the remainder digits are exactly 5000... 
+  bool IsExactlyHalf() const { return next_digit_ == 5 && chunk_index_ < 0; } 
+ 
+  struct Digits { 
+    int digit_before_nine; 
+    int num_nines; 
+  }; 
+ 
+  // Get the next set of digits. 
+  // They are composed by a non-9 digit followed by a runs of zero or more 9s. 
+  Digits GetDigits() { 
+    Digits digits{next_digit_, 0}; 
+ 
+    next_digit_ = GetOneDigit(); 
+    while (next_digit_ == 9) { 
+      ++digits.num_nines; 
+      next_digit_ = GetOneDigit(); 
+    } 
+ 
+    return digits; 
+  } 
+ 
+ private: 
+  // Return the next digit. 
+  int GetOneDigit() { 
+    if (chunk_index_ < 0) return 0; 
+ 
+    uint32_t carry = 0; 
+    for (int i = chunk_index_; i >= 0; --i) { 
+      carry = MultiplyBy10WithCarry(&data_[i], carry); 
+    } 
+    // If the lowest chunk is now empty, remove it from view. 
+    if (data_[chunk_index_] == 0) --chunk_index_; 
+    return carry; 
+  } 
+ 
+  FractionalDigitGenerator(y_absl::Span<uint32_t> data, uint128 v, int exp) 
+      : chunk_index_(exp / 32), data_(data) { 
+    const int offset = exp % 32; 
+    // Right shift `v` by `exp` bits. 
+    data_[chunk_index_] = static_cast<uint32_t>(v << (32 - offset)); 
+    v >>= offset; 
+    // Make sure we don't overflow the data. We already calculated that 
+    // non-zero bits fit, so we might not have space for leading zero bits. 
+    for (int pos = chunk_index_; v; v >>= 32) 
+      data_[--pos] = static_cast<uint32_t>(v); 
+ 
+    // Fill next_digit_, as GetDigits expects it to be populated always. 
+    next_digit_ = GetOneDigit(); 
+  } 
+ 
+  int next_digit_; 
+  int chunk_index_; 
+  y_absl::Span<uint32_t> data_; 
+}; 
+ 
+// Count the number of leading zero bits. 
+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); 
+} 
+ 
+// Round up the text digits starting at `p`. 
+// The buffer must have an extra digit that is known to not need rounding. 
+// This is done below by having an extra '0' digit on the left. 
+void RoundUp(char *p) { 
+  while (*p == '9' || *p == '.') { 
+    if (*p == '9') *p = '0'; 
+    --p; 
+  } 
+  ++*p; 
+} 
+ 
+// Check the previous digit and round up or down to follow the round-to-even 
+// policy. 
+void RoundToEven(char *p) { 
+  if (*p == '.') --p; 
+  if (*p % 2 == 1) RoundUp(p); 
+} 
+ 
+// Simple integral decimal digit printing for values that fit in 64-bits. 
+// Returns the pointer to the last written digit. 
+char *PrintIntegralDigitsFromRightFast(uint64_t v, char *p) { 
+  do { 
+    *--p = DivideBy10WithCarry(&v, 0) + '0'; 
+  } while (v != 0); 
+  return p; 
+} 
+ 
+// Simple integral decimal digit printing for values that fit in 128-bits. 
+// Returns the pointer to the last written digit. 
+char *PrintIntegralDigitsFromRightFast(uint128 v, char *p) { 
+  auto high = static_cast<uint64_t>(v >> 64); 
+  auto low = static_cast<uint64_t>(v); 
+ 
+  while (high != 0) { 
+    uint64_t carry = DivideBy10WithCarry(&high, 0); 
+    carry = DivideBy10WithCarry(&low, carry); 
+    *--p = carry + '0'; 
+  } 
+  return PrintIntegralDigitsFromRightFast(low, p); 
+} 
+ 
+// Simple fractional decimal digit printing for values that fir in 64-bits after 
+// shifting. 
+// Performs rounding if necessary to fit within `precision`. 
+// Returns the pointer to one after the last character written. 
+char *PrintFractionalDigitsFast(uint64_t v, char *start, int exp, 
+                                int precision) { 
+  char *p = start; 
+  v <<= (64 - exp); 
+  while (precision > 0) { 
+    if (!v) return p; 
+    *p++ = MultiplyBy10WithCarry(&v, uint64_t{0}) + '0'; 
+    --precision; 
+  } 
+ 
+  // We need to round. 
+  if (v < 0x8000000000000000) { 
+    // We round down, so nothing to do. 
+  } else if (v > 0x8000000000000000) { 
+    // We round up. 
+    RoundUp(p - 1); 
+  } else { 
+    RoundToEven(p - 1); 
+  } 
+ 
+  assert(precision == 0); 
+  // Precision can only be zero here. 
+  return p; 
+} 
+ 
+// Simple fractional decimal digit printing for values that fir in 128-bits 
+// after shifting. 
+// Performs rounding if necessary to fit within `precision`. 
+// Returns the pointer to one after the last character written. 
+char *PrintFractionalDigitsFast(uint128 v, char *start, int exp, 
+                                int precision) { 
+  char *p = start; 
+  v <<= (128 - exp); 
+  auto high = static_cast<uint64_t>(v >> 64); 
+  auto low = static_cast<uint64_t>(v); 
+ 
+  // While we have digits to print and `low` is not empty, do the long 
+  // multiplication. 
+  while (precision > 0 && low != 0) { 
+    uint64_t carry = MultiplyBy10WithCarry(&low, uint64_t{0}); 
+    carry = MultiplyBy10WithCarry(&high, carry); 
+ 
+    *p++ = carry + '0'; 
+    --precision; 
+  } 
+ 
+  // Now `low` is empty, so use a faster approach for the rest of the digits. 
+  // This block is pretty much the same as the main loop for the 64-bit case 
+  // above. 
+  while (precision > 0) { 
+    if (!high) return p; 
+    *p++ = MultiplyBy10WithCarry(&high, uint64_t{0}) + '0'; 
+    --precision; 
+  } 
+ 
+  // We need to round. 
+  if (high < 0x8000000000000000) { 
+    // We round down, so nothing to do. 
+  } else if (high > 0x8000000000000000 || low != 0) { 
+    // We round up. 
+    RoundUp(p - 1); 
+  } else { 
+    RoundToEven(p - 1); 
+  } 
+ 
+  assert(precision == 0); 
+  // Precision can only be zero here. 
+  return p; 
+} 
+ 
+struct FormatState { 
+  char sign_char; 
+  int precision; 
+  const FormatConversionSpecImpl &conv; 
+  FormatSinkImpl *sink; 
+ 
+  // In `alt` mode (flag #) we keep the `.` even if there are no fractional 
+  // digits. In non-alt mode, we strip it. 
+  bool ShouldPrintDot() const { return precision != 0 || conv.has_alt_flag(); } 
+}; 
+ 
+struct Padding { 
+  int left_spaces; 
+  int zeros; 
+  int right_spaces; 
+}; 
+ 
+Padding ExtraWidthToPadding(size_t total_size, const FormatState &state) { 
+  if (state.conv.width() < 0 || 
+      static_cast<size_t>(state.conv.width()) <= total_size) { 
+    return {0, 0, 0}; 
+  } 
+  int missing_chars = state.conv.width() - total_size; 
+  if (state.conv.has_left_flag()) { 
+    return {0, 0, missing_chars}; 
+  } else if (state.conv.has_zero_flag()) { 
+    return {0, missing_chars, 0}; 
+  } else { 
+    return {missing_chars, 0, 0}; 
+  } 
+} 
+ 
+void FinalPrint(const FormatState &state, y_absl::string_view data, 
+                int padding_offset, int trailing_zeros, 
+                y_absl::string_view data_postfix) { 
+  if (state.conv.width() < 0) { 
+    // No width specified. Fast-path. 
+    if (state.sign_char != '\0') state.sink->Append(1, state.sign_char); 
+    state.sink->Append(data); 
+    state.sink->Append(trailing_zeros, '0'); 
+    state.sink->Append(data_postfix); 
+    return; 
+  } 
+ 
+  auto padding = ExtraWidthToPadding((state.sign_char != '\0' ? 1 : 0) + 
+                                         data.size() + data_postfix.size() + 
+                                         static_cast<size_t>(trailing_zeros), 
+                                     state); 
+ 
+  state.sink->Append(padding.left_spaces, ' '); 
+  if (state.sign_char != '\0') state.sink->Append(1, state.sign_char); 
+  // Padding in general needs to be inserted somewhere in the middle of `data`. 
+  state.sink->Append(data.substr(0, padding_offset)); 
+  state.sink->Append(padding.zeros, '0'); 
+  state.sink->Append(data.substr(padding_offset)); 
+  state.sink->Append(trailing_zeros, '0'); 
+  state.sink->Append(data_postfix); 
+  state.sink->Append(padding.right_spaces, ' '); 
+} 
+ 
+// Fastpath %f formatter for when the shifted value fits in a simple integral 
+// type. 
+// Prints `v*2^exp` with the options from `state`. 
+template <typename Int> 
+void FormatFFast(Int v, int exp, const FormatState &state) { 
+  constexpr int input_bits = sizeof(Int) * 8; 
+ 
+  static constexpr size_t integral_size = 
+      /* in case we need to round up an extra digit */ 1 + 
+      /* decimal digits for uint128 */ 40 + 1; 
+  char buffer[integral_size + /* . */ 1 + /* max digits uint128 */ 128]; 
+  buffer[integral_size] = '.'; 
+  char *const integral_digits_end = buffer + integral_size; 
+  char *integral_digits_start; 
+  char *const fractional_digits_start = buffer + integral_size + 1; 
+  char *fractional_digits_end = fractional_digits_start; 
+ 
+  if (exp >= 0) { 
+    const int total_bits = input_bits - LeadingZeros(v) + exp; 
+    integral_digits_start = 
+        total_bits <= 64 
+            ? PrintIntegralDigitsFromRightFast(static_cast<uint64_t>(v) << exp, 
+                                               integral_digits_end) 
+            : PrintIntegralDigitsFromRightFast(static_cast<uint128>(v) << exp, 
+                                               integral_digits_end); 
+  } else { 
+    exp = -exp; 
+ 
+    integral_digits_start = PrintIntegralDigitsFromRightFast( 
+        exp < input_bits ? v >> exp : 0, integral_digits_end); 
+    // PrintFractionalDigits may pull a carried 1 all the way up through the 
+    // integral portion. 
+    integral_digits_start[-1] = '0'; 
+ 
+    fractional_digits_end = 
+        exp <= 64 ? PrintFractionalDigitsFast(v, fractional_digits_start, exp, 
+                                              state.precision) 
+                  : PrintFractionalDigitsFast(static_cast<uint128>(v), 
+                                              fractional_digits_start, exp, 
+                                              state.precision); 
+    // There was a carry, so include the first digit too. 
+    if (integral_digits_start[-1] != '0') --integral_digits_start; 
+  } 
+ 
+  size_t size = fractional_digits_end - integral_digits_start; 
+ 
+  // In `alt` mode (flag #) we keep the `.` even if there are no fractional 
+  // digits. In non-alt mode, we strip it. 
+  if (!state.ShouldPrintDot()) --size; 
+  FinalPrint(state, y_absl::string_view(integral_digits_start, size), 
+             /*padding_offset=*/0, 
+             static_cast<int>(state.precision - (fractional_digits_end - 
+                                                 fractional_digits_start)), 
+             /*data_postfix=*/""); 
+} 
+ 
+// Slow %f formatter for when the shifted value does not fit in a uint128, and 
+// `exp > 0`. 
+// Prints `v*2^exp` with the options from `state`. 
+// This one is guaranteed to not have fractional digits, so we don't have to 
+// worry about anything after the `.`. 
+void FormatFPositiveExpSlow(uint128 v, int exp, const FormatState &state) { 
+  BinaryToDecimal::RunConversion(v, exp, [&](BinaryToDecimal btd) { 
+    const size_t total_digits = 
+        btd.TotalDigits() + 
+        (state.ShouldPrintDot() ? static_cast<size_t>(state.precision) + 1 : 0); 
+ 
+    const auto padding = ExtraWidthToPadding( 
+        total_digits + (state.sign_char != '\0' ? 1 : 0), state); 
+ 
+    state.sink->Append(padding.left_spaces, ' '); 
+    if (state.sign_char != '\0') state.sink->Append(1, state.sign_char); 
+    state.sink->Append(padding.zeros, '0'); 
+ 
+    do { 
+      state.sink->Append(btd.CurrentDigits()); 
+    } while (btd.AdvanceDigits()); 
+ 
+    if (state.ShouldPrintDot()) state.sink->Append(1, '.'); 
+    state.sink->Append(state.precision, '0'); 
+    state.sink->Append(padding.right_spaces, ' '); 
+  }); 
+} 
+ 
+// Slow %f formatter for when the shifted value does not fit in a uint128, and 
+// `exp < 0`. 
+// Prints `v*2^exp` with the options from `state`. 
+// This one is guaranteed to be < 1.0, so we don't have to worry about integral 
+// digits. 
+void FormatFNegativeExpSlow(uint128 v, int exp, const FormatState &state) { 
+  const size_t total_digits = 
+      /* 0 */ 1 + 
+      (state.ShouldPrintDot() ? static_cast<size_t>(state.precision) + 1 : 0); 
+  auto padding = 
+      ExtraWidthToPadding(total_digits + (state.sign_char ? 1 : 0), state); 
+  padding.zeros += 1; 
+  state.sink->Append(padding.left_spaces, ' '); 
+  if (state.sign_char != '\0') state.sink->Append(1, state.sign_char); 
+  state.sink->Append(padding.zeros, '0'); 
+ 
+  if (state.ShouldPrintDot()) state.sink->Append(1, '.'); 
+ 
+  // Print digits 
+  int digits_to_go = state.precision; 
+ 
+  FractionalDigitGenerator::RunConversion( 
+      v, exp, [&](FractionalDigitGenerator digit_gen) { 
+        // There are no digits to print here. 
+        if (state.precision == 0) return; 
+ 
+        // We go one digit at a time, while keeping track of runs of nines. 
+        // The runs of nines are used to perform rounding when necessary. 
+ 
+        while (digits_to_go > 0 && digit_gen.HasMoreDigits()) { 
+          auto digits = digit_gen.GetDigits(); 
+ 
+          // Now we have a digit and a run of nines. 
+          // See if we can print them all. 
+          if (digits.num_nines + 1 < digits_to_go) { 
+            // We don't have to round yet, so print them. 
+            state.sink->Append(1, digits.digit_before_nine + '0'); 
+            state.sink->Append(digits.num_nines, '9'); 
+            digits_to_go -= digits.num_nines + 1; 
+ 
+          } else { 
+            // We can't print all the nines, see where we have to truncate. 
+ 
+            bool round_up = false; 
+            if (digits.num_nines + 1 > digits_to_go) { 
+              // We round up at a nine. No need to print them. 
+              round_up = true; 
+            } else { 
+              // We can fit all the nines, but truncate just after it. 
+              if (digit_gen.IsGreaterThanHalf()) { 
+                round_up = true; 
+              } else if (digit_gen.IsExactlyHalf()) { 
+                // Round to even 
+                round_up = 
+                    digits.num_nines != 0 || digits.digit_before_nine % 2 == 1; 
+              } 
+            } 
+ 
+            if (round_up) { 
+              state.sink->Append(1, digits.digit_before_nine + '1'); 
+              --digits_to_go; 
+              // The rest will be zeros. 
+            } else { 
+              state.sink->Append(1, digits.digit_before_nine + '0'); 
+              state.sink->Append(digits_to_go - 1, '9'); 
+              digits_to_go = 0; 
+            } 
+            return; 
+          } 
+        } 
+      }); 
+ 
+  state.sink->Append(digits_to_go, '0'); 
+  state.sink->Append(padding.right_spaces, ' '); 
+} 
+ 
+template <typename Int> 
+void FormatF(Int mantissa, int exp, const FormatState &state) { 
+  if (exp >= 0) { 
+    const int total_bits = sizeof(Int) * 8 - LeadingZeros(mantissa) + exp; 
+ 
+    // Fallback to the slow stack-based approach if we can't do it in a 64 or 
+    // 128 bit state. 
+    if (ABSL_PREDICT_FALSE(total_bits > 128)) { 
+      return FormatFPositiveExpSlow(mantissa, exp, state); 
+    } 
+  } else { 
+    // Fallback to the slow stack-based approach if we can't do it in a 64 or 
+    // 128 bit state. 
+    if (ABSL_PREDICT_FALSE(exp < -128)) { 
+      return FormatFNegativeExpSlow(mantissa, -exp, state); 
+    } 
+  } 
+  return FormatFFast(mantissa, exp, state); 
+} 
+ 
+// Grab the group of four bits (nibble) from `n`. E.g., nibble 1 corresponds to 
+// bits 4-7. 
+template <typename Int> 
+uint8_t GetNibble(Int n, int nibble_index) { 
+  constexpr Int mask_low_nibble = Int{0xf}; 
+  int shift = nibble_index * 4; 
+  n &= mask_low_nibble << shift; 
+  return static_cast<uint8_t>((n >> shift) & 0xf); 
+} 
+ 
+// Add one to the given nibble, applying carry to higher nibbles. Returns true 
+// if overflow, false otherwise. 
+template <typename Int> 
+bool IncrementNibble(int nibble_index, Int *n) { 
+  constexpr int kShift = sizeof(Int) * 8 - 1; 
+  constexpr int kNumNibbles = sizeof(Int) * 8 / 4; 
+  Int before = *n >> kShift; 
+  // Here we essentially want to take the number 1 and move it into the requsted 
+  // nibble, then add it to *n to effectively increment the nibble. However, 
+  // ASan will complain if we try to shift the 1 beyond the limits of the Int, 
+  // i.e., if the nibble_index is out of range. So therefore we check for this 
+  // and if we are out of range we just add 0 which leaves *n unchanged, which 
+  // seems like the reasonable thing to do in that case. 
+  *n += ((nibble_index >= kNumNibbles) ? 0 : (Int{1} << (nibble_index * 4))); 
+  Int after = *n >> kShift; 
+  return (before && !after) || (nibble_index >= kNumNibbles); 
+} 
+ 
+// Return a mask with 1's in the given nibble and all lower nibbles. 
+template <typename Int> 
+Int MaskUpToNibbleInclusive(int nibble_index) { 
+  constexpr int kNumNibbles = sizeof(Int) * 8 / 4; 
+  static const Int ones = ~Int{0}; 
+  return ones >> std::max(0, 4 * (kNumNibbles - nibble_index - 1)); 
+} 
+ 
+// Return a mask with 1's below the given nibble. 
+template <typename Int> 
+Int MaskUpToNibbleExclusive(int nibble_index) { 
+  return nibble_index <= 0 ? 0 : MaskUpToNibbleInclusive<Int>(nibble_index - 1); 
+} 
+ 
+template <typename Int> 
+Int MoveToNibble(uint8_t nibble, int nibble_index) { 
+  return Int{nibble} << (4 * nibble_index); 
+} 
+ 
+// Given mantissa size, find optimal # of mantissa bits to put in initial digit. 
+// 
+// In the hex representation we keep a single hex digit to the left of the dot. 
+// However, the question as to how many bits of the mantissa should be put into 
+// that hex digit in theory is arbitrary, but in practice it is optimal to 
+// choose based on the size of the mantissa. E.g., for a `double`, there are 53 
+// mantissa bits, so that means that we should put 1 bit to the left of the dot, 
+// thereby leaving 52 bits to the right, which is evenly divisible by four and 
+// thus all fractional digits represent actual precision. For a `long double`, 
+// on the other hand, there are 64 bits of mantissa, thus we can use all four 
+// bits for the initial hex digit and still have a number left over (60) that is 
+// a multiple of four. Once again, the goal is to have all fractional digits 
+// represent real precision. 
+template <typename Float> 
+constexpr int HexFloatLeadingDigitSizeInBits() { 
+  return std::numeric_limits<Float>::digits % 4 > 0 
+             ? std::numeric_limits<Float>::digits % 4 
+             : 4; 
+} 
+ 
+// This function captures the rounding behavior of glibc for hex float 
+// representations. E.g. when rounding 0x1.ab800000 to a precision of .2 
+// ("%.2a") glibc will round up because it rounds toward the even number (since 
+// 0xb is an odd number, it will round up to 0xc). However, when rounding at a 
+// point that is not followed by 800000..., it disregards the parity and rounds 
+// up if > 8 and rounds down if < 8. 
+template <typename Int> 
+bool HexFloatNeedsRoundUp(Int mantissa, int final_nibble_displayed, 
+                          uint8_t leading) { 
+  // If the last nibble (hex digit) to be displayed is the lowest on in the 
+  // mantissa then that means that we don't have any further nibbles to inform 
+  // rounding, so don't round. 
+  if (final_nibble_displayed <= 0) { 
+    return false; 
+  } 
+  int rounding_nibble_idx = final_nibble_displayed - 1; 
+  constexpr int kTotalNibbles = sizeof(Int) * 8 / 4; 
+  assert(final_nibble_displayed <= kTotalNibbles); 
+  Int mantissa_up_to_rounding_nibble_inclusive = 
+      mantissa & MaskUpToNibbleInclusive<Int>(rounding_nibble_idx); 
+  Int eight = MoveToNibble<Int>(8, rounding_nibble_idx); 
+  if (mantissa_up_to_rounding_nibble_inclusive != eight) { 
+    return mantissa_up_to_rounding_nibble_inclusive > eight; 
+  } 
+  // Nibble in question == 8. 
+  uint8_t round_if_odd = (final_nibble_displayed == kTotalNibbles) 
+                             ? leading 
+                             : GetNibble(mantissa, final_nibble_displayed); 
+  return round_if_odd % 2 == 1; 
+} 
+ 
+// Stores values associated with a Float type needed by the FormatA 
+// implementation in order to avoid templatizing that function by the Float 
+// type. 
+struct HexFloatTypeParams { 
+  template <typename Float> 
+  explicit HexFloatTypeParams(Float) 
+      : min_exponent(std::numeric_limits<Float>::min_exponent - 1), 
+        leading_digit_size_bits(HexFloatLeadingDigitSizeInBits<Float>()) { 
+    assert(leading_digit_size_bits >= 1 && leading_digit_size_bits <= 4); 
+  } 
+ 
+  int min_exponent; 
+  int leading_digit_size_bits; 
+}; 
+ 
+// Hex Float Rounding. First check if we need to round; if so, then we do that 
+// by manipulating (incrementing) the mantissa, that way we can later print the 
+// mantissa digits by iterating through them in the same way regardless of 
+// whether a rounding happened. 
+template <typename Int> 
+void FormatARound(bool precision_specified, const FormatState &state, 
+                  uint8_t *leading, Int *mantissa, int *exp) { 
+  constexpr int kTotalNibbles = sizeof(Int) * 8 / 4; 
+  // Index of the last nibble that we could display given precision. 
+  int final_nibble_displayed = 
+      precision_specified ? std::max(0, (kTotalNibbles - state.precision)) : 0; 
+  if (HexFloatNeedsRoundUp(*mantissa, final_nibble_displayed, *leading)) { 
+    // Need to round up. 
+    bool overflow = IncrementNibble(final_nibble_displayed, mantissa); 
+    *leading += (overflow ? 1 : 0); 
+    if (ABSL_PREDICT_FALSE(*leading > 15)) { 
+      // We have overflowed the leading digit. This would mean that we would 
+      // need two hex digits to the left of the dot, which is not allowed. So 
+      // adjust the mantissa and exponent so that the result is always 1.0eXXX. 
+      *leading = 1; 
+      *mantissa = 0; 
+      *exp += 4; 
+    } 
+  } 
+  // Now that we have handled a possible round-up we can go ahead and zero out 
+  // all the nibbles of the mantissa that we won't need. 
+  if (precision_specified) { 
+    *mantissa &= ~MaskUpToNibbleExclusive<Int>(final_nibble_displayed); 
+  } 
+} 
+ 
+template <typename Int> 
+void FormatANormalize(const HexFloatTypeParams float_traits, uint8_t *leading, 
+                      Int *mantissa, int *exp) { 
+  constexpr int kIntBits = sizeof(Int) * 8; 
+  static const Int kHighIntBit = Int{1} << (kIntBits - 1); 
+  const int kLeadDigitBitsCount = float_traits.leading_digit_size_bits; 
+  // Normalize mantissa so that highest bit set is in MSB position, unless we 
+  // get interrupted by the exponent threshold. 
+  while (*mantissa && !(*mantissa & kHighIntBit)) { 
+    if (ABSL_PREDICT_FALSE(*exp - 1 < float_traits.min_exponent)) { 
+      *mantissa >>= (float_traits.min_exponent - *exp); 
+      *exp = float_traits.min_exponent; 
+      return; 
+    } 
+    *mantissa <<= 1; 
+    --*exp; 
+  } 
+  // Extract bits for leading digit then shift them away leaving the 
+  // fractional part. 
+  *leading = 
+      static_cast<uint8_t>(*mantissa >> (kIntBits - kLeadDigitBitsCount)); 
+  *exp -= (*mantissa != 0) ? kLeadDigitBitsCount : *exp; 
+  *mantissa <<= kLeadDigitBitsCount; 
+} 
+ 
+template <typename Int> 
+void FormatA(const HexFloatTypeParams float_traits, Int mantissa, int exp, 
+             bool uppercase, const FormatState &state) { 
+  // Int properties. 
+  constexpr int kIntBits = sizeof(Int) * 8; 
+  constexpr int kTotalNibbles = sizeof(Int) * 8 / 4; 
+  // Did the user specify a precision explicitly? 
+  const bool precision_specified = state.conv.precision() >= 0; 
+ 
+  // ========== Normalize/Denormalize ========== 
+  exp += kIntBits;  // make all digits fractional digits. 
+  // This holds the (up to four) bits of leading digit, i.e., the '1' in the 
+  // number 0x1.e6fp+2. It's always > 0 unless number is zero or denormal. 
+  uint8_t leading = 0; 
+  FormatANormalize(float_traits, &leading, &mantissa, &exp); 
+ 
+  // =============== Rounding ================== 
+  // Check if we need to round; if so, then we do that by manipulating 
+  // (incrementing) the mantissa before beginning to print characters. 
+  FormatARound(precision_specified, state, &leading, &mantissa, &exp); 
+ 
+  // ============= Format Result =============== 
+  // 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) 
+  char digits_buffer[kBufSizeForHexFloatRepr]; 
+  char *digits_iter = digits_buffer; 
+  const char *const digits = 
+      static_cast<const char *>("0123456789ABCDEF0123456789abcdef") + 
+      (uppercase ? 0 : 16); 
+ 
+  // =============== Hex Prefix ================ 
+  *digits_iter++ = '0'; 
+  *digits_iter++ = uppercase ? 'X' : 'x'; 
+ 
+  // ========== Non-Fractional Digit =========== 
+  *digits_iter++ = digits[leading]; 
+ 
+  // ================== Dot ==================== 
+  // There are three reasons we might need a dot. Keep in mind that, at this 
+  // point, the mantissa holds only the fractional part. 
+  if ((precision_specified && state.precision > 0) || 
+      (!precision_specified && mantissa > 0) || state.conv.has_alt_flag()) { 
+    *digits_iter++ = '.'; 
+  } 
+ 
+  // ============ Fractional Digits ============ 
+  int digits_emitted = 0; 
+  while (mantissa > 0) { 
+    *digits_iter++ = digits[GetNibble(mantissa, kTotalNibbles - 1)]; 
+    mantissa <<= 4; 
+    ++digits_emitted; 
+  } 
+  int trailing_zeros = 
+      precision_specified ? state.precision - digits_emitted : 0; 
+  assert(trailing_zeros >= 0); 
+  auto digits_result = string_view(digits_buffer, digits_iter - digits_buffer); 
+ 
+  // =============== Exponent ================== 
+  constexpr size_t kBufSizeForExpDecRepr = 
+      numbers_internal::kFastToBufferSize  // requred for FastIntToBuffer 
+      + 1                                  // 'p' or 'P' 
+      + 1;                                 // '+' or '-' 
+  char exp_buffer[kBufSizeForExpDecRepr]; 
+  exp_buffer[0] = uppercase ? 'P' : 'p'; 
+  exp_buffer[1] = exp >= 0 ? '+' : '-'; 
+  numbers_internal::FastIntToBuffer(exp < 0 ? -exp : exp, exp_buffer + 2); 
+ 
+  // ============ Assemble Result ============== 
+  FinalPrint(state,           // 
+             digits_result,   // 0xN.NNN... 
+             2,               // offset in `data` to start padding if needed. 
+             trailing_zeros,  // num remaining mantissa padding zeros 
+             exp_buffer);     // exponent 
+} 
+ 
+char *CopyStringTo(y_absl::string_view v, char *out) { 
   std::memcpy(out, v.data(), v.size());
   return out + v.size();
 }
 
 template <typename Float>
-bool FallbackToSnprintf(const Float v, const FormatConversionSpecImpl &conv,
+bool FallbackToSnprintf(const Float v, const FormatConversionSpecImpl &conv, 
                         FormatSinkImpl *sink) {
   int w = conv.width() >= 0 ? conv.width() : 0;
   int p = conv.precision() >= 0 ? conv.precision() : -1;
@@ -951,17 +951,17 @@ bool FallbackToSnprintf(const Float v, const FormatConversionSpecImpl &conv,
     if (std::is_same<long double, Float>()) {
       *fp++ = 'L';
     }
-    *fp++ = FormatConversionCharToChar(conv.conversion_char());
+    *fp++ = FormatConversionCharToChar(conv.conversion_char()); 
     *fp = 0;
     assert(fp < fmt + sizeof(fmt));
   }
   TString space(512, '\0');
-  y_absl::string_view result;
+  y_absl::string_view result; 
   while (true) {
     int n = snprintf(&space[0], space.size(), fmt, w, p, v);
     if (n < 0) return false;
     if (static_cast<size_t>(n) < space.size()) {
-      result = y_absl::string_view(space.data(), n);
+      result = y_absl::string_view(space.data(), n); 
       break;
     }
     space.resize(n + 1);
@@ -1014,24 +1014,24 @@ enum class FormatStyle { Fixed, Precision };
 // Otherwise, return false.
 template <typename Float>
 bool ConvertNonNumericFloats(char sign_char, Float v,
-                             const FormatConversionSpecImpl &conv,
-                             FormatSinkImpl *sink) {
+                             const FormatConversionSpecImpl &conv, 
+                             FormatSinkImpl *sink) { 
   char text[4], *ptr = text;
-  if (sign_char != '\0') *ptr++ = sign_char;
+  if (sign_char != '\0') *ptr++ = sign_char; 
   if (std::isnan(v)) {
-    ptr = std::copy_n(
-        FormatConversionCharIsUpper(conv.conversion_char()) ? "NAN" : "nan", 3,
-        ptr);
+    ptr = std::copy_n( 
+        FormatConversionCharIsUpper(conv.conversion_char()) ? "NAN" : "nan", 3, 
+        ptr); 
   } else if (std::isinf(v)) {
-    ptr = std::copy_n(
-        FormatConversionCharIsUpper(conv.conversion_char()) ? "INF" : "inf", 3,
-        ptr);
+    ptr = std::copy_n( 
+        FormatConversionCharIsUpper(conv.conversion_char()) ? "INF" : "inf", 3, 
+        ptr); 
   } else {
     return false;
   }
 
   return sink->PutPaddedString(string_view(text, ptr - text), conv.width(), -1,
-                               conv.has_left_flag());
+                               conv.has_left_flag()); 
 }
 
 // Round up the last digit of the value.
@@ -1091,12 +1091,12 @@ constexpr bool CanFitMantissa() {
 
 template <typename Float>
 struct Decomposed {
-  using MantissaType =
-      y_absl::conditional_t<std::is_same<long double, Float>::value, uint128,
-                          uint64_t>;
-  static_assert(std::numeric_limits<Float>::digits <= sizeof(MantissaType) * 8,
-                "");
-  MantissaType mantissa;
+  using MantissaType = 
+      y_absl::conditional_t<std::is_same<long double, Float>::value, uint128, 
+                          uint64_t>; 
+  static_assert(std::numeric_limits<Float>::digits <= sizeof(MantissaType) * 8, 
+                ""); 
+  MantissaType mantissa; 
   int exponent;
 };
 
@@ -1107,8 +1107,8 @@ Decomposed<Float> Decompose(Float v) {
   Float m = std::frexp(v, &exp);
   m = std::ldexp(m, std::numeric_limits<Float>::digits);
   exp -= std::numeric_limits<Float>::digits;
-
-  return {static_cast<typename Decomposed<Float>::MantissaType>(m), exp};
+ 
+  return {static_cast<typename Decomposed<Float>::MantissaType>(m), exp}; 
 }
 
 // Print 'digits' as decimal.
@@ -1277,32 +1277,32 @@ bool FloatToBuffer(Decomposed<Float> decomposed, int precision, Buffer *out,
   return false;
 }
 
-void WriteBufferToSink(char sign_char, y_absl::string_view str,
-                       const FormatConversionSpecImpl &conv,
-                       FormatSinkImpl *sink) {
+void WriteBufferToSink(char sign_char, y_absl::string_view str, 
+                       const FormatConversionSpecImpl &conv, 
+                       FormatSinkImpl *sink) { 
   int left_spaces = 0, zeros = 0, right_spaces = 0;
   int missing_chars =
       conv.width() >= 0 ? std::max(conv.width() - static_cast<int>(str.size()) -
                                        static_cast<int>(sign_char != 0),
                                    0)
                         : 0;
-  if (conv.has_left_flag()) {
+  if (conv.has_left_flag()) { 
     right_spaces = missing_chars;
-  } else if (conv.has_zero_flag()) {
+  } else if (conv.has_zero_flag()) { 
     zeros = missing_chars;
   } else {
     left_spaces = missing_chars;
   }
 
   sink->Append(left_spaces, ' ');
-  if (sign_char != '\0') sink->Append(1, sign_char);
+  if (sign_char != '\0') sink->Append(1, sign_char); 
   sink->Append(zeros, '0');
   sink->Append(str);
   sink->Append(right_spaces, ' ');
 }
 
 template <typename Float>
-bool FloatToSink(const Float v, const FormatConversionSpecImpl &conv,
+bool FloatToSink(const Float v, const FormatConversionSpecImpl &conv, 
                  FormatSinkImpl *sink) {
   // Print the sign or the sign column.
   Float abs_v = v;
@@ -1310,9 +1310,9 @@ bool FloatToSink(const Float v, const FormatConversionSpecImpl &conv,
   if (std::signbit(abs_v)) {
     sign_char = '-';
     abs_v = -abs_v;
-  } else if (conv.has_show_pos_flag()) {
+  } else if (conv.has_show_pos_flag()) { 
     sign_char = '+';
-  } else if (conv.has_sign_col_flag()) {
+  } else if (conv.has_sign_col_flag()) { 
     sign_char = ' ';
   }
 
@@ -1329,91 +1329,91 @@ bool FloatToSink(const Float v, const FormatConversionSpecImpl &conv,
 
   Buffer buffer;
 
-  FormatConversionChar c = conv.conversion_char();
-
-  if (c == FormatConversionCharInternal::f ||
-      c == FormatConversionCharInternal::F) {
-    FormatF(decomposed.mantissa, decomposed.exponent,
-            {sign_char, precision, conv, sink});
-    return true;
-  } else if (c == FormatConversionCharInternal::e ||
-             c == FormatConversionCharInternal::E) {
-    if (!FloatToBuffer<FormatStyle::Precision>(decomposed, precision, &buffer,
-                                               &exp)) {
-      return FallbackToSnprintf(v, conv, sink);
-    }
-    if (!conv.has_alt_flag() && buffer.back() == '.') buffer.pop_back();
-    PrintExponent(
-        exp, FormatConversionCharIsUpper(conv.conversion_char()) ? 'E' : 'e',
-        &buffer);
-  } else if (c == FormatConversionCharInternal::g ||
-             c == FormatConversionCharInternal::G) {
-    precision = std::max(0, precision - 1);
-    if (!FloatToBuffer<FormatStyle::Precision>(decomposed, precision, &buffer,
-                                               &exp)) {
-      return FallbackToSnprintf(v, conv, sink);
-    }
-    if (precision + 1 > exp && exp >= -4) {
-      if (exp < 0) {
-        // Have 1.23456, needs 0.00123456
-        // Move the first digit
-        buffer.begin[1] = *buffer.begin;
-        // Add some zeros
-        for (; exp < -1; ++exp) *buffer.begin-- = '0';
-        *buffer.begin-- = '.';
-        *buffer.begin = '0';
-      } else if (exp > 0) {
-        // Have 1.23456, needs 1234.56
-        // Move the '.' exp positions to the right.
-        std::rotate(buffer.begin + 1, buffer.begin + 2, buffer.begin + exp + 2);
+  FormatConversionChar c = conv.conversion_char(); 
+
+  if (c == FormatConversionCharInternal::f || 
+      c == FormatConversionCharInternal::F) { 
+    FormatF(decomposed.mantissa, decomposed.exponent, 
+            {sign_char, precision, conv, sink}); 
+    return true; 
+  } else if (c == FormatConversionCharInternal::e || 
+             c == FormatConversionCharInternal::E) { 
+    if (!FloatToBuffer<FormatStyle::Precision>(decomposed, precision, &buffer, 
+                                               &exp)) { 
+      return FallbackToSnprintf(v, conv, sink); 
+    } 
+    if (!conv.has_alt_flag() && buffer.back() == '.') buffer.pop_back(); 
+    PrintExponent( 
+        exp, FormatConversionCharIsUpper(conv.conversion_char()) ? 'E' : 'e', 
+        &buffer); 
+  } else if (c == FormatConversionCharInternal::g || 
+             c == FormatConversionCharInternal::G) { 
+    precision = std::max(0, precision - 1); 
+    if (!FloatToBuffer<FormatStyle::Precision>(decomposed, precision, &buffer, 
+                                               &exp)) { 
+      return FallbackToSnprintf(v, conv, sink); 
+    } 
+    if (precision + 1 > exp && exp >= -4) { 
+      if (exp < 0) { 
+        // Have 1.23456, needs 0.00123456 
+        // Move the first digit 
+        buffer.begin[1] = *buffer.begin; 
+        // Add some zeros 
+        for (; exp < -1; ++exp) *buffer.begin-- = '0'; 
+        *buffer.begin-- = '.'; 
+        *buffer.begin = '0'; 
+      } else if (exp > 0) { 
+        // Have 1.23456, needs 1234.56 
+        // Move the '.' exp positions to the right. 
+        std::rotate(buffer.begin + 1, buffer.begin + 2, buffer.begin + exp + 2); 
       }
-      exp = 0;
-    }
-    if (!conv.has_alt_flag()) {
-      while (buffer.back() == '0') buffer.pop_back();
-      if (buffer.back() == '.') buffer.pop_back();
-    }
-    if (exp) {
-      PrintExponent(
-          exp, FormatConversionCharIsUpper(conv.conversion_char()) ? 'E' : 'e',
-          &buffer);
-    }
-  } else if (c == FormatConversionCharInternal::a ||
-             c == FormatConversionCharInternal::A) {
-    bool uppercase = (c == FormatConversionCharInternal::A);
-    FormatA(HexFloatTypeParams(Float{}), decomposed.mantissa,
-            decomposed.exponent, uppercase, {sign_char, precision, conv, sink});
-    return true;
-  } else {
-    return false;
+      exp = 0; 
+    } 
+    if (!conv.has_alt_flag()) { 
+      while (buffer.back() == '0') buffer.pop_back(); 
+      if (buffer.back() == '.') buffer.pop_back(); 
+    } 
+    if (exp) { 
+      PrintExponent( 
+          exp, FormatConversionCharIsUpper(conv.conversion_char()) ? 'E' : 'e', 
+          &buffer); 
+    } 
+  } else if (c == FormatConversionCharInternal::a || 
+             c == FormatConversionCharInternal::A) { 
+    bool uppercase = (c == FormatConversionCharInternal::A); 
+    FormatA(HexFloatTypeParams(Float{}), decomposed.mantissa, 
+            decomposed.exponent, uppercase, {sign_char, precision, conv, sink}); 
+    return true; 
+  } else { 
+    return false; 
   }
 
   WriteBufferToSink(sign_char,
-                    y_absl::string_view(buffer.begin, buffer.end - buffer.begin),
-                    conv, sink);
+                    y_absl::string_view(buffer.begin, buffer.end - buffer.begin), 
+                    conv, sink); 
 
   return true;
 }
 
 }  // namespace
 
-bool ConvertFloatImpl(long double 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.
-    return FallbackToSnprintf(v, conv, sink);
-  }
-
+  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); 
+  } 
+ 
   return FloatToSink(v, conv, sink);
 }
 
-bool ConvertFloatImpl(float v, const FormatConversionSpecImpl &conv,
+bool ConvertFloatImpl(float v, const FormatConversionSpecImpl &conv, 
                       FormatSinkImpl *sink) {
-  return FloatToSink(static_cast<double>(v), conv, sink);
+  return FloatToSink(static_cast<double>(v), conv, sink); 
 }
 
-bool ConvertFloatImpl(double v, const FormatConversionSpecImpl &conv,
+bool ConvertFloatImpl(double v, const FormatConversionSpecImpl &conv, 
                       FormatSinkImpl *sink) {
   return FloatToSink(v, conv, sink);
 }
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.h
index d93a415756..44e8ee2da2 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.h
@@ -1,17 +1,17 @@
-// 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. 
+ 
 #ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_FLOAT_CONVERSION_H_
 #define ABSL_STRINGS_INTERNAL_STR_FORMAT_FLOAT_CONVERSION_H_
 
@@ -21,13 +21,13 @@ namespace y_absl {
 ABSL_NAMESPACE_BEGIN
 namespace str_format_internal {
 
-bool ConvertFloatImpl(float v, const FormatConversionSpecImpl &conv,
+bool ConvertFloatImpl(float v, const FormatConversionSpecImpl &conv, 
                       FormatSinkImpl *sink);
 
-bool ConvertFloatImpl(double v, const FormatConversionSpecImpl &conv,
+bool ConvertFloatImpl(double v, const FormatConversionSpecImpl &conv, 
                       FormatSinkImpl *sink);
 
-bool ConvertFloatImpl(long double v, const FormatConversionSpecImpl &conv,
+bool ConvertFloatImpl(long double v, const FormatConversionSpecImpl &conv, 
                       FormatSinkImpl *sink);
 
 }  // namespace str_format_internal
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/output.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/output.h
index 8fc46fbafa..ae997ae7f7 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/output.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/output.h
@@ -82,11 +82,11 @@ inline void AbslFormatFlush(BufferRawSink* sink, string_view v) {
   sink->Write(v);
 }
 
-// This is a SFINAE to get a better compiler error message when the type
-// is not supported.
+// This is a SFINAE to get a better compiler error message when the type 
+// is not supported. 
 template <typename T>
-auto InvokeFlush(T* out, string_view s) -> decltype(AbslFormatFlush(out, s)) {
-  AbslFormatFlush(out, s);
+auto InvokeFlush(T* out, string_view s) -> decltype(AbslFormatFlush(out, s)) { 
+  AbslFormatFlush(out, s); 
 }
 
 }  // namespace str_format_internal
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.cc
index af07e32fe5..c48cdc9ea3 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.cc
@@ -1,17 +1,17 @@
-// 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 "y_absl/strings/internal/str_format/parser.h"
 
 #include <assert.h>
@@ -31,7 +31,7 @@ namespace y_absl {
 ABSL_NAMESPACE_BEGIN
 namespace str_format_internal {
 
-using CC = FormatConversionCharInternal;
+using CC = FormatConversionCharInternal; 
 using LM = LengthMod;
 
 // Abbreviations to fit in the table below.
@@ -299,17 +299,17 @@ struct ParsedFormatBase::ParsedFormatConsumer {
   char* data_pos;
 };
 
-ParsedFormatBase::ParsedFormatBase(
-    string_view format, bool allow_ignored,
-    std::initializer_list<FormatConversionCharSet> convs)
+ParsedFormatBase::ParsedFormatBase( 
+    string_view format, bool allow_ignored, 
+    std::initializer_list<FormatConversionCharSet> convs) 
     : data_(format.empty() ? nullptr : new char[format.size()]) {
   has_error_ = !ParseFormatString(format, ParsedFormatConsumer(this)) ||
                !MatchesConversions(allow_ignored, convs);
 }
 
 bool ParsedFormatBase::MatchesConversions(
-    bool allow_ignored,
-    std::initializer_list<FormatConversionCharSet> convs) const {
+    bool allow_ignored, 
+    std::initializer_list<FormatConversionCharSet> convs) const { 
   std::unordered_set<int> used;
   auto add_if_valid_conv = [&](int pos, char c) {
       if (static_cast<size_t>(pos) > convs.size() ||
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.h
index ba614bb8b4..4fcdc28c5f 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.h
@@ -1,17 +1,17 @@
-// 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. 
+ 
 #ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_PARSER_H_
 #define ABSL_STRINGS_INTERNAL_STR_FORMAT_PARSER_H_
 
@@ -78,7 +78,7 @@ struct UnboundConversion {
 
   Flags flags = Flags::kBasic;
   LengthMod length_mod = LengthMod::none;
-  FormatConversionChar conv = FormatConversionCharInternal::kNone;
+  FormatConversionChar conv = FormatConversionCharInternal::kNone; 
 };
 
 // Consume conversion spec prefix (not including '%') of [p, end) if valid.
@@ -94,7 +94,7 @@ const char* ConsumeUnboundConversion(const char* p, const char* end,
 // conversions.
 class ConvTag {
  public:
-  constexpr ConvTag(FormatConversionChar conversion_char)  // NOLINT
+  constexpr ConvTag(FormatConversionChar conversion_char)  // NOLINT 
       : tag_(static_cast<uint8_t>(conversion_char)) {}
   constexpr ConvTag(LengthMod length_mod)  // NOLINT
       : tag_(0x80 | static_cast<uint8_t>(length_mod)) {}
@@ -106,11 +106,11 @@ class ConvTag {
   bool is_length() const { return (tag_ & 0xC0) == 0x80; }
   bool is_flags() const { return (tag_ & 0xE0) == 0xC0; }
 
-  FormatConversionChar as_conv() const {
+  FormatConversionChar as_conv() const { 
     assert(is_conv());
     assert(!is_length());
     assert(!is_flags());
-    return static_cast<FormatConversionChar>(tag_);
+    return static_cast<FormatConversionChar>(tag_); 
   }
   LengthMod as_length() const {
     assert(!is_conv());
@@ -165,7 +165,7 @@ bool ParseFormatString(string_view src, Consumer consumer) {
     auto tag = GetTagForChar(percent[1]);
     if (tag.is_conv()) {
       if (ABSL_PREDICT_FALSE(next_arg < 0)) {
-        // This indicates an error in the format string.
+        // This indicates an error in the format string. 
         // The only way to get `next_arg < 0` here is to have a positional
         // argument first which sets next_arg to -1 and then a non-positional
         // argument.
@@ -208,9 +208,9 @@ constexpr bool EnsureConstexpr(string_view s) {
 
 class ParsedFormatBase {
  public:
-  explicit ParsedFormatBase(
-      string_view format, bool allow_ignored,
-      std::initializer_list<FormatConversionCharSet> convs);
+  explicit ParsedFormatBase( 
+      string_view format, bool allow_ignored, 
+      std::initializer_list<FormatConversionCharSet> convs); 
 
   ParsedFormatBase(const ParsedFormatBase& other) { *this = other; }
 
@@ -257,9 +257,9 @@ class ParsedFormatBase {
  private:
   // Returns whether the conversions match and if !allow_ignored it verifies
   // that all conversions are used by the format.
-  bool MatchesConversions(
-      bool allow_ignored,
-      std::initializer_list<FormatConversionCharSet> convs) const;
+  bool MatchesConversions( 
+      bool allow_ignored, 
+      std::initializer_list<FormatConversionCharSet> convs) const; 
 
   struct ParsedFormatConsumer;
 
@@ -304,14 +304,14 @@ class ParsedFormatBase {
 // This is the only API that allows the user to pass a runtime specified format
 // string. These factory functions will return NULL if the format does not match
 // the conversions requested by the user.
-template <FormatConversionCharSet... C>
+template <FormatConversionCharSet... C> 
 class ExtendedParsedFormat : public str_format_internal::ParsedFormatBase {
  public:
   explicit ExtendedParsedFormat(string_view format)
 #ifdef ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
       __attribute__((
           enable_if(str_format_internal::EnsureConstexpr(format),
-                    "Format string is not constexpr."),
+                    "Format string is not constexpr."), 
           enable_if(str_format_internal::ValidFormatImpl<C...>(format),
                     "Format specified does not match the template arguments.")))
 #endif  // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/ya.make
index ff8069cd0f..2c855146e6 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/ya.make
@@ -2,15 +2,15 @@
 
 LIBRARY()
 
-OWNER(
-    somov
-    g:cpp-contrib
-)
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
 
 LICENSE(Apache-2.0)
 
-LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
-
+LICENSE_TEXTS(.yandex_meta/licenses.list.txt) 
+ 
 PEERDIR(
     contrib/restricted/abseil-cpp-tstring/y_absl/base
     contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_split_internal.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_split_internal.h
index 237864c0ed..874f6f1d45 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_split_internal.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_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 y_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(TString&& s) = delete;
-  ConvertibleToStringView(const TString&& s) = delete;
+  ConvertibleToStringView(TString&& s) = delete; 
+  ConvertibleToStringView(const TString&& s) = delete; 
 
   y_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 y_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)) {}
 
-  y_absl::string_view text() const { return text_; }
+  y_absl::string_view text() const { return text_; } 
   const Delimiter& delimiter() const { return delimiter_; }
   const Predicate& predicate() const { return predicate_; }
 
@@ -318,7 +318,7 @@ class Splitter {
     Container operator()(const Splitter& splitter) const {
       Container c;
       auto it = std::inserter(c, c.end());
-      for (const auto& sp : splitter) {
+      for (const auto& sp : splitter) { 
         *it++ = ValueType(sp);
       }
       return c;
@@ -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-tstring/y_absl/strings/internal/string_constant.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/string_constant.h
index b18e821b49..df4fc0357e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/string_constant.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_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 "y_absl/meta/type_traits.h"
-#include "y_absl/strings/string_view.h"
-
-namespace y_absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
-
-// StringConstant<T> represents a compile time string constant.
-// It can be accessed via its `y_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 y_absl::string_view value = T{}();
-  constexpr y_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 y_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 `y_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 y_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 "y_absl/meta/type_traits.h" 
+#include "y_absl/strings/string_view.h" 
+ 
+namespace y_absl { 
+ABSL_NAMESPACE_BEGIN 
+namespace strings_internal { 
+ 
+// StringConstant<T> represents a compile time string constant. 
+// It can be accessed via its `y_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 y_absl::string_view value = T{}(); 
+  constexpr y_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 y_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 `y_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 y_absl 
+ 
+#endif  // ABSL_STRINGS_INTERNAL_STRING_CONSTANT_H_ 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/match.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/match.cc
index 3197bdf432..d60b195954 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/match.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/match.cc
@@ -19,22 +19,22 @@
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
 
-bool EqualsIgnoreCase(y_absl::string_view piece1,
-                      y_absl::string_view piece2) noexcept {
+bool EqualsIgnoreCase(y_absl::string_view piece1, 
+                      y_absl::string_view piece2) noexcept { 
   return (piece1.size() == piece2.size() &&
           0 == y_absl::strings_internal::memcasecmp(piece1.data(), piece2.data(),
                                                   piece1.size()));
   // memcasecmp uses y_absl::ascii_tolower().
 }
 
-bool StartsWithIgnoreCase(y_absl::string_view text,
-                          y_absl::string_view prefix) noexcept {
+bool StartsWithIgnoreCase(y_absl::string_view text, 
+                          y_absl::string_view prefix) noexcept { 
   return (text.size() >= prefix.size()) &&
          EqualsIgnoreCase(text.substr(0, prefix.size()), prefix);
 }
 
-bool EndsWithIgnoreCase(y_absl::string_view text,
-                        y_absl::string_view suffix) noexcept {
+bool EndsWithIgnoreCase(y_absl::string_view text, 
+                        y_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-tstring/y_absl/strings/match.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/match.h
index 4709abc93f..65f0f439d0 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/match.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_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(y_absl::string_view haystack,
-                        y_absl::string_view needle) noexcept {
+inline bool StrContains(y_absl::string_view haystack, 
+                        y_absl::string_view needle) noexcept { 
   return haystack.find(needle, 0) != haystack.npos;
 }
 
-inline bool StrContains(y_absl::string_view haystack, char needle) noexcept {
-  return haystack.find(needle) != haystack.npos;
-}
-
+inline bool StrContains(y_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(y_absl::string_view text,
-                       y_absl::string_view prefix) noexcept {
+inline bool StartsWith(y_absl::string_view text, 
+                       y_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(y_absl::string_view text,
 // EndsWith()
 //
 // Returns whether a given string `text` ends with `suffix`.
-inline bool EndsWith(y_absl::string_view text,
-                     y_absl::string_view suffix) noexcept {
+inline bool EndsWith(y_absl::string_view text, 
+                     y_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(y_absl::string_view text,
 //
 // Returns whether given ASCII strings `piece1` and `piece2` are equal, ignoring
 // case in the comparison.
-bool EqualsIgnoreCase(y_absl::string_view piece1,
-                      y_absl::string_view piece2) noexcept;
+bool EqualsIgnoreCase(y_absl::string_view piece1, 
+                      y_absl::string_view piece2) noexcept; 
 
 // StartsWithIgnoreCase()
 //
 // Returns whether a given ASCII string `text` starts with `prefix`,
 // ignoring case in the comparison.
-bool StartsWithIgnoreCase(y_absl::string_view text,
-                          y_absl::string_view prefix) noexcept;
+bool StartsWithIgnoreCase(y_absl::string_view text, 
+                          y_absl::string_view prefix) noexcept; 
 
 // EndsWithIgnoreCase()
 //
 // Returns whether a given ASCII string `text` ends with `suffix`, ignoring
 // case in the comparison.
-bool EndsWithIgnoreCase(y_absl::string_view text,
-                        y_absl::string_view suffix) noexcept;
+bool EndsWithIgnoreCase(y_absl::string_view text, 
+                        y_absl::string_view suffix) noexcept; 
 
 ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/numbers.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/numbers.cc
index 528d044fa6..fa7797a415 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/numbers.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/numbers.cc
@@ -32,7 +32,7 @@
 
 #include "y_absl/base/attributes.h"
 #include "y_absl/base/internal/raw_logging.h"
-#include "y_absl/numeric/bits.h"
+#include "y_absl/numeric/bits.h" 
 #include "y_absl/strings/ascii.h"
 #include "y_absl/strings/charconv.h"
 #include "y_absl/strings/escaping.h"
@@ -46,13 +46,13 @@ ABSL_NAMESPACE_BEGIN
 bool SimpleAtof(y_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 = y_absl::from_chars(str.data(), str.data() + str.size(), *out);
   if (result.ec == std::errc::invalid_argument) {
@@ -77,13 +77,13 @@ bool SimpleAtof(y_absl::string_view str, float* out) {
 bool SimpleAtod(y_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 = y_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) {
-//    y_absl::uint128 max = std::numeric_limits<y_absl::uint128>::max();
-//    auto result = max / base;
-//    std::cout << "    MakeUint128(" << y_absl::Uint128High64(result) << "u, "
-//              << y_absl::Uint128Low64(result) << "u),\n";
-//  }
-// See https://godbolt.org/z/aneYsb
-//
+// This kVmaxOverBase is generated with 
+//  for (int base = 2; base < 37; ++base) { 
+//    y_absl::uint128 max = std::numeric_limits<y_absl::uint128>::max(); 
+//    auto result = max / base; 
+//    std::cout << "    MakeUint128(" << y_absl::Uint128High64(result) << "u, " 
+//              << y_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) {
-//    y_absl::int128 max = std::numeric_limits<y_absl::int128>::max();
-//    auto result = max / base;
-//    std::cout << "\tMakeInt128(" << y_absl::Int128High64(result) << ", "
-//              << y_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) {
-//    y_absl::int128 min = std::numeric_limits<y_absl::int128>::min();
-//    auto result = min / base;
-//    std::cout << "\tMakeInt128(" << y_absl::Int128High64(result) << ", "
-//              << y_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) { 
+//    y_absl::int128 max = std::numeric_limits<y_absl::int128>::max(); 
+//    auto result = max / base; 
+//    std::cout << "\tMakeInt128(" << y_absl::Int128High64(result) << ", " 
+//              << y_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) { 
+//    y_absl::int128 min = std::numeric_limits<y_absl::int128>::min(); 
+//    auto result = min / base; 
+//    std::cout << "\tMakeInt128(" << y_absl::Int128High64(result) << ", " 
+//              << y_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(y_absl::string_view text, int64_t* value, int base) {
   return safe_int_internal<int64_t>(text, value, base);
 }
 
-bool safe_strto128_base(y_absl::string_view text, int128* value, int base) {
-  return safe_int_internal<y_absl::int128>(text, value, base);
-}
-
+bool safe_strto128_base(y_absl::string_view text, int128* value, int base) { 
+  return safe_int_internal<y_absl::int128>(text, value, base); 
+} 
+ 
 bool safe_strtou32_base(y_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-tstring/y_absl/strings/numbers.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/numbers.h
index ce181d8eb1..b65ab85904 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/numbers.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/numbers.h
@@ -54,7 +54,7 @@
 #endif
 #include "y_absl/base/macros.h"
 #include "y_absl/base/port.h"
-#include "y_absl/numeric/bits.h"
+#include "y_absl/numeric/bits.h" 
 #include "y_absl/numeric/int128.h"
 #include "y_absl/strings/string_view.h"
 
@@ -151,11 +151,11 @@ inline void PutTwoDigits(size_t i, char* buf) {
 }
 
 // safe_strto?() functions for implementing SimpleAtoi()
-
+ 
 bool safe_strto32_base(y_absl::string_view text, int32_t* value, int base);
 bool safe_strto64_base(y_absl::string_view text, int64_t* value, int base);
-bool safe_strto128_base(y_absl::string_view text, y_absl::int128* value,
-                         int base);
+bool safe_strto128_base(y_absl::string_view text, y_absl::int128* value, 
+                         int base); 
 bool safe_strtou32_base(y_absl::string_view text, uint32_t* value, int base);
 bool safe_strtou64_base(y_absl::string_view text, uint64_t* value, int base);
 bool safe_strtou128_base(y_absl::string_view text, y_absl::uint128* value,
@@ -267,7 +267,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
@@ -278,11 +278,11 @@ ABSL_MUST_USE_RESULT bool SimpleAtoi(y_absl::string_view str, int_type* out) {
 }
 
 ABSL_MUST_USE_RESULT inline bool SimpleAtoi(y_absl::string_view str,
-                                            y_absl::int128* out) {
-  return numbers_internal::safe_strto128_base(str, out, 10);
-}
-
-ABSL_MUST_USE_RESULT inline bool SimpleAtoi(y_absl::string_view str,
+                                            y_absl::int128* out) { 
+  return numbers_internal::safe_strto128_base(str, out, 10); 
+} 
+ 
+ABSL_MUST_USE_RESULT inline bool SimpleAtoi(y_absl::string_view str, 
                                             y_absl::uint128* out) {
   return numbers_internal::safe_strtou128_base(str, out, 10);
 }
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_cat.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_cat.cc
index 9e11702eae..9b154a60b8 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_cat.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_cat.cc
@@ -141,12 +141,12 @@ namespace strings_internal {
 TString CatPieces(std::initializer_list<y_absl::string_view> pieces) {
   TString result;
   size_t total_size = 0;
-  for (const y_absl::string_view& piece : pieces) total_size += piece.size();
+  for (const y_absl::string_view& piece : pieces) total_size += piece.size(); 
   strings_internal::STLStringResizeUninitialized(&result, total_size);
 
   char* const begin = &result[0];
   char* out = begin;
-  for (const y_absl::string_view& piece : pieces) {
+  for (const y_absl::string_view& piece : pieces) { 
     const size_t this_size = piece.size();
     if (this_size != 0) {
       memcpy(out, piece.data(), this_size);
@@ -170,7 +170,7 @@ void AppendPieces(TString* dest,
                   std::initializer_list<y_absl::string_view> pieces) {
   size_t old_size = dest->size();
   size_t total_size = old_size;
-  for (const y_absl::string_view& piece : pieces) {
+  for (const y_absl::string_view& piece : pieces) { 
     ASSERT_NO_OVERLAP(*dest, piece);
     total_size += piece.size();
   }
@@ -178,7 +178,7 @@ void AppendPieces(TString* dest,
 
   char* const begin = &(*dest)[0];
   char* out = begin + old_size;
-  for (const y_absl::string_view& piece : pieces) {
+  for (const y_absl::string_view& piece : pieces) { 
     const size_t this_size = piece.size();
     if (this_size != 0) {
       memcpy(out, piece.data(), this_size);
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_cat.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_cat.h
index a77c9ae906..9322fdf3d5 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_cat.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_cat.h
@@ -256,7 +256,7 @@ class AlphaNum {
   AlphaNum(const TString& str)
       : piece_(str.data(), str.size()) {}
 
-  // Use string literals ":" instead of character literals ':'.
+  // Use string literals ":" instead of character literals ':'. 
   AlphaNum(char c) = delete;  // NOLINT(runtime/explicit)
 
   AlphaNum(const AlphaNum&) = delete;
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_format.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_format.h
index 4079f38fb4..82e9902202 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_format.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_format.h
@@ -19,7 +19,7 @@
 //
 // The `str_format` library is a typesafe replacement for the family of
 // `printf()` string formatting routines within the `<cstdio>` standard library
-// header. Like the `printf` family, `str_format` uses a "format string" to
+// header. Like the `printf` family, `str_format` uses a "format string" to 
 // perform argument substitutions based on types. See the `FormatSpec` section
 // below for format string documentation.
 //
@@ -57,7 +57,7 @@
 // arbitrary sink types:
 //
 //   * A generic `Format()` function to write outputs to arbitrary sink types,
-//     which must implement a `FormatRawSink` interface.
+//     which must implement a `FormatRawSink` interface. 
 //
 //   * A `FormatUntyped()` function that is similar to `Format()` except it is
 //     loosely typed. `FormatUntyped()` is not a template and does not perform
@@ -65,7 +65,7 @@
 //     boolean from a runtime check.
 //
 // In addition, the `str_format` library provides extension points for
-// augmenting formatting to new types.  See "StrFormat Extensions" below.
+// augmenting formatting to new types.  See "StrFormat Extensions" below. 
 
 #ifndef ABSL_STRINGS_STR_FORMAT_H_
 #define ABSL_STRINGS_STR_FORMAT_H_
@@ -253,8 +253,8 @@ class FormatCountCapture {
 // argument, etc.
 
 template <typename... Args>
-using FormatSpec = str_format_internal::FormatSpecTemplate<
-    str_format_internal::ArgumentToConv<Args>()...>;
+using FormatSpec = str_format_internal::FormatSpecTemplate< 
+    str_format_internal::ArgumentToConv<Args>()...>; 
 
 // ParsedFormat
 //
@@ -281,36 +281,36 @@ using FormatSpec = str_format_internal::FormatSpecTemplate<
 //   } else {
 //     ... error case ...
 //   }
-
-#if defined(__cpp_nontype_template_parameter_auto)
-// If C++17 is available, an 'extended' format is also allowed that can specify
-// multiple conversion characters per format argument, using a combination of
-// `y_absl::FormatConversionCharSet` enum values (logically a set union)
-//  via the `|` operator. (Single character-based arguments are still accepted,
-// but cannot be combined). Some common conversions also have predefined enum
-// values, such as `y_absl::FormatConversionCharSet::kIntegral`.
-//
-// Example:
-//   // Extended format supports multiple conversion characters per argument,
-//   // specified via a combination of `FormatConversionCharSet` enums.
-//   using MyFormat = y_absl::ParsedFormat<y_absl::FormatConversionCharSet::d |
-//                                       y_absl::FormatConversionCharSet::x>;
-//   MyFormat GetFormat(bool use_hex) {
-//     if (use_hex) return MyFormat("foo %x bar");
-//     return MyFormat("foo %d bar");
-//   }
-//   // `format` can be used with any value that supports 'd' and 'x',
-//   // like `int`.
-//   auto format = GetFormat(use_hex);
-//   value = StringF(format, i);
-template <auto... Conv>
-using ParsedFormat = y_absl::str_format_internal::ExtendedParsedFormat<
-    y_absl::str_format_internal::ToFormatConversionCharSet(Conv)...>;
-#else
+ 
+#if defined(__cpp_nontype_template_parameter_auto) 
+// If C++17 is available, an 'extended' format is also allowed that can specify 
+// multiple conversion characters per format argument, using a combination of 
+// `y_absl::FormatConversionCharSet` enum values (logically a set union) 
+//  via the `|` operator. (Single character-based arguments are still accepted, 
+// but cannot be combined). Some common conversions also have predefined enum 
+// values, such as `y_absl::FormatConversionCharSet::kIntegral`. 
+// 
+// Example: 
+//   // Extended format supports multiple conversion characters per argument, 
+//   // specified via a combination of `FormatConversionCharSet` enums. 
+//   using MyFormat = y_absl::ParsedFormat<y_absl::FormatConversionCharSet::d | 
+//                                       y_absl::FormatConversionCharSet::x>; 
+//   MyFormat GetFormat(bool use_hex) { 
+//     if (use_hex) return MyFormat("foo %x bar"); 
+//     return MyFormat("foo %d bar"); 
+//   } 
+//   // `format` can be used with any value that supports 'd' and 'x', 
+//   // like `int`. 
+//   auto format = GetFormat(use_hex); 
+//   value = StringF(format, i); 
+template <auto... Conv> 
+using ParsedFormat = y_absl::str_format_internal::ExtendedParsedFormat< 
+    y_absl::str_format_internal::ToFormatConversionCharSet(Conv)...>; 
+#else 
 template <char... Conv>
 using ParsedFormat = str_format_internal::ExtendedParsedFormat<
-    y_absl::str_format_internal::ToFormatConversionCharSet(Conv)...>;
-#endif  // defined(__cpp_nontype_template_parameter_auto)
+    y_absl::str_format_internal::ToFormatConversionCharSet(Conv)...>; 
+#endif  // defined(__cpp_nontype_template_parameter_auto) 
 
 // StrFormat()
 //
@@ -457,16 +457,16 @@ int SNPrintF(char* output, std::size_t size, const FormatSpec<Args...>& format,
 //
 // FormatRawSink is a type erased wrapper around arbitrary sink objects
 // specifically used as an argument to `Format()`.
-//
-// All the object has to do define an overload of `AbslFormatFlush()` for the
-// sink, usually by adding a ADL-based free function in the same namespace as
-// the sink:
-//
-//   void AbslFormatFlush(MySink* dest, y_absl::string_view part);
-//
-// where `dest` is the pointer passed to `y_absl::Format()`. The function should
-// append `part` to `dest`.
-//
+// 
+// All the object has to do define an overload of `AbslFormatFlush()` for the 
+// sink, usually by adding a ADL-based free function in the same namespace as 
+// the sink: 
+// 
+//   void AbslFormatFlush(MySink* dest, y_absl::string_view part); 
+// 
+// where `dest` is the pointer passed to `y_absl::Format()`. The function should 
+// append `part` to `dest`. 
+// 
 // FormatRawSink does not own the passed sink object. The passed object must
 // outlive the FormatRawSink.
 class FormatRawSink {
@@ -490,13 +490,13 @@ class FormatRawSink {
 // `y_absl::FormatRawSink` interface), using a format string and zero or more
 // additional arguments.
 //
-// By default, `TString`, `std::ostream`, and `y_absl::Cord` are supported as
-// destination objects. If a `TString` is used the formatted string is
-// appended to it.
+// By default, `TString`, `std::ostream`, and `y_absl::Cord` are supported as 
+// destination objects. If a `TString` is used the formatted string is 
+// appended to it. 
 //
-// `y_absl::Format()` is a generic version of `y_absl::StrAppendFormat()`, for
-// custom sinks. The format string, like format strings for `StrFormat()`, is
-// checked at compile-time.
+// `y_absl::Format()` is a generic version of `y_absl::StrAppendFormat()`, for 
+// custom sinks. The format string, like format strings for `StrFormat()`, is 
+// checked at compile-time. 
 //
 // On failure, this function returns `false` and the state of the sink is
 // unspecified.
@@ -566,246 +566,246 @@ ABSL_MUST_USE_RESULT inline bool FormatUntyped(
       str_format_internal::UntypedFormatSpecImpl::Extract(format), args);
 }
 
-//------------------------------------------------------------------------------
-// StrFormat Extensions
-//------------------------------------------------------------------------------
-//
-// AbslFormatConvert()
-//
-// The StrFormat library provides a customization API for formatting
-// user-defined types using y_absl::StrFormat(). The API relies on detecting an
-// overload in the user-defined type's namespace of a free (non-member)
-// `AbslFormatConvert()` function, usually as a friend definition with the
-// following signature:
-//
-// y_absl::FormatConvertResult<...> AbslFormatConvert(
-//     const X& value,
-//     const y_absl::FormatConversionSpec& spec,
-//     y_absl::FormatSink *sink);
-//
-// An `AbslFormatConvert()` overload for a type should only be declared in the
-// same file and namespace as said type.
-//
-// The abstractions within this definition include:
-//
-// * An `y_absl::FormatConversionSpec` to specify the fields to pull from a
-//   user-defined type's format string
-// * An `y_absl::FormatSink` to hold the converted string data during the
-//   conversion process.
-// * An `y_absl::FormatConvertResult` to hold the status of the returned
-//   formatting operation
-//
-// The return type encodes all the conversion characters that your
-// AbslFormatConvert() routine accepts.  The return value should be {true}.
-// A return value of {false} will result in `StrFormat()` returning
-// an empty string.  This result will be propagated to the result of
-// `FormatUntyped`.
-//
-// Example:
-//
-// struct Point {
-//   // To add formatting support to `Point`, we simply need to add a free
-//   // (non-member) function `AbslFormatConvert()`.  This method interprets
-//   // `spec` to print in the request format. The allowed conversion characters
-//   // can be restricted via the type of the result, in this example
-//   // string and integral formatting are allowed (but not, for instance
-//   // floating point characters like "%f").  You can add such a free function
-//   // using a friend declaration within the body of the class:
-//   friend y_absl::FormatConvertResult<y_absl::FormatConversionCharSet::kString |
-//                                    y_absl::FormatConversionCharSet::kIntegral>
-//   AbslFormatConvert(const Point& p, const y_absl::FormatConversionSpec& spec,
-//                     y_absl::FormatSink* s) {
-//     if (spec.conversion_char() == y_absl::FormatConversionChar::s) {
-//       s->Append(y_absl::StrCat("x=", p.x, " y=", p.y));
-//     } else {
-//       s->Append(y_absl::StrCat(p.x, ",", p.y));
-//     }
-//     return {true};
-//   }
-//
-//   int x;
-//   int y;
-// };
-
-// clang-format off
-
-// FormatConversionChar
-//
-// Specifies the formatting character provided in the format string
-// passed to `StrFormat()`.
-enum class FormatConversionChar : uint8_t {
-  c, s,                    // text
-  d, i, o, u, x, X,        // int
-  f, F, e, E, g, G, a, A,  // float
-  n, p                     // misc
-};
-// clang-format on
-
-// FormatConversionSpec
-//
-// Specifies modifications to the conversion of the format string, through use
-// of one or more format flags in the source format string.
-class FormatConversionSpec {
- public:
-  // FormatConversionSpec::is_basic()
-  //
-  // Indicates that width and precision are not specified, and no additional
-  // flags are set for this conversion character in the format string.
-  bool is_basic() const { return impl_.is_basic(); }
-
-  // FormatConversionSpec::has_left_flag()
-  //
-  // Indicates whether the result should be left justified for this conversion
-  // character in the format string. This flag is set through use of a '-'
-  // character in the format string. E.g. "%-s"
-  bool has_left_flag() const { return impl_.has_left_flag(); }
-
-  // FormatConversionSpec::has_show_pos_flag()
-  //
-  // Indicates whether a sign column is prepended to the result for this
-  // conversion character in the format string, even if the result is positive.
-  // This flag is set through use of a '+' character in the format string.
-  // E.g. "%+d"
-  bool has_show_pos_flag() const { return impl_.has_show_pos_flag(); }
-
-  // FormatConversionSpec::has_sign_col_flag()
-  //
-  // Indicates whether a mandatory sign column is added to the result for this
-  // conversion character. This flag is set through use of a space character
-  // (' ') in the format string. E.g. "% i"
-  bool has_sign_col_flag() const { return impl_.has_sign_col_flag(); }
-
-  // FormatConversionSpec::has_alt_flag()
-  //
-  // Indicates whether an "alternate" format is applied to the result for this
-  // conversion character. Alternative forms depend on the type of conversion
-  // character, and unallowed alternatives are undefined. This flag is set
-  // through use of a '#' character in the format string. E.g. "%#h"
-  bool has_alt_flag() const { return impl_.has_alt_flag(); }
-
-  // FormatConversionSpec::has_zero_flag()
-  //
-  // Indicates whether zeroes should be prepended to the result for this
-  // conversion character instead of spaces. This flag is set through use of the
-  // '0' character in the format string. E.g. "%0f"
-  bool has_zero_flag() const { return impl_.has_zero_flag(); }
-
-  // FormatConversionSpec::conversion_char()
-  //
-  // Returns the underlying conversion character.
-  FormatConversionChar conversion_char() const {
-    return impl_.conversion_char();
-  }
-
-  // FormatConversionSpec::width()
-  //
-  // Returns the specified width (indicated through use of a non-zero integer
-  // value or '*' character) of the conversion character. If width is
-  // unspecified, it returns a negative value.
-  int width() const { return impl_.width(); }
-
-  // FormatConversionSpec::precision()
-  //
-  // Returns the specified precision (through use of the '.' character followed
-  // by a non-zero integer value or '*' character) of the conversion character.
-  // If precision is unspecified, it returns a negative value.
-  int precision() const { return impl_.precision(); }
-
- private:
-  explicit FormatConversionSpec(
-      str_format_internal::FormatConversionSpecImpl impl)
-      : impl_(impl) {}
-
-  friend str_format_internal::FormatConversionSpecImpl;
-
-  y_absl::str_format_internal::FormatConversionSpecImpl impl_;
-};
-
-// Type safe OR operator for FormatConversionCharSet to allow accepting multiple
-// conversion chars in custom format converters.
-constexpr FormatConversionCharSet operator|(FormatConversionCharSet a,
-                                            FormatConversionCharSet b) {
-  return static_cast<FormatConversionCharSet>(static_cast<uint64_t>(a) |
-                                              static_cast<uint64_t>(b));
-}
-
-// FormatConversionCharSet
-//
-// Specifies the _accepted_ conversion types as a template parameter to
-// FormatConvertResult for custom implementations of `AbslFormatConvert`.
-// Note the helper predefined alias definitions (kIntegral, etc.) below.
-enum class FormatConversionCharSet : uint64_t {
-  // text
-  c = str_format_internal::FormatConversionCharToConvInt('c'),
-  s = str_format_internal::FormatConversionCharToConvInt('s'),
-  // integer
-  d = str_format_internal::FormatConversionCharToConvInt('d'),
-  i = str_format_internal::FormatConversionCharToConvInt('i'),
-  o = str_format_internal::FormatConversionCharToConvInt('o'),
-  u = str_format_internal::FormatConversionCharToConvInt('u'),
-  x = str_format_internal::FormatConversionCharToConvInt('x'),
-  X = str_format_internal::FormatConversionCharToConvInt('X'),
-  // Float
-  f = str_format_internal::FormatConversionCharToConvInt('f'),
-  F = str_format_internal::FormatConversionCharToConvInt('F'),
-  e = str_format_internal::FormatConversionCharToConvInt('e'),
-  E = str_format_internal::FormatConversionCharToConvInt('E'),
-  g = str_format_internal::FormatConversionCharToConvInt('g'),
-  G = str_format_internal::FormatConversionCharToConvInt('G'),
-  a = str_format_internal::FormatConversionCharToConvInt('a'),
-  A = str_format_internal::FormatConversionCharToConvInt('A'),
-  // misc
-  n = str_format_internal::FormatConversionCharToConvInt('n'),
-  p = str_format_internal::FormatConversionCharToConvInt('p'),
-
-  // Used for width/precision '*' specification.
-  kStar = static_cast<uint64_t>(
-      y_absl::str_format_internal::FormatConversionCharSetInternal::kStar),
-  // Some predefined values:
-  kIntegral = d | i | u | o | x | X,
-  kFloating = a | e | f | g | A | E | F | G,
-  kNumeric = kIntegral | kFloating,
-  kString = s,
-  kPointer = p,
-};
-
-// FormatSink
-//
-// An abstraction to which conversions write their string data.
-//
-class FormatSink {
- public:
-  // Appends `count` copies of `ch`.
-  void Append(size_t count, char ch) { sink_->Append(count, ch); }
-
-  void Append(string_view v) { sink_->Append(v); }
-
-  // Appends the first `precision` bytes of `v`. If this is less than
-  // `width`, spaces will be appended first (if `left` is false), or
-  // after (if `left` is true) to ensure the total amount appended is
-  // at least `width`.
-  bool PutPaddedString(string_view v, int width, int precision, bool left) {
-    return sink_->PutPaddedString(v, width, precision, left);
-  }
-
- private:
-  friend str_format_internal::FormatSinkImpl;
-  explicit FormatSink(str_format_internal::FormatSinkImpl* s) : sink_(s) {}
-  str_format_internal::FormatSinkImpl* sink_;
-};
-
-// FormatConvertResult
-//
-// Indicates whether a call to AbslFormatConvert() was successful.
-// This return type informs the StrFormat extension framework (through
-// ADL but using the return type) of what conversion characters are supported.
-// It is strongly discouraged to return {false}, as this will result in an
-// empty string in StrFormat.
-template <FormatConversionCharSet C>
-struct FormatConvertResult {
-  bool value;
-};
-
+//------------------------------------------------------------------------------ 
+// StrFormat Extensions 
+//------------------------------------------------------------------------------ 
+// 
+// AbslFormatConvert() 
+// 
+// The StrFormat library provides a customization API for formatting 
+// user-defined types using y_absl::StrFormat(). The API relies on detecting an 
+// overload in the user-defined type's namespace of a free (non-member) 
+// `AbslFormatConvert()` function, usually as a friend definition with the 
+// following signature: 
+// 
+// y_absl::FormatConvertResult<...> AbslFormatConvert( 
+//     const X& value, 
+//     const y_absl::FormatConversionSpec& spec, 
+//     y_absl::FormatSink *sink); 
+// 
+// An `AbslFormatConvert()` overload for a type should only be declared in the 
+// same file and namespace as said type. 
+// 
+// The abstractions within this definition include: 
+// 
+// * An `y_absl::FormatConversionSpec` to specify the fields to pull from a 
+//   user-defined type's format string 
+// * An `y_absl::FormatSink` to hold the converted string data during the 
+//   conversion process. 
+// * An `y_absl::FormatConvertResult` to hold the status of the returned 
+//   formatting operation 
+// 
+// The return type encodes all the conversion characters that your 
+// AbslFormatConvert() routine accepts.  The return value should be {true}. 
+// A return value of {false} will result in `StrFormat()` returning 
+// an empty string.  This result will be propagated to the result of 
+// `FormatUntyped`. 
+// 
+// Example: 
+// 
+// struct Point { 
+//   // To add formatting support to `Point`, we simply need to add a free 
+//   // (non-member) function `AbslFormatConvert()`.  This method interprets 
+//   // `spec` to print in the request format. The allowed conversion characters 
+//   // can be restricted via the type of the result, in this example 
+//   // string and integral formatting are allowed (but not, for instance 
+//   // floating point characters like "%f").  You can add such a free function 
+//   // using a friend declaration within the body of the class: 
+//   friend y_absl::FormatConvertResult<y_absl::FormatConversionCharSet::kString | 
+//                                    y_absl::FormatConversionCharSet::kIntegral> 
+//   AbslFormatConvert(const Point& p, const y_absl::FormatConversionSpec& spec, 
+//                     y_absl::FormatSink* s) { 
+//     if (spec.conversion_char() == y_absl::FormatConversionChar::s) { 
+//       s->Append(y_absl::StrCat("x=", p.x, " y=", p.y)); 
+//     } else { 
+//       s->Append(y_absl::StrCat(p.x, ",", p.y)); 
+//     } 
+//     return {true}; 
+//   } 
+// 
+//   int x; 
+//   int y; 
+// }; 
+ 
+// clang-format off 
+ 
+// FormatConversionChar 
+// 
+// Specifies the formatting character provided in the format string 
+// passed to `StrFormat()`. 
+enum class FormatConversionChar : uint8_t { 
+  c, s,                    // text 
+  d, i, o, u, x, X,        // int 
+  f, F, e, E, g, G, a, A,  // float 
+  n, p                     // misc 
+}; 
+// clang-format on 
+ 
+// FormatConversionSpec 
+// 
+// Specifies modifications to the conversion of the format string, through use 
+// of one or more format flags in the source format string. 
+class FormatConversionSpec { 
+ public: 
+  // FormatConversionSpec::is_basic() 
+  // 
+  // Indicates that width and precision are not specified, and no additional 
+  // flags are set for this conversion character in the format string. 
+  bool is_basic() const { return impl_.is_basic(); } 
+ 
+  // FormatConversionSpec::has_left_flag() 
+  // 
+  // Indicates whether the result should be left justified for this conversion 
+  // character in the format string. This flag is set through use of a '-' 
+  // character in the format string. E.g. "%-s" 
+  bool has_left_flag() const { return impl_.has_left_flag(); } 
+ 
+  // FormatConversionSpec::has_show_pos_flag() 
+  // 
+  // Indicates whether a sign column is prepended to the result for this 
+  // conversion character in the format string, even if the result is positive. 
+  // This flag is set through use of a '+' character in the format string. 
+  // E.g. "%+d" 
+  bool has_show_pos_flag() const { return impl_.has_show_pos_flag(); } 
+ 
+  // FormatConversionSpec::has_sign_col_flag() 
+  // 
+  // Indicates whether a mandatory sign column is added to the result for this 
+  // conversion character. This flag is set through use of a space character 
+  // (' ') in the format string. E.g. "% i" 
+  bool has_sign_col_flag() const { return impl_.has_sign_col_flag(); } 
+ 
+  // FormatConversionSpec::has_alt_flag() 
+  // 
+  // Indicates whether an "alternate" format is applied to the result for this 
+  // conversion character. Alternative forms depend on the type of conversion 
+  // character, and unallowed alternatives are undefined. This flag is set 
+  // through use of a '#' character in the format string. E.g. "%#h" 
+  bool has_alt_flag() const { return impl_.has_alt_flag(); } 
+ 
+  // FormatConversionSpec::has_zero_flag() 
+  // 
+  // Indicates whether zeroes should be prepended to the result for this 
+  // conversion character instead of spaces. This flag is set through use of the 
+  // '0' character in the format string. E.g. "%0f" 
+  bool has_zero_flag() const { return impl_.has_zero_flag(); } 
+ 
+  // FormatConversionSpec::conversion_char() 
+  // 
+  // Returns the underlying conversion character. 
+  FormatConversionChar conversion_char() const { 
+    return impl_.conversion_char(); 
+  } 
+ 
+  // FormatConversionSpec::width() 
+  // 
+  // Returns the specified width (indicated through use of a non-zero integer 
+  // value or '*' character) of the conversion character. If width is 
+  // unspecified, it returns a negative value. 
+  int width() const { return impl_.width(); } 
+ 
+  // FormatConversionSpec::precision() 
+  // 
+  // Returns the specified precision (through use of the '.' character followed 
+  // by a non-zero integer value or '*' character) of the conversion character. 
+  // If precision is unspecified, it returns a negative value. 
+  int precision() const { return impl_.precision(); } 
+ 
+ private: 
+  explicit FormatConversionSpec( 
+      str_format_internal::FormatConversionSpecImpl impl) 
+      : impl_(impl) {} 
+ 
+  friend str_format_internal::FormatConversionSpecImpl; 
+ 
+  y_absl::str_format_internal::FormatConversionSpecImpl impl_; 
+}; 
+ 
+// Type safe OR operator for FormatConversionCharSet to allow accepting multiple 
+// conversion chars in custom format converters. 
+constexpr FormatConversionCharSet operator|(FormatConversionCharSet a, 
+                                            FormatConversionCharSet b) { 
+  return static_cast<FormatConversionCharSet>(static_cast<uint64_t>(a) | 
+                                              static_cast<uint64_t>(b)); 
+} 
+ 
+// FormatConversionCharSet 
+// 
+// Specifies the _accepted_ conversion types as a template parameter to 
+// FormatConvertResult for custom implementations of `AbslFormatConvert`. 
+// Note the helper predefined alias definitions (kIntegral, etc.) below. 
+enum class FormatConversionCharSet : uint64_t { 
+  // text 
+  c = str_format_internal::FormatConversionCharToConvInt('c'), 
+  s = str_format_internal::FormatConversionCharToConvInt('s'), 
+  // integer 
+  d = str_format_internal::FormatConversionCharToConvInt('d'), 
+  i = str_format_internal::FormatConversionCharToConvInt('i'), 
+  o = str_format_internal::FormatConversionCharToConvInt('o'), 
+  u = str_format_internal::FormatConversionCharToConvInt('u'), 
+  x = str_format_internal::FormatConversionCharToConvInt('x'), 
+  X = str_format_internal::FormatConversionCharToConvInt('X'), 
+  // Float 
+  f = str_format_internal::FormatConversionCharToConvInt('f'), 
+  F = str_format_internal::FormatConversionCharToConvInt('F'), 
+  e = str_format_internal::FormatConversionCharToConvInt('e'), 
+  E = str_format_internal::FormatConversionCharToConvInt('E'), 
+  g = str_format_internal::FormatConversionCharToConvInt('g'), 
+  G = str_format_internal::FormatConversionCharToConvInt('G'), 
+  a = str_format_internal::FormatConversionCharToConvInt('a'), 
+  A = str_format_internal::FormatConversionCharToConvInt('A'), 
+  // misc 
+  n = str_format_internal::FormatConversionCharToConvInt('n'), 
+  p = str_format_internal::FormatConversionCharToConvInt('p'), 
+ 
+  // Used for width/precision '*' specification. 
+  kStar = static_cast<uint64_t>( 
+      y_absl::str_format_internal::FormatConversionCharSetInternal::kStar), 
+  // Some predefined values: 
+  kIntegral = d | i | u | o | x | X, 
+  kFloating = a | e | f | g | A | E | F | G, 
+  kNumeric = kIntegral | kFloating, 
+  kString = s, 
+  kPointer = p, 
+}; 
+ 
+// FormatSink 
+// 
+// An abstraction to which conversions write their string data. 
+// 
+class FormatSink { 
+ public: 
+  // Appends `count` copies of `ch`. 
+  void Append(size_t count, char ch) { sink_->Append(count, ch); } 
+ 
+  void Append(string_view v) { sink_->Append(v); } 
+ 
+  // Appends the first `precision` bytes of `v`. If this is less than 
+  // `width`, spaces will be appended first (if `left` is false), or 
+  // after (if `left` is true) to ensure the total amount appended is 
+  // at least `width`. 
+  bool PutPaddedString(string_view v, int width, int precision, bool left) { 
+    return sink_->PutPaddedString(v, width, precision, left); 
+  } 
+ 
+ private: 
+  friend str_format_internal::FormatSinkImpl; 
+  explicit FormatSink(str_format_internal::FormatSinkImpl* s) : sink_(s) {} 
+  str_format_internal::FormatSinkImpl* sink_; 
+}; 
+ 
+// FormatConvertResult 
+// 
+// Indicates whether a call to AbslFormatConvert() was successful. 
+// This return type informs the StrFormat extension framework (through 
+// ADL but using the return type) of what conversion characters are supported. 
+// It is strongly discouraged to return {false}, as this will result in an 
+// empty string in StrFormat. 
+template <FormatConversionCharSet C> 
+struct FormatConvertResult { 
+  bool value; 
+}; 
+ 
 ABSL_NAMESPACE_END
 }  // namespace y_absl
 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_join.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_join.h
index 46a0323c6e..b362d5a24d 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_join.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_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-tstring/y_absl/strings/str_split.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_split.cc
index 5f9193e6ba..eb0228ac1b 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_split.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_split.cc
@@ -42,7 +42,7 @@ y_absl::string_view GenericFind(y_absl::string_view text,
                               y_absl::string_view delimiter, size_t pos,
                               FindPolicy find_policy) {
   if (delimiter.empty() && text.length() > 0) {
-    // Special case for empty string delimiters: always return a zero-length
+    // Special case for empty string delimiters: always return a zero-length 
     // y_absl::string_view referring to the item at position 1 past pos.
     return y_absl::string_view(text.data() + pos + 1, 0);
   }
@@ -127,7 +127,7 @@ y_absl::string_view ByLength::Find(y_absl::string_view text,
                                       size_t pos) const {
   pos = std::min(pos, text.size());  // truncate `pos`
   y_absl::string_view substr = text.substr(pos);
-  // If the string is shorter than the chunk size we say we
+  // If the string is shorter than the chunk size we say we 
   // "can't find the delimiter" so this will be the last chunk.
   if (substr.length() <= static_cast<size_t>(length_))
     return y_absl::string_view(text.data() + text.size(), 0);
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_split.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_split.h
index d32d54813e..35df211020 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_split.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_split.h
@@ -44,7 +44,7 @@
 #include <vector>
 
 #include "y_absl/base/internal/raw_logging.h"
-#include "y_absl/base/macros.h"
+#include "y_absl/base/macros.h" 
 #include "y_absl/strings/internal/str_split_internal.h"
 #include "y_absl/strings/string_view.h"
 #include "y_absl/strings/strip.h"
@@ -369,12 +369,12 @@ struct SkipWhitespace {
   }
 };
 
-template <typename T>
-using EnableSplitIfString =
-    typename std::enable_if<std::is_same<T, TString>::value ||
-                            std::is_same<T, const TString>::value,
-                            int>::type;
-
+template <typename T> 
+using EnableSplitIfString = 
+    typename std::enable_if<std::is_same<T, TString>::value || 
+                            std::is_same<T, const TString>::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,
-    y_absl::string_view>
+    typename strings_internal::SelectDelimiter<Delimiter>::type, AllowEmpty, 
+    y_absl::string_view> 
 StrSplit(strings_internal::ConvertibleToStringView text, Delimiter d) {
   using DelimiterType =
       typename strings_internal::SelectDelimiter<Delimiter>::type;
-  return strings_internal::Splitter<DelimiterType, AllowEmpty,
-                                    y_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,
-    TString>
-StrSplit(StringType&& text, Delimiter d) {
-  using DelimiterType =
-      typename strings_internal::SelectDelimiter<Delimiter>::type;
-  return strings_internal::Splitter<DelimiterType, AllowEmpty, TString>(
+  return strings_internal::Splitter<DelimiterType, AllowEmpty, 
+                                    y_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, 
+    TString> 
+StrSplit(StringType&& text, Delimiter d) { 
+  using DelimiterType = 
+      typename strings_internal::SelectDelimiter<Delimiter>::type; 
+  return strings_internal::Splitter<DelimiterType, AllowEmpty, TString>( 
       std::move(text), DelimiterType(d), AllowEmpty());
 }
 
 template <typename Delimiter, typename Predicate>
 strings_internal::Splitter<
-    typename strings_internal::SelectDelimiter<Delimiter>::type, Predicate,
-    y_absl::string_view>
+    typename strings_internal::SelectDelimiter<Delimiter>::type, Predicate, 
+    y_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,
-                                    y_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,
-    TString>
-StrSplit(StringType&& text, Delimiter d, Predicate p) {
-  using DelimiterType =
-      typename strings_internal::SelectDelimiter<Delimiter>::type;
-  return strings_internal::Splitter<DelimiterType, Predicate, TString>(
+  return strings_internal::Splitter<DelimiterType, Predicate, 
+                                    y_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, 
+    TString> 
+StrSplit(StringType&& text, Delimiter d, Predicate p) { 
+  using DelimiterType = 
+      typename strings_internal::SelectDelimiter<Delimiter>::type; 
+  return strings_internal::Splitter<DelimiterType, Predicate, TString>( 
       std::move(text), DelimiterType(d), std::move(p));
 }
 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/string_view.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/string_view.h
index c3906fe1c5..447e0f0dcd 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/string_view.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/string_view.h
@@ -49,7 +49,7 @@
 
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-using string_view = std::string_view;
+using string_view = std::string_view; 
 ABSL_NAMESPACE_END
 }  // namespace y_absl
 
@@ -120,11 +120,11 @@ ABSL_NAMESPACE_BEGIN
 // example, when splitting a string, `std::vector<y_absl::string_view>` is a
 // natural data type for the output.
 //
-// For another example, a Cord is a non-contiguous, potentially very
-// long string-like object.  The Cord class has an interface that iteratively
-// provides string_view objects that point to the successive pieces of a Cord
-// object.
-//
+// For another example, a Cord is a non-contiguous, potentially very 
+// long string-like object.  The Cord class has an interface that iteratively 
+// provides string_view objects that point to the successive pieces of a Cord 
+// object. 
+// 
 // When constructed from a source which is NUL-terminated, the `string_view`
 // itself will not include the NUL-terminator unless a specific size (including
 // the NUL) is passed to the constructor. As a result, common idioms that work
@@ -297,7 +297,7 @@ class string_view {
   // Returns the ith element of the `string_view` using the array operator.
   // Note that this operator does not perform any bounds checking.
   constexpr const_reference operator[](size_type i) const {
-    return ABSL_HARDENING_ASSERT(i < size()), ptr_[i];
+    return ABSL_HARDENING_ASSERT(i < size()), ptr_[i]; 
   }
 
   // string_view::at()
@@ -317,14 +317,14 @@ class string_view {
   //
   // Returns the first element of a `string_view`.
   constexpr const_reference front() const {
-    return ABSL_HARDENING_ASSERT(!empty()), ptr_[0];
+    return ABSL_HARDENING_ASSERT(!empty()), ptr_[0]; 
   }
 
   // string_view::back()
   //
   // Returns the last element of a `string_view`.
   constexpr const_reference back() const {
-    return ABSL_HARDENING_ASSERT(!empty()), ptr_[size() - 1];
+    return ABSL_HARDENING_ASSERT(!empty()), ptr_[size() - 1]; 
   }
 
   // string_view::data()
@@ -333,7 +333,7 @@ class string_view {
   // stored elsewhere). Note that `string_view::data()` may contain embedded nul
   // characters, but the returned buffer may or may not be NUL-terminated;
   // therefore, do not pass `data()` to a routine that expects a NUL-terminated
-  // string.
+  // string. 
   constexpr const_pointer data() const noexcept { return ptr_; }
 
   // Modifiers
@@ -341,9 +341,9 @@ class string_view {
   // string_view::remove_prefix()
   //
   // Removes the first `n` characters from the `string_view`. Note that the
-  // underlying string is not changed, only the view.
+  // underlying string is not changed, only the view. 
   ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR void remove_prefix(size_type n) {
-    ABSL_HARDENING_ASSERT(n <= length_);
+    ABSL_HARDENING_ASSERT(n <= length_); 
     ptr_ += n;
     length_ -= n;
   }
@@ -351,9 +351,9 @@ class string_view {
   // string_view::remove_suffix()
   //
   // Removes the last `n` characters from the `string_view`. Note that the
-  // underlying string is not changed, only the view.
+  // underlying string is not changed, only the view. 
   ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR void remove_suffix(size_type n) {
-    ABSL_HARDENING_ASSERT(n <= length_);
+    ABSL_HARDENING_ASSERT(n <= length_); 
     length_ -= n;
   }
 
@@ -396,13 +396,13 @@ class string_view {
   // Returns a "substring" of the `string_view` (at offset `pos` and length
   // `n`) as another string_view. This function throws `std::out_of_bounds` if
   // `pos > size`.
-  // Use y_absl::ClippedSubstr if you need a truncating substr operation.
+  // Use y_absl::ClippedSubstr if you need a truncating substr operation. 
   constexpr string_view substr(size_type pos = 0, size_type n = npos) const {
-    return ABSL_PREDICT_FALSE(pos > length_)
-               ? (base_internal::ThrowStdOutOfRange(
-                      "y_absl::string_view::substr"),
-                  string_view())
-               : string_view(ptr_ + pos, Min(n, length_ - pos));
+    return ABSL_PREDICT_FALSE(pos > length_) 
+               ? (base_internal::ThrowStdOutOfRange( 
+                      "y_absl::string_view::substr"), 
+                  string_view()) 
+               : string_view(ptr_ + pos, Min(n, length_ - pos)); 
   }
 
   // string_view::compare()
@@ -437,13 +437,13 @@ class string_view {
   constexpr int compare(const char* s) const { return compare(string_view(s)); }
 
   // Overload of `string_view::compare()` for comparing a substring of the
-  // `string_view` and a different string C-style string `s`.
+  // `string_view` and a different string C-style string `s`. 
   constexpr int compare(size_type pos1, size_type count1, const char* s) const {
     return substr(pos1, count1).compare(string_view(s));
   }
 
   // Overload of `string_view::compare()` for comparing a substring of the
-  // `string_view` and a substring of a different C-style string `s`.
+  // `string_view` and a substring of a different C-style string `s`. 
   constexpr int compare(size_type pos1, size_type count1, const char* s,
                         size_type count2) const {
     return substr(pos1, count1).compare(string_view(s, count2));
@@ -608,7 +608,7 @@ class string_view {
       (std::numeric_limits<difference_type>::max)();
 
   static constexpr size_type CheckLengthInternal(size_type len) {
-    return ABSL_HARDENING_ASSERT(len <= kMaxSize), len;
+    return ABSL_HARDENING_ASSERT(len <= kMaxSize), len; 
   }
 
   static constexpr size_type StrlenInternal(const char* str) {
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/substitute.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/substitute.cc
index 177fba8cbe..75035a5706 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/substitute.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/substitute.cc
@@ -36,7 +36,7 @@ void SubstituteAndAppendArray(TString* output, y_absl::string_view format,
       if (i + 1 >= format.size()) {
 #ifndef NDEBUG
         ABSL_RAW_LOG(FATAL,
-                     "Invalid y_absl::Substitute() format string: \"%s\".",
+                     "Invalid y_absl::Substitute() format string: \"%s\".", 
                      y_absl::CEscape(format).c_str());
 #endif
         return;
@@ -46,8 +46,8 @@ void SubstituteAndAppendArray(TString* output, y_absl::string_view format,
 #ifndef NDEBUG
           ABSL_RAW_LOG(
               FATAL,
-              "Invalid y_absl::Substitute() format string: asked for \"$"
-              "%d\", but only %d args were given.  Full format string was: "
+              "Invalid y_absl::Substitute() format string: asked for \"$" 
+              "%d\", but only %d args were given.  Full format string was: " 
               "\"%s\".",
               index, static_cast<int>(num_args), y_absl::CEscape(format).c_str());
 #endif
@@ -61,7 +61,7 @@ void SubstituteAndAppendArray(TString* output, y_absl::string_view format,
       } else {
 #ifndef NDEBUG
         ABSL_RAW_LOG(FATAL,
-                     "Invalid y_absl::Substitute() format string: \"%s\".",
+                     "Invalid y_absl::Substitute() format string: \"%s\".", 
                      y_absl::CEscape(format).c_str());
 #endif
         return;
@@ -73,7 +73,7 @@ void SubstituteAndAppendArray(TString* output, y_absl::string_view format,
 
   if (size == 0) return;
 
-  // Build the string.
+  // Build the string. 
   size_t original_size = output->size();
   strings_internal::STLStringResizeUninitializedAmortized(output,
                                                           original_size + size);
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/substitute.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/substitute.h
index c31191fbda..8b750f9787 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/substitute.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/substitute.h
@@ -50,7 +50,7 @@
 //
 // Supported types:
 //   * y_absl::string_view, TString, const char* (null is equivalent to "")
-//   * int32_t, int64_t, uint32_t, uint64_t
+//   * int32_t, int64_t, uint32_t, uint64_t 
 //   * float, double
 //   * bool (Printed as "true" or "false")
 //   * pointer types other than char* (Printed as "0x<lower case hex string>",
@@ -99,7 +99,7 @@ namespace substitute_internal {
 // This class has implicit constructors.
 class Arg {
  public:
-  // Overloads for string-y things
+  // Overloads for string-y things 
   //
   // Explicitly overload `const char*` so the compiler doesn't cast to `bool`.
   Arg(const char* value)  // NOLINT(runtime/explicit)
@@ -122,9 +122,9 @@ class Arg {
   // representation. However, we can't really know, so we make the caller decide
   // what to do.
   Arg(char value)  // NOLINT(runtime/explicit)
-      : piece_(scratch_, 1) {
-    scratch_[0] = value;
-  }
+      : piece_(scratch_, 1) { 
+    scratch_[0] = value; 
+  } 
   Arg(short value)  // NOLINT(*)
       : piece_(scratch_,
                numbers_internal::FastIntToBuffer(value, scratch_) - scratch_) {}
@@ -207,11 +207,11 @@ constexpr const char* SkipNumber(const char* format) {
 }
 
 constexpr int PlaceholderBitmask(const char* format) {
-  return !*format
-             ? 0
-             : *format != '$' ? PlaceholderBitmask(format + 1)
-                              : (CalculateOneBit(format + 1) |
-                                 PlaceholderBitmask(SkipNumber(format + 1)));
+  return !*format 
+             ? 0 
+             : *format != '$' ? PlaceholderBitmask(format + 1) 
+                              : (CalculateOneBit(format + 1) | 
+                                 PlaceholderBitmask(SkipNumber(format + 1))); 
 }
 #endif  // ABSL_BAD_CALL_IF
 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/ya.make
index 77c5a47dc9..bc65e01f18 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/ya.make
@@ -2,15 +2,15 @@
 
 LIBRARY()
 
-OWNER(
-    somov
-    g:cpp-contrib
-)
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
 
 LICENSE(Apache-2.0)
 
-LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
-
+LICENSE_TEXTS(.yandex_meta/licenses.list.txt) 
+ 
 PEERDIR(
     contrib/restricted/abseil-cpp-tstring/y_absl/base
     contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/.yandex_meta/licenses.list.txt b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/.yandex_meta/licenses.list.txt
index 7be6b42848..4335862815 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/.yandex_meta/licenses.list.txt
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/.yandex_meta/licenses.list.txt
@@ -1,16 +1,16 @@
-====================Apache-2.0====================
-// 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====================
-// Copyright 2017 The Abseil Authors.
+====================Apache-2.0==================== 
+// 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==================== 
+// Copyright 2017 The Abseil Authors. 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/.yandex_meta/licenses.list.txt b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/.yandex_meta/licenses.list.txt
index b94f79902f..4ae3f0cbbc 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/.yandex_meta/licenses.list.txt
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/.yandex_meta/licenses.list.txt
@@ -1,34 +1,34 @@
-====================Apache-2.0====================
- * 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.
-
-
-====================Apache-2.0====================
-// 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====================
-// Copyright 2017 The Abseil Authors.
-
-
-====================COPYRIGHT====================
-// Copyright 2020 The Abseil Authors.
+====================Apache-2.0==================== 
+ * 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. 
+ 
+ 
+====================Apache-2.0==================== 
+// 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==================== 
+// Copyright 2017 The Abseil Authors. 
+ 
+ 
+====================COPYRIGHT==================== 
+// Copyright 2020 The Abseil Authors. 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/create_thread_identity.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/create_thread_identity.cc
index 3c5764eeb9..b81c03ea03 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/create_thread_identity.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/create_thread_identity.cc
@@ -32,9 +32,9 @@ namespace synchronization_internal {
 
 // ThreadIdentity storage is persistent, we maintain a free-list of previously
 // released ThreadIdentity objects.
-ABSL_CONST_INIT static base_internal::SpinLock freelist_lock(
-    y_absl::kConstInit, base_internal::SCHEDULE_KERNEL_ONLY);
-ABSL_CONST_INIT static base_internal::ThreadIdentity* thread_identity_freelist;
+ABSL_CONST_INIT static base_internal::SpinLock freelist_lock( 
+    y_absl::kConstInit, base_internal::SCHEDULE_KERNEL_ONLY); 
+ABSL_CONST_INIT static base_internal::ThreadIdentity* thread_identity_freelist; 
 
 // A per-thread destructor for reclaiming associated ThreadIdentity objects.
 // Since we must preserve their storage we cache them for re-use.
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/futex.h b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/futex.h
index aea769d8ec..99e06d0d38 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/futex.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/futex.h
@@ -1,154 +1,154 @@
-// 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_SYNCHRONIZATION_INTERNAL_FUTEX_H_
-#define ABSL_SYNCHRONIZATION_INTERNAL_FUTEX_H_
-
-#include "y_absl/base/config.h"
-
-#ifdef _WIN32
-#include <windows.h>
-#else
-#include <sys/time.h>
-#include <unistd.h>
-#endif
-
-#ifdef __linux__
-#include <linux/futex.h>
-#include <sys/syscall.h>
-#endif
-
-#include <errno.h>
-#include <stdio.h>
-#include <time.h>
-
-#include <atomic>
-#include <cstdint>
-
-#include "y_absl/base/optimization.h"
-#include "y_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
-
-namespace y_absl {
-ABSL_NAMESPACE_BEGIN
-namespace synchronization_internal {
-
-// Some Android headers are missing these definitions even though they
-// support these futex operations.
-#ifdef __BIONIC__
-#ifndef SYS_futex
-#define SYS_futex __NR_futex
-#endif
-#ifndef FUTEX_WAIT_BITSET
-#define FUTEX_WAIT_BITSET 9
-#endif
-#ifndef FUTEX_PRIVATE_FLAG
-#define FUTEX_PRIVATE_FLAG 128
-#endif
-#ifndef FUTEX_CLOCK_REALTIME
-#define FUTEX_CLOCK_REALTIME 256
-#endif
-#ifndef FUTEX_BITSET_MATCH_ANY
-#define FUTEX_BITSET_MATCH_ANY 0xFFFFFFFF
-#endif
-#endif
-
-#if defined(__NR_futex_time64) && !defined(SYS_futex_time64)
-#define SYS_futex_time64 __NR_futex_time64
-#endif
-
-#if defined(SYS_futex_time64) && !defined(SYS_futex)
-#define SYS_futex SYS_futex_time64
-#endif
-
-class FutexImpl {
- public:
-  static int WaitUntil(std::atomic<int32_t> *v, int32_t val,
-                       KernelTimeout t) {
-    int err = 0;
-    if (t.has_timeout()) {
-      // https://locklessinc.com/articles/futex_cheat_sheet/
-      // Unlike FUTEX_WAIT, FUTEX_WAIT_BITSET uses absolute time.
-      struct timespec abs_timeout = t.MakeAbsTimespec();
-      // Atomically check that the futex value is still 0, and if it
-      // is, sleep until abs_timeout or until woken by FUTEX_WAKE.
-      err = syscall(
-          SYS_futex, reinterpret_cast<int32_t *>(v),
-          FUTEX_WAIT_BITSET | FUTEX_PRIVATE_FLAG | FUTEX_CLOCK_REALTIME, val,
-          &abs_timeout, nullptr, FUTEX_BITSET_MATCH_ANY);
-    } else {
-      // Atomically check that the futex value is still 0, and if it
-      // is, sleep until woken by FUTEX_WAKE.
-      err = syscall(SYS_futex, reinterpret_cast<int32_t *>(v),
-                    FUTEX_WAIT | FUTEX_PRIVATE_FLAG, val, nullptr);
-    }
-    if (ABSL_PREDICT_FALSE(err != 0)) {
-      err = -errno;
-    }
-    return err;
-  }
-
-  static int WaitBitsetAbsoluteTimeout(std::atomic<int32_t> *v, int32_t val,
-                                       int32_t bits,
-                                       const struct timespec *abstime) {
-    int err = syscall(SYS_futex, reinterpret_cast<int32_t *>(v),
-                      FUTEX_WAIT_BITSET | FUTEX_PRIVATE_FLAG, val, abstime,
-                      nullptr, bits);
-    if (ABSL_PREDICT_FALSE(err != 0)) {
-      err = -errno;
-    }
-    return err;
-  }
-
-  static int Wake(std::atomic<int32_t> *v, int32_t count) {
-    int err = syscall(SYS_futex, reinterpret_cast<int32_t *>(v),
-                      FUTEX_WAKE | FUTEX_PRIVATE_FLAG, count);
-    if (ABSL_PREDICT_FALSE(err < 0)) {
-      err = -errno;
-    }
-    return err;
-  }
-
-  // FUTEX_WAKE_BITSET
-  static int WakeBitset(std::atomic<int32_t> *v, int32_t count, int32_t bits) {
-    int err = syscall(SYS_futex, reinterpret_cast<int32_t *>(v),
-                      FUTEX_WAKE_BITSET | FUTEX_PRIVATE_FLAG, count, nullptr,
-                      nullptr, bits);
-    if (ABSL_PREDICT_FALSE(err < 0)) {
-      err = -errno;
-    }
-    return err;
-  }
-};
-
-class Futex : public FutexImpl {};
-
-}  // namespace synchronization_internal
-ABSL_NAMESPACE_END
-}  // namespace y_absl
-
-#endif  // ABSL_INTERNAL_HAVE_FUTEX
-
-#endif  // ABSL_SYNCHRONIZATION_INTERNAL_FUTEX_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_SYNCHRONIZATION_INTERNAL_FUTEX_H_ 
+#define ABSL_SYNCHRONIZATION_INTERNAL_FUTEX_H_ 
+ 
+#include "y_absl/base/config.h" 
+ 
+#ifdef _WIN32 
+#include <windows.h> 
+#else 
+#include <sys/time.h> 
+#include <unistd.h> 
+#endif 
+ 
+#ifdef __linux__ 
+#include <linux/futex.h> 
+#include <sys/syscall.h> 
+#endif 
+ 
+#include <errno.h> 
+#include <stdio.h> 
+#include <time.h> 
+ 
+#include <atomic> 
+#include <cstdint> 
+ 
+#include "y_absl/base/optimization.h" 
+#include "y_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 
+ 
+namespace y_absl { 
+ABSL_NAMESPACE_BEGIN 
+namespace synchronization_internal { 
+ 
+// Some Android headers are missing these definitions even though they 
+// support these futex operations. 
+#ifdef __BIONIC__ 
+#ifndef SYS_futex 
+#define SYS_futex __NR_futex 
+#endif 
+#ifndef FUTEX_WAIT_BITSET 
+#define FUTEX_WAIT_BITSET 9 
+#endif 
+#ifndef FUTEX_PRIVATE_FLAG 
+#define FUTEX_PRIVATE_FLAG 128 
+#endif 
+#ifndef FUTEX_CLOCK_REALTIME 
+#define FUTEX_CLOCK_REALTIME 256 
+#endif 
+#ifndef FUTEX_BITSET_MATCH_ANY 
+#define FUTEX_BITSET_MATCH_ANY 0xFFFFFFFF 
+#endif 
+#endif 
+ 
+#if defined(__NR_futex_time64) && !defined(SYS_futex_time64) 
+#define SYS_futex_time64 __NR_futex_time64 
+#endif 
+ 
+#if defined(SYS_futex_time64) && !defined(SYS_futex) 
+#define SYS_futex SYS_futex_time64 
+#endif 
+ 
+class FutexImpl { 
+ public: 
+  static int WaitUntil(std::atomic<int32_t> *v, int32_t val, 
+                       KernelTimeout t) { 
+    int err = 0; 
+    if (t.has_timeout()) { 
+      // https://locklessinc.com/articles/futex_cheat_sheet/ 
+      // Unlike FUTEX_WAIT, FUTEX_WAIT_BITSET uses absolute time. 
+      struct timespec abs_timeout = t.MakeAbsTimespec(); 
+      // Atomically check that the futex value is still 0, and if it 
+      // is, sleep until abs_timeout or until woken by FUTEX_WAKE. 
+      err = syscall( 
+          SYS_futex, reinterpret_cast<int32_t *>(v), 
+          FUTEX_WAIT_BITSET | FUTEX_PRIVATE_FLAG | FUTEX_CLOCK_REALTIME, val, 
+          &abs_timeout, nullptr, FUTEX_BITSET_MATCH_ANY); 
+    } else { 
+      // Atomically check that the futex value is still 0, and if it 
+      // is, sleep until woken by FUTEX_WAKE. 
+      err = syscall(SYS_futex, reinterpret_cast<int32_t *>(v), 
+                    FUTEX_WAIT | FUTEX_PRIVATE_FLAG, val, nullptr); 
+    } 
+    if (ABSL_PREDICT_FALSE(err != 0)) { 
+      err = -errno; 
+    } 
+    return err; 
+  } 
+ 
+  static int WaitBitsetAbsoluteTimeout(std::atomic<int32_t> *v, int32_t val, 
+                                       int32_t bits, 
+                                       const struct timespec *abstime) { 
+    int err = syscall(SYS_futex, reinterpret_cast<int32_t *>(v), 
+                      FUTEX_WAIT_BITSET | FUTEX_PRIVATE_FLAG, val, abstime, 
+                      nullptr, bits); 
+    if (ABSL_PREDICT_FALSE(err != 0)) { 
+      err = -errno; 
+    } 
+    return err; 
+  } 
+ 
+  static int Wake(std::atomic<int32_t> *v, int32_t count) { 
+    int err = syscall(SYS_futex, reinterpret_cast<int32_t *>(v), 
+                      FUTEX_WAKE | FUTEX_PRIVATE_FLAG, count); 
+    if (ABSL_PREDICT_FALSE(err < 0)) { 
+      err = -errno; 
+    } 
+    return err; 
+  } 
+ 
+  // FUTEX_WAKE_BITSET 
+  static int WakeBitset(std::atomic<int32_t> *v, int32_t count, int32_t bits) { 
+    int err = syscall(SYS_futex, reinterpret_cast<int32_t *>(v), 
+                      FUTEX_WAKE_BITSET | FUTEX_PRIVATE_FLAG, count, nullptr, 
+                      nullptr, bits); 
+    if (ABSL_PREDICT_FALSE(err < 0)) { 
+      err = -errno; 
+    } 
+    return err; 
+  } 
+}; 
+ 
+class Futex : public FutexImpl {}; 
+ 
+}  // namespace synchronization_internal 
+ABSL_NAMESPACE_END 
+}  // namespace y_absl 
+ 
+#endif  // ABSL_INTERNAL_HAVE_FUTEX 
+ 
+#endif  // ABSL_SYNCHRONIZATION_INTERNAL_FUTEX_H_ 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/graphcycles.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/graphcycles.cc
index d8987c1a98..8f922299a0 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/graphcycles.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/graphcycles.cc
@@ -37,7 +37,7 @@
 
 #include <algorithm>
 #include <array>
-#include <limits>
+#include <limits> 
 #include "y_absl/base/internal/hide_ptr.h"
 #include "y_absl/base/internal/raw_logging.h"
 #include "y_absl/base/internal/spinlock.h"
@@ -52,9 +52,9 @@ namespace {
 
 // Avoid LowLevelAlloc's default arena since it calls malloc hooks in
 // which people are doing things like acquiring Mutexes.
-ABSL_CONST_INIT static y_absl::base_internal::SpinLock arena_mu(
-    y_absl::kConstInit, base_internal::SCHEDULE_KERNEL_ONLY);
-ABSL_CONST_INIT static base_internal::LowLevelAlloc::Arena* arena;
+ABSL_CONST_INIT static y_absl::base_internal::SpinLock arena_mu( 
+    y_absl::kConstInit, base_internal::SCHEDULE_KERNEL_ONLY); 
+ABSL_CONST_INIT static base_internal::LowLevelAlloc::Arena* arena; 
 
 static void InitArenaIfNecessary() {
   arena_mu.Lock();
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/kernel_timeout.h b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/kernel_timeout.h
index ee4078702d..70efeaf72d 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/kernel_timeout.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/kernel_timeout.h
@@ -26,7 +26,7 @@
 #define ABSL_SYNCHRONIZATION_INTERNAL_KERNEL_TIMEOUT_H_
 
 #include <time.h>
-
+ 
 #include <algorithm>
 #include <limits>
 
@@ -58,10 +58,10 @@ class KernelTimeout {
 
   bool has_timeout() const { return ns_ != 0; }
 
-  // Convert to parameter for sem_timedwait/futex/similar.  Only for approved
-  // users.  Do not call if !has_timeout.
-  struct timespec MakeAbsTimespec();
-
+  // Convert to parameter for sem_timedwait/futex/similar.  Only for approved 
+  // users.  Do not call if !has_timeout. 
+  struct timespec MakeAbsTimespec(); 
+ 
  private:
   // internal rep, not user visible: ns after unix epoch.
   // zero = no timeout.
@@ -125,30 +125,30 @@ class KernelTimeout {
   friend class Waiter;
 };
 
-inline struct timespec KernelTimeout::MakeAbsTimespec() {
-  int64_t n = ns_;
-  static const int64_t kNanosPerSecond = 1000 * 1000 * 1000;
-  if (n == 0) {
-    ABSL_RAW_LOG(
-        ERROR, "Tried to create a timespec from a non-timeout; never do this.");
-    // But we'll try to continue sanely.  no-timeout ~= saturated timeout.
-    n = (std::numeric_limits<int64_t>::max)();
-  }
-
-  // Kernel APIs validate timespecs as being at or after the epoch,
-  // despite the kernel time type being signed.  However, no one can
-  // tell the difference between a timeout at or before the epoch (since
-  // all such timeouts have expired!)
-  if (n < 0) n = 0;
-
-  struct timespec abstime;
-  int64_t seconds = (std::min)(n / kNanosPerSecond,
-                               int64_t{(std::numeric_limits<time_t>::max)()});
-  abstime.tv_sec = static_cast<time_t>(seconds);
-  abstime.tv_nsec = static_cast<decltype(abstime.tv_nsec)>(n % kNanosPerSecond);
-  return abstime;
-}
-
+inline struct timespec KernelTimeout::MakeAbsTimespec() { 
+  int64_t n = ns_; 
+  static const int64_t kNanosPerSecond = 1000 * 1000 * 1000; 
+  if (n == 0) { 
+    ABSL_RAW_LOG( 
+        ERROR, "Tried to create a timespec from a non-timeout; never do this."); 
+    // But we'll try to continue sanely.  no-timeout ~= saturated timeout. 
+    n = (std::numeric_limits<int64_t>::max)(); 
+  } 
+ 
+  // Kernel APIs validate timespecs as being at or after the epoch, 
+  // despite the kernel time type being signed.  However, no one can 
+  // tell the difference between a timeout at or before the epoch (since 
+  // all such timeouts have expired!) 
+  if (n < 0) n = 0; 
+ 
+  struct timespec abstime; 
+  int64_t seconds = (std::min)(n / kNanosPerSecond, 
+                               int64_t{(std::numeric_limits<time_t>::max)()}); 
+  abstime.tv_sec = static_cast<time_t>(seconds); 
+  abstime.tv_nsec = static_cast<decltype(abstime.tv_nsec)>(n % kNanosPerSecond); 
+  return abstime; 
+} 
+ 
 }  // namespace synchronization_internal
 ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/per_thread_sem.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/per_thread_sem.cc
index 3e40e812a9..245bd110d0 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/per_thread_sem.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_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)( 
     y_absl::base_internal::ThreadIdentity *identity) {
   y_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)( 
     y_absl::synchronization_internal::KernelTimeout t) {
   bool timeout = false;
   y_absl::base_internal::ThreadIdentity *identity;
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/per_thread_sem.h b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/per_thread_sem.h
index 2fc39ca130..bd1bac4140 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/per_thread_sem.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/per_thread_sem.h
@@ -78,7 +78,7 @@ class PerThreadSem {
   // !t.has_timeout() => Wait(t) will return true.
   static inline bool Wait(KernelTimeout t);
 
-  // Permitted callers.
+  // Permitted callers. 
   friend class PerThreadSemTest;
   friend class y_absl::Mutex;
   friend y_absl::base_internal::ThreadIdentity* CreateThreadIdentity();
@@ -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)( 
     y_absl::base_internal::ThreadIdentity* identity);
-bool ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemWait)(
+bool ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemWait)( 
     y_absl::synchronization_internal::KernelTimeout t);
 }  // extern "C"
 
 void y_absl::synchronization_internal::PerThreadSem::Post(
     y_absl::base_internal::ThreadIdentity* identity) {
-  ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemPost)(identity);
+  ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemPost)(identity); 
 }
 
 bool y_absl::synchronization_internal::PerThreadSem::Wait(
     y_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-tstring/y_absl/synchronization/internal/waiter.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/waiter.cc
index 573ce9c6c5..d89c3e9ab1 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/waiter.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/waiter.cc
@@ -48,7 +48,7 @@
 #include "y_absl/base/optimization.h"
 #include "y_absl/synchronization/internal/kernel_timeout.h"
 
-
+ 
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
 namespace synchronization_internal {
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/waiter.h b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/waiter.h
index e6fede411f..611f9d25f5 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/waiter.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/waiter.h
@@ -36,7 +36,7 @@
 #include <cstdint>
 
 #include "y_absl/base/internal/thread_identity.h"
-#include "y_absl/synchronization/internal/futex.h"
+#include "y_absl/synchronization/internal/futex.h" 
 #include "y_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
@@ -96,8 +96,8 @@ class Waiter {
   }
 
   // How many periods to remain idle before releasing resources
-#ifndef ABSL_HAVE_THREAD_SANITIZER
-  static constexpr int kIdlePeriods = 60;
+#ifndef ABSL_HAVE_THREAD_SANITIZER 
+  static constexpr int kIdlePeriods = 60; 
 #else
   // Memory consumption under ThreadSanitizer is a serious concern,
   // so we release resources sooner. The value of 1 leads to 1 to 2 second
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/ya.make
index 167e710a78..6769fbcbd2 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/ya.make
@@ -2,15 +2,15 @@
 
 LIBRARY()
 
-OWNER(
-    somov
-    g:cpp-contrib
-)
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
 
 LICENSE(Apache-2.0)
 
-LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
-
+LICENSE_TEXTS(.yandex_meta/licenses.list.txt) 
+ 
 PEERDIR(
     contrib/restricted/abseil-cpp-tstring/y_absl/base
     contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/mutex.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/mutex.cc
index babe5c4ada..75f4bbfae2 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/mutex.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/mutex.cc
@@ -39,7 +39,7 @@
 #include <thread>  // NOLINT(build/c++11)
 
 #include "y_absl/base/attributes.h"
-#include "y_absl/base/call_once.h"
+#include "y_absl/base/call_once.h" 
 #include "y_absl/base/config.h"
 #include "y_absl/base/dynamic_annotations.h"
 #include "y_absl/base/internal/atomic_hook.h"
@@ -50,7 +50,7 @@
 #include "y_absl/base/internal/spinlock.h"
 #include "y_absl/base/internal/sysinfo.h"
 #include "y_absl/base/internal/thread_identity.h"
-#include "y_absl/base/internal/tsan_mutex_interface.h"
+#include "y_absl/base/internal/tsan_mutex_interface.h" 
 #include "y_absl/base/port.h"
 #include "y_absl/debugging/stacktrace.h"
 #include "y_absl/debugging/symbolize.h"
@@ -60,7 +60,7 @@
 
 using y_absl::base_internal::CurrentThreadIdentityIfPresent;
 using y_absl::base_internal::PerThreadSynch;
-using y_absl::base_internal::SchedulingGuard;
+using y_absl::base_internal::SchedulingGuard; 
 using y_absl::base_internal::ThreadIdentity;
 using y_absl::synchronization_internal::GetOrCreateCurrentThreadIdentity;
 using y_absl::synchronization_internal::GraphCycles;
@@ -70,9 +70,9 @@ using y_absl::synchronization_internal::KernelTimeout;
 using y_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 y_absl {
@@ -80,7 +80,7 @@ ABSL_NAMESPACE_BEGIN
 
 namespace {
 
-#if defined(ABSL_HAVE_THREAD_SANITIZER)
+#if defined(ABSL_HAVE_THREAD_SANITIZER) 
 constexpr OnDeadlockCycle kDeadlockDetectionDefault = OnDeadlockCycle::kIgnore;
 #else
 constexpr OnDeadlockCycle kDeadlockDetectionDefault = OnDeadlockCycle::kAbort;
@@ -91,8 +91,8 @@ ABSL_CONST_INIT std::atomic<OnDeadlockCycle> synch_deadlock_detection(
 ABSL_CONST_INIT std::atomic<bool> synch_check_invariants(false);
 
 ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES
-y_absl::base_internal::AtomicHook<void (*)(int64_t wait_cycles)>
-    submit_profile_data;
+y_absl::base_internal::AtomicHook<void (*)(int64_t wait_cycles)> 
+    submit_profile_data; 
 ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES y_absl::base_internal::AtomicHook<void (*)(
     const char *msg, const void *obj, int64_t wait_cycles)>
     mutex_tracer;
@@ -127,63 +127,63 @@ void RegisterSymbolizer(bool (*fn)(const void *pc, char *out, int out_size)) {
 }
 
 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 {
-  y_absl::once_flag once;
-  int spinloop_iterations = 0;
-  int32_t mutex_sleep_limit[2] = {};
+// Represents the strategy for spin and yield. 
+// See the comment in GetMutexGlobals() for more information. 
+enum DelayMode { AGGRESSIVE, GENTLE }; 
+ 
+struct ABSL_CACHELINE_ALIGNED MutexGlobals { 
+  y_absl::once_flag once; 
+  int spinloop_iterations = 0; 
+  int32_t mutex_sleep_limit[2] = {}; 
 };
-
-const MutexGlobals &GetMutexGlobals() {
-  ABSL_CONST_INIT static MutexGlobals data;
-  y_absl::base_internal::LowLevelCallOnce(&data.once, [&]() {
-    const int num_cpus = y_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 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`.
-int MutexDelay(int32_t c, int mode) {
-  const int32_t limit = GetMutexGlobals().mutex_sleep_limit[mode];
+ 
+const MutexGlobals &GetMutexGlobals() { 
+  ABSL_CONST_INIT static MutexGlobals data; 
+  y_absl::base_internal::LowLevelCallOnce(&data.once, [&]() { 
+    const int num_cpus = y_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 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`. 
+int MutexDelay(int32_t c, int mode) { 
+  const int32_t limit = GetMutexGlobals().mutex_sleep_limit[mode]; 
   if (c < limit) {
-    // Spin.
-    c++;
+    // Spin. 
+    c++; 
   } else {
-    SchedulingGuard::ScopedEnable enable_rescheduling;
+    SchedulingGuard::ScopedEnable enable_rescheduling; 
     ABSL_TSAN_MUTEX_PRE_DIVERT(nullptr, 0);
-    if (c == limit) {
-      // Yield once.
-      ABSL_INTERNAL_C_SYMBOL(AbslInternalMutexYield)();
+    if (c == limit) { 
+      // Yield once. 
+      ABSL_INTERNAL_C_SYMBOL(AbslInternalMutexYield)(); 
       c++;
-    } else {
-      // Then wait.
+    } else { 
+      // Then wait. 
       y_absl::SleepFor(y_absl::Microseconds(10));
       c = 0;
     }
     ABSL_TSAN_MUTEX_POST_DIVERT(nullptr, 0);
   }
-  return c;
+  return c; 
 }
-}  // namespace synchronization_internal
+}  // namespace synchronization_internal 
 
 // --------------------------Generic atomic ops
 // Ensure that "(*pv & bits) == bits" by doing an atomic update of "*pv" to
@@ -221,12 +221,12 @@ static void AtomicClearBits(std::atomic<intptr_t>* pv, intptr_t bits,
 //------------------------------------------------------------------
 
 // Data for doing deadlock detection.
-ABSL_CONST_INIT static y_absl::base_internal::SpinLock deadlock_graph_mu(
-    y_absl::kConstInit, base_internal::SCHEDULE_KERNEL_ONLY);
+ABSL_CONST_INIT static y_absl::base_internal::SpinLock deadlock_graph_mu( 
+    y_absl::kConstInit, base_internal::SCHEDULE_KERNEL_ONLY); 
 
-// Graph used to detect deadlocks.
-ABSL_CONST_INIT static GraphCycles *deadlock_graph
-    ABSL_GUARDED_BY(deadlock_graph_mu) ABSL_PT_GUARDED_BY(deadlock_graph_mu);
+// Graph used to detect deadlocks. 
+ABSL_CONST_INIT static GraphCycles *deadlock_graph 
+    ABSL_GUARDED_BY(deadlock_graph_mu) ABSL_PT_GUARDED_BY(deadlock_graph_mu); 
 
 //------------------------------------------------------------------
 // An event mechanism for debugging mutex use.
@@ -287,12 +287,12 @@ static const struct {
     {0, "SignalAll on "},
 };
 
-ABSL_CONST_INIT static y_absl::base_internal::SpinLock synch_event_mu(
-    y_absl::kConstInit, base_internal::SCHEDULE_KERNEL_ONLY);
+ABSL_CONST_INIT static y_absl::base_internal::SpinLock synch_event_mu( 
+    y_absl::kConstInit, base_internal::SCHEDULE_KERNEL_ONLY); 
 
 // Hash table size; should be prime > 2.
 // Can't be too small, as it's used for deadlock detection information.
-static constexpr uint32_t kNSynchEvent = 1031;
+static constexpr uint32_t kNSynchEvent = 1031; 
 
 static struct SynchEvent {     // this is a trivial hash table for the events
   // struct is freed when refcount reaches 0
@@ -312,7 +312,7 @@ static struct SynchEvent {     // this is a trivial hash table for the events
   bool log;             // logging turned on
 
   // Constant after initialization
-  char name[1];         // actually longer---NUL-terminated string
+  char name[1];         // actually longer---NUL-terminated string 
 } * synch_event[kNSynchEvent] ABSL_GUARDED_BY(synch_event_mu);
 
 // Ensure that the object at "addr" has a SynchEvent struct associated with it,
@@ -503,7 +503,7 @@ struct SynchWaitParams {
   std::atomic<intptr_t> *cv_word;
 
   int64_t contention_start_cycles;  // Time (in cycles) when this thread started
-                                    // to contend for the mutex.
+                                    // to contend for the mutex. 
 };
 
 struct SynchLocksHeld {
@@ -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
@@ -1064,7 +1064,7 @@ static PerThreadSynch *DequeueAllWakeable(PerThreadSynch *head,
 // Try to remove thread s from the list of waiters on this mutex.
 // Does nothing if s is not on the waiter list.
 void Mutex::TryRemove(PerThreadSynch *s) {
-  SchedulingGuard::ScopedDisable disable_rescheduling;
+  SchedulingGuard::ScopedDisable disable_rescheduling; 
   intptr_t v = mu_.load(std::memory_order_relaxed);
   // acquire spinlock & lock
   if ((v & (kMuWait | kMuSpin | kMuWriter | kMuReader)) == kMuWait &&
@@ -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;
@@ -1131,7 +1131,7 @@ ABSL_XRAY_LOG_ARGS(1) void Mutex::Block(PerThreadSynch *s) {
       this->TryRemove(s);
       int c = 0;
       while (s->next != nullptr) {
-        c = synchronization_internal::MutexDelay(c, GENTLE);
+        c = synchronization_internal::MutexDelay(c, GENTLE); 
         this->TryRemove(s);
       }
       if (kDebugMode) {
@@ -1374,9 +1374,9 @@ static GraphId DeadlockCheck(Mutex *mu) {
           len += static_cast<int>(strlen(&b->buf[len]));
         }
       }
-      ABSL_RAW_LOG(ERROR,
-                   "Acquiring y_absl::Mutex %p while holding %s; a cycle in the "
-                   "historical lock ordering graph has been observed",
+      ABSL_RAW_LOG(ERROR, 
+                   "Acquiring y_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(
@@ -1452,19 +1452,19 @@ void Mutex::AssertNotHeld() const {
 // Attempt to acquire *mu, and return whether successful.  The implementation
 // may spin for a short while if the lock cannot be acquired immediately.
 static bool TryAcquireWithSpinning(std::atomic<intptr_t>* mu) {
-  int c = GetMutexGlobals().spinloop_iterations;
+  int c = GetMutexGlobals().spinloop_iterations; 
   do {  // do/while somewhat faster on AMD
     intptr_t v = mu->load(std::memory_order_relaxed);
-    if ((v & (kMuReader|kMuEvent)) != 0) {
-      return false;  // a reader or tracing -> give up
+    if ((v & (kMuReader|kMuEvent)) != 0) { 
+      return false;  // a reader or tracing -> give up 
     } else if (((v & kMuWriter) == 0) &&  // no holder -> try to acquire
                mu->compare_exchange_strong(v, kMuWriter | v,
                                            std::memory_order_acquire,
                                            std::memory_order_relaxed)) {
-      return true;
+      return true; 
     }
-  } while (--c > 0);
-  return false;
+  } while (--c > 0); 
+  return false; 
 }
 
 ABSL_XRAY_LOG_ARGS(1) void Mutex::Lock() {
@@ -1763,8 +1763,8 @@ static const intptr_t ignore_waiting_writers[] = {
 };
 
 // Internal version of LockWhen().  See LockSlowWithDeadline()
-ABSL_ATTRIBUTE_NOINLINE void Mutex::LockSlow(MuHow how, const Condition *cond,
-                                             int flags) {
+ABSL_ATTRIBUTE_NOINLINE void Mutex::LockSlow(MuHow how, const Condition *cond, 
+                                             int flags) { 
   ABSL_RAW_CHECK(
       this->LockSlowWithDeadline(how, cond, KernelTimeout::Never(), flags),
       "condition untrue on return from LockSlow");
@@ -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
@@ -1829,9 +1829,9 @@ static inline bool EvalConditionIgnored(Mutex *mu, const Condition *cond) {
   // So we "divert" (which un-ignores both memory accesses and synchronization)
   // and then separately turn on ignores of memory accesses.
   ABSL_TSAN_MUTEX_PRE_DIVERT(mu, 0);
-  ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN();
+  ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN(); 
   bool res = cond->Eval();
-  ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_END();
+  ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_END(); 
   ABSL_TSAN_MUTEX_POST_DIVERT(mu, 0);
   static_cast<void>(mu);  // Prevent unused param warning in non-TSAN builds.
   return res;
@@ -1912,7 +1912,7 @@ static void CheckForMutexCorruption(intptr_t v, const char* label) {
 }
 
 void Mutex::LockSlowLoop(SynchWaitParams *waitp, int flags) {
-  SchedulingGuard::ScopedDisable disable_rescheduling;
+  SchedulingGuard::ScopedDisable disable_rescheduling; 
   int c = 0;
   intptr_t v = mu_.load(std::memory_order_relaxed);
   if ((v & kMuEvent) != 0) {
@@ -2014,8 +2014,8 @@ void Mutex::LockSlowLoop(SynchWaitParams *waitp, int flags) {
     ABSL_RAW_CHECK(
         waitp->thread->waitp == nullptr || waitp->thread->suppress_fatal_errors,
         "detected illegal recursion into Mutex code");
-    // delay, then try again
-    c = synchronization_internal::MutexDelay(c, GENTLE);
+    // delay, then try again 
+    c = synchronization_internal::MutexDelay(c, GENTLE); 
   }
   ABSL_RAW_CHECK(
       waitp->thread->waitp == nullptr || waitp->thread->suppress_fatal_errors,
@@ -2032,8 +2032,8 @@ void Mutex::LockSlowLoop(SynchWaitParams *waitp, int flags) {
 // which holds the lock but is not runnable because its condition is false
 // or it is in the process of blocking on a condition variable; it must requeue
 // itself on the mutex/condvar to wait for its condition to become true.
-ABSL_ATTRIBUTE_NOINLINE void Mutex::UnlockSlow(SynchWaitParams *waitp) {
-  SchedulingGuard::ScopedDisable disable_rescheduling;
+ABSL_ATTRIBUTE_NOINLINE void Mutex::UnlockSlow(SynchWaitParams *waitp) { 
+  SchedulingGuard::ScopedDisable disable_rescheduling; 
   intptr_t v = mu_.load(std::memory_order_relaxed);
   this->AssertReaderHeld();
   CheckForMutexCorruption(v, "Unlock");
@@ -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
         }
       }
@@ -2310,8 +2310,8 @@ ABSL_ATTRIBUTE_NOINLINE void Mutex::UnlockSlow(SynchWaitParams *waitp) {
       mu_.store(nv, std::memory_order_release);
       break;  // out of for(;;)-loop
     }
-    // aggressive here; no one can proceed till we do
-    c = synchronization_internal::MutexDelay(c, AGGRESSIVE);
+    // aggressive here; no one can proceed till we do 
+    c = synchronization_internal::MutexDelay(c, AGGRESSIVE); 
   }                            // end of for(;;)-loop
 
   if (wake_list != kPerThreadSynchNull) {
@@ -2323,8 +2323,8 @@ ABSL_ATTRIBUTE_NOINLINE void Mutex::UnlockSlow(SynchWaitParams *waitp) {
     if (!cond_waiter) {
       // Sample lock contention events only if the (first) waiter was trying to
       // acquire the lock, not waiting on a condition variable or Condition.
-      int64_t wait_cycles =
-          base_internal::CycleClock::Now() - enqueue_timestamp;
+      int64_t wait_cycles = 
+          base_internal::CycleClock::Now() - enqueue_timestamp; 
       mutex_tracer("slow release", this, wait_cycles);
       ABSL_TSAN_MUTEX_PRE_DIVERT(this, 0);
       submit_profile_data(enqueue_timestamp);
@@ -2351,7 +2351,7 @@ void Mutex::Trans(MuHow how) {
 // It will later acquire the mutex with high probability.  Otherwise, we
 // enqueue thread w on this mutex.
 void Mutex::Fer(PerThreadSynch *w) {
-  SchedulingGuard::ScopedDisable disable_rescheduling;
+  SchedulingGuard::ScopedDisable disable_rescheduling; 
   int c = 0;
   ABSL_RAW_CHECK(w->waitp->cond == nullptr,
                  "Mutex::Fer while waiting on Condition");
@@ -2401,7 +2401,7 @@ void Mutex::Fer(PerThreadSynch *w) {
         return;
       }
     }
-    c = synchronization_internal::MutexDelay(c, GENTLE);
+    c = synchronization_internal::MutexDelay(c, GENTLE); 
   }
 }
 
@@ -2450,7 +2450,7 @@ CondVar::~CondVar() {
 
 // Remove thread s from the list of waiters on this condition variable.
 void CondVar::Remove(PerThreadSynch *s) {
-  SchedulingGuard::ScopedDisable disable_rescheduling;
+  SchedulingGuard::ScopedDisable disable_rescheduling; 
   intptr_t v;
   int c = 0;
   for (v = cv_.load(std::memory_order_relaxed);;
@@ -2479,8 +2479,8 @@ void CondVar::Remove(PerThreadSynch *s) {
                 std::memory_order_release);
       return;
     } else {
-      // try again after a delay
-      c = synchronization_internal::MutexDelay(c, GENTLE);
+      // try again after a delay 
+      c = synchronization_internal::MutexDelay(c, GENTLE); 
     }
   }
 }
@@ -2513,7 +2513,7 @@ static void CondVarEnqueue(SynchWaitParams *waitp) {
          !cv_word->compare_exchange_weak(v, v | kCvSpin,
                                          std::memory_order_acquire,
                                          std::memory_order_relaxed)) {
-    c = synchronization_internal::MutexDelay(c, GENTLE);
+    c = synchronization_internal::MutexDelay(c, GENTLE); 
     v = cv_word->load(std::memory_order_relaxed);
   }
   ABSL_RAW_CHECK(waitp->thread->waitp == nullptr, "waiting when shouldn't be");
@@ -2612,7 +2612,7 @@ void CondVar::Wakeup(PerThreadSynch *w) {
 }
 
 void CondVar::Signal() {
-  SchedulingGuard::ScopedDisable disable_rescheduling;
+  SchedulingGuard::ScopedDisable disable_rescheduling; 
   ABSL_TSAN_MUTEX_PRE_SIGNAL(nullptr, 0);
   intptr_t v;
   int c = 0;
@@ -2645,7 +2645,7 @@ void CondVar::Signal() {
       ABSL_TSAN_MUTEX_POST_SIGNAL(nullptr, 0);
       return;
     } else {
-      c = synchronization_internal::MutexDelay(c, GENTLE);
+      c = synchronization_internal::MutexDelay(c, GENTLE); 
     }
   }
   ABSL_TSAN_MUTEX_POST_SIGNAL(nullptr, 0);
@@ -2682,8 +2682,8 @@ void CondVar::SignalAll () {
       ABSL_TSAN_MUTEX_POST_SIGNAL(nullptr, 0);
       return;
     } else {
-      // try again after a delay
-      c = synchronization_internal::MutexDelay(c, GENTLE);
+      // try again after a delay 
+      c = synchronization_internal::MutexDelay(c, GENTLE); 
     }
   }
   ABSL_TSAN_MUTEX_POST_SIGNAL(nullptr, 0);
@@ -2696,7 +2696,7 @@ void ReleasableMutexLock::Release() {
   this->mu_ = nullptr;
 }
 
-#ifdef ABSL_HAVE_THREAD_SANITIZER
+#ifdef ABSL_HAVE_THREAD_SANITIZER 
 extern "C" void __tsan_read1(void *addr);
 #else
 #define __tsan_read1(addr)  // do nothing if TSan not enabled
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/mutex.h b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/mutex.h
index 0762a852df..f8661ad8b9 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/mutex.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_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 y_absl::Mutex mu(y_absl::kConstInit);
+  //   ABSL_CONST_INIT y_absl::Mutex mu(y_absl::kConstInit); 
   //   }
   explicit constexpr Mutex(y_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()
@@ -323,16 +323,16 @@ class ABSL_LOCKABLE Mutex {
   // Mutex::AwaitWithTimeout()
   // Mutex::AwaitWithDeadline()
   //
-  // Unlocks this `Mutex` and blocks until simultaneously:
+  // Unlocks this `Mutex` and blocks until simultaneously: 
   //   - either `cond` is true or the {timeout has expired, deadline has passed}
   //     and
   //   - this `Mutex` can be reacquired,
   // then reacquire this `Mutex` in the same mode in which it was previously
   // held, returning `true` iff `cond` is `true` on return.
   //
-  // If the condition is initially `true`, the implementation *may* skip the
-  // release/re-acquire step and return immediately.
-  //
+  // If the condition is initially `true`, the implementation *may* skip the 
+  // release/re-acquire step and return immediately. 
+  // 
   // Deadlines in the past are equivalent to an immediate deadline.
   // Negative timeouts are equivalent to a zero timeout.
   //
@@ -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
@@ -701,11 +701,11 @@ class Condition {
   //     return processed_ >= current;
   //   };
   //   mu_.Await(Condition(&reached));
-  //
-  // NOTE: never use "mu_.AssertHeld()" instead of "mu_.AssertReaderHeld()" in
-  // the lambda as it may be called when the mutex is being unlocked from a
-  // scope holding only a reader lock, which will make the assertion not
-  // fulfilled and crash the binary.
+  // 
+  // NOTE: never use "mu_.AssertHeld()" instead of "mu_.AssertReaderHeld()" in 
+  // the lambda as it may be called when the mutex is being unlocked from a 
+  // scope holding only a reader lock, which will make the assertion not 
+  // fulfilled and crash the binary. 
 
   // See class comment for performance advice. In particular, if there
   // might be more than one waiter for the same condition, make sure
@@ -790,8 +790,8 @@ class Condition {
 //
 class CondVar {
  public:
-  // A `CondVar` allocated on the heap or on the stack can use the this
-  // constructor.
+  // A `CondVar` allocated on the heap or on the stack can use the this 
+  // constructor. 
   CondVar();
   ~CondVar();
 
@@ -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(); }
   }
@@ -1005,7 +1005,7 @@ void RegisterMutexProfiler(void (*fn)(int64_t wait_timestamp));
 //
 // This has the same memory ordering concerns as RegisterMutexProfiler() above.
 void RegisterMutexTracer(void (*fn)(const char *msg, const void *obj,
-                                    int64_t wait_cycles));
+                                    int64_t wait_cycles)); 
 
 // TODO(gfalcon): Combine RegisterMutexProfiler() and RegisterMutexTracer()
 // into a single interface, since they are only ever called in pairs.
@@ -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-tstring/y_absl/synchronization/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/ya.make
index 860fd01b0f..727a63eb92 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/ya.make
@@ -2,15 +2,15 @@
 
 LIBRARY()
 
-OWNER(
-    somov
-    g:cpp-contrib
-)
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
 
 LICENSE(Apache-2.0)
 
-LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
-
+LICENSE_TEXTS(.yandex_meta/licenses.list.txt) 
+ 
 PEERDIR(
     contrib/restricted/abseil-cpp-tstring/y_absl/base
     contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/.yandex_meta/licenses.list.txt b/contrib/restricted/abseil-cpp-tstring/y_absl/time/.yandex_meta/licenses.list.txt
index 7c1bf3b5ad..fda2d3852b 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/.yandex_meta/licenses.list.txt
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/.yandex_meta/licenses.list.txt
@@ -1,42 +1,42 @@
-====================Apache-2.0====================
-// 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.
-
-
-====================Apache-2.0====================
-// 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====================
-// Copyright 2016 Google Inc. All Rights Reserved.
-
-
-====================COPYRIGHT====================
-// Copyright 2017 The Abseil Authors.
-
-
-====================COPYRIGHT====================
-// Copyright 2018 The Abseil Authors.
-
-
-====================Public-Domain====================
-** This file is in the public domain, so clarified as of
+====================Apache-2.0==================== 
+// 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. 
+ 
+ 
+====================Apache-2.0==================== 
+// 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==================== 
+// Copyright 2016 Google Inc. All Rights Reserved. 
+ 
+ 
+====================COPYRIGHT==================== 
+// Copyright 2017 The Abseil Authors. 
+ 
+ 
+====================COPYRIGHT==================== 
+// Copyright 2018 The Abseil Authors. 
+ 
+ 
+====================Public-Domain==================== 
+** This file is in the public domain, so clarified as of 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time.cc
index f24bac91e8..ee255126f9 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time.cc
@@ -45,7 +45,7 @@ template <typename CivilT>
 bool ParseYearAnd(string_view fmt, string_view s, CivilT* c) {
   // Civil times support a larger year range than y_absl::Time, so we need to
   // parse the year separately, normalize it, then use y_absl::ParseTime on the
-  // normalized string.
+  // normalized string. 
   const TString ss = TString(s);  // TODO(y_absl-team): Avoid conversion.
   const char* const np = ss.c_str();
   char* endp;
@@ -80,7 +80,7 @@ bool ParseAs(string_view s, CivilT2* c) {
 
 template <typename CivilT>
 bool ParseLenient(string_view s, CivilT* c) {
-  // A fastpath for when the given string data parses exactly into the given
+  // A fastpath for when the given string data parses exactly into the given 
   // type T (e.g., s="YYYY-MM-DD" and CivilT=CivilDay).
   if (ParseCivilTime(s, c)) return true;
   // Try parsing as each of the 6 types, trying the most common types first
@@ -96,26 +96,26 @@ bool ParseLenient(string_view s, CivilT* c) {
 }  // namespace
 
 TString FormatCivilTime(CivilSecond c) {
-  return FormatYearAnd("-%m-%d%ET%H:%M:%S", c);
+  return FormatYearAnd("-%m-%d%ET%H:%M:%S", c); 
 }
 TString FormatCivilTime(CivilMinute c) {
-  return FormatYearAnd("-%m-%d%ET%H:%M", c);
+  return FormatYearAnd("-%m-%d%ET%H:%M", c); 
 }
 TString FormatCivilTime(CivilHour c) {
-  return FormatYearAnd("-%m-%d%ET%H", c);
+  return FormatYearAnd("-%m-%d%ET%H", c); 
 }
 TString FormatCivilTime(CivilDay c) { return FormatYearAnd("-%m-%d", c); }
 TString FormatCivilTime(CivilMonth c) { return FormatYearAnd("-%m", c); }
 TString FormatCivilTime(CivilYear c) { return FormatYearAnd("", c); }
 
 bool ParseCivilTime(string_view s, CivilSecond* c) {
-  return ParseYearAnd("-%m-%d%ET%H:%M:%S", s, c);
+  return ParseYearAnd("-%m-%d%ET%H:%M:%S", s, c); 
 }
 bool ParseCivilTime(string_view s, CivilMinute* c) {
-  return ParseYearAnd("-%m-%d%ET%H:%M", s, c);
+  return ParseYearAnd("-%m-%d%ET%H:%M", s, c); 
 }
 bool ParseCivilTime(string_view s, CivilHour* c) {
-  return ParseYearAnd("-%m-%d%ET%H", s, c);
+  return ParseYearAnd("-%m-%d%ET%H", s, c); 
 }
 bool ParseCivilTime(string_view s, CivilDay* c) {
   return ParseYearAnd("-%m-%d", s, c);
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time/ya.make
index 919773f619..86c47adf5b 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time/ya.make
@@ -2,13 +2,13 @@
 
 LIBRARY()
 
-WITHOUT_LICENSE_TEXTS()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
+WITHOUT_LICENSE_TEXTS() 
 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
 LICENSE(Apache-2.0)
 
 ADDINCL(
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/clock.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/clock.cc
index dcc12b5633..b4bd38b928 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/clock.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/clock.cc
@@ -15,7 +15,7 @@
 #include "y_absl/time/clock.h"
 
 #include "y_absl/base/attributes.h"
-#include "y_absl/base/optimization.h"
+#include "y_absl/base/optimization.h" 
 
 #ifdef _WIN32
 #include <windows.h>
@@ -75,7 +75,7 @@ ABSL_NAMESPACE_END
 #if !ABSL_USE_CYCLECLOCK_FOR_GET_CURRENT_TIME_NANOS
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-int64_t GetCurrentTimeNanos() { return GET_CURRENT_TIME_NANOS_FROM_SYSTEM(); }
+int64_t GetCurrentTimeNanos() { return GET_CURRENT_TIME_NANOS_FROM_SYSTEM(); } 
 ABSL_NAMESPACE_END
 }  // namespace y_absl
 #else  // Use the cyclecounter-based implementation below.
@@ -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.
-  y_absl::base_internal::SpinLock lock{y_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. 
+  y_absl::base_internal::SpinLock lock{y_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(y_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)(
-    y_absl::Duration duration) {
+ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSleepFor)( 
+    y_absl::Duration duration) { 
   while (duration > y_absl::ZeroDuration()) {
     y_absl::Duration to_sleep = std::min(duration, y_absl::MaxSleep());
     y_absl::SleepOnce(to_sleep);
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/clock.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/clock.h
index 178b96d828..1743884e8c 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/clock.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_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)(y_absl::Duration duration);
+void ABSL_INTERNAL_C_SYMBOL(AbslInternalSleepFor)(y_absl::Duration duration); 
 }  // extern "C"
 
 inline void y_absl::SleepFor(y_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-tstring/y_absl/time/duration.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/duration.cc
index d4914556e6..cf1e9ad038 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/duration.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/duration.cc
@@ -67,10 +67,10 @@
 #include <util/generic/string.h>
 
 #include "y_absl/base/casts.h"
-#include "y_absl/base/macros.h"
+#include "y_absl/base/macros.h" 
 #include "y_absl/numeric/int128.h"
-#include "y_absl/strings/string_view.h"
-#include "y_absl/strings/strip.h"
+#include "y_absl/strings/string_view.h" 
+#include "y_absl/strings/strip.h" 
 #include "y_absl/time/time.h"
 
 namespace y_absl {
@@ -356,7 +356,7 @@ namespace time_internal {
 // the remainder.  If it does not saturate, the remainder remain accurate,
 // but the returned quotient will over/underflow int64_t and should not be used.
 int64_t IDivDuration(bool satq, const Duration num, const Duration den,
-                     Duration* rem) {
+                     Duration* rem) { 
   int64_t q = 0;
   if (IDivFastPath(num, den, &q, rem)) {
     return q;
@@ -711,17 +711,17 @@ char* Format64(char* ep, int width, int64_t v) {
 // fractional digits, because it is in the noise of what a Duration can
 // represent.
 struct DisplayUnit {
-  y_absl::string_view abbr;
+  y_absl::string_view abbr; 
   int prec;
   double pow10;
 };
-ABSL_CONST_INIT const DisplayUnit kDisplayNano = {"ns", 2, 1e2};
-ABSL_CONST_INIT const DisplayUnit kDisplayMicro = {"us", 5, 1e5};
-ABSL_CONST_INIT const DisplayUnit kDisplayMilli = {"ms", 8, 1e8};
-ABSL_CONST_INIT const DisplayUnit kDisplaySec = {"s", 11, 1e11};
-ABSL_CONST_INIT const DisplayUnit kDisplayMin = {"m", -1, 0.0};  // prec ignored
-ABSL_CONST_INIT const DisplayUnit kDisplayHour = {"h", -1,
-                                                  0.0};  // prec ignored
+ABSL_CONST_INIT const DisplayUnit kDisplayNano = {"ns", 2, 1e2}; 
+ABSL_CONST_INIT const DisplayUnit kDisplayMicro = {"us", 5, 1e5}; 
+ABSL_CONST_INIT const DisplayUnit kDisplayMilli = {"ms", 8, 1e8}; 
+ABSL_CONST_INIT const DisplayUnit kDisplaySec = {"s", 11, 1e11}; 
+ABSL_CONST_INIT const DisplayUnit kDisplayMin = {"m", -1, 0.0};  // prec ignored 
+ABSL_CONST_INIT const DisplayUnit kDisplayHour = {"h", -1, 
+                                                  0.0};  // prec ignored 
 
 void AppendNumberUnit(TString* out, int64_t n, DisplayUnit unit) {
   char buf[sizeof("2562047788015216")];  // hours in max duration
@@ -729,16 +729,16 @@ void AppendNumberUnit(TString* out, int64_t n, DisplayUnit unit) {
   char* bp = Format64(ep, 0, n);
   if (*bp != '0' || bp + 1 != ep) {
     out->append(bp, ep - bp);
-    out->append(unit.abbr.data(), unit.abbr.size());
+    out->append(unit.abbr.data(), unit.abbr.size()); 
   }
 }
 
 // Note: unit.prec is limited to double's digits10 value (typically 15) so it
 // always fits in buf[].
 void AppendNumberUnit(TString* out, double n, DisplayUnit unit) {
-  constexpr int kBufferSize = std::numeric_limits<double>::digits10;
-  const int prec = std::min(kBufferSize, unit.prec);
-  char buf[kBufferSize];  // also large enough to hold integer part
+  constexpr int kBufferSize = std::numeric_limits<double>::digits10; 
+  const int prec = std::min(kBufferSize, unit.prec); 
+  char buf[kBufferSize];  // also large enough to hold integer part 
   char* ep = buf + sizeof(buf);
   double d = 0;
   int64_t frac_part = Round(std::modf(n, &d) * unit.pow10);
@@ -752,7 +752,7 @@ void AppendNumberUnit(TString* out, double n, DisplayUnit unit) {
       while (ep[-1] == '0') --ep;
       out->append(bp, ep - bp);
     }
-    out->append(unit.abbr.data(), unit.abbr.size());
+    out->append(unit.abbr.data(), unit.abbr.size()); 
   }
 }
 
@@ -763,8 +763,8 @@ void AppendNumberUnit(TString* out, double n, DisplayUnit unit) {
 //   form "72h3m0.5s". Leading zero units are omitted.  As a special
 //   case, durations less than one second format use a smaller unit
 //   (milli-, micro-, or nanoseconds) to ensure that the leading digit
-//   is non-zero.
-// Unlike Go, we format the zero duration as 0, with no unit.
+//   is non-zero. 
+// Unlike Go, we format the zero duration as 0, with no unit. 
 TString FormatDuration(Duration d) {
   const Duration min_duration = Seconds(kint64min);
   if (d == min_duration) {
@@ -805,27 +805,27 @@ namespace {
 // A helper for ParseDuration() that parses a leading number from the given
 // string and stores the result in *int_part/*frac_part/*frac_scale.  The
 // given string pointer is modified to point to the first unconsumed char.
-bool ConsumeDurationNumber(const char** dpp, const char* ep, int64_t* int_part,
+bool ConsumeDurationNumber(const char** dpp, const char* ep, int64_t* int_part, 
                            int64_t* frac_part, int64_t* frac_scale) {
   *int_part = 0;
   *frac_part = 0;
   *frac_scale = 1;  // invariant: *frac_part < *frac_scale
   const char* start = *dpp;
-  for (; *dpp != ep; *dpp += 1) {
+  for (; *dpp != ep; *dpp += 1) { 
     const int d = **dpp - '0';  // contiguous digits
-    if (d < 0 || 10 <= d) break;
-
+    if (d < 0 || 10 <= d) break; 
+ 
     if (*int_part > kint64max / 10) return false;
     *int_part *= 10;
     if (*int_part > kint64max - d) return false;
     *int_part += d;
   }
   const bool int_part_empty = (*dpp == start);
-  if (*dpp == ep || **dpp != '.') return !int_part_empty;
-
-  for (*dpp += 1; *dpp != ep; *dpp += 1) {
+  if (*dpp == ep || **dpp != '.') return !int_part_empty; 
+ 
+  for (*dpp += 1; *dpp != ep; *dpp += 1) { 
     const int d = **dpp - '0';  // contiguous digits
-    if (d < 0 || 10 <= d) break;
+    if (d < 0 || 10 <= d) break; 
     if (*frac_scale <= kint64max / 10) {
       *frac_part *= 10;
       *frac_part += d;
@@ -839,55 +839,55 @@ bool ConsumeDurationNumber(const char** dpp, const char* ep, int64_t* int_part,
 // ns, us, ms, s, m, h) from the given string and stores the resulting unit
 // in "*unit".  The given string pointer is modified to point to the first
 // unconsumed char.
-bool ConsumeDurationUnit(const char** start, const char* end, Duration* unit) {
-  size_t size = end - *start;
-  switch (size) {
-    case 0:
-      return false;
-    default:
-      switch (**start) {
-        case 'n':
-          if (*(*start + 1) == 's') {
-            *start += 2;
-            *unit = Nanoseconds(1);
-            return true;
-          }
-          break;
-        case 'u':
-          if (*(*start + 1) == 's') {
-            *start += 2;
-            *unit = Microseconds(1);
-            return true;
-          }
-          break;
-        case 'm':
-          if (*(*start + 1) == 's') {
-            *start += 2;
-            *unit = Milliseconds(1);
-            return true;
-          }
-          break;
-        default:
-          break;
-      }
-      ABSL_FALLTHROUGH_INTENDED;
-    case 1:
-      switch (**start) {
-        case 's':
-          *unit = Seconds(1);
-          *start += 1;
-          return true;
-        case 'm':
-          *unit = Minutes(1);
-          *start += 1;
-          return true;
-        case 'h':
-          *unit = Hours(1);
-          *start += 1;
-          return true;
-        default:
-          return false;
-      }
+bool ConsumeDurationUnit(const char** start, const char* end, Duration* unit) { 
+  size_t size = end - *start; 
+  switch (size) { 
+    case 0: 
+      return false; 
+    default: 
+      switch (**start) { 
+        case 'n': 
+          if (*(*start + 1) == 's') { 
+            *start += 2; 
+            *unit = Nanoseconds(1); 
+            return true; 
+          } 
+          break; 
+        case 'u': 
+          if (*(*start + 1) == 's') { 
+            *start += 2; 
+            *unit = Microseconds(1); 
+            return true; 
+          } 
+          break; 
+        case 'm': 
+          if (*(*start + 1) == 's') { 
+            *start += 2; 
+            *unit = Milliseconds(1); 
+            return true; 
+          } 
+          break; 
+        default: 
+          break; 
+      } 
+      ABSL_FALLTHROUGH_INTENDED; 
+    case 1: 
+      switch (**start) { 
+        case 's': 
+          *unit = Seconds(1); 
+          *start += 1; 
+          return true; 
+        case 'm': 
+          *unit = Minutes(1); 
+          *start += 1; 
+          return true; 
+        case 'h': 
+          *unit = Hours(1); 
+          *start += 1; 
+          return true; 
+        default: 
+          return false; 
+      } 
   }
 }
 
@@ -898,38 +898,38 @@ bool ConsumeDurationUnit(const char** start, const char* end, Duration* unit) {
 //   a possibly signed sequence of decimal numbers, each with optional
 //   fraction and a unit suffix, such as "300ms", "-1.5h" or "2h45m".
 //   Valid time units are "ns", "us" "ms", "s", "m", "h".
-bool ParseDuration(y_absl::string_view dur_sv, Duration* d) {
+bool ParseDuration(y_absl::string_view dur_sv, Duration* d) { 
   int sign = 1;
-  if (y_absl::ConsumePrefix(&dur_sv, "-")) {
-    sign = -1;
-  } else {
-    y_absl::ConsumePrefix(&dur_sv, "+");
+  if (y_absl::ConsumePrefix(&dur_sv, "-")) { 
+    sign = -1; 
+  } else { 
+    y_absl::ConsumePrefix(&dur_sv, "+"); 
   }
-  if (dur_sv.empty()) return false;
+  if (dur_sv.empty()) return false; 
 
-  // Special case for a string of "0".
-  if (dur_sv == "0") {
+  // Special case for a string of "0". 
+  if (dur_sv == "0") { 
     *d = ZeroDuration();
     return true;
   }
 
-  if (dur_sv == "inf") {
+  if (dur_sv == "inf") { 
     *d = sign * InfiniteDuration();
     return true;
   }
 
-  const char* start = dur_sv.data();
-  const char* end = start + dur_sv.size();
-
+  const char* start = dur_sv.data(); 
+  const char* end = start + dur_sv.size(); 
+ 
   Duration dur;
-  while (start != end) {
+  while (start != end) { 
     int64_t int_part;
     int64_t frac_part;
     int64_t frac_scale;
     Duration unit;
-    if (!ConsumeDurationNumber(&start, end, &int_part, &frac_part,
-                               &frac_scale) ||
-        !ConsumeDurationUnit(&start, end, &unit)) {
+    if (!ConsumeDurationNumber(&start, end, &int_part, &frac_part, 
+                               &frac_scale) || 
+        !ConsumeDurationUnit(&start, end, &unit)) { 
       return false;
     }
     if (int_part != 0) dur += sign * int_part * unit;
@@ -940,7 +940,7 @@ bool ParseDuration(y_absl::string_view dur_sv, Duration* d) {
 }
 
 bool AbslParseFlag(y_absl::string_view text, Duration* dst, TString*) {
-  return ParseDuration(text, dst);
+  return ParseDuration(text, dst); 
 }
 
 TString AbslUnparseFlag(Duration d) { return FormatDuration(d); }
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/format.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/format.cc
index c75e4ec21a..ee62b6e3b2 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/format.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/format.cc
@@ -13,12 +13,12 @@
 // limitations under the License.
 
 #include <string.h>
-
+ 
 #include <cctype>
 #include <cstdint>
 
-#include "y_absl/strings/match.h"
-#include "y_absl/strings/string_view.h"
+#include "y_absl/strings/match.h" 
+#include "y_absl/strings/string_view.h" 
 #include "y_absl/time/internal/cctz/include/cctz/time_zone.h"
 #include "y_absl/time/time.h"
 
@@ -27,11 +27,11 @@ namespace cctz = y_absl::time_internal::cctz;
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
 
-ABSL_DLL extern const char RFC3339_full[] = "%Y-%m-%d%ET%H:%M:%E*S%Ez";
-ABSL_DLL extern const char RFC3339_sec[] = "%Y-%m-%d%ET%H:%M:%S%Ez";
+ABSL_DLL extern const char RFC3339_full[] = "%Y-%m-%d%ET%H:%M:%E*S%Ez"; 
+ABSL_DLL extern const char RFC3339_sec[] = "%Y-%m-%d%ET%H:%M:%S%Ez"; 
 
-ABSL_DLL extern const char RFC1123_full[] = "%a, %d %b %E4Y %H:%M:%S %z";
-ABSL_DLL extern const char RFC1123_no_wday[] = "%d %b %E4Y %H:%M:%S %z";
+ABSL_DLL extern const char RFC1123_full[] = "%a, %d %b %E4Y %H:%M:%S %z"; 
+ABSL_DLL extern const char RFC1123_no_wday[] = "%d %b %E4Y %H:%M:%S %z"; 
 
 namespace {
 
@@ -71,12 +71,12 @@ y_absl::Time Join(const cctz_parts& parts) {
 
 }  // namespace
 
-TString FormatTime(y_absl::string_view format, y_absl::Time t,
+TString FormatTime(y_absl::string_view format, y_absl::Time t, 
                        y_absl::TimeZone tz) {
-  if (t == y_absl::InfiniteFuture()) return TString(kInfiniteFutureStr);
-  if (t == y_absl::InfinitePast()) return TString(kInfinitePastStr);
+  if (t == y_absl::InfiniteFuture()) return TString(kInfiniteFutureStr); 
+  if (t == y_absl::InfinitePast()) return TString(kInfinitePastStr); 
   const auto parts = Split(t);
-  return cctz::detail::format(TString(format), parts.sec, parts.fem,
+  return cctz::detail::format(TString(format), parts.sec, parts.fem, 
                               cctz::time_zone(tz));
 }
 
@@ -88,50 +88,50 @@ TString FormatTime(y_absl::Time t) {
   return y_absl::FormatTime(RFC3339_full, t, y_absl::LocalTimeZone());
 }
 
-bool ParseTime(y_absl::string_view format, y_absl::string_view input,
+bool ParseTime(y_absl::string_view format, y_absl::string_view input, 
                y_absl::Time* time, TString* err) {
   return y_absl::ParseTime(format, input, y_absl::UTCTimeZone(), time, err);
 }
 
 // If the input string does not contain an explicit UTC offset, interpret
 // the fields with respect to the given TimeZone.
-bool ParseTime(y_absl::string_view format, y_absl::string_view input,
+bool ParseTime(y_absl::string_view format, y_absl::string_view input, 
                y_absl::TimeZone tz, y_absl::Time* time, TString* err) {
-  auto strip_leading_space = [](y_absl::string_view* sv) {
-    while (!sv->empty()) {
-      if (!std::isspace(sv->front())) return;
-      sv->remove_prefix(1);
+  auto strip_leading_space = [](y_absl::string_view* sv) { 
+    while (!sv->empty()) { 
+      if (!std::isspace(sv->front())) return; 
+      sv->remove_prefix(1); 
     }
-  };
-
-  // Portable toolchains means we don't get nice constexpr here.
-  struct Literal {
-    const char* name;
-    size_t size;
-    y_absl::Time value;
-  };
-  static Literal literals[] = {
-      {kInfiniteFutureStr, strlen(kInfiniteFutureStr), InfiniteFuture()},
-      {kInfinitePastStr, strlen(kInfinitePastStr), InfinitePast()},
-  };
-  strip_leading_space(&input);
-  for (const auto& lit : literals) {
-    if (y_absl::StartsWith(input, y_absl::string_view(lit.name, lit.size))) {
-      y_absl::string_view tail = input;
-      tail.remove_prefix(lit.size);
-      strip_leading_space(&tail);
-      if (tail.empty()) {
-        *time = lit.value;
-        return true;
-      }
+  }; 
+
+  // Portable toolchains means we don't get nice constexpr here. 
+  struct Literal { 
+    const char* name; 
+    size_t size; 
+    y_absl::Time value; 
+  }; 
+  static Literal literals[] = { 
+      {kInfiniteFutureStr, strlen(kInfiniteFutureStr), InfiniteFuture()}, 
+      {kInfinitePastStr, strlen(kInfinitePastStr), InfinitePast()}, 
+  }; 
+  strip_leading_space(&input); 
+  for (const auto& lit : literals) { 
+    if (y_absl::StartsWith(input, y_absl::string_view(lit.name, lit.size))) { 
+      y_absl::string_view tail = input; 
+      tail.remove_prefix(lit.size); 
+      strip_leading_space(&tail); 
+      if (tail.empty()) { 
+        *time = lit.value; 
+        return true; 
+      } 
     }
   }
 
   TString error;
   cctz_parts parts;
-  const bool b =
-      cctz::detail::parse(TString(format), TString(input),
-                          cctz::time_zone(tz), &parts.sec, &parts.fem, &error);
+  const bool b = 
+      cctz::detail::parse(TString(format), TString(input), 
+                          cctz::time_zone(tz), &parts.sec, &parts.fem, &error); 
   if (b) {
     *time = Join(parts);
   } else if (err != nullptr) {
@@ -142,7 +142,7 @@ bool ParseTime(y_absl::string_view format, y_absl::string_view input,
 
 // Functions required to support y_absl::Time flags.
 bool AbslParseFlag(y_absl::string_view text, y_absl::Time* t, TString* error) {
-  return y_absl::ParseTime(RFC3339_full, text, y_absl::UTCTimeZone(), t, error);
+  return y_absl::ParseTime(RFC3339_full, text, y_absl::UTCTimeZone(), t, error); 
 }
 
 TString AbslUnparseFlag(y_absl::Time t) {
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/civil_time_detail.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/civil_time_detail.h
index 0e71a7cd33..ead002629b 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/civil_time_detail.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/civil_time_detail.h
@@ -106,64 +106,64 @@ CONSTEXPR_F int days_per_month(year_t y, month_t m) noexcept {
 
 CONSTEXPR_F fields n_day(year_t y, month_t m, diff_t d, diff_t cd, hour_t hh,
                          minute_t mm, second_t ss) noexcept {
-  year_t ey = y % 400;
-  const year_t oey = ey;
-  ey += (cd / 146097) * 400;
+  year_t ey = y % 400; 
+  const year_t oey = ey; 
+  ey += (cd / 146097) * 400; 
   cd %= 146097;
   if (cd < 0) {
-    ey -= 400;
+    ey -= 400; 
     cd += 146097;
   }
-  ey += (d / 146097) * 400;
+  ey += (d / 146097) * 400; 
   d = d % 146097 + cd;
   if (d > 0) {
     if (d > 146097) {
-      ey += 400;
+      ey += 400; 
       d -= 146097;
     }
   } else {
     if (d > -365) {
       // We often hit the previous year when stepping a civil time backwards,
       // so special case it to avoid counting up by 100/4/1-year chunks.
-      ey -= 1;
-      d += days_per_year(ey, m);
+      ey -= 1; 
+      d += days_per_year(ey, m); 
     } else {
-      ey -= 400;
+      ey -= 400; 
       d += 146097;
     }
   }
   if (d > 365) {
-    for (;;) {
-      int n = days_per_century(ey, m);
-      if (d <= n) break;
+    for (;;) { 
+      int n = days_per_century(ey, m); 
+      if (d <= n) break; 
       d -= n;
-      ey += 100;
+      ey += 100; 
     }
-    for (;;) {
-      int n = days_per_4years(ey, m);
-      if (d <= n) break;
+    for (;;) { 
+      int n = days_per_4years(ey, m); 
+      if (d <= n) break; 
       d -= n;
-      ey += 4;
+      ey += 4; 
     }
-    for (;;) {
-      int n = days_per_year(ey, m);
-      if (d <= n) break;
+    for (;;) { 
+      int n = days_per_year(ey, m); 
+      if (d <= n) break; 
       d -= n;
-      ++ey;
+      ++ey; 
     }
   }
   if (d > 28) {
-    for (;;) {
-      int n = days_per_month(ey, m);
-      if (d <= n) break;
+    for (;;) { 
+      int n = days_per_month(ey, m); 
+      if (d <= n) break; 
       d -= n;
       if (++m > 12) {
-        ++ey;
+        ++ey; 
         m = 1;
       }
     }
   }
-  return fields(y + (ey - oey), m, static_cast<day_t>(d), hh, mm, ss);
+  return fields(y + (ey - oey), m, static_cast<day_t>(d), hh, mm, ss); 
 }
 CONSTEXPR_F fields n_mon(year_t y, diff_t m, diff_t d, diff_t cd, hour_t hh,
                          minute_t mm, second_t ss) noexcept {
@@ -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-tstring/y_absl/time/internal/cctz/include/cctz/time_zone.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/time_zone.h
index 524654df4b..ee0852a182 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/time_zone.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/time_zone.h
@@ -199,7 +199,7 @@ class time_zone {
   // version() and description() provide additional information about the
   // time zone. The content of each of the returned strings is unspecified,
   // however, when the IANA Time Zone Database is the underlying data source
-  // the version() string will be in the familar form (e.g, "2018e") or
+  // the version() string will be in the familar form (e.g, "2018e") or 
   // empty when unavailable.
   //
   // Note: These functions are for informational or testing purposes only.
@@ -296,7 +296,7 @@ bool join_seconds(const time_point<seconds>& sec, const femtoseconds&,
 //   - %E#f - Fractional seconds with # digits of precision
 //   - %E*f - Fractional seconds with full precision (a literal '*')
 //   - %E4Y - Four-character years (-999 ... -001, 0000, 0001 ... 9999)
-//   - %ET  - The RFC3339 "date-time" separator "T"
+//   - %ET  - The RFC3339 "date-time" separator "T" 
 //
 // Note that %E0S behaves like %S, and %E0f produces no characters. In
 // contrast %E*f always produces at least one digit, which may be '0'.
@@ -326,8 +326,8 @@ inline TString format(const TString& fmt, const time_point<D>& tp,
 // returns the corresponding time_point. Uses strftime()-like formatting
 // options, with the same extensions as cctz::format(), but with the
 // exceptions that %E#S is interpreted as %E*S, and %E#f as %E*f. %Ez
-// and %E*z also accept the same inputs, which (along with %z) includes
-// 'z' and 'Z' as synonyms for +00:00.  %ET accepts either 'T' or 't'.
+// and %E*z also accept the same inputs, which (along with %z) includes 
+// 'z' and 'Z' as synonyms for +00:00.  %ET accepts either 'T' or 't'. 
 //
 // %Y consumes as many numeric characters as it can, so the matching data
 // should always be terminated with a non-numeric. %E4Y always consumes
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/zone_info_source.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/zone_info_source.h
index fd6dc4bbb0..a8e08d0c87 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/zone_info_source.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/zone_info_source.h
@@ -37,7 +37,7 @@ class ZoneInfoSource {
 
   // Until the zoneinfo data supports versioning information, we provide
   // a way for a ZoneInfoSource to indicate it out-of-band.  The default
-  // implementation returns an empty string.
+  // implementation returns an empty string. 
   virtual TString Version() const;
 };
 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_format.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_format.cc
index 2f9597018b..73edae8488 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_format.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_format.cc
@@ -67,48 +67,48 @@ char* strptime(const char* s, const char* fmt, std::tm* tm) {
 }
 #endif
 
-// Convert a cctz::weekday to a tm_wday value (0-6, Sunday = 0).
-int ToTmWday(weekday wd) {
-  switch (wd) {
-    case weekday::sunday:
-      return 0;
-    case weekday::monday:
-      return 1;
-    case weekday::tuesday:
-      return 2;
-    case weekday::wednesday:
-      return 3;
-    case weekday::thursday:
-      return 4;
-    case weekday::friday:
-      return 5;
-    case weekday::saturday:
-      return 6;
-  }
-  return 0; /*NOTREACHED*/
-}
-
-// Convert a tm_wday value (0-6, Sunday = 0) to a cctz::weekday.
-weekday FromTmWday(int tm_wday) {
-  switch (tm_wday) {
-    case 0:
-      return weekday::sunday;
-    case 1:
-      return weekday::monday;
-    case 2:
-      return weekday::tuesday;
-    case 3:
-      return weekday::wednesday;
-    case 4:
-      return weekday::thursday;
-    case 5:
-      return weekday::friday;
-    case 6:
-      return weekday::saturday;
-  }
-  return weekday::sunday; /*NOTREACHED*/
-}
-
+// Convert a cctz::weekday to a tm_wday value (0-6, Sunday = 0). 
+int ToTmWday(weekday wd) { 
+  switch (wd) { 
+    case weekday::sunday: 
+      return 0; 
+    case weekday::monday: 
+      return 1; 
+    case weekday::tuesday: 
+      return 2; 
+    case weekday::wednesday: 
+      return 3; 
+    case weekday::thursday: 
+      return 4; 
+    case weekday::friday: 
+      return 5; 
+    case weekday::saturday: 
+      return 6; 
+  } 
+  return 0; /*NOTREACHED*/ 
+} 
+ 
+// Convert a tm_wday value (0-6, Sunday = 0) to a cctz::weekday. 
+weekday FromTmWday(int tm_wday) { 
+  switch (tm_wday) { 
+    case 0: 
+      return weekday::sunday; 
+    case 1: 
+      return weekday::monday; 
+    case 2: 
+      return weekday::tuesday; 
+    case 3: 
+      return weekday::wednesday; 
+    case 4: 
+      return weekday::thursday; 
+    case 5: 
+      return weekday::friday; 
+    case 6: 
+      return weekday::saturday; 
+  } 
+  return weekday::sunday; /*NOTREACHED*/ 
+} 
+ 
 std::tm ToTM(const time_zone::absolute_lookup& al) {
   std::tm tm{};
   tm.tm_sec = al.cs.second();
@@ -126,19 +126,19 @@ std::tm ToTM(const time_zone::absolute_lookup& al) {
     tm.tm_year = static_cast<int>(al.cs.year() - 1900);
   }
 
-  tm.tm_wday = ToTmWday(get_weekday(al.cs));
+  tm.tm_wday = ToTmWday(get_weekday(al.cs)); 
   tm.tm_yday = get_yearday(al.cs) - 1;
   tm.tm_isdst = al.is_dst ? 1 : 0;
   return tm;
 }
 
-// Returns the week of the year [0:53] given a civil day and the day on
-// which weeks are defined to start.
-int ToWeek(const civil_day& cd, weekday week_start) {
-  const civil_day d(cd.year() % 400, cd.month(), cd.day());
-  return static_cast<int>((d - prev_weekday(civil_year(d), week_start)) / 7);
-}
-
+// Returns the week of the year [0:53] given a civil day and the day on 
+// which weeks are defined to start. 
+int ToWeek(const civil_day& cd, weekday week_start) { 
+  const civil_day d(cd.year() % 400, cd.month(), cd.day()); 
+  return static_cast<int>((d - prev_weekday(civil_year(d), week_start)) / 7); 
+} 
+ 
 const char kDigits[] = "0123456789";
 
 // Formats a 64-bit integer in the given field width.  Note that it is up
@@ -216,7 +216,7 @@ void FormatTM(TString* out, const TString& fmt, const std::tm& tm) {
   // strftime(3) returns the number of characters placed in the output
   // array (which may be 0 characters).  It also returns 0 to indicate
   // an error, like the array wasn't large enough.  To accommodate this,
-  // the following code grows the buffer size from 2x the format string
+  // the following code grows the buffer size from 2x the format string 
   // length up to 32x.
   for (std::size_t i = 2; i != 32; i *= 2) {
     std::size_t buf_size = fmt.size() * i;
@@ -317,7 +317,7 @@ const std::int_fast64_t kExp10[kDigits10_64 + 1] = {
 //   - %E#S - Seconds with # digits of fractional precision
 //   - %E*S - Seconds with full fractional precision (a literal '*')
 //   - %E4Y - Four-character years (-999 ... -001, 0000, 0001 ... 9999)
-//   - %ET  - The RFC3339 "date-time" separator "T"
+//   - %ET  - The RFC3339 "date-time" separator "T" 
 //
 // The standard specifiers from RFC3339_* (%Y, %m, %d, %H, %M, and %S) are
 // handled internally for performance reasons.  strftime(3) is slow due to
@@ -382,7 +382,7 @@ TString format(const TString& format, const time_point<seconds>& tp,
     if (cur == end || (cur - percent) % 2 == 0) continue;
 
     // Simple specifiers that we handle ourselves.
-    if (strchr("YmdeUuWwHMSzZs%", *cur)) {
+    if (strchr("YmdeUuWwHMSzZs%", *cur)) { 
       if (cur - 1 != pending) {
         FormatTM(&result, TString(pending, cur - 1), tm);
       }
@@ -403,22 +403,22 @@ TString format(const TString& format, const time_point<seconds>& tp,
           if (*cur == 'e' && *bp == '0') *bp = ' ';  // for Windows
           result.append(bp, static_cast<std::size_t>(ep - bp));
           break;
-        case 'U':
-          bp = Format02d(ep, ToWeek(civil_day(al.cs), weekday::sunday));
-          result.append(bp, static_cast<std::size_t>(ep - bp));
-          break;
-        case 'u':
-          bp = Format64(ep, 0, tm.tm_wday ? tm.tm_wday : 7);
-          result.append(bp, static_cast<std::size_t>(ep - bp));
-          break;
-        case 'W':
-          bp = Format02d(ep, ToWeek(civil_day(al.cs), weekday::monday));
-          result.append(bp, static_cast<std::size_t>(ep - bp));
-          break;
-        case 'w':
-          bp = Format64(ep, 0, tm.tm_wday);
-          result.append(bp, static_cast<std::size_t>(ep - bp));
-          break;
+        case 'U': 
+          bp = Format02d(ep, ToWeek(civil_day(al.cs), weekday::sunday)); 
+          result.append(bp, static_cast<std::size_t>(ep - bp)); 
+          break; 
+        case 'u': 
+          bp = Format64(ep, 0, tm.tm_wday ? tm.tm_wday : 7); 
+          result.append(bp, static_cast<std::size_t>(ep - bp)); 
+          break; 
+        case 'W': 
+          bp = Format02d(ep, ToWeek(civil_day(al.cs), weekday::monday)); 
+          result.append(bp, static_cast<std::size_t>(ep - bp)); 
+          break; 
+        case 'w': 
+          bp = Format64(ep, 0, tm.tm_wday); 
+          result.append(bp, static_cast<std::size_t>(ep - bp)); 
+          break; 
         case 'H':
           bp = Format02d(ep, al.cs.hour());
           result.append(bp, static_cast<std::size_t>(ep - bp));
@@ -492,14 +492,14 @@ TString format(const TString& format, const time_point<seconds>& tp,
     if (*cur != 'E' || ++cur == end) continue;
 
     // Format our extensions.
-    if (*cur == 'T') {
-      // Formats %ET.
-      if (cur - 2 != pending) {
-        FormatTM(&result, TString(pending, cur - 2), tm);
-      }
-      result.append("T");
-      pending = ++cur;
-    } else if (*cur == 'z') {
+    if (*cur == 'T') { 
+      // Formats %ET. 
+      if (cur - 2 != pending) { 
+        FormatTM(&result, TString(pending, cur - 2), tm); 
+      } 
+      result.append("T"); 
+      pending = ++cur; 
+    } else if (*cur == 'z') { 
       // Formats %Ez.
       if (cur - 2 != pending) {
         FormatTM(&result, TString(pending, cur - 2), tm);
@@ -602,7 +602,7 @@ const char* ParseOffset(const char* dp, const char* mode, int* offset) {
       } else {
         dp = nullptr;
       }
-    } else if (first == 'Z' || first == 'z') {  // Zulu
+    } else if (first == 'Z' || first == 'z') {  // Zulu 
       *offset = 0;
     } else {
       dp = nullptr;
@@ -653,32 +653,32 @@ const char* ParseTM(const char* dp, const char* fmt, std::tm* tm) {
   return dp;
 }
 
-// Sets year, tm_mon and tm_mday given the year, week_num, and tm_wday,
-// and the day on which weeks are defined to start.  Returns false if year
-// would need to move outside its bounds.
-bool FromWeek(int week_num, weekday week_start, year_t* year, std::tm* tm) {
-  const civil_year y(*year % 400);
-  civil_day cd = prev_weekday(y, week_start);  // week 0
-  cd = next_weekday(cd - 1, FromTmWday(tm->tm_wday)) + (week_num * 7);
-  if (const year_t shift = cd.year() - y.year()) {
-    if (shift > 0) {
-      if (*year > std::numeric_limits<year_t>::max() - shift) return false;
-    } else {
-      if (*year < std::numeric_limits<year_t>::min() - shift) return false;
-    }
-    *year += shift;
-  }
-  tm->tm_mon = cd.month() - 1;
-  tm->tm_mday = cd.day();
-  return true;
-}
-
+// Sets year, tm_mon and tm_mday given the year, week_num, and tm_wday, 
+// and the day on which weeks are defined to start.  Returns false if year 
+// would need to move outside its bounds. 
+bool FromWeek(int week_num, weekday week_start, year_t* year, std::tm* tm) { 
+  const civil_year y(*year % 400); 
+  civil_day cd = prev_weekday(y, week_start);  // week 0 
+  cd = next_weekday(cd - 1, FromTmWday(tm->tm_wday)) + (week_num * 7); 
+  if (const year_t shift = cd.year() - y.year()) { 
+    if (shift > 0) { 
+      if (*year > std::numeric_limits<year_t>::max() - shift) return false; 
+    } else { 
+      if (*year < std::numeric_limits<year_t>::min() - shift) return false; 
+    } 
+    *year += shift; 
+  } 
+  tm->tm_mon = cd.month() - 1; 
+  tm->tm_mday = cd.day(); 
+  return true; 
+} 
+ 
 }  // namespace
 
 // Uses strptime(3) to parse the given input.  Supports the same extended
 // format specifiers as format(), although %E#S and %E*S are treated
 // identically (and similarly for %E#f and %E*f).  %Ez and %E*z also accept
-// the same inputs. %ET accepts either 'T' or 't'.
+// the same inputs. %ET accepts either 'T' or 't'. 
 //
 // The standard specifiers from RFC3339_* (%Y, %m, %d, %H, %M, and %S) are
 // handled internally so that we can normally avoid strptime() altogether
@@ -722,8 +722,8 @@ bool parse(const TString& format, const TString& input,
   const char* fmt = format.c_str();  // NUL terminated
   bool twelve_hour = false;
   bool afternoon = false;
-  int week_num = -1;
-  weekday week_start = weekday::sunday;
+  int week_num = -1; 
+  weekday week_start = weekday::sunday; 
 
   bool saw_percent_s = false;
   std::int_fast64_t percent_s = 0;
@@ -762,28 +762,28 @@ bool parse(const TString& format, const TString& input,
       case 'm':
         data = ParseInt(data, 2, 1, 12, &tm.tm_mon);
         if (data != nullptr) tm.tm_mon -= 1;
-        week_num = -1;
+        week_num = -1; 
         continue;
       case 'd':
       case 'e':
         data = ParseInt(data, 2, 1, 31, &tm.tm_mday);
-        week_num = -1;
-        continue;
-      case 'U':
-        data = ParseInt(data, 0, 0, 53, &week_num);
-        week_start = weekday::sunday;
-        continue;
-      case 'W':
-        data = ParseInt(data, 0, 0, 53, &week_num);
-        week_start = weekday::monday;
-        continue;
-      case 'u':
-        data = ParseInt(data, 0, 1, 7, &tm.tm_wday);
-        if (data != nullptr) tm.tm_wday %= 7;
-        continue;
-      case 'w':
-        data = ParseInt(data, 0, 0, 6, &tm.tm_wday);
+        week_num = -1; 
         continue;
+      case 'U': 
+        data = ParseInt(data, 0, 0, 53, &week_num); 
+        week_start = weekday::sunday; 
+        continue; 
+      case 'W': 
+        data = ParseInt(data, 0, 0, 53, &week_num); 
+        week_start = weekday::monday; 
+        continue; 
+      case 'u': 
+        data = ParseInt(data, 0, 1, 7, &tm.tm_wday); 
+        if (data != nullptr) tm.tm_wday %= 7; 
+        continue; 
+      case 'w': 
+        data = ParseInt(data, 0, 0, 6, &tm.tm_wday); 
+        continue; 
       case 'H':
         data = ParseInt(data, 2, 0, 23, &tm.tm_hour);
         twelve_hour = false;
@@ -832,15 +832,15 @@ bool parse(const TString& format, const TString& input,
         data = (*data == '%' ? data + 1 : nullptr);
         continue;
       case 'E':
-        if (fmt[0] == 'T') {
-          if (*data == 'T' || *data == 't') {
-            ++data;
-            ++fmt;
-          } else {
-            data = nullptr;
-          }
-          continue;
-        }
+        if (fmt[0] == 'T') { 
+          if (*data == 'T' || *data == 't') { 
+            ++data; 
+            ++fmt; 
+          } else { 
+            data = nullptr; 
+          } 
+          continue; 
+        } 
         if (fmt[0] == 'z' || (fmt[0] == '*' && fmt[1] == 'z')) {
           data = ParseOffset(data, ":", &offset);
           if (data != nullptr) saw_offset = true;
@@ -938,7 +938,7 @@ bool parse(const TString& format, const TString& input,
   // Skip any remaining whitespace.
   while (std::isspace(*data)) ++data;
 
-  // parse() must consume the entire input string.
+  // parse() must consume the entire input string. 
   if (*data != '\0') {
     if (err != nullptr) *err = "Illegal trailing data in input string";
     return false;
@@ -973,14 +973,14 @@ bool parse(const TString& format, const TString& input,
     year += 1900;
   }
 
-  // Compute year, tm.tm_mon and tm.tm_mday if we parsed a week number.
-  if (week_num != -1) {
-    if (!FromWeek(week_num, week_start, &year, &tm)) {
-      if (err != nullptr) *err = "Out-of-range field";
-      return false;
-    }
-  }
-
+  // Compute year, tm.tm_mon and tm.tm_mday if we parsed a week number. 
+  if (week_num != -1) { 
+    if (!FromWeek(week_num, week_start, &year, &tm)) { 
+      if (err != nullptr) *err = "Out-of-range field"; 
+      return false; 
+    } 
+  } 
+ 
   const int month = tm.tm_mon + 1;
   civil_second cs(year, month, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_impl.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_impl.cc
index 3810defe3c..df48bd6976 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_impl.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_impl.cc
@@ -15,7 +15,7 @@
 #include "time_zone_impl.h"
 
 #include <deque>
-#include <memory>
+#include <memory> 
 #include <mutex>
 #include <util/generic/string.h>
 #include <unordered_map>
@@ -49,16 +49,16 @@ std::mutex& TimeZoneMutex() {
 time_zone time_zone::Impl::UTC() { return time_zone(UTCImpl()); }
 
 bool time_zone::Impl::LoadTimeZone(const TString& name, time_zone* tz) {
-  const Impl* const utc_impl = UTCImpl();
+  const Impl* const utc_impl = UTCImpl(); 
 
-  // Check for UTC (which is never a key in time_zone_map).
+  // Check for UTC (which is never a key in time_zone_map). 
   auto offset = seconds::zero();
   if (FixedOffsetFromName(name, &offset) && offset == seconds::zero()) {
     *tz = time_zone(utc_impl);
     return true;
   }
 
-  // Check whether the time zone has already been loaded.
+  // Check whether the time zone has already been loaded. 
   {
     std::lock_guard<std::mutex> lock(TimeZoneMutex());
     if (time_zone_map != nullptr) {
@@ -70,15 +70,15 @@ bool time_zone::Impl::LoadTimeZone(const TString& name, time_zone* tz) {
     }
   }
 
-  // Load the new time zone (outside the lock).
-  std::unique_ptr<const Impl> new_impl(new Impl(name));
-
-  // Add the new time zone to the map.
+  // Load the new time zone (outside the lock). 
+  std::unique_ptr<const Impl> new_impl(new Impl(name)); 
+ 
+  // Add the new time zone to the map. 
   std::lock_guard<std::mutex> lock(TimeZoneMutex());
   if (time_zone_map == nullptr) time_zone_map = new TimeZoneImplByName;
   const Impl*& impl = (*time_zone_map)[name];
-  if (impl == nullptr) {  // this thread won any load race
-    impl = new_impl->zone_ ? new_impl.release() : utc_impl;
+  if (impl == nullptr) {  // this thread won any load race 
+    impl = new_impl->zone_ ? new_impl.release() : utc_impl; 
   }
   *tz = time_zone(impl);
   return impl != utc_impl;
@@ -99,11 +99,11 @@ void time_zone::Impl::ClearTimeZoneMapTestOnly() {
   }
 }
 
-time_zone::Impl::Impl(const TString& name)
-    : name_(name), zone_(TimeZoneIf::Load(name_)) {}
+time_zone::Impl::Impl(const TString& name) 
+    : name_(name), zone_(TimeZoneIf::Load(name_)) {} 
 
 const time_zone::Impl* time_zone::Impl::UTCImpl() {
-  static const Impl* utc_impl = new Impl("UTC");  // never fails
+  static const Impl* utc_impl = new Impl("UTC");  // never fails 
   return utc_impl;
 }
 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_impl.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_impl.h
index c014ab41df..456025bf91 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_impl.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_impl.h
@@ -71,7 +71,7 @@ class time_zone::Impl {
     return zone_->PrevTransition(tp, trans);
   }
 
-  // Returns an implementation-defined version string for this time zone.
+  // Returns an implementation-defined version string for this time zone. 
   TString Version() const { return zone_->Version(); }
 
   // Returns an implementation-defined description of this time zone.
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_info.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_info.cc
index 72f7bdc3ca..5633f367f4 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_info.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_info.cc
@@ -84,27 +84,27 @@ const std::int_least32_t kSecsPerYear[2] = {
     366 * kSecsPerDay,
 };
 
-// Convert a cctz::weekday to a POSIX TZ weekday number (0==Sun, ..., 6=Sat).
-inline int ToPosixWeekday(weekday wd) {
-  switch (wd) {
-    case weekday::sunday:
-      return 0;
-    case weekday::monday:
-      return 1;
-    case weekday::tuesday:
-      return 2;
-    case weekday::wednesday:
-      return 3;
-    case weekday::thursday:
-      return 4;
-    case weekday::friday:
-      return 5;
-    case weekday::saturday:
-      return 6;
-  }
-  return 0; /*NOTREACHED*/
-}
-
+// Convert a cctz::weekday to a POSIX TZ weekday number (0==Sun, ..., 6=Sat). 
+inline int ToPosixWeekday(weekday wd) { 
+  switch (wd) { 
+    case weekday::sunday: 
+      return 0; 
+    case weekday::monday: 
+      return 1; 
+    case weekday::tuesday: 
+      return 2; 
+    case weekday::wednesday: 
+      return 3; 
+    case weekday::thursday: 
+      return 4; 
+    case weekday::friday: 
+      return 5; 
+    case weekday::saturday: 
+      return 6; 
+  } 
+  return 0; /*NOTREACHED*/ 
+} 
+ 
 // Single-byte, unsigned numeric values are encoded directly.
 inline std::uint_fast8_t Decode8(const char* cp) {
   return static_cast<std::uint_fast8_t>(*cp) & 0xff;
@@ -210,13 +210,13 @@ bool TimeZoneInfo::ResetToBuiltinUTC(const seconds& offset) {
   tt.is_dst = false;
   tt.abbr_index = 0;
 
-  // We temporarily add some redundant, contemporary (2015 through 2025)
+  // We temporarily add some redundant, contemporary (2015 through 2025) 
   // transitions for performance reasons.  See TimeZoneInfo::LocalTime().
   // TODO: Fix the performance issue and remove the extra transitions.
   transitions_.clear();
   transitions_.reserve(12);
   for (const std::int_fast64_t unix_time : {
-           -(1LL << 59),  // a "first half" transition
+           -(1LL << 59),  // a "first half" transition 
            1420070400LL,  // 2015-01-01T00:00:00+00:00
            1451606400LL,  // 2016-01-01T00:00:00+00:00
            1483228800LL,  // 2017-01-01T00:00:00+00:00
@@ -226,8 +226,8 @@ bool TimeZoneInfo::ResetToBuiltinUTC(const seconds& offset) {
            1609459200LL,  // 2021-01-01T00:00:00+00:00
            1640995200LL,  // 2022-01-01T00:00:00+00:00
            1672531200LL,  // 2023-01-01T00:00:00+00:00
-           1704067200LL,  // 2024-01-01T00:00:00+00:00
-           1735689600LL,  // 2025-01-01T00:00:00+00:00
+           1704067200LL,  // 2024-01-01T00:00:00+00:00 
+           1735689600LL,  // 2025-01-01T00:00:00+00:00 
        }) {
     Transition& tr(*transitions_.emplace(transitions_.end()));
     tr.unix_time = unix_time;
@@ -238,8 +238,8 @@ bool TimeZoneInfo::ResetToBuiltinUTC(const seconds& offset) {
 
   default_transition_type_ = 0;
   abbreviations_ = FixedOffsetToAbbr(offset);
-  abbreviations_.append(1, '\0');
-  future_spec_.clear();  // never needed for a fixed-offset zone
+  abbreviations_.append(1, '\0'); 
+  future_spec_.clear();  // never needed for a fixed-offset zone 
   extended_ = false;
 
   tt.civil_max = LocalTime(seconds::max().count(), tt).cs;
@@ -288,108 +288,108 @@ bool TimeZoneInfo::EquivTransitions(std::uint_fast8_t tt1_index,
   if (tt1_index == tt2_index) return true;
   const TransitionType& tt1(transition_types_[tt1_index]);
   const TransitionType& tt2(transition_types_[tt2_index]);
-  if (tt1.utc_offset != tt2.utc_offset) return false;
+  if (tt1.utc_offset != tt2.utc_offset) return false; 
   if (tt1.is_dst != tt2.is_dst) return false;
   if (tt1.abbr_index != tt2.abbr_index) return false;
   return true;
 }
 
-// Find/make a transition type with these attributes.
-bool TimeZoneInfo::GetTransitionType(std::int_fast32_t utc_offset, bool is_dst,
-                                     const TString& abbr,
-                                     std::uint_least8_t* index) {
-  std::size_t type_index = 0;
-  std::size_t abbr_index = abbreviations_.size();
-  for (; type_index != transition_types_.size(); ++type_index) {
-    const TransitionType& tt(transition_types_[type_index]);
-    const char* tt_abbr = &*abbreviations_.begin() + tt.abbr_index;
-    if (tt_abbr == abbr) abbr_index = tt.abbr_index;
-    if (tt.utc_offset == utc_offset && tt.is_dst == is_dst) {
-      if (abbr_index == tt.abbr_index) break;  // reuse
-    }
-  }
-  if (type_index > 255 || abbr_index > 255) {
-    // No index space (8 bits) available for a new type or abbreviation.
-    return false;
-  }
-  if (type_index == transition_types_.size()) {
-    TransitionType& tt(*transition_types_.emplace(transition_types_.end()));
-    tt.utc_offset = static_cast<std::int_least32_t>(utc_offset);
-    tt.is_dst = is_dst;
-    if (abbr_index == abbreviations_.size()) {
-      abbreviations_.append(abbr);
-      abbreviations_.append(1, '\0');
-    }
-    tt.abbr_index = static_cast<std::uint_least8_t>(abbr_index);
-  }
-  *index = static_cast<std::uint_least8_t>(type_index);
-  return true;
-}
-
+// Find/make a transition type with these attributes. 
+bool TimeZoneInfo::GetTransitionType(std::int_fast32_t utc_offset, bool is_dst, 
+                                     const TString& abbr, 
+                                     std::uint_least8_t* index) { 
+  std::size_t type_index = 0; 
+  std::size_t abbr_index = abbreviations_.size(); 
+  for (; type_index != transition_types_.size(); ++type_index) { 
+    const TransitionType& tt(transition_types_[type_index]); 
+    const char* tt_abbr = &*abbreviations_.begin() + tt.abbr_index; 
+    if (tt_abbr == abbr) abbr_index = tt.abbr_index; 
+    if (tt.utc_offset == utc_offset && tt.is_dst == is_dst) { 
+      if (abbr_index == tt.abbr_index) break;  // reuse 
+    } 
+  } 
+  if (type_index > 255 || abbr_index > 255) { 
+    // No index space (8 bits) available for a new type or abbreviation. 
+    return false; 
+  } 
+  if (type_index == transition_types_.size()) { 
+    TransitionType& tt(*transition_types_.emplace(transition_types_.end())); 
+    tt.utc_offset = static_cast<std::int_least32_t>(utc_offset); 
+    tt.is_dst = is_dst; 
+    if (abbr_index == abbreviations_.size()) { 
+      abbreviations_.append(abbr); 
+      abbreviations_.append(1, '\0'); 
+    } 
+    tt.abbr_index = static_cast<std::uint_least8_t>(abbr_index); 
+  } 
+  *index = static_cast<std::uint_least8_t>(type_index); 
+  return true; 
+} 
+ 
 // Use the POSIX-TZ-environment-variable-style string to handle times
 // in years after the last transition stored in the zoneinfo data.
-bool TimeZoneInfo::ExtendTransitions() {
+bool TimeZoneInfo::ExtendTransitions() { 
   extended_ = false;
-  if (future_spec_.empty()) return true;  // last transition prevails
+  if (future_spec_.empty()) return true;  // last transition prevails 
 
   PosixTimeZone posix;
-  if (!ParsePosixSpec(future_spec_, &posix)) return false;
+  if (!ParsePosixSpec(future_spec_, &posix)) return false; 
 
-  // Find transition type for the future std specification.
-  std::uint_least8_t std_ti;
-  if (!GetTransitionType(posix.std_offset, false, posix.std_abbr, &std_ti))
-    return false;
+  // Find transition type for the future std specification. 
+  std::uint_least8_t std_ti; 
+  if (!GetTransitionType(posix.std_offset, false, posix.std_abbr, &std_ti)) 
+    return false; 
 
-  if (posix.dst_abbr.empty()) {  // std only
-    // The future specification should match the last transition, and
-    // that means that handling the future will fall out naturally.
-    return EquivTransitions(transitions_.back().type_index, std_ti);
+  if (posix.dst_abbr.empty()) {  // std only 
+    // The future specification should match the last transition, and 
+    // that means that handling the future will fall out naturally. 
+    return EquivTransitions(transitions_.back().type_index, std_ti); 
   }
 
-  // Find transition type for the future dst specification.
-  std::uint_least8_t dst_ti;
-  if (!GetTransitionType(posix.dst_offset, true, posix.dst_abbr, &dst_ti))
-    return false;
+  // Find transition type for the future dst specification. 
+  std::uint_least8_t dst_ti; 
+  if (!GetTransitionType(posix.dst_offset, true, posix.dst_abbr, &dst_ti)) 
+    return false; 
 
   // Extend the transitions for an additional 400 years using the
   // future specification. Years beyond those can be handled by
   // mapping back to a cycle-equivalent year within that range.
-  // We may need two additional transitions for the current year.
-  transitions_.reserve(transitions_.size() + 400 * 2 + 2);
+  // We may need two additional transitions for the current year. 
+  transitions_.reserve(transitions_.size() + 400 * 2 + 2); 
   extended_ = true;
 
-  const Transition& last(transitions_.back());
-  const std::int_fast64_t last_time = last.unix_time;
-  const TransitionType& last_tt(transition_types_[last.type_index]);
-  last_year_ = LocalTime(last_time, last_tt).cs.year();
-  bool leap_year = IsLeap(last_year_);
-  const civil_second jan1(last_year_);
-  std::int_fast64_t jan1_time = jan1 - civil_second();
-  int jan1_weekday = ToPosixWeekday(get_weekday(jan1));
-
-  Transition dst = {0, dst_ti, civil_second(), civil_second()};
-  Transition std = {0, std_ti, civil_second(), civil_second()};
-  for (const year_t limit = last_year_ + 400;; ++last_year_) {
-    auto dst_trans_off = TransOffset(leap_year, jan1_weekday, posix.dst_start);
-    auto std_trans_off = TransOffset(leap_year, jan1_weekday, posix.dst_end);
-    dst.unix_time = jan1_time + dst_trans_off - posix.std_offset;
-    std.unix_time = jan1_time + std_trans_off - posix.dst_offset;
-    const auto* ta = dst.unix_time < std.unix_time ? &dst : &std;
-    const auto* tb = dst.unix_time < std.unix_time ? &std : &dst;
-    if (last_time < tb->unix_time) {
-      if (last_time < ta->unix_time) transitions_.push_back(*ta);
-      transitions_.push_back(*tb);
-    }
-    if (last_year_ == limit) break;
+  const Transition& last(transitions_.back()); 
+  const std::int_fast64_t last_time = last.unix_time; 
+  const TransitionType& last_tt(transition_types_[last.type_index]); 
+  last_year_ = LocalTime(last_time, last_tt).cs.year(); 
+  bool leap_year = IsLeap(last_year_); 
+  const civil_second jan1(last_year_); 
+  std::int_fast64_t jan1_time = jan1 - civil_second(); 
+  int jan1_weekday = ToPosixWeekday(get_weekday(jan1)); 
+
+  Transition dst = {0, dst_ti, civil_second(), civil_second()}; 
+  Transition std = {0, std_ti, civil_second(), civil_second()}; 
+  for (const year_t limit = last_year_ + 400;; ++last_year_) { 
+    auto dst_trans_off = TransOffset(leap_year, jan1_weekday, posix.dst_start); 
+    auto std_trans_off = TransOffset(leap_year, jan1_weekday, posix.dst_end); 
+    dst.unix_time = jan1_time + dst_trans_off - posix.std_offset; 
+    std.unix_time = jan1_time + std_trans_off - posix.dst_offset; 
+    const auto* ta = dst.unix_time < std.unix_time ? &dst : &std; 
+    const auto* tb = dst.unix_time < std.unix_time ? &std : &dst; 
+    if (last_time < tb->unix_time) { 
+      if (last_time < ta->unix_time) transitions_.push_back(*ta); 
+      transitions_.push_back(*tb); 
+    } 
+    if (last_year_ == limit) break; 
     jan1_time += kSecsPerYear[leap_year];
     jan1_weekday = (jan1_weekday + kDaysPerYear[leap_year]) % 7;
-    leap_year = !leap_year && IsLeap(last_year_ + 1);
+    leap_year = !leap_year && IsLeap(last_year_ + 1); 
   }
-
-  return true;
+ 
+  return true; 
 }
 
-bool TimeZoneInfo::Load(ZoneInfoSource* zip) {
+bool TimeZoneInfo::Load(ZoneInfoSource* zip) { 
   // Read and validate the header.
   tzhead tzh;
   if (zip->Read(&tzh, sizeof(tzh)) != sizeof(tzh)) return false;
@@ -427,7 +427,7 @@ bool TimeZoneInfo::Load(ZoneInfoSource* zip) {
   const char* bp = tbuf.data();
 
   // Decode and validate the transitions.
-  transitions_.reserve(hdr.timecnt + 2);
+  transitions_.reserve(hdr.timecnt + 2); 
   transitions_.resize(hdr.timecnt);
   for (std::size_t i = 0; i != hdr.timecnt; ++i) {
     transitions_[i].unix_time = (time_len == 4) ? Decode32(bp) : Decode64(bp);
@@ -446,7 +446,7 @@ bool TimeZoneInfo::Load(ZoneInfoSource* zip) {
   }
 
   // Decode and validate the transition types.
-  transition_types_.reserve(hdr.typecnt + 2);
+  transition_types_.reserve(hdr.typecnt + 2); 
   transition_types_.resize(hdr.typecnt);
   for (std::size_t i = 0; i != hdr.typecnt; ++i) {
     transition_types_[i].utc_offset =
@@ -473,7 +473,7 @@ bool TimeZoneInfo::Load(ZoneInfoSource* zip) {
   }
 
   // Copy all the abbreviations.
-  abbreviations_.reserve(hdr.charcnt + 10);
+  abbreviations_.reserve(hdr.charcnt + 10); 
   abbreviations_.assign(bp, hdr.charcnt);
   bp += hdr.charcnt;
 
@@ -505,7 +505,7 @@ bool TimeZoneInfo::Load(ZoneInfoSource* zip) {
 
   // If we did not find version information during the standard loading
   // process (as of tzh_version '3' that is unsupported), then ask the
-  // ZoneInfoSource for any out-of-bound version string it may be privy to.
+  // ZoneInfoSource for any out-of-bound version string it may be privy to. 
   if (version_.empty()) {
     version_ = zip->Version();
   }
@@ -524,30 +524,30 @@ bool TimeZoneInfo::Load(ZoneInfoSource* zip) {
   transitions_.resize(hdr.timecnt);
 
   // Ensure that there is always a transition in the first half of the
-  // time line (the second half is handled below) so that the signed
-  // difference between a civil_second and the civil_second of its
-  // previous transition is always representable, without overflow.
+  // time line (the second half is handled below) so that the signed 
+  // difference between a civil_second and the civil_second of its 
+  // previous transition is always representable, without overflow. 
   if (transitions_.empty() || transitions_.front().unix_time >= 0) {
     Transition& tr(*transitions_.emplace(transitions_.begin()));
-    tr.unix_time = -(1LL << 59);  // -18267312070-10-26T17:01:52+00:00
+    tr.unix_time = -(1LL << 59);  // -18267312070-10-26T17:01:52+00:00 
     tr.type_index = default_transition_type_;
   }
 
   // Extend the transitions using the future specification.
-  if (!ExtendTransitions()) return false;
-
-  // Ensure that there is always a transition in the second half of the
-  // time line (the first half is handled above) so that the signed
-  // difference between a civil_second and the civil_second of its
-  // previous transition is always representable, without overflow.
-  const Transition& last(transitions_.back());
-  if (last.unix_time < 0) {
-    const std::uint_fast8_t type_index = last.type_index;
-    Transition& tr(*transitions_.emplace(transitions_.end()));
-    tr.unix_time = 2147483647;  // 2038-01-19T03:14:07+00:00
-    tr.type_index = type_index;
-  }
-
+  if (!ExtendTransitions()) return false; 
+
+  // Ensure that there is always a transition in the second half of the 
+  // time line (the first half is handled above) so that the signed 
+  // difference between a civil_second and the civil_second of its 
+  // previous transition is always representable, without overflow. 
+  const Transition& last(transitions_.back()); 
+  if (last.unix_time < 0) { 
+    const std::uint_fast8_t type_index = last.type_index; 
+    Transition& tr(*transitions_.emplace(transitions_.end())); 
+    tr.unix_time = 2147483647;  // 2038-01-19T03:14:07+00:00 
+    tr.type_index = type_index; 
+  } 
+ 
   // Compute the local civil time for each transition and the preceding
   // second. These will be used for reverse conversions in MakeTime().
   const TransitionType* ttp = &transition_types_[default_transition_type_];
@@ -786,13 +786,13 @@ bool TimeZoneInfo::Load(const TString& name) {
 
   // Find and use a ZoneInfoSource to load the named zone.
   auto zip = cctz_extension::zone_info_source_factory(
-      name, [](const TString& n) -> std::unique_ptr<ZoneInfoSource> {
-        if (auto z = FileZoneInfoSource::Open(n)) return z;
-        if (auto z = AndroidZoneInfoSource::Open(n)) return z;
+      name, [](const TString& n) -> std::unique_ptr<ZoneInfoSource> { 
+        if (auto z = FileZoneInfoSource::Open(n)) return z; 
+        if (auto z = AndroidZoneInfoSource::Open(n)) return z; 
         if (auto z = FuchsiaZoneInfoSource::Open(n)) return z;
         return nullptr;
       });
-  return zip != nullptr && Load(zip.get());
+  return zip != nullptr && Load(zip.get()); 
 }
 
 // BreakTime() translation for a particular transition type.
@@ -966,8 +966,8 @@ bool TimeZoneInfo::NextTransition(const time_point<seconds>& tp,
   const Transition* begin = &transitions_[0];
   const Transition* end = begin + transitions_.size();
   if (begin->unix_time <= -(1LL << 59)) {
-    // Do not report the BIG_BANG found in some zoneinfo data as it is
-    // really a sentinel, not a transition.  See pre-2018f tz/zic.c.
+    // Do not report the BIG_BANG found in some zoneinfo data as it is 
+    // really a sentinel, not a transition.  See pre-2018f tz/zic.c. 
     ++begin;
   }
   std::int_fast64_t unix_time = ToUnixSeconds(tp);
@@ -992,8 +992,8 @@ bool TimeZoneInfo::PrevTransition(const time_point<seconds>& tp,
   const Transition* begin = &transitions_[0];
   const Transition* end = begin + transitions_.size();
   if (begin->unix_time <= -(1LL << 59)) {
-    // Do not report the BIG_BANG found in some zoneinfo data as it is
-    // really a sentinel, not a transition.  See pre-2018f tz/zic.c.
+    // Do not report the BIG_BANG found in some zoneinfo data as it is 
+    // really a sentinel, not a transition.  See pre-2018f tz/zic.c. 
     ++begin;
   }
   std::int_fast64_t unix_time = ToUnixSeconds(tp);
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_info.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_info.h
index e55fd51847..f35d6cc60b 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_info.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_info.h
@@ -95,14 +95,14 @@ class TimeZoneInfo : public TimeZoneIf {
     std::size_t DataLength(std::size_t time_len) const;
   };
 
-  bool GetTransitionType(std::int_fast32_t utc_offset, bool is_dst,
-                         const TString& abbr, std::uint_least8_t* index);
+  bool GetTransitionType(std::int_fast32_t utc_offset, bool is_dst, 
+                         const TString& abbr, std::uint_least8_t* index); 
   bool EquivTransitions(std::uint_fast8_t tt1_index,
                         std::uint_fast8_t tt2_index) const;
-  bool ExtendTransitions();
+  bool ExtendTransitions(); 
 
   bool ResetToBuiltinUTC(const seconds& offset);
-  bool Load(ZoneInfoSource* zip);
+  bool Load(ZoneInfoSource* zip); 
 
   // Helpers for BreakTime() and MakeTime().
   time_zone::absolute_lookup LocalTime(std::int_fast64_t unix_time,
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_libc.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_libc.cc
index a73832fc29..a7ad1a0f0a 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_libc.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_libc.cc
@@ -27,12 +27,12 @@
 #include "y_absl/time/internal/cctz/include/cctz/civil_time.h"
 #include "y_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 y_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;
@@ -159,8 +159,8 @@ std::time_t find_trans(std::time_t lo, std::time_t hi, int offset) {
   std::tm tm;
   while (lo + 1 != hi) {
     const std::time_t mid = lo + (hi - lo) / 2;
-    std::tm* tmp = local_time(&mid, &tm);
-    if (tmp != nullptr) {
+    std::tm* tmp = local_time(&mid, &tm); 
+    if (tmp != nullptr) { 
       if (tm_gmtoff(*tmp) == offset) {
         hi = mid;
       } else {
@@ -170,8 +170,8 @@ std::time_t find_trans(std::time_t lo, std::time_t hi, int offset) {
       // If std::tm cannot hold some result we resort to a linear search,
       // ignoring all failed conversions.  Slow, but never really happens.
       while (++lo != hi) {
-        tmp = local_time(&lo, &tm);
-        if (tmp != nullptr) {
+        tmp = local_time(&lo, &tm); 
+        if (tmp != nullptr) { 
           if (tm_gmtoff(*tmp) == offset) break;
         }
       }
@@ -231,10 +231,10 @@ time_zone::civil_lookup TimeZoneLibC::MakeTime(const civil_second& cs) const {
         civil_second() + ToUnixSeconds(time_point<seconds>::min());
     static const civil_second max_tp_cs =
         civil_second() + ToUnixSeconds(time_point<seconds>::max());
-    const time_point<seconds> tp = (cs < min_tp_cs) ? time_point<seconds>::min()
-                                   : (cs > max_tp_cs)
-                                       ? time_point<seconds>::max()
-                                       : FromUnixSeconds(cs - civil_second());
+    const time_point<seconds> tp = (cs < min_tp_cs) ? time_point<seconds>::min() 
+                                   : (cs > max_tp_cs) 
+                                       ? time_point<seconds>::max() 
+                                       : FromUnixSeconds(cs - civil_second()); 
     return {time_zone::civil_lookup::UNIQUE, tp, tp, tp};
   }
 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/tzfile.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/tzfile.h
index 31e8598257..6622ea0423 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/tzfile.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/tzfile.h
@@ -83,13 +83,13 @@ struct tzhead {
 ** If tzh_version is '2' or greater, the above is followed by a second instance
 ** of tzhead and a second instance of the data in which each coded transition
 ** time uses 8 rather than 4 chars,
-** then a POSIX-TZ-environment-variable-style string for use in handling
+** then a POSIX-TZ-environment-variable-style string for use in handling 
 ** instants after the last transition time stored in the file
 ** (with nothing between the newlines if there is no POSIX representation for
 ** such instants).
 **
 ** If tz_version is '3' or greater, the above is extended as follows.
-** First, the POSIX TZ string's hour offset may range from -167
+** First, the POSIX TZ string's hour offset may range from -167 
 ** through 167 as compared to the POSIX-required 0 through 24.
 ** Second, its DST start time may be January 1 at 00:00 and its stop
 ** time December 31 at 24:00 plus the difference between DST and
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/time.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/time.cc
index 441638b256..0518296cc9 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/time.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/time.cc
@@ -60,10 +60,10 @@ inline cctz::time_point<cctz::seconds> unix_epoch() {
 inline int64_t FloorToUnit(y_absl::Duration d, y_absl::Duration unit) {
   y_absl::Duration rem;
   int64_t q = y_absl::IDivDuration(d, unit, &rem);
-  return (q > 0 || rem >= ZeroDuration() ||
-          q == std::numeric_limits<int64_t>::min())
-             ? q
-             : q - 1;
+  return (q > 0 || rem >= ZeroDuration() || 
+          q == std::numeric_limits<int64_t>::min()) 
+             ? q 
+             : q - 1; 
 }
 
 inline y_absl::Time::Breakdown InfiniteFutureBreakdown() {
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/time.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/time.h
index 16150ad3b6..dd2a947c19 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/time.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/time.h
@@ -488,12 +488,12 @@ Duration Hours(T n) {
 //
 //   y_absl::Duration d = y_absl::Milliseconds(1500);
 //   int64_t isec = y_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);
 //
 //   y_absl::Duration d = y_absl::Milliseconds(1500);
 //   double dsec = y_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()
 //
@@ -575,7 +575,7 @@ inline std::ostream& operator<<(std::ostream& os, Duration d) {
 // suffix.  The valid suffixes are "ns", "us" "ms", "s", "m", and "h".
 // Simple examples include "300ms", "-1.5h", and "2h45m".  Parses "0" as
 // `ZeroDuration()`. Parses "inf" and "-inf" as +/- `InfiniteDuration()`.
-bool ParseDuration(y_absl::string_view dur_string, Duration* d);
+bool ParseDuration(y_absl::string_view dur_string, Duration* d); 
 
 // AbslParseFlag()
 //
@@ -679,7 +679,7 @@ class Time {
   // Deprecated. Use `y_absl::TimeZone::CivilInfo`.
   struct
       Breakdown {
-    int64_t year;        // year (e.g., 2013)
+    int64_t year;        // year (e.g., 2013) 
     int month;           // month of year [1:12]
     int day;             // day of month [1:31]
     int hour;            // hour of day [0:23]
@@ -1071,13 +1071,13 @@ class TimeZone {
 // Loads the named zone. May perform I/O on the initial load of the named
 // zone. If the name is invalid, or some other kind of error occurs, returns
 // `false` and `*tz` is set to the UTC time zone.
-inline bool LoadTimeZone(y_absl::string_view name, TimeZone* tz) {
+inline bool LoadTimeZone(y_absl::string_view name, TimeZone* tz) { 
   if (name == "localtime") {
     *tz = TimeZone(time_internal::cctz::local_time_zone());
     return true;
   }
   time_internal::cctz::time_zone cz;
-  const bool b = time_internal::cctz::load_time_zone(TString(name), &cz);
+  const bool b = time_internal::cctz::load_time_zone(TString(name), &cz); 
   *tz = TimeZone(cz);
   return b;
 }
@@ -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 `y_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 `y_absl::TimeZone::At(y_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 `y_absl::TimeZone::At(y_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()
@@ -1257,15 +1257,15 @@ struct tm ToTM(Time t, TimeZone tz);
 // time with UTC offset.  Also note the use of "%Y": RFC3339 mandates that
 // years have exactly four digits, but we allow them to take their natural
 // width.
-ABSL_DLL extern const char RFC3339_full[];  // %Y-%m-%d%ET%H:%M:%E*S%Ez
-ABSL_DLL extern const char RFC3339_sec[];   // %Y-%m-%d%ET%H:%M:%S%Ez
+ABSL_DLL extern const char RFC3339_full[];  // %Y-%m-%d%ET%H:%M:%E*S%Ez 
+ABSL_DLL extern const char RFC3339_sec[];   // %Y-%m-%d%ET%H:%M:%S%Ez 
 
 // RFC1123_full
 // RFC1123_no_wday
 //
 // FormatTime()/ParseTime() format specifiers for RFC1123 date/time strings.
-ABSL_DLL extern const char RFC1123_full[];     // %a, %d %b %E4Y %H:%M:%S %z
-ABSL_DLL extern const char RFC1123_no_wday[];  // %d %b %E4Y %H:%M:%S %z
+ABSL_DLL extern const char RFC1123_full[];     // %a, %d %b %E4Y %H:%M:%S %z 
+ABSL_DLL extern const char RFC1123_no_wday[];  // %d %b %E4Y %H:%M:%S %z 
 
 // FormatTime()
 //
@@ -1280,7 +1280,7 @@ ABSL_DLL extern const char RFC1123_no_wday[];  // %d %b %E4Y %H:%M:%S %z
 //   - %E#f - Fractional seconds with # digits of precision
 //   - %E*f - Fractional seconds with full precision (a literal '*')
 //   - %E4Y - Four-character years (-999 ... -001, 0000, 0001 ... 9999)
-//   - %ET  - The RFC3339 "date-time" separator "T"
+//   - %ET  - The RFC3339 "date-time" separator "T" 
 //
 // Note that %E0S behaves like %S, and %E0f produces no characters.  In
 // contrast %E*f always produces at least one digit, which may be '0'.
@@ -1304,7 +1304,7 @@ ABSL_DLL extern const char RFC1123_no_wday[];  // %d %b %E4Y %H:%M:%S %z
 // `y_absl::InfinitePast()`, the returned string will be exactly "infinite-past".
 // In both cases the given format string and `y_absl::TimeZone` are ignored.
 //
-TString FormatTime(y_absl::string_view format, Time t, TimeZone tz);
+TString FormatTime(y_absl::string_view format, Time t, TimeZone tz); 
 
 // Convenience functions that format the given time using the RFC3339_full
 // format.  The first overload uses the provided TimeZone, while the second
@@ -1323,8 +1323,8 @@ inline std::ostream& operator<<(std::ostream& os, Time t) {
 // returns the corresponding `y_absl::Time`. Uses strftime()-like formatting
 // options, with the same extensions as FormatTime(), but with the
 // exceptions that %E#S is interpreted as %E*S, and %E#f as %E*f.  %Ez
-// and %E*z also accept the same inputs, which (along with %z) includes
-// 'z' and 'Z' as synonyms for +00:00.  %ET accepts either 'T' or 't'.
+// and %E*z also accept the same inputs, which (along with %z) includes 
+// 'z' and 'Z' as synonyms for +00:00.  %ET accepts either 'T' or 't'. 
 //
 // %Y consumes as many numeric characters as it can, so the matching data
 // should always be terminated with a non-numeric.  %E4Y always consumes
@@ -1366,7 +1366,7 @@ inline std::ostream& operator<<(std::ostream& os, Time t) {
 // If the input string is "infinite-past", the returned `y_absl::Time` will be
 // `y_absl::InfinitePast()` and `true` will be returned.
 //
-bool ParseTime(y_absl::string_view format, y_absl::string_view input, Time* time,
+bool ParseTime(y_absl::string_view format, y_absl::string_view input, Time* time, 
                TString* err);
 
 // Like ParseTime() above, but if the format string does not contain a UTC
@@ -1376,7 +1376,7 @@ bool ParseTime(y_absl::string_view format, y_absl::string_view input, Time* time
 // of ambiguity or non-existence, in which case the "pre" time (as defined
 // by TimeZone::TimeInfo) is returned.  For these reasons we recommend that
 // all date/time strings include a UTC offset so they're context independent.
-bool ParseTime(y_absl::string_view format, y_absl::string_view input, TimeZone tz,
+bool ParseTime(y_absl::string_view format, y_absl::string_view input, TimeZone tz, 
                Time* time, TString* err);
 
 // ============================================================================
@@ -1401,7 +1401,7 @@ constexpr Duration MakeDuration(int64_t hi, int64_t lo) {
 // it's positive and can be converted to int64_t without risk of UB.
 inline Duration MakePosDoubleDuration(double n) {
   const int64_t int_secs = static_cast<int64_t>(n);
-  const uint32_t ticks = static_cast<uint32_t>(
+  const uint32_t ticks = static_cast<uint32_t>( 
       std::round((n - static_cast<double>(int_secs)) * kTicksPerSecond));
   return ticks < kTicksPerSecond
              ? MakeDuration(int_secs, ticks)
@@ -1529,10 +1529,10 @@ T ToChronoDuration(Duration d) {
 constexpr bool operator<(Duration lhs, Duration rhs) {
   return time_internal::GetRepHi(lhs) != time_internal::GetRepHi(rhs)
              ? time_internal::GetRepHi(lhs) < time_internal::GetRepHi(rhs)
-         : time_internal::GetRepHi(lhs) == (std::numeric_limits<int64_t>::min)()
-             ? time_internal::GetRepLo(lhs) + 1 <
-                   time_internal::GetRepLo(rhs) + 1
-             : time_internal::GetRepLo(lhs) < time_internal::GetRepLo(rhs);
+         : time_internal::GetRepHi(lhs) == (std::numeric_limits<int64_t>::min)() 
+             ? time_internal::GetRepLo(lhs) + 1 < 
+                   time_internal::GetRepLo(rhs) + 1 
+             : time_internal::GetRepLo(lhs) < time_internal::GetRepLo(rhs); 
 }
 
 constexpr bool operator==(Duration lhs, Duration rhs) {
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/time_zone/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/time/time_zone/ya.make
index d7e1dc0c26..ea9d25cd34 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/time_zone/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/time_zone/ya.make
@@ -2,13 +2,13 @@
 
 LIBRARY()
 
-WITHOUT_LICENSE_TEXTS()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
+WITHOUT_LICENSE_TEXTS() 
 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
 LICENSE(Apache-2.0)
 
 ADDINCL(
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/time/ya.make
index 37cc779265..c511d7a8f0 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/ya.make
@@ -2,18 +2,18 @@
 
 LIBRARY()
 
-OWNER(
-    somov
-    g:cpp-contrib
-)
-
-LICENSE(
-    Apache-2.0 AND
-    Public-Domain
-)
-
-LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
-
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+
+LICENSE( 
+    Apache-2.0 AND 
+    Public-Domain 
+) 
+
+LICENSE_TEXTS(.yandex_meta/licenses.list.txt) 
+ 
 PEERDIR(
     contrib/restricted/abseil-cpp-tstring/y_absl/base
     contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/.yandex_meta/licenses.list.txt b/contrib/restricted/abseil-cpp-tstring/y_absl/types/.yandex_meta/licenses.list.txt
index 2ff2fa2fd3..2030853dc3 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/.yandex_meta/licenses.list.txt
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/.yandex_meta/licenses.list.txt
@@ -1,20 +1,20 @@
-====================Apache-2.0====================
-// 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====================
-// Copyright 2017 The Abseil Authors.
-
-
-====================COPYRIGHT====================
-// Copyright 2018 The Abseil Authors.
+====================Apache-2.0==================== 
+// 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==================== 
+// Copyright 2017 The Abseil Authors. 
+ 
+ 
+====================COPYRIGHT==================== 
+// Copyright 2018 The Abseil Authors. 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/any.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/any.h
index f03d940ed9..c41ae61849 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/any.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/any.h
@@ -47,9 +47,9 @@
 // this abstraction, make sure that you should not instead be rewriting your
 // code to be more specific.
 //
-// Abseil has also released an `y_absl::variant` type (a C++11 compatible version
-// of the C++17 `std::variant`), which is generally preferred for use over
-// `y_absl::any`.
+// Abseil has also released an `y_absl::variant` type (a C++11 compatible version 
+// of the C++17 `std::variant`), which is generally preferred for use over 
+// `y_absl::any`. 
 #ifndef ABSL_TYPES_ANY_H_
 #define ABSL_TYPES_ANY_H_
 
@@ -80,7 +80,7 @@ ABSL_NAMESPACE_END
 #include <typeinfo>
 #include <utility>
 
-#include "y_absl/base/internal/fast_type_id.h"
+#include "y_absl/base/internal/fast_type_id.h" 
 #include "y_absl/base/macros.h"
 #include "y_absl/meta/type_traits.h"
 #include "y_absl/types/bad_any_cast.h"
@@ -404,11 +404,11 @@ class any {
     using NormalizedType =
         typename std::remove_cv<typename std::remove_reference<T>::type>::type;
 
-    return base_internal::FastTypeId<NormalizedType>();
+    return base_internal::FastTypeId<NormalizedType>(); 
   }
 
   const void* GetObjTypeId() const {
-    return obj_ ? obj_->ObjTypeId() : base_internal::FastTypeId<void>();
+    return obj_ ? obj_->ObjTypeId() : base_internal::FastTypeId<void>(); 
   }
 
   // `y_absl::any` nonmember functions //
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_any_cast/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_any_cast/ya.make
index a008127937..094adc4ba4 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_any_cast/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_any_cast/ya.make
@@ -2,13 +2,13 @@
 
 LIBRARY()
 
-WITHOUT_LICENSE_TEXTS()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
+WITHOUT_LICENSE_TEXTS() 
 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
 LICENSE(Apache-2.0)
 
 PEERDIR(
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access/ya.make
index fca9a916ac..fbea4ac0b7 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access/ya.make
@@ -2,13 +2,13 @@
 
 LIBRARY()
 
-WITHOUT_LICENSE_TEXTS()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
+WITHOUT_LICENSE_TEXTS() 
 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
 LICENSE(Apache-2.0)
 
 PEERDIR(
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_variant_access/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_variant_access/ya.make
index a80f8ed987..50d9185e83 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_variant_access/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_variant_access/ya.make
@@ -2,13 +2,13 @@
 
 LIBRARY()
 
-WITHOUT_LICENSE_TEXTS()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
+WITHOUT_LICENSE_TEXTS() 
 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
 LICENSE(Apache-2.0)
 
 PEERDIR(
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/compare.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/compare.h
index 4c8cf2f59f..04f0e99967 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/compare.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/compare.h
@@ -86,8 +86,8 @@ enum class ncmp : value_type { unordered = -127 };
 // incomplete types so they need to be defined after the types are complete.
 #ifdef __cpp_inline_variables
 
-// A no-op expansion that can be followed by a semicolon at class level.
-#define ABSL_COMPARE_INLINE_BASECLASS_DECL(name) static_assert(true, "")
+// A no-op expansion that can be followed by a semicolon at class level. 
+#define ABSL_COMPARE_INLINE_BASECLASS_DECL(name) static_assert(true, "") 
 
 #define ABSL_COMPARE_INLINE_SUBCLASS_DECL(type, name) \
   static const type name
@@ -100,8 +100,8 @@ enum class ncmp : value_type { unordered = -127 };
 #define ABSL_COMPARE_INLINE_BASECLASS_DECL(name) \
   ABSL_CONST_INIT static const T name
 
-// A no-op expansion that can be followed by a semicolon at class level.
-#define ABSL_COMPARE_INLINE_SUBCLASS_DECL(type, name) static_assert(true, "")
+// A no-op expansion that can be followed by a semicolon at class level. 
+#define ABSL_COMPARE_INLINE_SUBCLASS_DECL(type, name) static_assert(true, "") 
 
 #define ABSL_COMPARE_INLINE_INIT(type, name, init) \
   template <typename T>                            \
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_profile.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_profile.h
index b19165a4b9..d725f31733 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_profile.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_profile.h
@@ -36,19 +36,19 @@
 #ifndef ABSL_TYPES_INTERNAL_CONFORMANCE_PROFILE_H_
 #define ABSL_TYPES_INTERNAL_CONFORMANCE_PROFILE_H_
 
-#include <set>
+#include <set> 
 #include <type_traits>
 #include <utility>
-#include <vector>
+#include <vector> 
 
-#include "gtest/gtest.h"
-#include "y_absl/algorithm/container.h"
+#include "gtest/gtest.h" 
+#include "y_absl/algorithm/container.h" 
 #include "y_absl/meta/type_traits.h"
-#include "y_absl/strings/ascii.h"
-#include "y_absl/strings/str_cat.h"
-#include "y_absl/strings/string_view.h"
-#include "y_absl/types/internal/conformance_testing_helpers.h"
-#include "y_absl/utility/utility.h"
+#include "y_absl/strings/ascii.h" 
+#include "y_absl/strings/str_cat.h" 
+#include "y_absl/strings/string_view.h" 
+#include "y_absl/types/internal/conformance_testing_helpers.h" 
+#include "y_absl/utility/utility.h" 
 
 // TODO(calabrese) Add support for extending profiles.
 
@@ -56,187 +56,187 @@ namespace y_absl {
 ABSL_NAMESPACE_BEGIN
 namespace types_internal {
 
-// Converts an enum to its underlying integral value.
-template <typename Enum>
-constexpr y_absl::underlying_type_t<Enum> UnderlyingValue(Enum value) {
-  return static_cast<y_absl::underlying_type_t<Enum>>(value);
-}
-
-// A tag type used in place of a matcher when checking that an assertion result
-// does not actually contain any errors.
-struct NoError {};
-
-// -----------------------------------------------------------------------------
-// ConformanceErrors
-// -----------------------------------------------------------------------------
-class ConformanceErrors {
- public:
-  // Setup the error reporting mechanism by seeding it with the name of the type
-  // that is being tested.
-  explicit ConformanceErrors(TString type_name)
-      : assertion_result_(false), type_name_(std::move(type_name)) {
-    assertion_result_ << "\n\n"
-                         "Assuming the following type alias:\n"
-                         "\n"
-                         "  using _T = "
-                      << type_name_ << ";\n\n";
-    outputDivider();
-  }
-
-  // Adds the test name to the list of successfully run tests iff it was not
-  // previously reported as failing. This behavior is useful for tests that
-  // have multiple parts, where failures and successes are reported individually
-  // with the same test name.
-  void addTestSuccess(y_absl::string_view test_name) {
-    auto normalized_test_name = y_absl::AsciiStrToLower(test_name);
-
-    // If the test is already reported as failing, do not add it to the list of
-    // successes.
-    if (test_failures_.find(normalized_test_name) == test_failures_.end()) {
-      test_successes_.insert(std::move(normalized_test_name));
-    }
-  }
-
-  // Streams a single error description into the internal buffer (a visual
-  // divider is automatically inserted after the error so that multiple errors
-  // are visibly distinct).
-  //
-  // This function increases the error count by 1.
-  //
-  // TODO(calabrese) Determine desired behavior when if this function throws.
-  template <class... P>
-  void addTestFailure(y_absl::string_view test_name, const P&... args) {
-    // Output a message related to the test failure.
-    assertion_result_ << "\n\n"
-                         "Failed test: "
-                      << test_name << "\n\n";
-    addTestFailureImpl(args...);
-    assertion_result_ << "\n\n";
-    outputDivider();
-
-    auto normalized_test_name = y_absl::AsciiStrToLower(test_name);
-
-    // If previous parts of this test succeeded, remove it from that set.
-    test_successes_.erase(normalized_test_name);
-
-    // Add the test name to the list of failed tests.
-    test_failures_.insert(std::move(normalized_test_name));
-
-    has_error_ = true;
-  }
-
-  // Convert this object into a testing::AssertionResult instance such that it
-  // can be used with gtest.
-  ::testing::AssertionResult assertionResult() const {
-    return has_error_ ? assertion_result_ : ::testing::AssertionSuccess();
-  }
-
-  // Convert this object into a testing::AssertionResult instance such that it
-  // can be used with gtest. This overload expects errors, using the specified
-  // matcher.
-  ::testing::AssertionResult expectFailedTests(
-      const std::set<TString>& test_names) const {
-    // Since we are expecting nonconformance, output an error message when the
-    // type actually conformed to the specified profile.
-    if (!has_error_) {
-      return ::testing::AssertionFailure()
-             << "Unexpected conformance of type:\n"
-                "    "
-             << type_name_ << "\n\n";
-    }
-
-    // Get a list of all expected failures that did not actually fail
-    // (or that were not run).
-    std::vector<TString> nonfailing_tests;
-    y_absl::c_set_difference(test_names, test_failures_,
-                           std::back_inserter(nonfailing_tests));
-
-    // Get a list of all "expected failures" that were never actually run.
-    std::vector<TString> unrun_tests;
-    y_absl::c_set_difference(nonfailing_tests, test_successes_,
-                           std::back_inserter(unrun_tests));
-
-    // Report when the user specified tests that were not run.
-    if (!unrun_tests.empty()) {
-      const bool tests_were_run =
-          !(test_failures_.empty() && test_successes_.empty());
-
-      // Prepare an assertion result used in the case that tests pass that were
-      // expected to fail.
-      ::testing::AssertionResult result = ::testing::AssertionFailure();
-      result << "When testing type:\n    " << type_name_
-             << "\n\nThe following tests were expected to fail but were not "
-                "run";
-
-      if (tests_were_run) result << " (was the test name spelled correctly?)";
-
-      result << ":\n\n";
-
-      // List all of the tests that unexpectedly passed.
-      for (const auto& test_name : unrun_tests) {
-        result << "    " << test_name << "\n";
-      }
-
-      if (!tests_were_run) result << "\nNo tests were run.";
-
-      if (!test_failures_.empty()) {
-        // List test failures
-        result << "\nThe tests that were run and failed are:\n\n";
-        for (const auto& test_name : test_failures_) {
-          result << "    " << test_name << "\n";
-        }
-      }
-
-      if (!test_successes_.empty()) {
-        // List test successes
-        result << "\nThe tests that were run and succeeded are:\n\n";
-        for (const auto& test_name : test_successes_) {
-          result << "    " << test_name << "\n";
-        }
-      }
-
-      return result;
-    }
-
-    // If some tests passed when they were expected to fail, alert the caller.
-    if (nonfailing_tests.empty()) return ::testing::AssertionSuccess();
-
-    // Prepare an assertion result used in the case that tests pass that were
-    // expected to fail.
-    ::testing::AssertionResult unexpected_successes =
-        ::testing::AssertionFailure();
-    unexpected_successes << "When testing type:\n    " << type_name_
-                         << "\n\nThe following tests passed when they were "
-                            "expected to fail:\n\n";
-
-    // List all of the tests that unexpectedly passed.
-    for (const auto& test_name : nonfailing_tests) {
-      unexpected_successes << "    " << test_name << "\n";
-    }
-
-    return unexpected_successes;
-  }
-
- private:
-  void outputDivider() {
-    assertion_result_ << "========================================";
-  }
-
-  void addTestFailureImpl() {}
-
-  template <class H, class... T>
-  void addTestFailureImpl(const H& head, const T&... tail) {
-    assertion_result_ << head;
-    addTestFailureImpl(tail...);
-  }
-
-  ::testing::AssertionResult assertion_result_;
-  std::set<TString> test_failures_;
-  std::set<TString> test_successes_;
-  TString type_name_;
-  bool has_error_ = false;
-};
-
+// Converts an enum to its underlying integral value. 
+template <typename Enum> 
+constexpr y_absl::underlying_type_t<Enum> UnderlyingValue(Enum value) { 
+  return static_cast<y_absl::underlying_type_t<Enum>>(value); 
+} 
+ 
+// A tag type used in place of a matcher when checking that an assertion result 
+// does not actually contain any errors. 
+struct NoError {}; 
+ 
+// ----------------------------------------------------------------------------- 
+// ConformanceErrors 
+// ----------------------------------------------------------------------------- 
+class ConformanceErrors { 
+ public: 
+  // Setup the error reporting mechanism by seeding it with the name of the type 
+  // that is being tested. 
+  explicit ConformanceErrors(TString type_name) 
+      : assertion_result_(false), type_name_(std::move(type_name)) { 
+    assertion_result_ << "\n\n" 
+                         "Assuming the following type alias:\n" 
+                         "\n" 
+                         "  using _T = " 
+                      << type_name_ << ";\n\n"; 
+    outputDivider(); 
+  } 
+ 
+  // Adds the test name to the list of successfully run tests iff it was not 
+  // previously reported as failing. This behavior is useful for tests that 
+  // have multiple parts, where failures and successes are reported individually 
+  // with the same test name. 
+  void addTestSuccess(y_absl::string_view test_name) { 
+    auto normalized_test_name = y_absl::AsciiStrToLower(test_name); 
+ 
+    // If the test is already reported as failing, do not add it to the list of 
+    // successes. 
+    if (test_failures_.find(normalized_test_name) == test_failures_.end()) { 
+      test_successes_.insert(std::move(normalized_test_name)); 
+    } 
+  } 
+ 
+  // Streams a single error description into the internal buffer (a visual 
+  // divider is automatically inserted after the error so that multiple errors 
+  // are visibly distinct). 
+  // 
+  // This function increases the error count by 1. 
+  // 
+  // TODO(calabrese) Determine desired behavior when if this function throws. 
+  template <class... P> 
+  void addTestFailure(y_absl::string_view test_name, const P&... args) { 
+    // Output a message related to the test failure. 
+    assertion_result_ << "\n\n" 
+                         "Failed test: " 
+                      << test_name << "\n\n"; 
+    addTestFailureImpl(args...); 
+    assertion_result_ << "\n\n"; 
+    outputDivider(); 
+ 
+    auto normalized_test_name = y_absl::AsciiStrToLower(test_name); 
+ 
+    // If previous parts of this test succeeded, remove it from that set. 
+    test_successes_.erase(normalized_test_name); 
+ 
+    // Add the test name to the list of failed tests. 
+    test_failures_.insert(std::move(normalized_test_name)); 
+ 
+    has_error_ = true; 
+  } 
+ 
+  // Convert this object into a testing::AssertionResult instance such that it 
+  // can be used with gtest. 
+  ::testing::AssertionResult assertionResult() const { 
+    return has_error_ ? assertion_result_ : ::testing::AssertionSuccess(); 
+  } 
+ 
+  // Convert this object into a testing::AssertionResult instance such that it 
+  // can be used with gtest. This overload expects errors, using the specified 
+  // matcher. 
+  ::testing::AssertionResult expectFailedTests( 
+      const std::set<TString>& test_names) const { 
+    // Since we are expecting nonconformance, output an error message when the 
+    // type actually conformed to the specified profile. 
+    if (!has_error_) { 
+      return ::testing::AssertionFailure() 
+             << "Unexpected conformance of type:\n" 
+                "    " 
+             << type_name_ << "\n\n"; 
+    } 
+ 
+    // Get a list of all expected failures that did not actually fail 
+    // (or that were not run). 
+    std::vector<TString> nonfailing_tests; 
+    y_absl::c_set_difference(test_names, test_failures_, 
+                           std::back_inserter(nonfailing_tests)); 
+ 
+    // Get a list of all "expected failures" that were never actually run. 
+    std::vector<TString> unrun_tests; 
+    y_absl::c_set_difference(nonfailing_tests, test_successes_, 
+                           std::back_inserter(unrun_tests)); 
+ 
+    // Report when the user specified tests that were not run. 
+    if (!unrun_tests.empty()) { 
+      const bool tests_were_run = 
+          !(test_failures_.empty() && test_successes_.empty()); 
+ 
+      // Prepare an assertion result used in the case that tests pass that were 
+      // expected to fail. 
+      ::testing::AssertionResult result = ::testing::AssertionFailure(); 
+      result << "When testing type:\n    " << type_name_ 
+             << "\n\nThe following tests were expected to fail but were not " 
+                "run"; 
+ 
+      if (tests_were_run) result << " (was the test name spelled correctly?)"; 
+ 
+      result << ":\n\n"; 
+ 
+      // List all of the tests that unexpectedly passed. 
+      for (const auto& test_name : unrun_tests) { 
+        result << "    " << test_name << "\n"; 
+      } 
+ 
+      if (!tests_were_run) result << "\nNo tests were run."; 
+ 
+      if (!test_failures_.empty()) { 
+        // List test failures 
+        result << "\nThe tests that were run and failed are:\n\n"; 
+        for (const auto& test_name : test_failures_) { 
+          result << "    " << test_name << "\n"; 
+        } 
+      } 
+ 
+      if (!test_successes_.empty()) { 
+        // List test successes 
+        result << "\nThe tests that were run and succeeded are:\n\n"; 
+        for (const auto& test_name : test_successes_) { 
+          result << "    " << test_name << "\n"; 
+        } 
+      } 
+ 
+      return result; 
+    } 
+ 
+    // If some tests passed when they were expected to fail, alert the caller. 
+    if (nonfailing_tests.empty()) return ::testing::AssertionSuccess(); 
+ 
+    // Prepare an assertion result used in the case that tests pass that were 
+    // expected to fail. 
+    ::testing::AssertionResult unexpected_successes = 
+        ::testing::AssertionFailure(); 
+    unexpected_successes << "When testing type:\n    " << type_name_ 
+                         << "\n\nThe following tests passed when they were " 
+                            "expected to fail:\n\n"; 
+ 
+    // List all of the tests that unexpectedly passed. 
+    for (const auto& test_name : nonfailing_tests) { 
+      unexpected_successes << "    " << test_name << "\n"; 
+    } 
+ 
+    return unexpected_successes; 
+  } 
+ 
+ private: 
+  void outputDivider() { 
+    assertion_result_ << "========================================"; 
+  } 
+ 
+  void addTestFailureImpl() {} 
+ 
+  template <class H, class... T> 
+  void addTestFailureImpl(const H& head, const T&... tail) { 
+    assertion_result_ << head; 
+    addTestFailureImpl(tail...); 
+  } 
+ 
+  ::testing::AssertionResult assertion_result_; 
+  std::set<TString> test_failures_; 
+  std::set<TString> test_successes_; 
+  TString type_name_; 
+  bool has_error_ = false; 
+}; 
+ 
 template <class T, class /*Enabler*/ = void>
 struct PropertiesOfImpl {};
 
@@ -260,100 +260,100 @@ using PropertiesOfT = typename PropertiesOf<T>::type;
 // standard trait names, which is useful since it allows us to match up each
 // enum name with a corresponding trait name in macro definitions.
 
-// An enum that describes the various expectations on an operations existence.
-enum class function_support { maybe, yes, nothrow, trivial };
-
-constexpr const char* PessimisticPropertyDescription(function_support v) {
-  return v == function_support::maybe
-             ? "no"
-             : v == function_support::yes
-                   ? "yes, potentially throwing"
-                   : v == function_support::nothrow ? "yes, nothrow"
-                                                    : "yes, trivial";
-}
-
-// Return a string that describes the kind of property support that was
-// expected.
-inline TString ExpectedFunctionKindList(function_support min,
-                                            function_support max) {
-  if (min == max) {
-    TString result =
-        y_absl::StrCat("Expected:\n  ",
-                     PessimisticPropertyDescription(
-                         static_cast<function_support>(UnderlyingValue(min))),
-                     "\n");
-    return result;
-  }
-
-  TString result = "Expected one of:\n";
-  for (auto curr_support = UnderlyingValue(min);
-       curr_support <= UnderlyingValue(max); ++curr_support) {
-    y_absl::StrAppend(&result, "  ",
-                    PessimisticPropertyDescription(
-                        static_cast<function_support>(curr_support)),
-                    "\n");
-  }
-
-  return result;
-}
-
-template <class Enum>
-void ExpectModelOfImpl(ConformanceErrors* errors, Enum min_support,
-                       Enum max_support, Enum kind) {
-  const auto kind_value = UnderlyingValue(kind);
-  const auto min_support_value = UnderlyingValue(min_support);
-  const auto max_support_value = UnderlyingValue(max_support);
-
-  if (!(kind_value >= min_support_value && kind_value <= max_support_value)) {
-    errors->addTestFailure(
-        PropertyName(kind), "**Failed property expectation**\n\n",
-        ExpectedFunctionKindList(
-            static_cast<function_support>(min_support_value),
-            static_cast<function_support>(max_support_value)),
-        '\n', "Actual:\n  ",
-        PessimisticPropertyDescription(
-            static_cast<function_support>(kind_value)));
-  } else {
-    errors->addTestSuccess(PropertyName(kind));
-  }
-}
-
-#define ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM(description, name) \
-  enum class name { maybe, yes, nothrow, trivial };                   \
-                                                                      \
-  constexpr const char* PropertyName(name v) { return description; }  \
-  static_assert(true, "")  // Force a semicolon when using this macro.
-
-ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for default construction",
-                                           default_constructible);
-ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for move construction",
-                                           move_constructible);
-ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for copy construction",
-                                           copy_constructible);
-ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for move assignment",
-                                           move_assignable);
-ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for copy assignment",
-                                           copy_assignable);
-ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for destruction",
-                                           destructible);
-
+// An enum that describes the various expectations on an operations existence. 
+enum class function_support { maybe, yes, nothrow, trivial }; 
+
+constexpr const char* PessimisticPropertyDescription(function_support v) { 
+  return v == function_support::maybe 
+             ? "no" 
+             : v == function_support::yes 
+                   ? "yes, potentially throwing" 
+                   : v == function_support::nothrow ? "yes, nothrow" 
+                                                    : "yes, trivial"; 
+} 
+
+// Return a string that describes the kind of property support that was 
+// expected. 
+inline TString ExpectedFunctionKindList(function_support min, 
+                                            function_support max) { 
+  if (min == max) { 
+    TString result = 
+        y_absl::StrCat("Expected:\n  ", 
+                     PessimisticPropertyDescription( 
+                         static_cast<function_support>(UnderlyingValue(min))), 
+                     "\n"); 
+    return result; 
+  } 
+
+  TString result = "Expected one of:\n"; 
+  for (auto curr_support = UnderlyingValue(min); 
+       curr_support <= UnderlyingValue(max); ++curr_support) { 
+    y_absl::StrAppend(&result, "  ", 
+                    PessimisticPropertyDescription( 
+                        static_cast<function_support>(curr_support)), 
+                    "\n"); 
+  } 
+ 
+  return result; 
+} 
+ 
+template <class Enum> 
+void ExpectModelOfImpl(ConformanceErrors* errors, Enum min_support, 
+                       Enum max_support, Enum kind) { 
+  const auto kind_value = UnderlyingValue(kind); 
+  const auto min_support_value = UnderlyingValue(min_support); 
+  const auto max_support_value = UnderlyingValue(max_support); 
+ 
+  if (!(kind_value >= min_support_value && kind_value <= max_support_value)) { 
+    errors->addTestFailure( 
+        PropertyName(kind), "**Failed property expectation**\n\n", 
+        ExpectedFunctionKindList( 
+            static_cast<function_support>(min_support_value), 
+            static_cast<function_support>(max_support_value)), 
+        '\n', "Actual:\n  ", 
+        PessimisticPropertyDescription( 
+            static_cast<function_support>(kind_value))); 
+  } else { 
+    errors->addTestSuccess(PropertyName(kind)); 
+  } 
+} 
+ 
+#define ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM(description, name) \ 
+  enum class name { maybe, yes, nothrow, trivial };                   \ 
+                                                                      \ 
+  constexpr const char* PropertyName(name v) { return description; }  \ 
+  static_assert(true, "")  // Force a semicolon when using this macro. 
+ 
+ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for default construction", 
+                                           default_constructible); 
+ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for move construction", 
+                                           move_constructible); 
+ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for copy construction", 
+                                           copy_constructible); 
+ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for move assignment", 
+                                           move_assignable); 
+ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for copy assignment", 
+                                           copy_assignable); 
+ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for destruction", 
+                                           destructible); 
+ 
 #undef ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM
 
-#define ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM(description, name)     \
-  enum class name { maybe, yes, nothrow };                           \
-                                                                     \
-  constexpr const char* PropertyName(name v) { return description; } \
-  static_assert(true, "")  // Force a semicolon when using this macro.
+#define ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM(description, name)     \ 
+  enum class name { maybe, yes, nothrow };                           \ 
+                                                                     \ 
+  constexpr const char* PropertyName(name v) { return description; } \ 
+  static_assert(true, "")  // Force a semicolon when using this macro. 
 
-ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for ==", equality_comparable);
-ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for !=", inequality_comparable);
-ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for <", less_than_comparable);
-ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for <=", less_equal_comparable);
-ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for >=",
-                                      greater_equal_comparable);
-ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for >", greater_than_comparable);
+ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for ==", equality_comparable); 
+ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for !=", inequality_comparable); 
+ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for <", less_than_comparable); 
+ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for <=", less_equal_comparable); 
+ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for >=", 
+                                      greater_equal_comparable); 
+ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for >", greater_than_comparable); 
 
-ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for swap", swappable);
+ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for swap", swappable); 
 
 #undef ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM
 
@@ -363,184 +363,184 @@ constexpr const char* PropertyName(hashable v) {
   return "support for std::hash";
 }
 
-template <class T>
-using AlwaysFalse = std::false_type;
-
-#define ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(name, property)   \
-  template <class T>                                                        \
-  constexpr property property##_support_of() {                              \
-    return std::is_##property<T>::value                                     \
-               ? std::is_nothrow_##property<T>::value                       \
-                     ? y_absl::is_trivially_##property<T>::value              \
-                           ? property::trivial                              \
-                           : property::nothrow                              \
-                     : property::yes                                        \
-               : property::maybe;                                           \
-  }                                                                         \
-                                                                            \
-  template <class T, class MinProf, class MaxProf>                          \
-  void ExpectModelOf##name(ConformanceErrors* errors) {                     \
-    (ExpectModelOfImpl)(errors, PropertiesOfT<MinProf>::property##_support, \
-                        PropertiesOfT<MaxProf>::property##_support,         \
-                        property##_support_of<T>());                        \
-  }
-
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(DefaultConstructible,
-                                                  default_constructible);
-
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(MoveConstructible,
-                                                  move_constructible);
-
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(CopyConstructible,
-                                                  copy_constructible);
-
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(MoveAssignable,
-                                                  move_assignable);
-
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(CopyAssignable,
-                                                  copy_assignable);
-
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(Destructible, destructible);
-
-#undef ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER
-
-void BoolFunction(bool) noexcept;
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// A metafunction for checking if an operation exists through SFINAE.
-//
-// `T` is the type to test and Op is an alias containing the expression to test.
-template <class T, template <class...> class Op, class = void>
-struct IsOpableImpl : std::false_type {};
-
-template <class T, template <class...> class Op>
-struct IsOpableImpl<T, Op, y_absl::void_t<Op<T>>> : std::true_type {};
-
-template <template <class...> class Op>
-struct IsOpable {
-  template <class T>
-  using apply = typename IsOpableImpl<T, Op>::type;
-};
-//
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// A metafunction for checking if an operation exists and is also noexcept
-// through SFINAE and the noexcept operator.
-///
-// `T` is the type to test and Op is an alias containing the expression to test.
-template <class T, template <class...> class Op, class = void>
-struct IsNothrowOpableImpl : std::false_type {};
-
-template <class T, template <class...> class Op>
-struct IsNothrowOpableImpl<T, Op, y_absl::enable_if_t<Op<T>::value>>
-    : std::true_type {};
-
-template <template <class...> class Op>
-struct IsNothrowOpable {
-  template <class T>
-  using apply = typename IsNothrowOpableImpl<T, Op>::type;
-};
-//
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// A macro that produces the necessary function for reporting what kind of
-// support a specific comparison operation has and a function for reporting an
-// error if a given type's support for that operation does not meet the expected
-// requirements.
-#define ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(name, property, op)      \
-  template <class T,                                                           \
-            class Result = std::integral_constant<                             \
-                bool, noexcept((BoolFunction)(std::declval<const T&>() op      \
-                                                  std::declval<const T&>()))>> \
-  using name = Result;                                                         \
-                                                                               \
-  template <class T>                                                           \
-  constexpr property property##_support_of() {                                 \
-    return IsOpable<name>::apply<T>::value                                     \
-               ? IsNothrowOpable<name>::apply<T>::value ? property::nothrow    \
-                                                        : property::yes        \
-               : property::maybe;                                              \
-  }                                                                            \
-                                                                               \
-  template <class T, class MinProf, class MaxProf>                             \
-  void ExpectModelOf##name(ConformanceErrors* errors) {                        \
-    (ExpectModelOfImpl)(errors, PropertiesOfT<MinProf>::property##_support,    \
-                        PropertiesOfT<MaxProf>::property##_support,            \
-                        property##_support_of<T>());                           \
-  }
-//
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// Generate the necessary support-checking and error reporting functions for
-// each of the comparison operators.
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(EqualityComparable,
-                                              equality_comparable, ==);
-
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(InequalityComparable,
-                                              inequality_comparable, !=);
-
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(LessThanComparable,
-                                              less_than_comparable, <);
-
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(LessEqualComparable,
-                                              less_equal_comparable, <=);
-
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(GreaterEqualComparable,
-                                              greater_equal_comparable, >=);
-
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(GreaterThanComparable,
-                                              greater_than_comparable, >);
-
-#undef ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON
-//
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// The necessary support-checking and error-reporting functions for swap.
-template <class T>
-constexpr swappable swappable_support_of() {
-  return type_traits_internal::IsSwappable<T>::value
-             ? type_traits_internal::IsNothrowSwappable<T>::value
-                   ? swappable::nothrow
-                   : swappable::yes
-             : swappable::maybe;
-}
-
-template <class T, class MinProf, class MaxProf>
-void ExpectModelOfSwappable(ConformanceErrors* errors) {
-  (ExpectModelOfImpl)(errors, PropertiesOfT<MinProf>::swappable_support,
-                      PropertiesOfT<MaxProf>::swappable_support,
-                      swappable_support_of<T>());
-}
-//
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// The necessary support-checking and error-reporting functions for std::hash.
-template <class T>
-constexpr hashable hashable_support_of() {
-  return type_traits_internal::IsHashable<T>::value ? hashable::yes
-                                                    : hashable::maybe;
-}
-
-template <class T, class MinProf, class MaxProf>
-void ExpectModelOfHashable(ConformanceErrors* errors) {
-  (ExpectModelOfImpl)(errors, PropertiesOfT<MinProf>::hashable_support,
-                      PropertiesOfT<MaxProf>::hashable_support,
-                      hashable_support_of<T>());
-}
-//
-////////////////////////////////////////////////////////////////////////////////
-
+template <class T> 
+using AlwaysFalse = std::false_type; 
+ 
+#define ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(name, property)   \ 
+  template <class T>                                                        \ 
+  constexpr property property##_support_of() {                              \ 
+    return std::is_##property<T>::value                                     \ 
+               ? std::is_nothrow_##property<T>::value                       \ 
+                     ? y_absl::is_trivially_##property<T>::value              \ 
+                           ? property::trivial                              \ 
+                           : property::nothrow                              \ 
+                     : property::yes                                        \ 
+               : property::maybe;                                           \ 
+  }                                                                         \ 
+                                                                            \ 
+  template <class T, class MinProf, class MaxProf>                          \ 
+  void ExpectModelOf##name(ConformanceErrors* errors) {                     \ 
+    (ExpectModelOfImpl)(errors, PropertiesOfT<MinProf>::property##_support, \ 
+                        PropertiesOfT<MaxProf>::property##_support,         \ 
+                        property##_support_of<T>());                        \ 
+  } 
+ 
+ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(DefaultConstructible, 
+                                                  default_constructible); 
+ 
+ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(MoveConstructible, 
+                                                  move_constructible); 
+ 
+ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(CopyConstructible, 
+                                                  copy_constructible); 
+ 
+ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(MoveAssignable, 
+                                                  move_assignable); 
+ 
+ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(CopyAssignable, 
+                                                  copy_assignable); 
+ 
+ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(Destructible, destructible); 
+ 
+#undef ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER 
+ 
+void BoolFunction(bool) noexcept; 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+// 
+// A metafunction for checking if an operation exists through SFINAE. 
+// 
+// `T` is the type to test and Op is an alias containing the expression to test. 
+template <class T, template <class...> class Op, class = void> 
+struct IsOpableImpl : std::false_type {}; 
+ 
+template <class T, template <class...> class Op> 
+struct IsOpableImpl<T, Op, y_absl::void_t<Op<T>>> : std::true_type {}; 
+ 
+template <template <class...> class Op> 
+struct IsOpable { 
+  template <class T> 
+  using apply = typename IsOpableImpl<T, Op>::type; 
+}; 
+// 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+// 
+// A metafunction for checking if an operation exists and is also noexcept 
+// through SFINAE and the noexcept operator. 
+/// 
+// `T` is the type to test and Op is an alias containing the expression to test. 
+template <class T, template <class...> class Op, class = void> 
+struct IsNothrowOpableImpl : std::false_type {}; 
+ 
+template <class T, template <class...> class Op> 
+struct IsNothrowOpableImpl<T, Op, y_absl::enable_if_t<Op<T>::value>> 
+    : std::true_type {}; 
+ 
+template <template <class...> class Op> 
+struct IsNothrowOpable { 
+  template <class T> 
+  using apply = typename IsNothrowOpableImpl<T, Op>::type; 
+}; 
+// 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+// 
+// A macro that produces the necessary function for reporting what kind of 
+// support a specific comparison operation has and a function for reporting an 
+// error if a given type's support for that operation does not meet the expected 
+// requirements. 
+#define ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(name, property, op)      \ 
+  template <class T,                                                           \ 
+            class Result = std::integral_constant<                             \ 
+                bool, noexcept((BoolFunction)(std::declval<const T&>() op      \ 
+                                                  std::declval<const T&>()))>> \ 
+  using name = Result;                                                         \ 
+                                                                               \ 
+  template <class T>                                                           \ 
+  constexpr property property##_support_of() {                                 \ 
+    return IsOpable<name>::apply<T>::value                                     \ 
+               ? IsNothrowOpable<name>::apply<T>::value ? property::nothrow    \ 
+                                                        : property::yes        \ 
+               : property::maybe;                                              \ 
+  }                                                                            \ 
+                                                                               \ 
+  template <class T, class MinProf, class MaxProf>                             \ 
+  void ExpectModelOf##name(ConformanceErrors* errors) {                        \ 
+    (ExpectModelOfImpl)(errors, PropertiesOfT<MinProf>::property##_support,    \ 
+                        PropertiesOfT<MaxProf>::property##_support,            \ 
+                        property##_support_of<T>());                           \ 
+  } 
+// 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+// 
+// Generate the necessary support-checking and error reporting functions for 
+// each of the comparison operators. 
+ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(EqualityComparable, 
+                                              equality_comparable, ==); 
+ 
+ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(InequalityComparable, 
+                                              inequality_comparable, !=); 
+ 
+ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(LessThanComparable, 
+                                              less_than_comparable, <); 
+ 
+ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(LessEqualComparable, 
+                                              less_equal_comparable, <=); 
+ 
+ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(GreaterEqualComparable, 
+                                              greater_equal_comparable, >=); 
+ 
+ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(GreaterThanComparable, 
+                                              greater_than_comparable, >); 
+ 
+#undef ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON 
+// 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+// 
+// The necessary support-checking and error-reporting functions for swap. 
+template <class T> 
+constexpr swappable swappable_support_of() { 
+  return type_traits_internal::IsSwappable<T>::value 
+             ? type_traits_internal::IsNothrowSwappable<T>::value 
+                   ? swappable::nothrow 
+                   : swappable::yes 
+             : swappable::maybe; 
+} 
+ 
+template <class T, class MinProf, class MaxProf> 
+void ExpectModelOfSwappable(ConformanceErrors* errors) { 
+  (ExpectModelOfImpl)(errors, PropertiesOfT<MinProf>::swappable_support, 
+                      PropertiesOfT<MaxProf>::swappable_support, 
+                      swappable_support_of<T>()); 
+} 
+// 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+// 
+// The necessary support-checking and error-reporting functions for std::hash. 
+template <class T> 
+constexpr hashable hashable_support_of() { 
+  return type_traits_internal::IsHashable<T>::value ? hashable::yes 
+                                                    : hashable::maybe; 
+} 
+ 
+template <class T, class MinProf, class MaxProf> 
+void ExpectModelOfHashable(ConformanceErrors* errors) { 
+  (ExpectModelOfImpl)(errors, PropertiesOfT<MinProf>::hashable_support, 
+                      PropertiesOfT<MaxProf>::hashable_support, 
+                      hashable_support_of<T>()); 
+} 
+// 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
 template <
     default_constructible DefaultConstructibleValue =
         default_constructible::maybe,
@@ -653,45 +653,45 @@ struct ConformanceProfile {
       HashableValue != hashable::maybe;
 };
 
-////////////////////////////////////////////////////////////////////////////////
-//
-// Compliant SFINAE-friendliness is not always present on the standard library
-// implementations that we support. This helper-struct (and associated enum) is
-// used as a means to conditionally check the hashability support of a type.
-enum class CheckHashability { no, yes };
-
-template <class T, CheckHashability ShouldCheckHashability>
-struct conservative_hashable_support_of;
-
-template <class T>
-struct conservative_hashable_support_of<T, CheckHashability::no> {
-  static constexpr hashable Invoke() { return hashable::maybe; }
-};
-
-template <class T>
-struct conservative_hashable_support_of<T, CheckHashability::yes> {
-  static constexpr hashable Invoke() { return hashable_support_of<T>(); }
-};
-//
-////////////////////////////////////////////////////////////////////////////////
-
-// The ConformanceProfile that is expected based on introspection into the type
-// by way of trait checks.
-template <class T, CheckHashability ShouldCheckHashability>
-struct SyntacticConformanceProfileOf {
-  using properties = ConformanceProfile<
-      default_constructible_support_of<T>(), move_constructible_support_of<T>(),
-      copy_constructible_support_of<T>(), move_assignable_support_of<T>(),
-      copy_assignable_support_of<T>(), destructible_support_of<T>(),
-      equality_comparable_support_of<T>(),
-      inequality_comparable_support_of<T>(),
-      less_than_comparable_support_of<T>(),
-      less_equal_comparable_support_of<T>(),
-      greater_equal_comparable_support_of<T>(),
-      greater_than_comparable_support_of<T>(), swappable_support_of<T>(),
-      conservative_hashable_support_of<T, ShouldCheckHashability>::Invoke()>;
-};
-
+//////////////////////////////////////////////////////////////////////////////// 
+// 
+// Compliant SFINAE-friendliness is not always present on the standard library 
+// implementations that we support. This helper-struct (and associated enum) is 
+// used as a means to conditionally check the hashability support of a type. 
+enum class CheckHashability { no, yes }; 
+ 
+template <class T, CheckHashability ShouldCheckHashability> 
+struct conservative_hashable_support_of; 
+ 
+template <class T> 
+struct conservative_hashable_support_of<T, CheckHashability::no> { 
+  static constexpr hashable Invoke() { return hashable::maybe; } 
+}; 
+ 
+template <class T> 
+struct conservative_hashable_support_of<T, CheckHashability::yes> { 
+  static constexpr hashable Invoke() { return hashable_support_of<T>(); } 
+}; 
+// 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+// The ConformanceProfile that is expected based on introspection into the type 
+// by way of trait checks. 
+template <class T, CheckHashability ShouldCheckHashability> 
+struct SyntacticConformanceProfileOf { 
+  using properties = ConformanceProfile< 
+      default_constructible_support_of<T>(), move_constructible_support_of<T>(), 
+      copy_constructible_support_of<T>(), move_assignable_support_of<T>(), 
+      copy_assignable_support_of<T>(), destructible_support_of<T>(), 
+      equality_comparable_support_of<T>(), 
+      inequality_comparable_support_of<T>(), 
+      less_than_comparable_support_of<T>(), 
+      less_equal_comparable_support_of<T>(), 
+      greater_equal_comparable_support_of<T>(), 
+      greater_than_comparable_support_of<T>(), swappable_support_of<T>(), 
+      conservative_hashable_support_of<T, ShouldCheckHashability>::Invoke()>; 
+}; 
+ 
 #define ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF_IMPL(type, name)     \
   template <default_constructible DefaultConstructibleValue,                   \
             move_constructible MoveConstructibleValue,                         \
@@ -737,80 +737,80 @@ ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(hashable);
 #undef ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF
 #undef ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF_IMPL
 
-// Retrieve the enum with the minimum underlying value.
-// Note: std::min is not constexpr in C++11, which is why this is necessary.
-template <class H>
-constexpr H MinEnum(H head) {
-  return head;
-}
-
-template <class H, class N, class... T>
-constexpr H MinEnum(H head, N next, T... tail) {
-  return (UnderlyingValue)(head) < (UnderlyingValue)(next)
-             ? (MinEnum)(head, tail...)
-             : (MinEnum)(next, tail...);
+// Retrieve the enum with the minimum underlying value. 
+// Note: std::min is not constexpr in C++11, which is why this is necessary. 
+template <class H> 
+constexpr H MinEnum(H head) { 
+  return head; 
 }
 
-template <class... Profs>
-struct MinimalProfiles {
-  static constexpr default_constructible
-      default_constructible_support =  // NOLINT
-      (MinEnum)(PropertiesOfT<Profs>::default_constructible_support...);
-
-  static constexpr move_constructible move_constructible_support =  // NOLINT
-      (MinEnum)(PropertiesOfT<Profs>::move_constructible_support...);
-
-  static constexpr copy_constructible copy_constructible_support =  // NOLINT
-      (MinEnum)(PropertiesOfT<Profs>::copy_constructible_support...);
-
-  static constexpr move_assignable move_assignable_support =  // NOLINT
-      (MinEnum)(PropertiesOfT<Profs>::move_assignable_support...);
-
-  static constexpr copy_assignable copy_assignable_support =  // NOLINT
-      (MinEnum)(PropertiesOfT<Profs>::copy_assignable_support...);
-
-  static constexpr destructible destructible_support =  // NOLINT
-      (MinEnum)(PropertiesOfT<Profs>::destructible_support...);
-
-  static constexpr equality_comparable equality_comparable_support =  // NOLINT
-      (MinEnum)(PropertiesOfT<Profs>::equality_comparable_support...);
-
-  static constexpr inequality_comparable
-      inequality_comparable_support =  // NOLINT
-      (MinEnum)(PropertiesOfT<Profs>::inequality_comparable_support...);
-
-  static constexpr less_than_comparable
-      less_than_comparable_support =  // NOLINT
-      (MinEnum)(PropertiesOfT<Profs>::less_than_comparable_support...);
-
-  static constexpr less_equal_comparable
-      less_equal_comparable_support =  // NOLINT
-      (MinEnum)(PropertiesOfT<Profs>::less_equal_comparable_support...);
-
-  static constexpr greater_equal_comparable
-      greater_equal_comparable_support =  // NOLINT
-      (MinEnum)(PropertiesOfT<Profs>::greater_equal_comparable_support...);
-
-  static constexpr greater_than_comparable
-      greater_than_comparable_support =  // NOLINT
-      (MinEnum)(PropertiesOfT<Profs>::greater_than_comparable_support...);
-
-  static constexpr swappable swappable_support =  // NOLINT
-      (MinEnum)(PropertiesOfT<Profs>::swappable_support...);
-
-  static constexpr hashable hashable_support =  // NOLINT
-      (MinEnum)(PropertiesOfT<Profs>::hashable_support...);
-
-  using properties = ConformanceProfile<
-      default_constructible_support, move_constructible_support,
-      copy_constructible_support, move_assignable_support,
-      copy_assignable_support, destructible_support,
-      equality_comparable_support, inequality_comparable_support,
-      less_than_comparable_support, less_equal_comparable_support,
-      greater_equal_comparable_support, greater_than_comparable_support,
-      swappable_support, hashable_support>;
-};
-
+template <class H, class N, class... T> 
+constexpr H MinEnum(H head, N next, T... tail) { 
+  return (UnderlyingValue)(head) < (UnderlyingValue)(next) 
+             ? (MinEnum)(head, tail...) 
+             : (MinEnum)(next, tail...); 
+} 
+ 
+template <class... Profs> 
+struct MinimalProfiles { 
+  static constexpr default_constructible 
+      default_constructible_support =  // NOLINT 
+      (MinEnum)(PropertiesOfT<Profs>::default_constructible_support...); 
+ 
+  static constexpr move_constructible move_constructible_support =  // NOLINT 
+      (MinEnum)(PropertiesOfT<Profs>::move_constructible_support...); 
+ 
+  static constexpr copy_constructible copy_constructible_support =  // NOLINT 
+      (MinEnum)(PropertiesOfT<Profs>::copy_constructible_support...); 
+ 
+  static constexpr move_assignable move_assignable_support =  // NOLINT 
+      (MinEnum)(PropertiesOfT<Profs>::move_assignable_support...); 
+ 
+  static constexpr copy_assignable copy_assignable_support =  // NOLINT 
+      (MinEnum)(PropertiesOfT<Profs>::copy_assignable_support...); 
+ 
+  static constexpr destructible destructible_support =  // NOLINT 
+      (MinEnum)(PropertiesOfT<Profs>::destructible_support...); 
+ 
+  static constexpr equality_comparable equality_comparable_support =  // NOLINT 
+      (MinEnum)(PropertiesOfT<Profs>::equality_comparable_support...); 
+ 
+  static constexpr inequality_comparable 
+      inequality_comparable_support =  // NOLINT 
+      (MinEnum)(PropertiesOfT<Profs>::inequality_comparable_support...); 
+ 
+  static constexpr less_than_comparable 
+      less_than_comparable_support =  // NOLINT 
+      (MinEnum)(PropertiesOfT<Profs>::less_than_comparable_support...); 
+ 
+  static constexpr less_equal_comparable 
+      less_equal_comparable_support =  // NOLINT 
+      (MinEnum)(PropertiesOfT<Profs>::less_equal_comparable_support...); 
+ 
+  static constexpr greater_equal_comparable 
+      greater_equal_comparable_support =  // NOLINT 
+      (MinEnum)(PropertiesOfT<Profs>::greater_equal_comparable_support...); 
+ 
+  static constexpr greater_than_comparable 
+      greater_than_comparable_support =  // NOLINT 
+      (MinEnum)(PropertiesOfT<Profs>::greater_than_comparable_support...); 
+ 
+  static constexpr swappable swappable_support =  // NOLINT 
+      (MinEnum)(PropertiesOfT<Profs>::swappable_support...); 
+ 
+  static constexpr hashable hashable_support =  // NOLINT 
+      (MinEnum)(PropertiesOfT<Profs>::hashable_support...); 
+ 
+  using properties = ConformanceProfile< 
+      default_constructible_support, move_constructible_support, 
+      copy_constructible_support, move_assignable_support, 
+      copy_assignable_support, destructible_support, 
+      equality_comparable_support, inequality_comparable_support, 
+      less_than_comparable_support, less_equal_comparable_support, 
+      greater_equal_comparable_support, greater_than_comparable_support, 
+      swappable_support, hashable_support>; 
+}; 
+ 
 // Retrieve the enum with the greatest underlying value.
 // Note: std::max is not constexpr in C++11, which is why this is necessary.
 template <class H>
@@ -913,17 +913,17 @@ struct IsProfileImpl<T, y_absl::void_t<PropertiesOfT<T>>> : std::true_type {};
 template <class T>
 struct IsProfile : IsProfileImpl<T>::type {};
 
-// A tag that describes which set of properties we will check when the user
-// requires a strict match in conformance (as opposed to a loose match which
-// allows more-refined support of any given operation).
-//
-// Currently only the RegularityDomain exists and it includes all operations
-// that the conformance testing suite knows about. The intent is that if the
-// suite is expanded to support extension, such as for checking conformance of
-// concepts like Iterators or Containers, additional corresponding domains can
-// be created.
-struct RegularityDomain {};
-
+// A tag that describes which set of properties we will check when the user 
+// requires a strict match in conformance (as opposed to a loose match which 
+// allows more-refined support of any given operation). 
+// 
+// Currently only the RegularityDomain exists and it includes all operations 
+// that the conformance testing suite knows about. The intent is that if the 
+// suite is expanded to support extension, such as for checking conformance of 
+// concepts like Iterators or Containers, additional corresponding domains can 
+// be created. 
+struct RegularityDomain {}; 
+ 
 }  // namespace types_internal
 ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_testing.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_testing.h
index 799ba18e46..661347579f 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_testing.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_testing.h
@@ -1,1386 +1,1386 @@
-// Copyright 2019 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.
-//
-// -----------------------------------------------------------------------------
-// conformance_testing.h
-// -----------------------------------------------------------------------------
-//
-
-#ifndef ABSL_TYPES_INTERNAL_CONFORMANCE_TESTING_H_
-#define ABSL_TYPES_INTERNAL_CONFORMANCE_TESTING_H_
-
-////////////////////////////////////////////////////////////////////////////////
-//                                                                            //
-// Many templates in this file take a `T` and a `Prof` type as explicit       //
-// template arguments. These are a type to be checked and a                   //
-// "Regularity Profile" that describes what operations that type `T` is       //
-// expected to support. See "regularity_profiles.h" for more details          //
-// regarding Regularity Profiles.                                             //
-//                                                                            //
-////////////////////////////////////////////////////////////////////////////////
-
-#include <cstddef>
-#include <set>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-
-#include "gtest/gtest.h"
-#include "y_absl/meta/type_traits.h"
-#include "y_absl/strings/ascii.h"
-#include "y_absl/strings/str_cat.h"
-#include "y_absl/strings/string_view.h"
-#include "y_absl/types/internal/conformance_aliases.h"
-#include "y_absl/types/internal/conformance_archetype.h"
-#include "y_absl/types/internal/conformance_profile.h"
-#include "y_absl/types/internal/conformance_testing_helpers.h"
-#include "y_absl/types/internal/parentheses.h"
-#include "y_absl/types/internal/transform_args.h"
-#include "y_absl/utility/utility.h"
-
-namespace y_absl {
-ABSL_NAMESPACE_BEGIN
-namespace types_internal {
-
-// Returns true if the compiler incorrectly greedily instantiates constexpr
-// templates in any unevaluated context.
-constexpr bool constexpr_instantiation_when_unevaluated() {
-#if defined(__apple_build_version__)  // TODO(calabrese) Make more specific
-  return true;
-#elif defined(__clang__)
-  return __clang_major__ < 4;
-#elif defined(__GNUC__)
-  // TODO(calabrese) Figure out why gcc 7 fails (seems like a different bug)
-  return __GNUC__ < 5 || (__GNUC__ == 5 && __GNUC_MINOR__ < 2) || __GNUC__ >= 7;
-#else
-  return false;
-#endif
-}
-
-// Returns true if the standard library being used incorrectly produces an error
-// when instantiating the definition of a poisoned std::hash specialization.
-constexpr bool poisoned_hash_fails_instantiation() {
-#if defined(_MSC_VER) && !defined(_LIBCPP_VERSION)
-  return _MSC_VER < 1914;
-#else
-  return false;
-#endif
-}
-
-template <class Fun>
-struct GeneratorType {
-  decltype(std::declval<const Fun&>()()) operator()() const
-      noexcept(noexcept(std::declval<const Fun&>()())) {
-    return fun();
-  }
-
-  Fun fun;
-  const char* description;
-};
-
-// A "make" function for the GeneratorType template that deduces the function
-// object type.
-template <class Fun,
-          y_absl::enable_if_t<IsNullaryCallable<Fun>::value>** = nullptr>
-GeneratorType<Fun> Generator(Fun fun, const char* description) {
-  return GeneratorType<Fun>{y_absl::move(fun), description};
-}
-
-// A type that contains a set of nullary function objects that each return an
-// instance of the same type and value (though possibly different
-// representations, such as +0 and -0 or two vectors with the same elements but
-// with different capacities).
-template <class... Funs>
-struct EquivalenceClassType {
-  std::tuple<GeneratorType<Funs>...> generators;
-};
-
-// A "make" function for the EquivalenceClassType template that deduces the
-// function object types and is constrained such that a user can only pass in
-// function objects that all have the same return type.
-template <class... Funs, y_absl::enable_if_t<AreGeneratorsWithTheSameReturnType<
-                             Funs...>::value>** = nullptr>
-EquivalenceClassType<Funs...> EquivalenceClass(GeneratorType<Funs>... funs) {
-  return {std::make_tuple(y_absl::move(funs)...)};
-}
-
-// A type that contains an ordered series of EquivalenceClassTypes, from
-// smallest value to largest value.
-template <class... EqClasses>
-struct OrderedEquivalenceClasses {
-  std::tuple<EqClasses...> eq_classes;
-};
-
-// An object containing the parts of a given (name, initialization expression),
-// and is capable of generating a string that describes the given.
-struct GivenDeclaration {
-  TString outputDeclaration(std::size_t width) const {
-    const std::size_t indent_size = 2;
-    TString result = y_absl::StrCat("  ", name);
-
-    if (!expression.empty()) {
-      // Indent
-      result.resize(indent_size + width, ' ');
-      y_absl::StrAppend(&result, " = ", expression, ";\n");
-    } else {
-      y_absl::StrAppend(&result, ";\n");
-    }
-
-    return result;
-  }
-
-  TString name;
-  TString expression;
-};
-
-// Produce a string that contains all of the givens of an error report.
-template <class... Decls>
-TString PrepareGivenContext(const Decls&... decls) {
-  const std::size_t width = (std::max)({decls.name.size()...});
-  return y_absl::StrCat("Given:\n", decls.outputDeclaration(width)..., "\n");
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Function objects that perform a check for each comparison operator         //
-////////////////////////////////////////////////////////////////////////////////
-
-#define ABSL_INTERNAL_EXPECT_OP(name, op)                                   \
-  struct Expect##name {                                                     \
-    template <class T>                                                      \
-    void operator()(y_absl::string_view test_name, y_absl::string_view context, \
-                    const T& lhs, const T& rhs, y_absl::string_view lhs_name, \
-                    y_absl::string_view rhs_name) const {                     \
-      if (!static_cast<bool>(lhs op rhs)) {                                 \
-        errors->addTestFailure(                                             \
-            test_name, y_absl::StrCat(context,                                \
-                                    "**Unexpected comparison result**\n"    \
-                                    "\n"                                    \
-                                    "Expression:\n"                         \
-                                    "  ",                                   \
-                                    lhs_name, " " #op " ", rhs_name,        \
-                                    "\n"                                    \
-                                    "\n"                                    \
-                                    "Expected: true\n"                      \
-                                    "  Actual: false"));                    \
-      } else {                                                              \
-        errors->addTestSuccess(test_name);                                  \
-      }                                                                     \
-    }                                                                       \
-                                                                            \
-    ConformanceErrors* errors;                                              \
-  };                                                                        \
-                                                                            \
-  struct ExpectNot##name {                                                  \
-    template <class T>                                                      \
-    void operator()(y_absl::string_view test_name, y_absl::string_view context, \
-                    const T& lhs, const T& rhs, y_absl::string_view lhs_name, \
-                    y_absl::string_view rhs_name) const {                     \
-      if (lhs op rhs) {                                                     \
-        errors->addTestFailure(                                             \
-            test_name, y_absl::StrCat(context,                                \
-                                    "**Unexpected comparison result**\n"    \
-                                    "\n"                                    \
-                                    "Expression:\n"                         \
-                                    "  ",                                   \
-                                    lhs_name, " " #op " ", rhs_name,        \
-                                    "\n"                                    \
-                                    "\n"                                    \
-                                    "Expected: false\n"                     \
-                                    "  Actual: true"));                     \
-      } else {                                                              \
-        errors->addTestSuccess(test_name);                                  \
-      }                                                                     \
-    }                                                                       \
-                                                                            \
-    ConformanceErrors* errors;                                              \
-  }
-
-ABSL_INTERNAL_EXPECT_OP(Eq, ==);
-ABSL_INTERNAL_EXPECT_OP(Ne, !=);
-ABSL_INTERNAL_EXPECT_OP(Lt, <);
-ABSL_INTERNAL_EXPECT_OP(Le, <=);
-ABSL_INTERNAL_EXPECT_OP(Ge, >=);
-ABSL_INTERNAL_EXPECT_OP(Gt, >);
-
-#undef ABSL_INTERNAL_EXPECT_OP
-
-// A function object that verifies that two objects hash to the same value by
-// way of the std::hash specialization.
-struct ExpectSameHash {
-  template <class T>
-  void operator()(y_absl::string_view test_name, y_absl::string_view context,
-                  const T& lhs, const T& rhs, y_absl::string_view lhs_name,
-                  y_absl::string_view rhs_name) const {
-    if (std::hash<T>()(lhs) != std::hash<T>()(rhs)) {
-      errors->addTestFailure(
-          test_name, y_absl::StrCat(context,
-                                  "**Unexpected hash result**\n"
-                                  "\n"
-                                  "Expression:\n"
-                                  "  std::hash<T>()(",
-                                  lhs_name, ") == std::hash<T>()(", rhs_name,
-                                  ")\n"
-                                  "\n"
-                                  "Expected: true\n"
-                                  "  Actual: false"));
-    } else {
-      errors->addTestSuccess(test_name);
-    }
-  }
-
-  ConformanceErrors* errors;
-};
-
-// A function template that takes two objects and verifies that each comparison
-// operator behaves in a way that is consistent with equality. It has "OneWay"
-// in the name because the first argument will always be the left-hand operand
-// of the corresponding comparison operator and the second argument will
-// always be the right-hand operand. It will never switch that order.
-// At a higher level in the test suite, the one-way form is called once for each
-// of the two possible orders whenever lhs and rhs are not the same initializer.
-template <class T, class Prof>
-void ExpectOneWayEquality(ConformanceErrors* errors,
-                          y_absl::string_view test_name,
-                          y_absl::string_view context, const T& lhs, const T& rhs,
-                          y_absl::string_view lhs_name,
-                          y_absl::string_view rhs_name) {
-  If<PropertiesOfT<Prof>::is_equality_comparable>::Invoke(
-      ExpectEq{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name);
-
-  If<PropertiesOfT<Prof>::is_inequality_comparable>::Invoke(
-      ExpectNotNe{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name);
-
-  If<PropertiesOfT<Prof>::is_less_than_comparable>::Invoke(
-      ExpectNotLt{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name);
-
-  If<PropertiesOfT<Prof>::is_less_equal_comparable>::Invoke(
-      ExpectLe{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name);
-
-  If<PropertiesOfT<Prof>::is_greater_equal_comparable>::Invoke(
-      ExpectGe{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name);
-
-  If<PropertiesOfT<Prof>::is_greater_than_comparable>::Invoke(
-      ExpectNotGt{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name);
-
-  If<PropertiesOfT<Prof>::is_hashable>::Invoke(
-      ExpectSameHash{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name);
-}
-
-// A function template that takes two objects and verifies that each comparison
-// operator behaves in a way that is consistent with equality. This function
-// differs from ExpectOneWayEquality in that this will do checks with argument
-// order reversed in addition to in-order.
-template <class T, class Prof>
-void ExpectEquality(ConformanceErrors* errors, y_absl::string_view test_name,
-                    y_absl::string_view context, const T& lhs, const T& rhs,
-                    y_absl::string_view lhs_name, y_absl::string_view rhs_name) {
-  (ExpectOneWayEquality<T, Prof>)(errors, test_name, context, lhs, rhs,
-                                  lhs_name, rhs_name);
-  (ExpectOneWayEquality<T, Prof>)(errors, test_name, context, rhs, lhs,
-                                  rhs_name, lhs_name);
-}
-
-// Given a generator, makes sure that a generated value and a moved-from
-// generated value are equal.
-template <class T, class Prof>
-struct ExpectMoveConstructOneGenerator {
-  template <class Fun>
-  void operator()(const Fun& generator) const {
-    const T object = generator();
-    const T moved_object = y_absl::move(generator());  // Force no elision.
-
-    (ExpectEquality<T, Prof>)(errors, "Move construction",
-                              PrepareGivenContext(
-                                  GivenDeclaration{"const _T object",
-                                                   generator.description},
-                                  GivenDeclaration{"const _T moved_object",
-                                                   TString("std::move(") +
-                                                       generator.description +
-                                                       ")"}),
-                              object, moved_object, "object", "moved_object");
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Given a generator, makes sure that a generated value and a copied-from
-// generated value are equal.
-template <class T, class Prof>
-struct ExpectCopyConstructOneGenerator {
-  template <class Fun>
-  void operator()(const Fun& generator) const {
-    const T object = generator();
-    const T copied_object = static_cast<const T&>(generator());
-
-    (ExpectEquality<T, Prof>)(errors, "Copy construction",
-                              PrepareGivenContext(
-                                  GivenDeclaration{"const _T object",
-                                                   generator.description},
-                                  GivenDeclaration{
-                                      "const _T copied_object",
-                                      TString("static_cast<const _T&>(") +
-                                          generator.description + ")"}),
-                              object, copied_object, "object", "copied_object");
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Default-construct and do nothing before destruction.
-//
-// This is useful in exercising the codepath of default construction followed by
-// destruction, but does not explicitly test anything. An example of where this
-// might fail is a default destructor that default-initializes a scalar and a
-// destructor reads the value of that member. Sanitizers can catch this as long
-// as our test attempts to execute such a case.
-template <class T>
-struct ExpectDefaultConstructWithDestruct {
-  void operator()() const {
-    // Scoped so that destructor gets called before reporting success.
-    {
-      T object;
-      static_cast<void>(object);
-    }
-
-    errors->addTestSuccess("Default construction");
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Check move-assign into a default-constructed object.
-template <class T, class Prof>
-struct ExpectDefaultConstructWithMoveAssign {
-  template <class Fun>
-  void operator()(const Fun& generator) const {
-    const T source_of_truth = generator();
-    T object;
-    object = generator();
-
-    (ExpectEquality<T, Prof>)(errors, "Move assignment",
-                              PrepareGivenContext(
-                                  GivenDeclaration{"const _T object",
-                                                   generator.description},
-                                  GivenDeclaration{"_T object", ""},
-                                  GivenDeclaration{"object",
-                                                   generator.description}),
-                              object, source_of_truth, "std::as_const(object)",
-                              "source_of_truth");
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Check copy-assign into a default-constructed object.
-template <class T, class Prof>
-struct ExpectDefaultConstructWithCopyAssign {
-  template <class Fun>
-  void operator()(const Fun& generator) const {
-    const T source_of_truth = generator();
-    T object;
-    object = static_cast<const T&>(generator());
-
-    (ExpectEquality<T, Prof>)(errors, "Copy assignment",
-                              PrepareGivenContext(
-                                  GivenDeclaration{"const _T source_of_truth",
-                                                   generator.description},
-                                  GivenDeclaration{"_T object", ""},
-                                  GivenDeclaration{
-                                      "object",
-                                      TString("static_cast<const _T&>(") +
-                                          generator.description + ")"}),
-                              object, source_of_truth, "std::as_const(object)",
-                              "source_of_truth");
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Perform a self move-assign.
-template <class T, class Prof>
-struct ExpectSelfMoveAssign {
-  template <class Fun>
-  void operator()(const Fun& generator) const {
-    T object = generator();
-    object = y_absl::move(object);
-
-    // NOTE: Self move-assign results in a valid-but-unspecified state.
-
-    (ExpectEquality<T, Prof>)(errors, "Move assignment",
-                              PrepareGivenContext(
-                                  GivenDeclaration{"_T object",
-                                                   generator.description},
-                                  GivenDeclaration{"object",
-                                                   "std::move(object)"}),
-                              object, object, "object", "object");
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Perform a self copy-assign.
-template <class T, class Prof>
-struct ExpectSelfCopyAssign {
-  template <class Fun>
-  void operator()(const Fun& generator) const {
-    const T source_of_truth = generator();
-    T object = generator();
-    const T& const_object = object;
-    object = const_object;
-
-    (ExpectEquality<T, Prof>)(errors, "Copy assignment",
-                              PrepareGivenContext(
-                                  GivenDeclaration{"const _T source_of_truth",
-                                                   generator.description},
-                                  GivenDeclaration{"_T object",
-                                                   generator.description},
-                                  GivenDeclaration{"object",
-                                                   "std::as_const(object)"}),
-                              const_object, source_of_truth,
-                              "std::as_const(object)", "source_of_truth");
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Perform a self-swap.
-template <class T, class Prof>
-struct ExpectSelfSwap {
-  template <class Fun>
-  void operator()(const Fun& generator) const {
-    const T source_of_truth = generator();
-    T object = generator();
-
-    type_traits_internal::Swap(object, object);
-
-    TString preliminary_info = y_absl::StrCat(
-        PrepareGivenContext(
-            GivenDeclaration{"const _T source_of_truth", generator.description},
-            GivenDeclaration{"_T object", generator.description}),
-        "After performing a self-swap:\n"
-        "  using std::swap;\n"
-        "  swap(object, object);\n"
-        "\n");
-
-    (ExpectEquality<T, Prof>)(errors, "Swap", std::move(preliminary_info),
-                              object, source_of_truth, "std::as_const(object)",
-                              "source_of_truth");
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Perform each of the single-generator checks when necessary operations are
-// supported.
-template <class T, class Prof>
-struct ExpectSelfComparison {
-  template <class Fun>
-  void operator()(const Fun& generator) const {
-    const T object = generator();
-    (ExpectOneWayEquality<T, Prof>)(errors, "Comparison",
-                                    PrepareGivenContext(GivenDeclaration{
-                                        "const _T object",
-                                        generator.description}),
-                                    object, object, "object", "object");
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Perform each of the single-generator checks when necessary operations are
-// supported.
-template <class T, class Prof>
-struct ExpectConsistency {
-  template <class Fun>
-  void operator()(const Fun& generator) const {
-    If<PropertiesOfT<Prof>::is_move_constructible>::Invoke(
-        ExpectMoveConstructOneGenerator<T, Prof>{errors}, generator);
-
-    If<PropertiesOfT<Prof>::is_copy_constructible>::Invoke(
-        ExpectCopyConstructOneGenerator<T, Prof>{errors}, generator);
-
-    If<PropertiesOfT<Prof>::is_default_constructible &&
-       PropertiesOfT<Prof>::is_move_assignable>::
-        Invoke(ExpectDefaultConstructWithMoveAssign<T, Prof>{errors},
-               generator);
-
-    If<PropertiesOfT<Prof>::is_default_constructible &&
-       PropertiesOfT<Prof>::is_copy_assignable>::
-        Invoke(ExpectDefaultConstructWithCopyAssign<T, Prof>{errors},
-               generator);
-
-    If<PropertiesOfT<Prof>::is_move_assignable>::Invoke(
-        ExpectSelfMoveAssign<T, Prof>{errors}, generator);
-
-    If<PropertiesOfT<Prof>::is_copy_assignable>::Invoke(
-        ExpectSelfCopyAssign<T, Prof>{errors}, generator);
-
-    If<PropertiesOfT<Prof>::is_swappable>::Invoke(
-        ExpectSelfSwap<T, Prof>{errors}, generator);
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Check move-assign with two different values.
-template <class T, class Prof>
-struct ExpectMoveAssign {
-  template <class Fun0, class Fun1>
-  void operator()(const Fun0& generator0, const Fun1& generator1) const {
-    const T source_of_truth1 = generator1();
-    T object = generator0();
-    object = generator1();
-
-    (ExpectEquality<T, Prof>)(errors, "Move assignment",
-                              PrepareGivenContext(
-                                  GivenDeclaration{"const _T source_of_truth1",
-                                                   generator1.description},
-                                  GivenDeclaration{"_T object",
-                                                   generator0.description},
-                                  GivenDeclaration{"object",
-                                                   generator1.description}),
-                              object, source_of_truth1, "std::as_const(object)",
-                              "source_of_truth1");
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Check copy-assign with two different values.
-template <class T, class Prof>
-struct ExpectCopyAssign {
-  template <class Fun0, class Fun1>
-  void operator()(const Fun0& generator0, const Fun1& generator1) const {
-    const T source_of_truth1 = generator1();
-    T object = generator0();
-    object = static_cast<const T&>(generator1());
-
-    (ExpectEquality<T, Prof>)(errors, "Copy assignment",
-                              PrepareGivenContext(
-                                  GivenDeclaration{"const _T source_of_truth1",
-                                                   generator1.description},
-                                  GivenDeclaration{"_T object",
-                                                   generator0.description},
-                                  GivenDeclaration{
-                                      "object",
-                                      TString("static_cast<const _T&>(") +
-                                          generator1.description + ")"}),
-                              object, source_of_truth1, "std::as_const(object)",
-                              "source_of_truth1");
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Check swap with two different values.
-template <class T, class Prof>
-struct ExpectSwap {
-  template <class Fun0, class Fun1>
-  void operator()(const Fun0& generator0, const Fun1& generator1) const {
-    const T source_of_truth0 = generator0();
-    const T source_of_truth1 = generator1();
-    T object0 = generator0();
-    T object1 = generator1();
-
-    type_traits_internal::Swap(object0, object1);
-
-    const TString context =
-        PrepareGivenContext(
-            GivenDeclaration{"const _T source_of_truth0",
-                             generator0.description},
-            GivenDeclaration{"const _T source_of_truth1",
-                             generator1.description},
-            GivenDeclaration{"_T object0", generator0.description},
-            GivenDeclaration{"_T object1", generator1.description}) +
-        "After performing a swap:\n"
-        "  using std::swap;\n"
-        "  swap(object0, object1);\n"
-        "\n";
-
-    (ExpectEquality<T, Prof>)(errors, "Swap", context, object0,
-                              source_of_truth1, "std::as_const(object0)",
-                              "source_of_truth1");
-    (ExpectEquality<T, Prof>)(errors, "Swap", context, object1,
-                              source_of_truth0, "std::as_const(object1)",
-                              "source_of_truth0");
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Validate that `generator0` and `generator1` produce values that are equal.
-template <class T, class Prof>
-struct ExpectEquivalenceClassComparison {
-  template <class Fun0, class Fun1>
-  void operator()(const Fun0& generator0, const Fun1& generator1) const {
-    const T object0 = generator0();
-    const T object1 = generator1();
-
-    (ExpectEquality<T, Prof>)(errors, "Comparison",
-                              PrepareGivenContext(
-                                  GivenDeclaration{"const _T object0",
-                                                   generator0.description},
-                                  GivenDeclaration{"const _T object1",
-                                                   generator1.description}),
-                              object0, object1, "object0", "object1");
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Validate that all objects in the same equivalence-class have the same value.
-template <class T, class Prof>
-struct ExpectEquivalenceClassConsistency {
-  template <class Fun0, class Fun1>
-  void operator()(const Fun0& generator0, const Fun1& generator1) const {
-    If<PropertiesOfT<Prof>::is_move_assignable>::Invoke(
-        ExpectMoveAssign<T, Prof>{errors}, generator0, generator1);
-
-    If<PropertiesOfT<Prof>::is_copy_assignable>::Invoke(
-        ExpectCopyAssign<T, Prof>{errors}, generator0, generator1);
-
-    If<PropertiesOfT<Prof>::is_swappable>::Invoke(ExpectSwap<T, Prof>{errors},
-                                                  generator0, generator1);
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Given a "lesser" object and a "greater" object, perform every combination of
-// comparison operators supported for the type, expecting consistent results.
-template <class T, class Prof>
-void ExpectOrdered(ConformanceErrors* errors, y_absl::string_view context,
-                   const T& small, const T& big, y_absl::string_view small_name,
-                   y_absl::string_view big_name) {
-  const y_absl::string_view test_name = "Comparison";
-
-  If<PropertiesOfT<Prof>::is_equality_comparable>::Invoke(
-      ExpectNotEq{errors}, test_name, context, small, big, small_name,
-      big_name);
-  If<PropertiesOfT<Prof>::is_equality_comparable>::Invoke(
-      ExpectNotEq{errors}, test_name, context, big, small, big_name,
-      small_name);
-
-  If<PropertiesOfT<Prof>::is_inequality_comparable>::Invoke(
-      ExpectNe{errors}, test_name, context, small, big, small_name, big_name);
-  If<PropertiesOfT<Prof>::is_inequality_comparable>::Invoke(
-      ExpectNe{errors}, test_name, context, big, small, big_name, small_name);
-
-  If<PropertiesOfT<Prof>::is_less_than_comparable>::Invoke(
-      ExpectLt{errors}, test_name, context, small, big, small_name, big_name);
-  If<PropertiesOfT<Prof>::is_less_than_comparable>::Invoke(
-      ExpectNotLt{errors}, test_name, context, big, small, big_name,
-      small_name);
-
-  If<PropertiesOfT<Prof>::is_less_equal_comparable>::Invoke(
-      ExpectLe{errors}, test_name, context, small, big, small_name, big_name);
-  If<PropertiesOfT<Prof>::is_less_equal_comparable>::Invoke(
-      ExpectNotLe{errors}, test_name, context, big, small, big_name,
-      small_name);
-
-  If<PropertiesOfT<Prof>::is_greater_equal_comparable>::Invoke(
-      ExpectNotGe{errors}, test_name, context, small, big, small_name,
-      big_name);
-  If<PropertiesOfT<Prof>::is_greater_equal_comparable>::Invoke(
-      ExpectGe{errors}, test_name, context, big, small, big_name, small_name);
-
-  If<PropertiesOfT<Prof>::is_greater_than_comparable>::Invoke(
-      ExpectNotGt{errors}, test_name, context, small, big, small_name,
-      big_name);
-  If<PropertiesOfT<Prof>::is_greater_than_comparable>::Invoke(
-      ExpectGt{errors}, test_name, context, big, small, big_name, small_name);
-}
-
-// For every two elements of an equivalence class, makes sure that those two
-// elements compare equal, including checks with the same argument passed as
-// both operands.
-template <class T, class Prof>
-struct ExpectEquivalenceClassComparisons {
-  template <class... Funs>
-  void operator()(EquivalenceClassType<Funs...> eq_class) const {
-    (ForEachTupleElement)(ExpectSelfComparison<T, Prof>{errors},
-                          eq_class.generators);
-
-    (ForEveryTwo)(ExpectEquivalenceClassComparison<T, Prof>{errors},
-                  eq_class.generators);
-  }
-
-  ConformanceErrors* errors;
-};
-
-// For every element of an equivalence class, makes sure that the element is
-// self-consistent (in other words, if any of move/copy/swap are defined,
-// perform those operations and make such that results and operands still
-// compare equal to known values whenever it is required for that operation.
-template <class T, class Prof>
-struct ExpectEquivalenceClass {
-  template <class... Funs>
-  void operator()(EquivalenceClassType<Funs...> eq_class) const {
-    (ForEachTupleElement)(ExpectConsistency<T, Prof>{errors},
-                          eq_class.generators);
-
-    (ForEveryTwo)(ExpectEquivalenceClassConsistency<T, Prof>{errors},
-                  eq_class.generators);
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Validate that the passed-in argument is a generator of a greater value than
-// the one produced by the "small_gen" datamember with respect to all of the
-// comparison operators that Prof requires, with both argument orders to test.
-template <class T, class Prof, class SmallGenerator>
-struct ExpectBiggerGeneratorThanComparisons {
-  template <class BigGenerator>
-  void operator()(BigGenerator big_gen) const {
-    const T small = small_gen();
-    const T big = big_gen();
-
-    (ExpectOrdered<T, Prof>)(errors,
-                             PrepareGivenContext(
-                                 GivenDeclaration{"const _T small",
-                                                  small_gen.description},
-                                 GivenDeclaration{"const _T big",
-                                                  big_gen.description}),
-                             small, big, "small", "big");
-  }
-
-  SmallGenerator small_gen;
-  ConformanceErrors* errors;
-};
-
-// Perform all of the move, copy, and swap checks on the value generated by
-// `small_gen` and the value generated by `big_gen`.
-template <class T, class Prof, class SmallGenerator>
-struct ExpectBiggerGeneratorThan {
-  template <class BigGenerator>
-  void operator()(BigGenerator big_gen) const {
-    If<PropertiesOfT<Prof>::is_move_assignable>::Invoke(
-        ExpectMoveAssign<T, Prof>{errors}, small_gen, big_gen);
-    If<PropertiesOfT<Prof>::is_move_assignable>::Invoke(
-        ExpectMoveAssign<T, Prof>{errors}, big_gen, small_gen);
-
-    If<PropertiesOfT<Prof>::is_copy_assignable>::Invoke(
-        ExpectCopyAssign<T, Prof>{errors}, small_gen, big_gen);
-    If<PropertiesOfT<Prof>::is_copy_assignable>::Invoke(
-        ExpectCopyAssign<T, Prof>{errors}, big_gen, small_gen);
-
-    If<PropertiesOfT<Prof>::is_swappable>::Invoke(ExpectSwap<T, Prof>{errors},
-                                                  small_gen, big_gen);
-  }
-
-  SmallGenerator small_gen;
-  ConformanceErrors* errors;
-};
-
-// Validate that the result of a generator is greater than the results of all
-// generators in an equivalence class with respect to comparisons.
-template <class T, class Prof, class SmallGenerator>
-struct ExpectBiggerGeneratorThanEqClassesComparisons {
-  template <class BigEqClass>
-  void operator()(BigEqClass big_eq_class) const {
-    (ForEachTupleElement)(
-        ExpectBiggerGeneratorThanComparisons<T, Prof, SmallGenerator>{small_gen,
-                                                                      errors},
-        big_eq_class.generators);
-  }
-
-  SmallGenerator small_gen;
-  ConformanceErrors* errors;
-};
-
-// Validate that the non-comparison binary operations required by Prof are
-// correct for the result of each generator of big_eq_class and a generator of
-// the logically smaller value returned by small_gen.
-template <class T, class Prof, class SmallGenerator>
-struct ExpectBiggerGeneratorThanEqClasses {
-  template <class BigEqClass>
-  void operator()(BigEqClass big_eq_class) const {
-    (ForEachTupleElement)(
-        ExpectBiggerGeneratorThan<T, Prof, SmallGenerator>{small_gen, errors},
-        big_eq_class.generators);
-  }
-
-  SmallGenerator small_gen;
-  ConformanceErrors* errors;
-};
-
-// Validate that each equivalence class that is passed is logically less than
-// the equivalence classes that comes later on in the argument list.
-template <class T, class Prof>
-struct ExpectOrderedEquivalenceClassesComparisons {
-  template <class... BigEqClasses>
-  struct Impl {
-    // Validate that the value produced by `small_gen` is less than all of the
-    // values generated by those of the logically larger equivalence classes.
-    template <class SmallGenerator>
-    void operator()(SmallGenerator small_gen) const {
-      (ForEachTupleElement)(ExpectBiggerGeneratorThanEqClassesComparisons<
-                                T, Prof, SmallGenerator>{small_gen, errors},
-                            big_eq_classes);
-    }
-
-    std::tuple<BigEqClasses...> big_eq_classes;
-    ConformanceErrors* errors;
-  };
-
-  // When given no equivalence classes, no validation is necessary.
-  void operator()() const {}
-
-  template <class SmallEqClass, class... BigEqClasses>
-  void operator()(SmallEqClass small_eq_class,
-                  BigEqClasses... big_eq_classes) const {
-    // For each generator in the first equivalence class, make sure that it is
-    // less than each of those in the logically greater equivalence classes.
-    (ForEachTupleElement)(
-        Impl<BigEqClasses...>{std::make_tuple(y_absl::move(big_eq_classes)...),
-                              errors},
-        small_eq_class.generators);
-
-    // Recurse so that all equivalence class combinations are checked.
-    (*this)(y_absl::move(big_eq_classes)...);
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Validate that the non-comparison binary operations required by Prof are
-// correct for the result of each generator of big_eq_classes and a generator of
-// the logically smaller value returned by small_gen.
-template <class T, class Prof>
-struct ExpectOrderedEquivalenceClasses {
-  template <class... BigEqClasses>
-  struct Impl {
-    template <class SmallGenerator>
-    void operator()(SmallGenerator small_gen) const {
-      (ForEachTupleElement)(
-          ExpectBiggerGeneratorThanEqClasses<T, Prof, SmallGenerator>{small_gen,
-                                                                      errors},
-          big_eq_classes);
-    }
-
-    std::tuple<BigEqClasses...> big_eq_classes;
-    ConformanceErrors* errors;
-  };
-
-  // Check that small_eq_class is logically consistent and also is logically
-  // less than all values in big_eq_classes.
-  template <class SmallEqClass, class... BigEqClasses>
-  void operator()(SmallEqClass small_eq_class,
-                  BigEqClasses... big_eq_classes) const {
-    (ForEachTupleElement)(
-        Impl<BigEqClasses...>{std::make_tuple(y_absl::move(big_eq_classes)...),
-                              errors},
-        small_eq_class.generators);
-
-    (*this)(y_absl::move(big_eq_classes)...);
-  }
-
-  // Terminating case of operator().
-  void operator()() const {}
-
-  ConformanceErrors* errors;
-};
-
-// Validate that a type meets the syntactic requirements of std::hash if the
-// range of profiles requires it.
-template <class T, class MinProf, class MaxProf>
-struct ExpectHashable {
-  void operator()() const {
-    ExpectModelOfHashable<T, MinProf, MaxProf>(errors);
-  }
-
-  ConformanceErrors* errors;
-};
-
-// Validate that the type `T` meets all of the requirements associated with
-// `MinProf` and without going beyond the syntactic properties of `MaxProf`.
-template <class T, class MinProf, class MaxProf>
-struct ExpectModels {
-  void operator()(ConformanceErrors* errors) const {
-    ExpectModelOfDefaultConstructible<T, MinProf, MaxProf>(errors);
-    ExpectModelOfMoveConstructible<T, MinProf, MaxProf>(errors);
-    ExpectModelOfCopyConstructible<T, MinProf, MaxProf>(errors);
-    ExpectModelOfMoveAssignable<T, MinProf, MaxProf>(errors);
-    ExpectModelOfCopyAssignable<T, MinProf, MaxProf>(errors);
-    ExpectModelOfDestructible<T, MinProf, MaxProf>(errors);
-    ExpectModelOfEqualityComparable<T, MinProf, MaxProf>(errors);
-    ExpectModelOfInequalityComparable<T, MinProf, MaxProf>(errors);
-    ExpectModelOfLessThanComparable<T, MinProf, MaxProf>(errors);
-    ExpectModelOfLessEqualComparable<T, MinProf, MaxProf>(errors);
-    ExpectModelOfGreaterEqualComparable<T, MinProf, MaxProf>(errors);
-    ExpectModelOfGreaterThanComparable<T, MinProf, MaxProf>(errors);
-    ExpectModelOfSwappable<T, MinProf, MaxProf>(errors);
-
-    // Only check hashability on compilers that have a compliant default-hash.
-    If<!poisoned_hash_fails_instantiation()>::Invoke(
-        ExpectHashable<T, MinProf, MaxProf>{errors});
-  }
-};
-
-// A metafunction that yields a Profile matching the set of properties that are
-// safe to be checked (lack-of-hashability is only checked on standard library
-// implementations that are standards compliant in that they provide a std::hash
-// primary template that is SFINAE-friendly)
-template <class LogicalProf, class T>
-struct MinimalCheckableProfile {
-  using type =
-      MinimalProfiles<PropertiesOfT<LogicalProf>,
-                      PropertiesOfT<SyntacticConformanceProfileOf<
-                          T, !PropertiesOfT<LogicalProf>::is_hashable &&
-                                     poisoned_hash_fails_instantiation()
-                                 ? CheckHashability::no
-                                 : CheckHashability::yes>>>;
-};
-
-// An identity metafunction
-template <class T>
-struct Always {
-  using type = T;
-};
-
-// Validate the T meets all of the necessary requirements of LogicalProf, with
-// syntactic requirements defined by the profile range [MinProf, MaxProf].
-template <class T, class LogicalProf, class MinProf, class MaxProf,
-          class... EqClasses>
-ConformanceErrors ExpectRegularityImpl(
-    OrderedEquivalenceClasses<EqClasses...> vals) {
-  ConformanceErrors errors((NameOf<T>()));
-
-  If<!constexpr_instantiation_when_unevaluated()>::Invoke(
-      ExpectModels<T, MinProf, MaxProf>(), &errors);
-
-  using minimal_profile = typename y_absl::conditional_t<
-      constexpr_instantiation_when_unevaluated(), Always<LogicalProf>,
-      MinimalCheckableProfile<LogicalProf, T>>::type;
-
-  If<PropertiesOfT<minimal_profile>::is_default_constructible>::Invoke(
-      ExpectDefaultConstructWithDestruct<T>{&errors});
-
-  //////////////////////////////////////////////////////////////////////////////
-  // Perform all comparison checks first, since later checks depend on their
-  // correctness.
-  //
-  // Check all of the comparisons for all values in the same equivalence
-  // class (equal with respect to comparison operators and hash the same).
-  (ForEachTupleElement)(
-      ExpectEquivalenceClassComparisons<T, minimal_profile>{&errors},
-      vals.eq_classes);
-
-  // Check all of the comparisons for each combination of values that are in
-  // different equivalence classes (not equal with respect to comparison
-  // operators).
-  y_absl::apply(
-      ExpectOrderedEquivalenceClassesComparisons<T, minimal_profile>{&errors},
-      vals.eq_classes);
-  //
-  //////////////////////////////////////////////////////////////////////////////
-
-  // Perform remaining checks, relying on comparisons.
-  // TODO(calabrese) short circuit if any comparisons above failed.
-  (ForEachTupleElement)(ExpectEquivalenceClass<T, minimal_profile>{&errors},
-                        vals.eq_classes);
-
-  y_absl::apply(ExpectOrderedEquivalenceClasses<T, minimal_profile>{&errors},
-              vals.eq_classes);
-
-  return errors;
-}
-
-// A type that represents a range of profiles that are acceptable to be matched.
-//
-// `MinProf` is the minimum set of syntactic requirements that must be met.
-//
-// `MaxProf` is the maximum set of syntactic requirements that must be met.
-// This maximum is particularly useful for certain "strictness" checking. Some
-// examples for when this is useful:
-//
-// * Making sure that a type is move-only (rather than simply movable)
-//
-// * Making sure that a member function is *not* noexcept in cases where it
-//   cannot be noexcept, such as if a dependent datamember has certain
-//   operations that are not noexcept.
-//
-// * Making sure that a type tightly matches a spec, such as the standard.
-//
-// `LogicalProf` is the Profile for which run-time testing is to take place.
-//
-// Note: The reason for `LogicalProf` is because it is often the case, when
-// dealing with templates, that a declaration of a given operation is specified,
-// but whose body would fail to instantiate. Examples include the
-// copy-constructor of a standard container when the element-type is move-only,
-// or the comparison operators of a standard container when the element-type
-// does not have the necessary comparison operations defined. The `LogicalProf`
-// parameter allows us to capture the intent of what should be tested at
-// run-time, even in the cases where syntactically it might otherwise appear as
-// though the type undergoing testing supports more than it actually does.
-template <class LogicalProf, class MinProf = LogicalProf,
-          class MaxProf = MinProf>
-struct ProfileRange {
-  using logical_profile = LogicalProf;
-  using min_profile = MinProf;
-  using max_profile = MaxProf;
-};
-
-// Similar to ProfileRange except that it creates a profile range that is
-// coupled with a Domain and is used when testing that a type matches exactly
-// the "minimum" requirements of LogicalProf.
-template <class StrictnessDomain, class LogicalProf,
-          class MinProf = LogicalProf, class MaxProf = MinProf>
-struct StrictProfileRange {
-  // We do not yet support extension.
-  static_assert(
-      std::is_same<StrictnessDomain, RegularityDomain>::value,
-      "Currently, the only valid StrictnessDomain is RegularityDomain.");
-  using strictness_domain = StrictnessDomain;
-  using logical_profile = LogicalProf;
-  using min_profile = MinProf;
-  using max_profile = MaxProf;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// A metafunction that creates a StrictProfileRange from a Domain and either a
-// Profile or ProfileRange.
-template <class StrictnessDomain, class ProfOrRange>
-struct MakeStrictProfileRange;
-
-template <class StrictnessDomain, class LogicalProf>
-struct MakeStrictProfileRange {
-  using type = StrictProfileRange<StrictnessDomain, LogicalProf>;
-};
-
-template <class StrictnessDomain, class LogicalProf, class MinProf,
-          class MaxProf>
-struct MakeStrictProfileRange<StrictnessDomain,
-                              ProfileRange<LogicalProf, MinProf, MaxProf>> {
-  using type =
-      StrictProfileRange<StrictnessDomain, LogicalProf, MinProf, MaxProf>;
-};
-
-template <class StrictnessDomain, class ProfOrRange>
-using MakeStrictProfileRangeT =
-    typename MakeStrictProfileRange<StrictnessDomain, ProfOrRange>::type;
-//
-////////////////////////////////////////////////////////////////////////////////
-
-// A profile in the RegularityDomain with the strongest possible requirements.
-using MostStrictProfile =
-    CombineProfiles<TriviallyCompleteProfile, NothrowComparableProfile>;
-
-// Forms a ProfileRange that treats the Profile as the bare minimum requirements
-// of a type.
-template <class LogicalProf, class MinProf = LogicalProf>
-using LooseProfileRange = StrictProfileRange<RegularityDomain, LogicalProf,
-                                             MinProf, MostStrictProfile>;
-
-template <class Prof>
-using MakeLooseProfileRangeT = Prof;
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// The following classes implement the metafunction ProfileRangeOfT<T> that
-// takes either a Profile or ProfileRange and yields the ProfileRange to be
-// used during testing.
-//
-template <class T, class /*Enabler*/ = void>
-struct ProfileRangeOfImpl;
-
-template <class T>
-struct ProfileRangeOfImpl<T, y_absl::void_t<PropertiesOfT<T>>> {
-  using type = LooseProfileRange<T>;
-};
-
-template <class T>
-struct ProfileRangeOf : ProfileRangeOfImpl<T> {};
-
-template <class StrictnessDomain, class LogicalProf, class MinProf,
-          class MaxProf>
-struct ProfileRangeOf<
-    StrictProfileRange<StrictnessDomain, LogicalProf, MinProf, MaxProf>> {
-  using type =
-      StrictProfileRange<StrictnessDomain, LogicalProf, MinProf, MaxProf>;
-};
-
-template <class T>
-using ProfileRangeOfT = typename ProfileRangeOf<T>::type;
-//
-////////////////////////////////////////////////////////////////////////////////
-
-// Extract the logical profile of a range (what will be runtime tested).
-template <class T>
-using LogicalProfileOfT = typename ProfileRangeOfT<T>::logical_profile;
-
-// Extract the minimal syntactic profile of a range (error if not at least).
-template <class T>
-using MinProfileOfT = typename ProfileRangeOfT<T>::min_profile;
-
-// Extract the maximum syntactic profile of a range (error if more than).
-template <class T>
-using MaxProfileOfT = typename ProfileRangeOfT<T>::max_profile;
-
-////////////////////////////////////////////////////////////////////////////////
-//
-template <class T>
-struct IsProfileOrProfileRange : IsProfile<T>::type {};
-
-template <class StrictnessDomain, class LogicalProf, class MinProf,
-          class MaxProf>
-struct IsProfileOrProfileRange<
-    StrictProfileRange<StrictnessDomain, LogicalProf, MinProf, MaxProf>>
-    : std::true_type {};
-//
-////////////////////////////////////////////////////////////////////////////////
-
-// TODO(calabrese): Consider naming the functions in this class the same as
-// the macros (defined later on) so that auto-complete leads to the correct name
-// and so that a user cannot accidentally call a function rather than the macro
-// form.
-template <bool ExpectSuccess, class T, class... EqClasses>
-struct ExpectConformanceOf {
-  // Add a value to be tested. Subsequent calls to this function on the same
-  // object must specify logically "larger" values with respect to the
-  // comparison operators of the type, if any.
-  //
-  // NOTE: This function should not be called directly. A stateless lambda is
-  // implicitly formed and passed when using the INITIALIZER macro at the bottom
-  // of this file.
-  template <class Fun,
-            y_absl::enable_if_t<std::is_same<
-                ResultOfGeneratorT<GeneratorType<Fun>>, T>::value>** = nullptr>
-  ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses...,
-                                           EquivalenceClassType<Fun>>
-  initializer(GeneratorType<Fun> fun) && {
-    return {
-        {std::tuple_cat(y_absl::move(ordered_vals.eq_classes),
-                        std::make_tuple((EquivalenceClass)(y_absl::move(fun))))},
-        std::move(expected_failed_tests)};
-  }
-
-  template <class... TestNames,
-            y_absl::enable_if_t<!ExpectSuccess && sizeof...(EqClasses) == 0 &&
-                              y_absl::conjunction<std::is_convertible<
-                                  TestNames, y_absl::string_view>...>::value>** =
-                nullptr>
-  ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses...>
-  due_to(TestNames&&... test_names) && {
-    (InsertEach)(&expected_failed_tests,
-                 y_absl::AsciiStrToLower(y_absl::string_view(test_names))...);
-
-    return {y_absl::move(ordered_vals), std::move(expected_failed_tests)};
-  }
-
-  template <class... TestNames, int = 0,  // MSVC disambiguator
-            y_absl::enable_if_t<ExpectSuccess && sizeof...(EqClasses) == 0 &&
-                              y_absl::conjunction<std::is_convertible<
-                                  TestNames, y_absl::string_view>...>::value>** =
-                nullptr>
-  ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses...>
-  due_to(TestNames&&... test_names) && {
-    // TODO(calabrese) Instead have DUE_TO only exist via a CRTP base.
-    // This would produce better errors messages than the static_assert.
-    static_assert(!ExpectSuccess,
-                  "DUE_TO cannot be called when conformance is expected -- did "
-                  "you mean to use ASSERT_NONCONFORMANCE_OF?");
-  }
-
-  // Add a value to be tested. Subsequent calls to this function on the same
-  // object must specify logically "larger" values with respect to the
-  // comparison operators of the type, if any.
-  //
-  // NOTE: This function should not be called directly. A stateful lambda is
-  // implicitly formed and passed when using the INITIALIZER macro at the bottom
-  // of this file.
-  template <class Fun,
-            y_absl::enable_if_t<std::is_same<
-                ResultOfGeneratorT<GeneratorType<Fun>>, T>::value>** = nullptr>
-  ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses...,
-                                           EquivalenceClassType<Fun>>
-  dont_class_directly_stateful_initializer(GeneratorType<Fun> fun) && {
-    return {
-        {std::tuple_cat(y_absl::move(ordered_vals.eq_classes),
-                        std::make_tuple((EquivalenceClass)(y_absl::move(fun))))},
-        std::move(expected_failed_tests)};
-  }
-
-  // Add a set of value to be tested, where each value is equal with respect to
-  // the comparison operators and std::hash specialization, if defined.
-  template <
-      class... Funs,
-      y_absl::void_t<y_absl::enable_if_t<std::is_same<
-          ResultOfGeneratorT<GeneratorType<Funs>>, T>::value>...>** = nullptr>
-  ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses...,
-                                           EquivalenceClassType<Funs...>>
-  equivalence_class(GeneratorType<Funs>... funs) && {
-    return {{std::tuple_cat(
-                y_absl::move(ordered_vals.eq_classes),
-                std::make_tuple((EquivalenceClass)(y_absl::move(funs)...)))},
-            std::move(expected_failed_tests)};
-  }
-
-  // Execute the tests for the captured set of values, strictly matching a range
-  // of expected profiles in a given domain.
-  template <
-      class ProfRange,
-      y_absl::enable_if_t<IsProfileOrProfileRange<ProfRange>::value>** = nullptr>
-  ABSL_MUST_USE_RESULT ::testing::AssertionResult with_strict_profile(
-      ProfRange /*profile*/) {
-    ConformanceErrors test_result =
-        (ExpectRegularityImpl<
-            T, LogicalProfileOfT<ProfRange>, MinProfileOfT<ProfRange>,
-            MaxProfileOfT<ProfRange>>)(y_absl::move(ordered_vals));
-
-    return ExpectSuccess ? test_result.assertionResult()
-                         : test_result.expectFailedTests(expected_failed_tests);
-  }
-
-  // Execute the tests for the captured set of values, loosely matching a range
-  // of expected profiles (loose in that an interface is allowed to be more
-  // refined that a profile suggests, such as a type having a noexcept copy
-  // constructor when all that is required is that the copy constructor exists).
-  template <class Prof, y_absl::enable_if_t<IsProfile<Prof>::value>** = nullptr>
-  ABSL_MUST_USE_RESULT ::testing::AssertionResult with_loose_profile(
-      Prof /*profile*/) {
-    ConformanceErrors test_result =
-        (ExpectRegularityImpl<
-            T, Prof, Prof,
-            CombineProfiles<TriviallyCompleteProfile,
-                            NothrowComparableProfile>>)(y_absl::
-                                                            move(ordered_vals));
-
-    return ExpectSuccess ? test_result.assertionResult()
-                         : test_result.expectFailedTests(expected_failed_tests);
-  }
-
-  OrderedEquivalenceClasses<EqClasses...> ordered_vals;
-  std::set<TString> expected_failed_tests;
-};
-
-template <class T>
-using ExpectConformanceOfType = ExpectConformanceOf</*ExpectSuccess=*/true, T>;
-
-template <class T>
-using ExpectNonconformanceOfType =
-    ExpectConformanceOf</*ExpectSuccess=*/false, T>;
-
-struct EquivalenceClassMaker {
-  // TODO(calabrese) Constrain to callable
-  template <class Fun>
-  static GeneratorType<Fun> initializer(GeneratorType<Fun> fun) {
-    return fun;
-  }
-};
-
-// A top-level macro that begins the builder pattern.
-//
-// The argument here takes the datatype to be tested.
-#define ABSL_INTERNAL_ASSERT_CONFORMANCE_OF(...)                            \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                             \
-  if ABSL_INTERNAL_LPAREN                                                   \
-  const ::testing::AssertionResult gtest_ar =                               \
-      ABSL_INTERNAL_LPAREN ::y_absl::types_internal::ExpectConformanceOfType< \
-          __VA_ARGS__>()
-
-// Akin to ASSERT_CONFORMANCE_OF except that it expects failure and tries to
-// match text.
-#define ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(...)                            \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                                \
-  if ABSL_INTERNAL_LPAREN                                                      \
-  const ::testing::AssertionResult gtest_ar =                                  \
-      ABSL_INTERNAL_LPAREN ::y_absl::types_internal::ExpectNonconformanceOfType< \
-          __VA_ARGS__>()
-
-////////////////////////////////////////////////////////////////////////////////
-// NOTE: The following macros look like they are recursive, but are not (macros
-// cannot recurse). These actually refer to member functions of the same name.
-// This is done intentionally so that a user cannot accidentally invoke a
-// member function of the conformance-testing suite without going through the
-// macro.
-////////////////////////////////////////////////////////////////////////////////
-
-// Specify expected test failures as comma-separated strings.
-#define DUE_TO(...) due_to(__VA_ARGS__)
-
-// Specify a value to be tested.
-//
-// Note: Internally, this takes an expression and turns it into the return value
-// of lambda that captures no data. The expression is stringized during
-// preprocessing so that it can be used in error reports.
-#define INITIALIZER(...)                         \
-  initializer(::y_absl::types_internal::Generator( \
-      [] { return __VA_ARGS__; }, ABSL_INTERNAL_STRINGIZE(__VA_ARGS__)))
-
-// Specify a value to be tested.
-//
-// Note: Internally, this takes an expression and turns it into the return value
-// of lambda that captures data by reference. The expression is stringized
-// during preprocessing so that it can be used in error reports.
-#define STATEFUL_INITIALIZER(...)                         \
-  stateful_initializer(::y_absl::types_internal::Generator( \
-      [&] { return __VA_ARGS__; }, ABSL_INTERNAL_STRINGIZE(__VA_ARGS__)))
-
-// Used in the builder-pattern.
-//
-// Takes a series of INITIALIZER and/or STATEFUL_INITIALIZER invocations and
-// forwards them along to be tested, grouping them such that the testing suite
-// knows that they are supposed to represent the same logical value (the values
-// compare the same, hash the same, etc.).
-#define EQUIVALENCE_CLASS(...)                    \
-  equivalence_class(ABSL_INTERNAL_TRANSFORM_ARGS( \
-      ABSL_INTERNAL_PREPEND_EQ_MAKER, __VA_ARGS__))
-
-// An invocation of this or WITH_STRICT_PROFILE must end the builder-pattern.
-// It takes a Profile as its argument.
-//
-// This executes the tests and allows types that are "more referined" than the
-// profile specifies, but not less. For instance, if the Profile specifies
-// noexcept copy-constructiblity, the test will fail if the copy-constructor is
-// not noexcept, however, it will succeed if the copy constructor is trivial.
-//
-// This is useful for testing that a type meets some minimum set of
-// requirements.
-#define WITH_LOOSE_PROFILE(...)                                      \
-  with_loose_profile(                                                \
-      ::y_absl::types_internal::MakeLooseProfileRangeT<__VA_ARGS__>()) \
-      ABSL_INTERNAL_RPAREN ABSL_INTERNAL_RPAREN;                     \
-  else GTEST_FATAL_FAILURE_(gtest_ar.failure_message())  // NOLINT
-
-// An invocation of this or WITH_STRICT_PROFILE must end the builder-pattern.
-// It takes a Domain and a Profile as its arguments.
-//
-// This executes the tests and disallows types that differ at all from the
-// properties of the Profile. For instance, if the Profile specifies noexcept
-// copy-constructiblity, the test will fail if the copy constructor is trivial.
-//
-// This is useful for testing that a type does not do anything more than a
-// specification requires, such as to minimize things like Hyrum's Law, or more
-// commonly, to prevent a type from being "accidentally" copy-constructible in
-// a way that may produce incorrect results, simply because the user forget to
-// delete that operation.
-#define WITH_STRICT_PROFILE(...)                                      \
-  with_strict_profile(                                                \
-      ::y_absl::types_internal::MakeStrictProfileRangeT<__VA_ARGS__>()) \
-      ABSL_INTERNAL_RPAREN ABSL_INTERNAL_RPAREN;                      \
-  else GTEST_FATAL_FAILURE_(gtest_ar.failure_message())  // NOLINT
-
-// Internal macro that is used in the internals of the EDSL when forming
-// equivalence classes.
-#define ABSL_INTERNAL_PREPEND_EQ_MAKER(arg) \
-  ::y_absl::types_internal::EquivalenceClassMaker().arg
-
-}  // namespace types_internal
-ABSL_NAMESPACE_END
-}  // namespace y_absl
-
-#endif  // ABSL_TYPES_INTERNAL_CONFORMANCE_TESTING_H_
+// Copyright 2019 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. 
+// 
+// ----------------------------------------------------------------------------- 
+// conformance_testing.h 
+// ----------------------------------------------------------------------------- 
+// 
+ 
+#ifndef ABSL_TYPES_INTERNAL_CONFORMANCE_TESTING_H_ 
+#define ABSL_TYPES_INTERNAL_CONFORMANCE_TESTING_H_ 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+//                                                                            // 
+// Many templates in this file take a `T` and a `Prof` type as explicit       // 
+// template arguments. These are a type to be checked and a                   // 
+// "Regularity Profile" that describes what operations that type `T` is       // 
+// expected to support. See "regularity_profiles.h" for more details          // 
+// regarding Regularity Profiles.                                             // 
+//                                                                            // 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+#include <cstddef> 
+#include <set> 
+#include <tuple> 
+#include <type_traits> 
+#include <utility> 
+ 
+#include "gtest/gtest.h" 
+#include "y_absl/meta/type_traits.h" 
+#include "y_absl/strings/ascii.h" 
+#include "y_absl/strings/str_cat.h" 
+#include "y_absl/strings/string_view.h" 
+#include "y_absl/types/internal/conformance_aliases.h" 
+#include "y_absl/types/internal/conformance_archetype.h" 
+#include "y_absl/types/internal/conformance_profile.h" 
+#include "y_absl/types/internal/conformance_testing_helpers.h" 
+#include "y_absl/types/internal/parentheses.h" 
+#include "y_absl/types/internal/transform_args.h" 
+#include "y_absl/utility/utility.h" 
+ 
+namespace y_absl { 
+ABSL_NAMESPACE_BEGIN 
+namespace types_internal { 
+ 
+// Returns true if the compiler incorrectly greedily instantiates constexpr 
+// templates in any unevaluated context. 
+constexpr bool constexpr_instantiation_when_unevaluated() { 
+#if defined(__apple_build_version__)  // TODO(calabrese) Make more specific 
+  return true; 
+#elif defined(__clang__) 
+  return __clang_major__ < 4; 
+#elif defined(__GNUC__) 
+  // TODO(calabrese) Figure out why gcc 7 fails (seems like a different bug) 
+  return __GNUC__ < 5 || (__GNUC__ == 5 && __GNUC_MINOR__ < 2) || __GNUC__ >= 7; 
+#else 
+  return false; 
+#endif 
+} 
+ 
+// Returns true if the standard library being used incorrectly produces an error 
+// when instantiating the definition of a poisoned std::hash specialization. 
+constexpr bool poisoned_hash_fails_instantiation() { 
+#if defined(_MSC_VER) && !defined(_LIBCPP_VERSION) 
+  return _MSC_VER < 1914; 
+#else 
+  return false; 
+#endif 
+} 
+ 
+template <class Fun> 
+struct GeneratorType { 
+  decltype(std::declval<const Fun&>()()) operator()() const 
+      noexcept(noexcept(std::declval<const Fun&>()())) { 
+    return fun(); 
+  } 
+ 
+  Fun fun; 
+  const char* description; 
+}; 
+ 
+// A "make" function for the GeneratorType template that deduces the function 
+// object type. 
+template <class Fun, 
+          y_absl::enable_if_t<IsNullaryCallable<Fun>::value>** = nullptr> 
+GeneratorType<Fun> Generator(Fun fun, const char* description) { 
+  return GeneratorType<Fun>{y_absl::move(fun), description}; 
+} 
+ 
+// A type that contains a set of nullary function objects that each return an 
+// instance of the same type and value (though possibly different 
+// representations, such as +0 and -0 or two vectors with the same elements but 
+// with different capacities). 
+template <class... Funs> 
+struct EquivalenceClassType { 
+  std::tuple<GeneratorType<Funs>...> generators; 
+}; 
+ 
+// A "make" function for the EquivalenceClassType template that deduces the 
+// function object types and is constrained such that a user can only pass in 
+// function objects that all have the same return type. 
+template <class... Funs, y_absl::enable_if_t<AreGeneratorsWithTheSameReturnType< 
+                             Funs...>::value>** = nullptr> 
+EquivalenceClassType<Funs...> EquivalenceClass(GeneratorType<Funs>... funs) { 
+  return {std::make_tuple(y_absl::move(funs)...)}; 
+} 
+ 
+// A type that contains an ordered series of EquivalenceClassTypes, from 
+// smallest value to largest value. 
+template <class... EqClasses> 
+struct OrderedEquivalenceClasses { 
+  std::tuple<EqClasses...> eq_classes; 
+}; 
+ 
+// An object containing the parts of a given (name, initialization expression), 
+// and is capable of generating a string that describes the given. 
+struct GivenDeclaration { 
+  TString outputDeclaration(std::size_t width) const { 
+    const std::size_t indent_size = 2; 
+    TString result = y_absl::StrCat("  ", name); 
+ 
+    if (!expression.empty()) { 
+      // Indent 
+      result.resize(indent_size + width, ' '); 
+      y_absl::StrAppend(&result, " = ", expression, ";\n"); 
+    } else { 
+      y_absl::StrAppend(&result, ";\n"); 
+    } 
+ 
+    return result; 
+  } 
+ 
+  TString name; 
+  TString expression; 
+}; 
+ 
+// Produce a string that contains all of the givens of an error report. 
+template <class... Decls> 
+TString PrepareGivenContext(const Decls&... decls) { 
+  const std::size_t width = (std::max)({decls.name.size()...}); 
+  return y_absl::StrCat("Given:\n", decls.outputDeclaration(width)..., "\n"); 
+} 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+// Function objects that perform a check for each comparison operator         // 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+#define ABSL_INTERNAL_EXPECT_OP(name, op)                                   \ 
+  struct Expect##name {                                                     \ 
+    template <class T>                                                      \ 
+    void operator()(y_absl::string_view test_name, y_absl::string_view context, \ 
+                    const T& lhs, const T& rhs, y_absl::string_view lhs_name, \ 
+                    y_absl::string_view rhs_name) const {                     \ 
+      if (!static_cast<bool>(lhs op rhs)) {                                 \ 
+        errors->addTestFailure(                                             \ 
+            test_name, y_absl::StrCat(context,                                \ 
+                                    "**Unexpected comparison result**\n"    \ 
+                                    "\n"                                    \ 
+                                    "Expression:\n"                         \ 
+                                    "  ",                                   \ 
+                                    lhs_name, " " #op " ", rhs_name,        \ 
+                                    "\n"                                    \ 
+                                    "\n"                                    \ 
+                                    "Expected: true\n"                      \ 
+                                    "  Actual: false"));                    \ 
+      } else {                                                              \ 
+        errors->addTestSuccess(test_name);                                  \ 
+      }                                                                     \ 
+    }                                                                       \ 
+                                                                            \ 
+    ConformanceErrors* errors;                                              \ 
+  };                                                                        \ 
+                                                                            \ 
+  struct ExpectNot##name {                                                  \ 
+    template <class T>                                                      \ 
+    void operator()(y_absl::string_view test_name, y_absl::string_view context, \ 
+                    const T& lhs, const T& rhs, y_absl::string_view lhs_name, \ 
+                    y_absl::string_view rhs_name) const {                     \ 
+      if (lhs op rhs) {                                                     \ 
+        errors->addTestFailure(                                             \ 
+            test_name, y_absl::StrCat(context,                                \ 
+                                    "**Unexpected comparison result**\n"    \ 
+                                    "\n"                                    \ 
+                                    "Expression:\n"                         \ 
+                                    "  ",                                   \ 
+                                    lhs_name, " " #op " ", rhs_name,        \ 
+                                    "\n"                                    \ 
+                                    "\n"                                    \ 
+                                    "Expected: false\n"                     \ 
+                                    "  Actual: true"));                     \ 
+      } else {                                                              \ 
+        errors->addTestSuccess(test_name);                                  \ 
+      }                                                                     \ 
+    }                                                                       \ 
+                                                                            \ 
+    ConformanceErrors* errors;                                              \ 
+  } 
+ 
+ABSL_INTERNAL_EXPECT_OP(Eq, ==); 
+ABSL_INTERNAL_EXPECT_OP(Ne, !=); 
+ABSL_INTERNAL_EXPECT_OP(Lt, <); 
+ABSL_INTERNAL_EXPECT_OP(Le, <=); 
+ABSL_INTERNAL_EXPECT_OP(Ge, >=); 
+ABSL_INTERNAL_EXPECT_OP(Gt, >); 
+ 
+#undef ABSL_INTERNAL_EXPECT_OP 
+ 
+// A function object that verifies that two objects hash to the same value by 
+// way of the std::hash specialization. 
+struct ExpectSameHash { 
+  template <class T> 
+  void operator()(y_absl::string_view test_name, y_absl::string_view context, 
+                  const T& lhs, const T& rhs, y_absl::string_view lhs_name, 
+                  y_absl::string_view rhs_name) const { 
+    if (std::hash<T>()(lhs) != std::hash<T>()(rhs)) { 
+      errors->addTestFailure( 
+          test_name, y_absl::StrCat(context, 
+                                  "**Unexpected hash result**\n" 
+                                  "\n" 
+                                  "Expression:\n" 
+                                  "  std::hash<T>()(", 
+                                  lhs_name, ") == std::hash<T>()(", rhs_name, 
+                                  ")\n" 
+                                  "\n" 
+                                  "Expected: true\n" 
+                                  "  Actual: false")); 
+    } else { 
+      errors->addTestSuccess(test_name); 
+    } 
+  } 
+ 
+  ConformanceErrors* errors; 
+}; 
+ 
+// A function template that takes two objects and verifies that each comparison 
+// operator behaves in a way that is consistent with equality. It has "OneWay" 
+// in the name because the first argument will always be the left-hand operand 
+// of the corresponding comparison operator and the second argument will 
+// always be the right-hand operand. It will never switch that order. 
+// At a higher level in the test suite, the one-way form is called once for each 
+// of the two possible orders whenever lhs and rhs are not the same initializer. 
+template <class T, class Prof> 
+void ExpectOneWayEquality(ConformanceErrors* errors, 
+                          y_absl::string_view test_name, 
+                          y_absl::string_view context, const T& lhs, const T& rhs, 
+                          y_absl::string_view lhs_name, 
+                          y_absl::string_view rhs_name) { 
+  If<PropertiesOfT<Prof>::is_equality_comparable>::Invoke( 
+      ExpectEq{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name); 
+ 
+  If<PropertiesOfT<Prof>::is_inequality_comparable>::Invoke( 
+      ExpectNotNe{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name); 
+ 
+  If<PropertiesOfT<Prof>::is_less_than_comparable>::Invoke( 
+      ExpectNotLt{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name); 
+ 
+  If<PropertiesOfT<Prof>::is_less_equal_comparable>::Invoke( 
+      ExpectLe{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name); 
+ 
+  If<PropertiesOfT<Prof>::is_greater_equal_comparable>::Invoke( 
+      ExpectGe{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name); 
+ 
+  If<PropertiesOfT<Prof>::is_greater_than_comparable>::Invoke( 
+      ExpectNotGt{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name); 
+ 
+  If<PropertiesOfT<Prof>::is_hashable>::Invoke( 
+      ExpectSameHash{errors}, test_name, context, lhs, rhs, lhs_name, rhs_name); 
+} 
+ 
+// A function template that takes two objects and verifies that each comparison 
+// operator behaves in a way that is consistent with equality. This function 
+// differs from ExpectOneWayEquality in that this will do checks with argument 
+// order reversed in addition to in-order. 
+template <class T, class Prof> 
+void ExpectEquality(ConformanceErrors* errors, y_absl::string_view test_name, 
+                    y_absl::string_view context, const T& lhs, const T& rhs, 
+                    y_absl::string_view lhs_name, y_absl::string_view rhs_name) { 
+  (ExpectOneWayEquality<T, Prof>)(errors, test_name, context, lhs, rhs, 
+                                  lhs_name, rhs_name); 
+  (ExpectOneWayEquality<T, Prof>)(errors, test_name, context, rhs, lhs, 
+                                  rhs_name, lhs_name); 
+} 
+ 
+// Given a generator, makes sure that a generated value and a moved-from 
+// generated value are equal. 
+template <class T, class Prof> 
+struct ExpectMoveConstructOneGenerator { 
+  template <class Fun> 
+  void operator()(const Fun& generator) const { 
+    const T object = generator(); 
+    const T moved_object = y_absl::move(generator());  // Force no elision. 
+ 
+    (ExpectEquality<T, Prof>)(errors, "Move construction", 
+                              PrepareGivenContext( 
+                                  GivenDeclaration{"const _T object", 
+                                                   generator.description}, 
+                                  GivenDeclaration{"const _T moved_object", 
+                                                   TString("std::move(") + 
+                                                       generator.description + 
+                                                       ")"}), 
+                              object, moved_object, "object", "moved_object"); 
+  } 
+ 
+  ConformanceErrors* errors; 
+}; 
+ 
+// Given a generator, makes sure that a generated value and a copied-from 
+// generated value are equal. 
+template <class T, class Prof> 
+struct ExpectCopyConstructOneGenerator { 
+  template <class Fun> 
+  void operator()(const Fun& generator) const { 
+    const T object = generator(); 
+    const T copied_object = static_cast<const T&>(generator()); 
+ 
+    (ExpectEquality<T, Prof>)(errors, "Copy construction", 
+                              PrepareGivenContext( 
+                                  GivenDeclaration{"const _T object", 
+                                                   generator.description}, 
+                                  GivenDeclaration{ 
+                                      "const _T copied_object", 
+                                      TString("static_cast<const _T&>(") + 
+                                          generator.description + ")"}), 
+                              object, copied_object, "object", "copied_object"); 
+  } 
+ 
+  ConformanceErrors* errors; 
+}; 
+ 
+// Default-construct and do nothing before destruction. 
+// 
+// This is useful in exercising the codepath of default construction followed by 
+// destruction, but does not explicitly test anything. An example of where this 
+// might fail is a default destructor that default-initializes a scalar and a 
+// destructor reads the value of that member. Sanitizers can catch this as long 
+// as our test attempts to execute such a case. 
+template <class T> 
+struct ExpectDefaultConstructWithDestruct { 
+  void operator()() const { 
+    // Scoped so that destructor gets called before reporting success. 
+    { 
+      T object; 
+      static_cast<void>(object); 
+    } 
+ 
+    errors->addTestSuccess("Default construction"); 
+  } 
+ 
+  ConformanceErrors* errors; 
+}; 
+ 
+// Check move-assign into a default-constructed object. 
+template <class T, class Prof> 
+struct ExpectDefaultConstructWithMoveAssign { 
+  template <class Fun> 
+  void operator()(const Fun& generator) const { 
+    const T source_of_truth = generator(); 
+    T object; 
+    object = generator(); 
+ 
+    (ExpectEquality<T, Prof>)(errors, "Move assignment", 
+                              PrepareGivenContext( 
+                                  GivenDeclaration{"const _T object", 
+                                                   generator.description}, 
+                                  GivenDeclaration{"_T object", ""}, 
+                                  GivenDeclaration{"object", 
+                                                   generator.description}), 
+                              object, source_of_truth, "std::as_const(object)", 
+                              "source_of_truth"); 
+  } 
+ 
+  ConformanceErrors* errors; 
+}; 
+ 
+// Check copy-assign into a default-constructed object. 
+template <class T, class Prof> 
+struct ExpectDefaultConstructWithCopyAssign { 
+  template <class Fun> 
+  void operator()(const Fun& generator) const { 
+    const T source_of_truth = generator(); 
+    T object; 
+    object = static_cast<const T&>(generator()); 
+ 
+    (ExpectEquality<T, Prof>)(errors, "Copy assignment", 
+                              PrepareGivenContext( 
+                                  GivenDeclaration{"const _T source_of_truth", 
+                                                   generator.description}, 
+                                  GivenDeclaration{"_T object", ""}, 
+                                  GivenDeclaration{ 
+                                      "object", 
+                                      TString("static_cast<const _T&>(") + 
+                                          generator.description + ")"}), 
+                              object, source_of_truth, "std::as_const(object)", 
+                              "source_of_truth"); 
+  } 
+ 
+  ConformanceErrors* errors; 
+}; 
+ 
+// Perform a self move-assign. 
+template <class T, class Prof> 
+struct ExpectSelfMoveAssign { 
+  template <class Fun> 
+  void operator()(const Fun& generator) const { 
+    T object = generator(); 
+    object = y_absl::move(object); 
+ 
+    // NOTE: Self move-assign results in a valid-but-unspecified state. 
+ 
+    (ExpectEquality<T, Prof>)(errors, "Move assignment", 
+                              PrepareGivenContext( 
+                                  GivenDeclaration{"_T object", 
+                                                   generator.description}, 
+                                  GivenDeclaration{"object", 
+                                                   "std::move(object)"}), 
+                              object, object, "object", "object"); 
+  } 
+ 
+  ConformanceErrors* errors; 
+}; 
+ 
+// Perform a self copy-assign. 
+template <class T, class Prof> 
+struct ExpectSelfCopyAssign { 
+  template <class Fun> 
+  void operator()(const Fun& generator) const { 
+    const T source_of_truth = generator(); 
+    T object = generator(); 
+    const T& const_object = object; 
+    object = const_object; 
+ 
+    (ExpectEquality<T, Prof>)(errors, "Copy assignment", 
+                              PrepareGivenContext( 
+                                  GivenDeclaration{"const _T source_of_truth", 
+                                                   generator.description}, 
+                                  GivenDeclaration{"_T object", 
+                                                   generator.description}, 
+                                  GivenDeclaration{"object", 
+                                                   "std::as_const(object)"}), 
+                              const_object, source_of_truth, 
+                              "std::as_const(object)", "source_of_truth"); 
+  } 
+ 
+  ConformanceErrors* errors; 
+}; 
+ 
+// Perform a self-swap. 
+template <class T, class Prof> 
+struct ExpectSelfSwap { 
+  template <class Fun> 
+  void operator()(const Fun& generator) const { 
+    const T source_of_truth = generator(); 
+    T object = generator(); 
+ 
+    type_traits_internal::Swap(object, object); 
+ 
+    TString preliminary_info = y_absl::StrCat( 
+        PrepareGivenContext( 
+            GivenDeclaration{"const _T source_of_truth", generator.description}, 
+            GivenDeclaration{"_T object", generator.description}), 
+        "After performing a self-swap:\n" 
+        "  using std::swap;\n" 
+        "  swap(object, object);\n" 
+        "\n"); 
+ 
+    (ExpectEquality<T, Prof>)(errors, "Swap", std::move(preliminary_info), 
+                              object, source_of_truth, "std::as_const(object)", 
+                              "source_of_truth"); 
+  } 
+ 
+  ConformanceErrors* errors; 
+}; 
+ 
+// Perform each of the single-generator checks when necessary operations are 
+// supported. 
+template <class T, class Prof> 
+struct ExpectSelfComparison { 
+  template <class Fun> 
+  void operator()(const Fun& generator) const { 
+    const T object = generator(); 
+    (ExpectOneWayEquality<T, Prof>)(errors, "Comparison", 
+                                    PrepareGivenContext(GivenDeclaration{ 
+                                        "const _T object", 
+                                        generator.description}), 
+                                    object, object, "object", "object"); 
+  } 
+ 
+  ConformanceErrors* errors; 
+}; 
+ 
+// Perform each of the single-generator checks when necessary operations are 
+// supported. 
+template <class T, class Prof> 
+struct ExpectConsistency { 
+  template <class Fun> 
+  void operator()(const Fun& generator) const { 
+    If<PropertiesOfT<Prof>::is_move_constructible>::Invoke( 
+        ExpectMoveConstructOneGenerator<T, Prof>{errors}, generator); 
+ 
+    If<PropertiesOfT<Prof>::is_copy_constructible>::Invoke( 
+        ExpectCopyConstructOneGenerator<T, Prof>{errors}, generator); 
+ 
+    If<PropertiesOfT<Prof>::is_default_constructible && 
+       PropertiesOfT<Prof>::is_move_assignable>:: 
+        Invoke(ExpectDefaultConstructWithMoveAssign<T, Prof>{errors}, 
+               generator); 
+ 
+    If<PropertiesOfT<Prof>::is_default_constructible && 
+       PropertiesOfT<Prof>::is_copy_assignable>:: 
+        Invoke(ExpectDefaultConstructWithCopyAssign<T, Prof>{errors}, 
+               generator); 
+ 
+    If<PropertiesOfT<Prof>::is_move_assignable>::Invoke( 
+        ExpectSelfMoveAssign<T, Prof>{errors}, generator); 
+ 
+    If<PropertiesOfT<Prof>::is_copy_assignable>::Invoke( 
+        ExpectSelfCopyAssign<T, Prof>{errors}, generator); 
+ 
+    If<PropertiesOfT<Prof>::is_swappable>::Invoke( 
+        ExpectSelfSwap<T, Prof>{errors}, generator); 
+  } 
+ 
+  ConformanceErrors* errors; 
+}; 
+ 
+// Check move-assign with two different values. 
+template <class T, class Prof> 
+struct ExpectMoveAssign { 
+  template <class Fun0, class Fun1> 
+  void operator()(const Fun0& generator0, const Fun1& generator1) const { 
+    const T source_of_truth1 = generator1(); 
+    T object = generator0(); 
+    object = generator1(); 
+ 
+    (ExpectEquality<T, Prof>)(errors, "Move assignment", 
+                              PrepareGivenContext( 
+                                  GivenDeclaration{"const _T source_of_truth1", 
+                                                   generator1.description}, 
+                                  GivenDeclaration{"_T object", 
+                                                   generator0.description}, 
+                                  GivenDeclaration{"object", 
+                                                   generator1.description}), 
+                              object, source_of_truth1, "std::as_const(object)", 
+                              "source_of_truth1"); 
+  } 
+ 
+  ConformanceErrors* errors; 
+}; 
+ 
+// Check copy-assign with two different values. 
+template <class T, class Prof> 
+struct ExpectCopyAssign { 
+  template <class Fun0, class Fun1> 
+  void operator()(const Fun0& generator0, const Fun1& generator1) const { 
+    const T source_of_truth1 = generator1(); 
+    T object = generator0(); 
+    object = static_cast<const T&>(generator1()); 
+ 
+    (ExpectEquality<T, Prof>)(errors, "Copy assignment", 
+                              PrepareGivenContext( 
+                                  GivenDeclaration{"const _T source_of_truth1", 
+                                                   generator1.description}, 
+                                  GivenDeclaration{"_T object", 
+                                                   generator0.description}, 
+                                  GivenDeclaration{ 
+                                      "object", 
+                                      TString("static_cast<const _T&>(") + 
+                                          generator1.description + ")"}), 
+                              object, source_of_truth1, "std::as_const(object)", 
+                              "source_of_truth1"); 
+  } 
+ 
+  ConformanceErrors* errors; 
+}; 
+ 
+// Check swap with two different values. 
+template <class T, class Prof> 
+struct ExpectSwap { 
+  template <class Fun0, class Fun1> 
+  void operator()(const Fun0& generator0, const Fun1& generator1) const { 
+    const T source_of_truth0 = generator0(); 
+    const T source_of_truth1 = generator1(); 
+    T object0 = generator0(); 
+    T object1 = generator1(); 
+ 
+    type_traits_internal::Swap(object0, object1); 
+ 
+    const TString context = 
+        PrepareGivenContext( 
+            GivenDeclaration{"const _T source_of_truth0", 
+                             generator0.description}, 
+            GivenDeclaration{"const _T source_of_truth1", 
+                             generator1.description}, 
+            GivenDeclaration{"_T object0", generator0.description}, 
+            GivenDeclaration{"_T object1", generator1.description}) + 
+        "After performing a swap:\n" 
+        "  using std::swap;\n" 
+        "  swap(object0, object1);\n" 
+        "\n"; 
+ 
+    (ExpectEquality<T, Prof>)(errors, "Swap", context, object0, 
+                              source_of_truth1, "std::as_const(object0)", 
+                              "source_of_truth1"); 
+    (ExpectEquality<T, Prof>)(errors, "Swap", context, object1, 
+                              source_of_truth0, "std::as_const(object1)", 
+                              "source_of_truth0"); 
+  } 
+ 
+  ConformanceErrors* errors; 
+}; 
+ 
+// Validate that `generator0` and `generator1` produce values that are equal. 
+template <class T, class Prof> 
+struct ExpectEquivalenceClassComparison { 
+  template <class Fun0, class Fun1> 
+  void operator()(const Fun0& generator0, const Fun1& generator1) const { 
+    const T object0 = generator0(); 
+    const T object1 = generator1(); 
+ 
+    (ExpectEquality<T, Prof>)(errors, "Comparison", 
+                              PrepareGivenContext( 
+                                  GivenDeclaration{"const _T object0", 
+                                                   generator0.description}, 
+                                  GivenDeclaration{"const _T object1", 
+                                                   generator1.description}), 
+                              object0, object1, "object0", "object1"); 
+  } 
+ 
+  ConformanceErrors* errors; 
+}; 
+ 
+// Validate that all objects in the same equivalence-class have the same value. 
+template <class T, class Prof> 
+struct ExpectEquivalenceClassConsistency { 
+  template <class Fun0, class Fun1> 
+  void operator()(const Fun0& generator0, const Fun1& generator1) const { 
+    If<PropertiesOfT<Prof>::is_move_assignable>::Invoke( 
+        ExpectMoveAssign<T, Prof>{errors}, generator0, generator1); 
+ 
+    If<PropertiesOfT<Prof>::is_copy_assignable>::Invoke( 
+        ExpectCopyAssign<T, Prof>{errors}, generator0, generator1); 
+ 
+    If<PropertiesOfT<Prof>::is_swappable>::Invoke(ExpectSwap<T, Prof>{errors}, 
+                                                  generator0, generator1); 
+  } 
+ 
+  ConformanceErrors* errors; 
+}; 
+ 
+// Given a "lesser" object and a "greater" object, perform every combination of 
+// comparison operators supported for the type, expecting consistent results. 
+template <class T, class Prof> 
+void ExpectOrdered(ConformanceErrors* errors, y_absl::string_view context, 
+                   const T& small, const T& big, y_absl::string_view small_name, 
+                   y_absl::string_view big_name) { 
+  const y_absl::string_view test_name = "Comparison"; 
+ 
+  If<PropertiesOfT<Prof>::is_equality_comparable>::Invoke( 
+      ExpectNotEq{errors}, test_name, context, small, big, small_name, 
+      big_name); 
+  If<PropertiesOfT<Prof>::is_equality_comparable>::Invoke( 
+      ExpectNotEq{errors}, test_name, context, big, small, big_name, 
+      small_name); 
+ 
+  If<PropertiesOfT<Prof>::is_inequality_comparable>::Invoke( 
+      ExpectNe{errors}, test_name, context, small, big, small_name, big_name); 
+  If<PropertiesOfT<Prof>::is_inequality_comparable>::Invoke( 
+      ExpectNe{errors}, test_name, context, big, small, big_name, small_name); 
+ 
+  If<PropertiesOfT<Prof>::is_less_than_comparable>::Invoke( 
+      ExpectLt{errors}, test_name, context, small, big, small_name, big_name); 
+  If<PropertiesOfT<Prof>::is_less_than_comparable>::Invoke( 
+      ExpectNotLt{errors}, test_name, context, big, small, big_name, 
+      small_name); 
+ 
+  If<PropertiesOfT<Prof>::is_less_equal_comparable>::Invoke( 
+      ExpectLe{errors}, test_name, context, small, big, small_name, big_name); 
+  If<PropertiesOfT<Prof>::is_less_equal_comparable>::Invoke( 
+      ExpectNotLe{errors}, test_name, context, big, small, big_name, 
+      small_name); 
+ 
+  If<PropertiesOfT<Prof>::is_greater_equal_comparable>::Invoke( 
+      ExpectNotGe{errors}, test_name, context, small, big, small_name, 
+      big_name); 
+  If<PropertiesOfT<Prof>::is_greater_equal_comparable>::Invoke( 
+      ExpectGe{errors}, test_name, context, big, small, big_name, small_name); 
+ 
+  If<PropertiesOfT<Prof>::is_greater_than_comparable>::Invoke( 
+      ExpectNotGt{errors}, test_name, context, small, big, small_name, 
+      big_name); 
+  If<PropertiesOfT<Prof>::is_greater_than_comparable>::Invoke( 
+      ExpectGt{errors}, test_name, context, big, small, big_name, small_name); 
+} 
+ 
+// For every two elements of an equivalence class, makes sure that those two 
+// elements compare equal, including checks with the same argument passed as 
+// both operands. 
+template <class T, class Prof> 
+struct ExpectEquivalenceClassComparisons { 
+  template <class... Funs> 
+  void operator()(EquivalenceClassType<Funs...> eq_class) const { 
+    (ForEachTupleElement)(ExpectSelfComparison<T, Prof>{errors}, 
+                          eq_class.generators); 
+ 
+    (ForEveryTwo)(ExpectEquivalenceClassComparison<T, Prof>{errors}, 
+                  eq_class.generators); 
+  } 
+ 
+  ConformanceErrors* errors; 
+}; 
+ 
+// For every element of an equivalence class, makes sure that the element is 
+// self-consistent (in other words, if any of move/copy/swap are defined, 
+// perform those operations and make such that results and operands still 
+// compare equal to known values whenever it is required for that operation. 
+template <class T, class Prof> 
+struct ExpectEquivalenceClass { 
+  template <class... Funs> 
+  void operator()(EquivalenceClassType<Funs...> eq_class) const { 
+    (ForEachTupleElement)(ExpectConsistency<T, Prof>{errors}, 
+                          eq_class.generators); 
+ 
+    (ForEveryTwo)(ExpectEquivalenceClassConsistency<T, Prof>{errors}, 
+                  eq_class.generators); 
+  } 
+ 
+  ConformanceErrors* errors; 
+}; 
+ 
+// Validate that the passed-in argument is a generator of a greater value than 
+// the one produced by the "small_gen" datamember with respect to all of the 
+// comparison operators that Prof requires, with both argument orders to test. 
+template <class T, class Prof, class SmallGenerator> 
+struct ExpectBiggerGeneratorThanComparisons { 
+  template <class BigGenerator> 
+  void operator()(BigGenerator big_gen) const { 
+    const T small = small_gen(); 
+    const T big = big_gen(); 
+ 
+    (ExpectOrdered<T, Prof>)(errors, 
+                             PrepareGivenContext( 
+                                 GivenDeclaration{"const _T small", 
+                                                  small_gen.description}, 
+                                 GivenDeclaration{"const _T big", 
+                                                  big_gen.description}), 
+                             small, big, "small", "big"); 
+  } 
+ 
+  SmallGenerator small_gen; 
+  ConformanceErrors* errors; 
+}; 
+ 
+// Perform all of the move, copy, and swap checks on the value generated by 
+// `small_gen` and the value generated by `big_gen`. 
+template <class T, class Prof, class SmallGenerator> 
+struct ExpectBiggerGeneratorThan { 
+  template <class BigGenerator> 
+  void operator()(BigGenerator big_gen) const { 
+    If<PropertiesOfT<Prof>::is_move_assignable>::Invoke( 
+        ExpectMoveAssign<T, Prof>{errors}, small_gen, big_gen); 
+    If<PropertiesOfT<Prof>::is_move_assignable>::Invoke( 
+        ExpectMoveAssign<T, Prof>{errors}, big_gen, small_gen); 
+ 
+    If<PropertiesOfT<Prof>::is_copy_assignable>::Invoke( 
+        ExpectCopyAssign<T, Prof>{errors}, small_gen, big_gen); 
+    If<PropertiesOfT<Prof>::is_copy_assignable>::Invoke( 
+        ExpectCopyAssign<T, Prof>{errors}, big_gen, small_gen); 
+ 
+    If<PropertiesOfT<Prof>::is_swappable>::Invoke(ExpectSwap<T, Prof>{errors}, 
+                                                  small_gen, big_gen); 
+  } 
+ 
+  SmallGenerator small_gen; 
+  ConformanceErrors* errors; 
+}; 
+ 
+// Validate that the result of a generator is greater than the results of all 
+// generators in an equivalence class with respect to comparisons. 
+template <class T, class Prof, class SmallGenerator> 
+struct ExpectBiggerGeneratorThanEqClassesComparisons { 
+  template <class BigEqClass> 
+  void operator()(BigEqClass big_eq_class) const { 
+    (ForEachTupleElement)( 
+        ExpectBiggerGeneratorThanComparisons<T, Prof, SmallGenerator>{small_gen, 
+                                                                      errors}, 
+        big_eq_class.generators); 
+  } 
+ 
+  SmallGenerator small_gen; 
+  ConformanceErrors* errors; 
+}; 
+ 
+// Validate that the non-comparison binary operations required by Prof are 
+// correct for the result of each generator of big_eq_class and a generator of 
+// the logically smaller value returned by small_gen. 
+template <class T, class Prof, class SmallGenerator> 
+struct ExpectBiggerGeneratorThanEqClasses { 
+  template <class BigEqClass> 
+  void operator()(BigEqClass big_eq_class) const { 
+    (ForEachTupleElement)( 
+        ExpectBiggerGeneratorThan<T, Prof, SmallGenerator>{small_gen, errors}, 
+        big_eq_class.generators); 
+  } 
+ 
+  SmallGenerator small_gen; 
+  ConformanceErrors* errors; 
+}; 
+ 
+// Validate that each equivalence class that is passed is logically less than 
+// the equivalence classes that comes later on in the argument list. 
+template <class T, class Prof> 
+struct ExpectOrderedEquivalenceClassesComparisons { 
+  template <class... BigEqClasses> 
+  struct Impl { 
+    // Validate that the value produced by `small_gen` is less than all of the 
+    // values generated by those of the logically larger equivalence classes. 
+    template <class SmallGenerator> 
+    void operator()(SmallGenerator small_gen) const { 
+      (ForEachTupleElement)(ExpectBiggerGeneratorThanEqClassesComparisons< 
+                                T, Prof, SmallGenerator>{small_gen, errors}, 
+                            big_eq_classes); 
+    } 
+ 
+    std::tuple<BigEqClasses...> big_eq_classes; 
+    ConformanceErrors* errors; 
+  }; 
+ 
+  // When given no equivalence classes, no validation is necessary. 
+  void operator()() const {} 
+ 
+  template <class SmallEqClass, class... BigEqClasses> 
+  void operator()(SmallEqClass small_eq_class, 
+                  BigEqClasses... big_eq_classes) const { 
+    // For each generator in the first equivalence class, make sure that it is 
+    // less than each of those in the logically greater equivalence classes. 
+    (ForEachTupleElement)( 
+        Impl<BigEqClasses...>{std::make_tuple(y_absl::move(big_eq_classes)...), 
+                              errors}, 
+        small_eq_class.generators); 
+ 
+    // Recurse so that all equivalence class combinations are checked. 
+    (*this)(y_absl::move(big_eq_classes)...); 
+  } 
+ 
+  ConformanceErrors* errors; 
+}; 
+ 
+// Validate that the non-comparison binary operations required by Prof are 
+// correct for the result of each generator of big_eq_classes and a generator of 
+// the logically smaller value returned by small_gen. 
+template <class T, class Prof> 
+struct ExpectOrderedEquivalenceClasses { 
+  template <class... BigEqClasses> 
+  struct Impl { 
+    template <class SmallGenerator> 
+    void operator()(SmallGenerator small_gen) const { 
+      (ForEachTupleElement)( 
+          ExpectBiggerGeneratorThanEqClasses<T, Prof, SmallGenerator>{small_gen, 
+                                                                      errors}, 
+          big_eq_classes); 
+    } 
+ 
+    std::tuple<BigEqClasses...> big_eq_classes; 
+    ConformanceErrors* errors; 
+  }; 
+ 
+  // Check that small_eq_class is logically consistent and also is logically 
+  // less than all values in big_eq_classes. 
+  template <class SmallEqClass, class... BigEqClasses> 
+  void operator()(SmallEqClass small_eq_class, 
+                  BigEqClasses... big_eq_classes) const { 
+    (ForEachTupleElement)( 
+        Impl<BigEqClasses...>{std::make_tuple(y_absl::move(big_eq_classes)...), 
+                              errors}, 
+        small_eq_class.generators); 
+ 
+    (*this)(y_absl::move(big_eq_classes)...); 
+  } 
+ 
+  // Terminating case of operator(). 
+  void operator()() const {} 
+ 
+  ConformanceErrors* errors; 
+}; 
+ 
+// Validate that a type meets the syntactic requirements of std::hash if the 
+// range of profiles requires it. 
+template <class T, class MinProf, class MaxProf> 
+struct ExpectHashable { 
+  void operator()() const { 
+    ExpectModelOfHashable<T, MinProf, MaxProf>(errors); 
+  } 
+ 
+  ConformanceErrors* errors; 
+}; 
+ 
+// Validate that the type `T` meets all of the requirements associated with 
+// `MinProf` and without going beyond the syntactic properties of `MaxProf`. 
+template <class T, class MinProf, class MaxProf> 
+struct ExpectModels { 
+  void operator()(ConformanceErrors* errors) const { 
+    ExpectModelOfDefaultConstructible<T, MinProf, MaxProf>(errors); 
+    ExpectModelOfMoveConstructible<T, MinProf, MaxProf>(errors); 
+    ExpectModelOfCopyConstructible<T, MinProf, MaxProf>(errors); 
+    ExpectModelOfMoveAssignable<T, MinProf, MaxProf>(errors); 
+    ExpectModelOfCopyAssignable<T, MinProf, MaxProf>(errors); 
+    ExpectModelOfDestructible<T, MinProf, MaxProf>(errors); 
+    ExpectModelOfEqualityComparable<T, MinProf, MaxProf>(errors); 
+    ExpectModelOfInequalityComparable<T, MinProf, MaxProf>(errors); 
+    ExpectModelOfLessThanComparable<T, MinProf, MaxProf>(errors); 
+    ExpectModelOfLessEqualComparable<T, MinProf, MaxProf>(errors); 
+    ExpectModelOfGreaterEqualComparable<T, MinProf, MaxProf>(errors); 
+    ExpectModelOfGreaterThanComparable<T, MinProf, MaxProf>(errors); 
+    ExpectModelOfSwappable<T, MinProf, MaxProf>(errors); 
+ 
+    // Only check hashability on compilers that have a compliant default-hash. 
+    If<!poisoned_hash_fails_instantiation()>::Invoke( 
+        ExpectHashable<T, MinProf, MaxProf>{errors}); 
+  } 
+}; 
+ 
+// A metafunction that yields a Profile matching the set of properties that are 
+// safe to be checked (lack-of-hashability is only checked on standard library 
+// implementations that are standards compliant in that they provide a std::hash 
+// primary template that is SFINAE-friendly) 
+template <class LogicalProf, class T> 
+struct MinimalCheckableProfile { 
+  using type = 
+      MinimalProfiles<PropertiesOfT<LogicalProf>, 
+                      PropertiesOfT<SyntacticConformanceProfileOf< 
+                          T, !PropertiesOfT<LogicalProf>::is_hashable && 
+                                     poisoned_hash_fails_instantiation() 
+                                 ? CheckHashability::no 
+                                 : CheckHashability::yes>>>; 
+}; 
+ 
+// An identity metafunction 
+template <class T> 
+struct Always { 
+  using type = T; 
+}; 
+ 
+// Validate the T meets all of the necessary requirements of LogicalProf, with 
+// syntactic requirements defined by the profile range [MinProf, MaxProf]. 
+template <class T, class LogicalProf, class MinProf, class MaxProf, 
+          class... EqClasses> 
+ConformanceErrors ExpectRegularityImpl( 
+    OrderedEquivalenceClasses<EqClasses...> vals) { 
+  ConformanceErrors errors((NameOf<T>())); 
+ 
+  If<!constexpr_instantiation_when_unevaluated()>::Invoke( 
+      ExpectModels<T, MinProf, MaxProf>(), &errors); 
+ 
+  using minimal_profile = typename y_absl::conditional_t< 
+      constexpr_instantiation_when_unevaluated(), Always<LogicalProf>, 
+      MinimalCheckableProfile<LogicalProf, T>>::type; 
+ 
+  If<PropertiesOfT<minimal_profile>::is_default_constructible>::Invoke( 
+      ExpectDefaultConstructWithDestruct<T>{&errors}); 
+ 
+  ////////////////////////////////////////////////////////////////////////////// 
+  // Perform all comparison checks first, since later checks depend on their 
+  // correctness. 
+  // 
+  // Check all of the comparisons for all values in the same equivalence 
+  // class (equal with respect to comparison operators and hash the same). 
+  (ForEachTupleElement)( 
+      ExpectEquivalenceClassComparisons<T, minimal_profile>{&errors}, 
+      vals.eq_classes); 
+ 
+  // Check all of the comparisons for each combination of values that are in 
+  // different equivalence classes (not equal with respect to comparison 
+  // operators). 
+  y_absl::apply( 
+      ExpectOrderedEquivalenceClassesComparisons<T, minimal_profile>{&errors}, 
+      vals.eq_classes); 
+  // 
+  ////////////////////////////////////////////////////////////////////////////// 
+ 
+  // Perform remaining checks, relying on comparisons. 
+  // TODO(calabrese) short circuit if any comparisons above failed. 
+  (ForEachTupleElement)(ExpectEquivalenceClass<T, minimal_profile>{&errors}, 
+                        vals.eq_classes); 
+ 
+  y_absl::apply(ExpectOrderedEquivalenceClasses<T, minimal_profile>{&errors}, 
+              vals.eq_classes); 
+ 
+  return errors; 
+} 
+ 
+// A type that represents a range of profiles that are acceptable to be matched. 
+// 
+// `MinProf` is the minimum set of syntactic requirements that must be met. 
+// 
+// `MaxProf` is the maximum set of syntactic requirements that must be met. 
+// This maximum is particularly useful for certain "strictness" checking. Some 
+// examples for when this is useful: 
+// 
+// * Making sure that a type is move-only (rather than simply movable) 
+// 
+// * Making sure that a member function is *not* noexcept in cases where it 
+//   cannot be noexcept, such as if a dependent datamember has certain 
+//   operations that are not noexcept. 
+// 
+// * Making sure that a type tightly matches a spec, such as the standard. 
+// 
+// `LogicalProf` is the Profile for which run-time testing is to take place. 
+// 
+// Note: The reason for `LogicalProf` is because it is often the case, when 
+// dealing with templates, that a declaration of a given operation is specified, 
+// but whose body would fail to instantiate. Examples include the 
+// copy-constructor of a standard container when the element-type is move-only, 
+// or the comparison operators of a standard container when the element-type 
+// does not have the necessary comparison operations defined. The `LogicalProf` 
+// parameter allows us to capture the intent of what should be tested at 
+// run-time, even in the cases where syntactically it might otherwise appear as 
+// though the type undergoing testing supports more than it actually does. 
+template <class LogicalProf, class MinProf = LogicalProf, 
+          class MaxProf = MinProf> 
+struct ProfileRange { 
+  using logical_profile = LogicalProf; 
+  using min_profile = MinProf; 
+  using max_profile = MaxProf; 
+}; 
+ 
+// Similar to ProfileRange except that it creates a profile range that is 
+// coupled with a Domain and is used when testing that a type matches exactly 
+// the "minimum" requirements of LogicalProf. 
+template <class StrictnessDomain, class LogicalProf, 
+          class MinProf = LogicalProf, class MaxProf = MinProf> 
+struct StrictProfileRange { 
+  // We do not yet support extension. 
+  static_assert( 
+      std::is_same<StrictnessDomain, RegularityDomain>::value, 
+      "Currently, the only valid StrictnessDomain is RegularityDomain."); 
+  using strictness_domain = StrictnessDomain; 
+  using logical_profile = LogicalProf; 
+  using min_profile = MinProf; 
+  using max_profile = MaxProf; 
+}; 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+// 
+// A metafunction that creates a StrictProfileRange from a Domain and either a 
+// Profile or ProfileRange. 
+template <class StrictnessDomain, class ProfOrRange> 
+struct MakeStrictProfileRange; 
+ 
+template <class StrictnessDomain, class LogicalProf> 
+struct MakeStrictProfileRange { 
+  using type = StrictProfileRange<StrictnessDomain, LogicalProf>; 
+}; 
+ 
+template <class StrictnessDomain, class LogicalProf, class MinProf, 
+          class MaxProf> 
+struct MakeStrictProfileRange<StrictnessDomain, 
+                              ProfileRange<LogicalProf, MinProf, MaxProf>> { 
+  using type = 
+      StrictProfileRange<StrictnessDomain, LogicalProf, MinProf, MaxProf>; 
+}; 
+ 
+template <class StrictnessDomain, class ProfOrRange> 
+using MakeStrictProfileRangeT = 
+    typename MakeStrictProfileRange<StrictnessDomain, ProfOrRange>::type; 
+// 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+// A profile in the RegularityDomain with the strongest possible requirements. 
+using MostStrictProfile = 
+    CombineProfiles<TriviallyCompleteProfile, NothrowComparableProfile>; 
+ 
+// Forms a ProfileRange that treats the Profile as the bare minimum requirements 
+// of a type. 
+template <class LogicalProf, class MinProf = LogicalProf> 
+using LooseProfileRange = StrictProfileRange<RegularityDomain, LogicalProf, 
+                                             MinProf, MostStrictProfile>; 
+ 
+template <class Prof> 
+using MakeLooseProfileRangeT = Prof; 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+// 
+// The following classes implement the metafunction ProfileRangeOfT<T> that 
+// takes either a Profile or ProfileRange and yields the ProfileRange to be 
+// used during testing. 
+// 
+template <class T, class /*Enabler*/ = void> 
+struct ProfileRangeOfImpl; 
+ 
+template <class T> 
+struct ProfileRangeOfImpl<T, y_absl::void_t<PropertiesOfT<T>>> { 
+  using type = LooseProfileRange<T>; 
+}; 
+ 
+template <class T> 
+struct ProfileRangeOf : ProfileRangeOfImpl<T> {}; 
+ 
+template <class StrictnessDomain, class LogicalProf, class MinProf, 
+          class MaxProf> 
+struct ProfileRangeOf< 
+    StrictProfileRange<StrictnessDomain, LogicalProf, MinProf, MaxProf>> { 
+  using type = 
+      StrictProfileRange<StrictnessDomain, LogicalProf, MinProf, MaxProf>; 
+}; 
+ 
+template <class T> 
+using ProfileRangeOfT = typename ProfileRangeOf<T>::type; 
+// 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+// Extract the logical profile of a range (what will be runtime tested). 
+template <class T> 
+using LogicalProfileOfT = typename ProfileRangeOfT<T>::logical_profile; 
+ 
+// Extract the minimal syntactic profile of a range (error if not at least). 
+template <class T> 
+using MinProfileOfT = typename ProfileRangeOfT<T>::min_profile; 
+ 
+// Extract the maximum syntactic profile of a range (error if more than). 
+template <class T> 
+using MaxProfileOfT = typename ProfileRangeOfT<T>::max_profile; 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+// 
+template <class T> 
+struct IsProfileOrProfileRange : IsProfile<T>::type {}; 
+ 
+template <class StrictnessDomain, class LogicalProf, class MinProf, 
+          class MaxProf> 
+struct IsProfileOrProfileRange< 
+    StrictProfileRange<StrictnessDomain, LogicalProf, MinProf, MaxProf>> 
+    : std::true_type {}; 
+// 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+// TODO(calabrese): Consider naming the functions in this class the same as 
+// the macros (defined later on) so that auto-complete leads to the correct name 
+// and so that a user cannot accidentally call a function rather than the macro 
+// form. 
+template <bool ExpectSuccess, class T, class... EqClasses> 
+struct ExpectConformanceOf { 
+  // Add a value to be tested. Subsequent calls to this function on the same 
+  // object must specify logically "larger" values with respect to the 
+  // comparison operators of the type, if any. 
+  // 
+  // NOTE: This function should not be called directly. A stateless lambda is 
+  // implicitly formed and passed when using the INITIALIZER macro at the bottom 
+  // of this file. 
+  template <class Fun, 
+            y_absl::enable_if_t<std::is_same< 
+                ResultOfGeneratorT<GeneratorType<Fun>>, T>::value>** = nullptr> 
+  ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses..., 
+                                           EquivalenceClassType<Fun>> 
+  initializer(GeneratorType<Fun> fun) && { 
+    return { 
+        {std::tuple_cat(y_absl::move(ordered_vals.eq_classes), 
+                        std::make_tuple((EquivalenceClass)(y_absl::move(fun))))}, 
+        std::move(expected_failed_tests)}; 
+  } 
+ 
+  template <class... TestNames, 
+            y_absl::enable_if_t<!ExpectSuccess && sizeof...(EqClasses) == 0 && 
+                              y_absl::conjunction<std::is_convertible< 
+                                  TestNames, y_absl::string_view>...>::value>** = 
+                nullptr> 
+  ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses...> 
+  due_to(TestNames&&... test_names) && { 
+    (InsertEach)(&expected_failed_tests, 
+                 y_absl::AsciiStrToLower(y_absl::string_view(test_names))...); 
+ 
+    return {y_absl::move(ordered_vals), std::move(expected_failed_tests)}; 
+  } 
+ 
+  template <class... TestNames, int = 0,  // MSVC disambiguator 
+            y_absl::enable_if_t<ExpectSuccess && sizeof...(EqClasses) == 0 && 
+                              y_absl::conjunction<std::is_convertible< 
+                                  TestNames, y_absl::string_view>...>::value>** = 
+                nullptr> 
+  ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses...> 
+  due_to(TestNames&&... test_names) && { 
+    // TODO(calabrese) Instead have DUE_TO only exist via a CRTP base. 
+    // This would produce better errors messages than the static_assert. 
+    static_assert(!ExpectSuccess, 
+                  "DUE_TO cannot be called when conformance is expected -- did " 
+                  "you mean to use ASSERT_NONCONFORMANCE_OF?"); 
+  } 
+ 
+  // Add a value to be tested. Subsequent calls to this function on the same 
+  // object must specify logically "larger" values with respect to the 
+  // comparison operators of the type, if any. 
+  // 
+  // NOTE: This function should not be called directly. A stateful lambda is 
+  // implicitly formed and passed when using the INITIALIZER macro at the bottom 
+  // of this file. 
+  template <class Fun, 
+            y_absl::enable_if_t<std::is_same< 
+                ResultOfGeneratorT<GeneratorType<Fun>>, T>::value>** = nullptr> 
+  ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses..., 
+                                           EquivalenceClassType<Fun>> 
+  dont_class_directly_stateful_initializer(GeneratorType<Fun> fun) && { 
+    return { 
+        {std::tuple_cat(y_absl::move(ordered_vals.eq_classes), 
+                        std::make_tuple((EquivalenceClass)(y_absl::move(fun))))}, 
+        std::move(expected_failed_tests)}; 
+  } 
+ 
+  // Add a set of value to be tested, where each value is equal with respect to 
+  // the comparison operators and std::hash specialization, if defined. 
+  template < 
+      class... Funs, 
+      y_absl::void_t<y_absl::enable_if_t<std::is_same< 
+          ResultOfGeneratorT<GeneratorType<Funs>>, T>::value>...>** = nullptr> 
+  ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses..., 
+                                           EquivalenceClassType<Funs...>> 
+  equivalence_class(GeneratorType<Funs>... funs) && { 
+    return {{std::tuple_cat( 
+                y_absl::move(ordered_vals.eq_classes), 
+                std::make_tuple((EquivalenceClass)(y_absl::move(funs)...)))}, 
+            std::move(expected_failed_tests)}; 
+  } 
+ 
+  // Execute the tests for the captured set of values, strictly matching a range 
+  // of expected profiles in a given domain. 
+  template < 
+      class ProfRange, 
+      y_absl::enable_if_t<IsProfileOrProfileRange<ProfRange>::value>** = nullptr> 
+  ABSL_MUST_USE_RESULT ::testing::AssertionResult with_strict_profile( 
+      ProfRange /*profile*/) { 
+    ConformanceErrors test_result = 
+        (ExpectRegularityImpl< 
+            T, LogicalProfileOfT<ProfRange>, MinProfileOfT<ProfRange>, 
+            MaxProfileOfT<ProfRange>>)(y_absl::move(ordered_vals)); 
+ 
+    return ExpectSuccess ? test_result.assertionResult() 
+                         : test_result.expectFailedTests(expected_failed_tests); 
+  } 
+ 
+  // Execute the tests for the captured set of values, loosely matching a range 
+  // of expected profiles (loose in that an interface is allowed to be more 
+  // refined that a profile suggests, such as a type having a noexcept copy 
+  // constructor when all that is required is that the copy constructor exists). 
+  template <class Prof, y_absl::enable_if_t<IsProfile<Prof>::value>** = nullptr> 
+  ABSL_MUST_USE_RESULT ::testing::AssertionResult with_loose_profile( 
+      Prof /*profile*/) { 
+    ConformanceErrors test_result = 
+        (ExpectRegularityImpl< 
+            T, Prof, Prof, 
+            CombineProfiles<TriviallyCompleteProfile, 
+                            NothrowComparableProfile>>)(y_absl:: 
+                                                            move(ordered_vals)); 
+ 
+    return ExpectSuccess ? test_result.assertionResult() 
+                         : test_result.expectFailedTests(expected_failed_tests); 
+  } 
+ 
+  OrderedEquivalenceClasses<EqClasses...> ordered_vals; 
+  std::set<TString> expected_failed_tests; 
+}; 
+ 
+template <class T> 
+using ExpectConformanceOfType = ExpectConformanceOf</*ExpectSuccess=*/true, T>; 
+ 
+template <class T> 
+using ExpectNonconformanceOfType = 
+    ExpectConformanceOf</*ExpectSuccess=*/false, T>; 
+ 
+struct EquivalenceClassMaker { 
+  // TODO(calabrese) Constrain to callable 
+  template <class Fun> 
+  static GeneratorType<Fun> initializer(GeneratorType<Fun> fun) { 
+    return fun; 
+  } 
+}; 
+ 
+// A top-level macro that begins the builder pattern. 
+// 
+// The argument here takes the datatype to be tested. 
+#define ABSL_INTERNAL_ASSERT_CONFORMANCE_OF(...)                            \ 
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                             \ 
+  if ABSL_INTERNAL_LPAREN                                                   \ 
+  const ::testing::AssertionResult gtest_ar =                               \ 
+      ABSL_INTERNAL_LPAREN ::y_absl::types_internal::ExpectConformanceOfType< \ 
+          __VA_ARGS__>() 
+ 
+// Akin to ASSERT_CONFORMANCE_OF except that it expects failure and tries to 
+// match text. 
+#define ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(...)                            \ 
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                                \ 
+  if ABSL_INTERNAL_LPAREN                                                      \ 
+  const ::testing::AssertionResult gtest_ar =                                  \ 
+      ABSL_INTERNAL_LPAREN ::y_absl::types_internal::ExpectNonconformanceOfType< \ 
+          __VA_ARGS__>() 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+// NOTE: The following macros look like they are recursive, but are not (macros 
+// cannot recurse). These actually refer to member functions of the same name. 
+// This is done intentionally so that a user cannot accidentally invoke a 
+// member function of the conformance-testing suite without going through the 
+// macro. 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+// Specify expected test failures as comma-separated strings. 
+#define DUE_TO(...) due_to(__VA_ARGS__) 
+ 
+// Specify a value to be tested. 
+// 
+// Note: Internally, this takes an expression and turns it into the return value 
+// of lambda that captures no data. The expression is stringized during 
+// preprocessing so that it can be used in error reports. 
+#define INITIALIZER(...)                         \ 
+  initializer(::y_absl::types_internal::Generator( \ 
+      [] { return __VA_ARGS__; }, ABSL_INTERNAL_STRINGIZE(__VA_ARGS__))) 
+ 
+// Specify a value to be tested. 
+// 
+// Note: Internally, this takes an expression and turns it into the return value 
+// of lambda that captures data by reference. The expression is stringized 
+// during preprocessing so that it can be used in error reports. 
+#define STATEFUL_INITIALIZER(...)                         \ 
+  stateful_initializer(::y_absl::types_internal::Generator( \ 
+      [&] { return __VA_ARGS__; }, ABSL_INTERNAL_STRINGIZE(__VA_ARGS__))) 
+ 
+// Used in the builder-pattern. 
+// 
+// Takes a series of INITIALIZER and/or STATEFUL_INITIALIZER invocations and 
+// forwards them along to be tested, grouping them such that the testing suite 
+// knows that they are supposed to represent the same logical value (the values 
+// compare the same, hash the same, etc.). 
+#define EQUIVALENCE_CLASS(...)                    \ 
+  equivalence_class(ABSL_INTERNAL_TRANSFORM_ARGS( \ 
+      ABSL_INTERNAL_PREPEND_EQ_MAKER, __VA_ARGS__)) 
+ 
+// An invocation of this or WITH_STRICT_PROFILE must end the builder-pattern. 
+// It takes a Profile as its argument. 
+// 
+// This executes the tests and allows types that are "more referined" than the 
+// profile specifies, but not less. For instance, if the Profile specifies 
+// noexcept copy-constructiblity, the test will fail if the copy-constructor is 
+// not noexcept, however, it will succeed if the copy constructor is trivial. 
+// 
+// This is useful for testing that a type meets some minimum set of 
+// requirements. 
+#define WITH_LOOSE_PROFILE(...)                                      \ 
+  with_loose_profile(                                                \ 
+      ::y_absl::types_internal::MakeLooseProfileRangeT<__VA_ARGS__>()) \ 
+      ABSL_INTERNAL_RPAREN ABSL_INTERNAL_RPAREN;                     \ 
+  else GTEST_FATAL_FAILURE_(gtest_ar.failure_message())  // NOLINT 
+ 
+// An invocation of this or WITH_STRICT_PROFILE must end the builder-pattern. 
+// It takes a Domain and a Profile as its arguments. 
+// 
+// This executes the tests and disallows types that differ at all from the 
+// properties of the Profile. For instance, if the Profile specifies noexcept 
+// copy-constructiblity, the test will fail if the copy constructor is trivial. 
+// 
+// This is useful for testing that a type does not do anything more than a 
+// specification requires, such as to minimize things like Hyrum's Law, or more 
+// commonly, to prevent a type from being "accidentally" copy-constructible in 
+// a way that may produce incorrect results, simply because the user forget to 
+// delete that operation. 
+#define WITH_STRICT_PROFILE(...)                                      \ 
+  with_strict_profile(                                                \ 
+      ::y_absl::types_internal::MakeStrictProfileRangeT<__VA_ARGS__>()) \ 
+      ABSL_INTERNAL_RPAREN ABSL_INTERNAL_RPAREN;                      \ 
+  else GTEST_FATAL_FAILURE_(gtest_ar.failure_message())  // NOLINT 
+ 
+// Internal macro that is used in the internals of the EDSL when forming 
+// equivalence classes. 
+#define ABSL_INTERNAL_PREPEND_EQ_MAKER(arg) \ 
+  ::y_absl::types_internal::EquivalenceClassMaker().arg 
+ 
+}  // namespace types_internal 
+ABSL_NAMESPACE_END 
+}  // namespace y_absl 
+ 
+#endif  // ABSL_TYPES_INTERNAL_CONFORMANCE_TESTING_H_ 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_testing_helpers.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_testing_helpers.h
index 920b5c23ea..cc69cb69b6 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_testing_helpers.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_testing_helpers.h
@@ -1,391 +1,391 @@
-// Copyright 2019 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_TYPES_INTERNAL_CONFORMANCE_TESTING_HELPERS_H_
-#define ABSL_TYPES_INTERNAL_CONFORMANCE_TESTING_HELPERS_H_
-
-// Checks to determine whether or not we can use abi::__cxa_demangle
-#if (defined(__ANDROID__) || defined(ANDROID)) && !defined(OS_ANDROID)
-#define ABSL_INTERNAL_OS_ANDROID
-#endif
-
-// We support certain compilers only.  See demangle.h for details.
-#if defined(OS_ANDROID) && (defined(__i386__) || defined(__x86_64__))
-#define ABSL_TYPES_INTERNAL_HAS_CXA_DEMANGLE 0
-#elif (__GNUC__ >= 4 || (__GNUC__ >= 3 && __GNUC_MINOR__ >= 4)) && \
-    !defined(__mips__)
-#define ABSL_TYPES_INTERNAL_HAS_CXA_DEMANGLE 1
-#elif defined(__clang__) && !defined(_MSC_VER)
-#define ABSL_TYPES_INTERNAL_HAS_CXA_DEMANGLE 1
-#else
-#define ABSL_TYPES_INTERNAL_HAS_CXA_DEMANGLE 0
-#endif
-
-#include <tuple>
-#include <type_traits>
-#include <utility>
-
-#include "y_absl/meta/type_traits.h"
-#include "y_absl/strings/string_view.h"
-#include "y_absl/utility/utility.h"
-
-#if ABSL_TYPES_INTERNAL_HAS_CXA_DEMANGLE
-#include <cxxabi.h>
-
-#include <cstdlib>
-#endif
-
-namespace y_absl {
-ABSL_NAMESPACE_BEGIN
-namespace types_internal {
-
-// Return a readable name for type T.
-template <class T>
-y_absl::string_view NameOfImpl() {
-// TODO(calabrese) Investigate using debugging:internal_demangle as a fallback.
-#if ABSL_TYPES_INTERNAL_HAS_CXA_DEMANGLE
-  int status = 0;
-  char* demangled_name = nullptr;
-
-  demangled_name =
-      abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, &status);
-
-  if (status == 0 && demangled_name != nullptr) {
-    return demangled_name;
-  } else {
-    return typeid(T).name();
-  }
-#else
-  return typeid(T).name();
-#endif
-  // NOTE: We intentionally leak demangled_name so that it remains valid
-  // throughout the remainder of the program.
-}
-
-// Given a type, returns as nice of a type name as we can produce (demangled).
-//
-// Note: This currently strips cv-qualifiers and references, but that is okay
-// because we only use this internally with unqualified object types.
-template <class T>
-TString NameOf() {
-  static const y_absl::string_view result = NameOfImpl<T>();
-  return TString(result);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// Metafunction to check if a type is callable with no explicit arguments
-template <class Fun, class /*Enabler*/ = void>
-struct IsNullaryCallableImpl : std::false_type {};
-
-template <class Fun>
-struct IsNullaryCallableImpl<
-    Fun, y_absl::void_t<decltype(std::declval<const Fun&>()())>>
-    : std::true_type {
-  using result_type = decltype(std::declval<const Fun&>()());
-
-  template <class ValueType>
-  using for_type = std::is_same<ValueType, result_type>;
-
-  using void_if_true = void;
-};
-
-template <class Fun>
-struct IsNullaryCallable : IsNullaryCallableImpl<Fun> {};
-//
-////////////////////////////////////////////////////////////////////////////////
-
-// A type that contains a function object that returns an instance of a type
-// that is undergoing conformance testing. This function is required to always
-// return the same value upon invocation.
-template <class Fun>
-struct GeneratorType;
-
-// A type that contains a tuple of GeneratorType<Fun> where each Fun has the
-// same return type. The result of each of the different generators should all
-// be equal values, though the underlying object representation may differ (such
-// as if one returns 0.0 and another return -0.0, or if one returns an empty
-// vector and another returns an empty vector with a different capacity.
-template <class... Funs>
-struct EquivalenceClassType;
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// A metafunction to check if a type is a specialization of EquivalenceClassType
-template <class T>
-struct IsEquivalenceClass : std::false_type {};
-
-template <>
-struct IsEquivalenceClass<EquivalenceClassType<>> : std::true_type {
-  using self = IsEquivalenceClass;
-
-  // A metafunction to check if this EquivalenceClassType is a valid
-  // EquivalenceClassType for a type `ValueType` that is undergoing testing
-  template <class ValueType>
-  using for_type = std::true_type;
-};
-
-template <class Head, class... Tail>
-struct IsEquivalenceClass<EquivalenceClassType<Head, Tail...>>
-    : std::true_type {
-  using self = IsEquivalenceClass;
-
-  // The type undergoing conformance testing that this EquivalenceClass
-  // corresponds to
-  using result_type = typename IsNullaryCallable<Head>::result_type;
-
-  // A metafunction to check if this EquivalenceClassType is a valid
-  // EquivalenceClassType for a type `ValueType` that is undergoing testing
-  template <class ValueType>
-  using for_type = std::is_same<ValueType, result_type>;
-};
-//
-////////////////////////////////////////////////////////////////////////////////
-
-// A type that contains an ordered series of EquivalenceClassTypes, where the
-// the function object of each underlying GeneratorType has the same return type
-//
-// These equivalence classes are required to be in a logical ascending order
-// that is consistent with comparison operators that are defined for the return
-// type of each GeneratorType, if any.
-template <class... EqClasses>
-struct OrderedEquivalenceClasses;
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// A metafunction to determine the return type of the function object contained
-// in a GeneratorType specialization.
-template <class T>
-struct ResultOfGenerator {};
-
-template <class Fun>
-struct ResultOfGenerator<GeneratorType<Fun>> {
-  using type = decltype(std::declval<const Fun&>()());
-};
-
-template <class Fun>
-using ResultOfGeneratorT = typename ResultOfGenerator<GeneratorType<Fun>>::type;
-//
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// A metafunction that yields true iff each of Funs is a GeneratorType
-// specialization and they all contain functions with the same return type
-template <class /*Enabler*/, class... Funs>
-struct AreGeneratorsWithTheSameReturnTypeImpl : std::false_type {};
-
-template <>
-struct AreGeneratorsWithTheSameReturnTypeImpl<void> : std::true_type {};
-
-template <class Head, class... Tail>
-struct AreGeneratorsWithTheSameReturnTypeImpl<
-    typename std::enable_if<y_absl::conjunction<std::is_same<
-        ResultOfGeneratorT<Head>, ResultOfGeneratorT<Tail>>...>::value>::type,
-    Head, Tail...> : std::true_type {};
-
-template <class... Funs>
-struct AreGeneratorsWithTheSameReturnType
-    : AreGeneratorsWithTheSameReturnTypeImpl<void, Funs...>::type {};
-//
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// A metafunction that yields true iff each of Funs is an EquivalenceClassType
-// specialization and they all contain GeneratorType specializations that have
-// the same return type
-template <class... EqClasses>
-struct AreEquivalenceClassesOfTheSameType {
-  static_assert(sizeof...(EqClasses) != sizeof...(EqClasses), "");
-};
-
-template <>
-struct AreEquivalenceClassesOfTheSameType<> : std::true_type {
-  using self = AreEquivalenceClassesOfTheSameType;
-
-  // Metafunction to check that a type is the same as all of the equivalence
-  // classes, if any.
-  // Note: In this specialization there are no equivalence classes, so the
-  // value type is always compatible.
-  template <class /*ValueType*/>
-  using for_type = std::true_type;
-};
-
-template <class... Funs>
-struct AreEquivalenceClassesOfTheSameType<EquivalenceClassType<Funs...>>
-    : std::true_type {
-  using self = AreEquivalenceClassesOfTheSameType;
-
-  // Metafunction to check that a type is the same as all of the equivalence
-  // classes, if any.
-  template <class ValueType>
-  using for_type = typename IsEquivalenceClass<
-      EquivalenceClassType<Funs...>>::template for_type<ValueType>;
-};
-
-template <class... TailEqClasses>
-struct AreEquivalenceClassesOfTheSameType<
-    EquivalenceClassType<>, EquivalenceClassType<>, TailEqClasses...>
-    : AreEquivalenceClassesOfTheSameType<TailEqClasses...>::self {};
-
-template <class HeadNextFun, class... TailNextFuns, class... TailEqClasses>
-struct AreEquivalenceClassesOfTheSameType<
-    EquivalenceClassType<>, EquivalenceClassType<HeadNextFun, TailNextFuns...>,
-    TailEqClasses...>
-    : AreEquivalenceClassesOfTheSameType<
-          EquivalenceClassType<HeadNextFun, TailNextFuns...>,
-          TailEqClasses...>::self {};
-
-template <class HeadHeadFun, class... TailHeadFuns, class... TailEqClasses>
-struct AreEquivalenceClassesOfTheSameType<
-    EquivalenceClassType<HeadHeadFun, TailHeadFuns...>, EquivalenceClassType<>,
-    TailEqClasses...>
-    : AreEquivalenceClassesOfTheSameType<
-          EquivalenceClassType<HeadHeadFun, TailHeadFuns...>,
-          TailEqClasses...>::self {};
-
-template <class HeadHeadFun, class... TailHeadFuns, class HeadNextFun,
-          class... TailNextFuns, class... TailEqClasses>
-struct AreEquivalenceClassesOfTheSameType<
-    EquivalenceClassType<HeadHeadFun, TailHeadFuns...>,
-    EquivalenceClassType<HeadNextFun, TailNextFuns...>, TailEqClasses...>
-    : y_absl::conditional_t<
-          IsNullaryCallable<HeadNextFun>::template for_type<
-              typename IsNullaryCallable<HeadHeadFun>::result_type>::value,
-          AreEquivalenceClassesOfTheSameType<
-              EquivalenceClassType<HeadHeadFun, TailHeadFuns...>,
-              TailEqClasses...>,
-          std::false_type> {};
-//
-////////////////////////////////////////////////////////////////////////////////
-
-// Execute a function for each passed-in parameter.
-template <class Fun, class... Cases>
-void ForEachParameter(const Fun& fun, const Cases&... cases) {
-  const std::initializer_list<bool> results = {
-      (static_cast<void>(fun(cases)), true)...};
-
-  (void)results;
-}
-
-// Execute a function on each passed-in parameter (using a bound function).
-template <class Fun>
-struct ForEachParameterFun {
-  template <class... T>
-  void operator()(const T&... cases) const {
-    (ForEachParameter)(fun, cases...);
-  }
-
-  Fun fun;
-};
-
-// Execute a function on each element of a tuple.
-template <class Fun, class Tup>
-void ForEachTupleElement(const Fun& fun, const Tup& tup) {
-  y_absl::apply(ForEachParameterFun<Fun>{fun}, tup);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// Execute a function for each combination of two elements of a tuple, including
-// combinations of an element with itself.
-template <class Fun, class... T>
-struct ForEveryTwoImpl {
-  template <class Lhs>
-  struct WithBoundLhs {
-    template <class Rhs>
-    void operator()(const Rhs& rhs) const {
-      fun(lhs, rhs);
-    }
-
-    Fun fun;
-    Lhs lhs;
-  };
-
-  template <class Lhs>
-  void operator()(const Lhs& lhs) const {
-    (ForEachTupleElement)(WithBoundLhs<Lhs>{fun, lhs}, args);
-  }
-
-  Fun fun;
-  std::tuple<T...> args;
-};
-
-template <class Fun, class... T>
-void ForEveryTwo(const Fun& fun, std::tuple<T...> args) {
-  (ForEachTupleElement)(ForEveryTwoImpl<Fun, T...>{fun, args}, args);
-}
-//
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// Insert all values into an associative container
-template<class Container>
-void InsertEach(Container* cont) {
-}
-
-template<class Container, class H, class... T>
-void InsertEach(Container* cont, H&& head, T&&... tail) {
-  cont->insert(head);
-  (InsertEach)(cont, tail...);
-}
-//
-////////////////////////////////////////////////////////////////////////////////
-// A template with a nested "Invoke" static-member-function that executes a
-// passed-in Callable when `Condition` is true, otherwise it ignores the
-// Callable. This is useful for executing a function object with a condition
-// that corresponds to whether or not the Callable can be safely instantiated.
-// It has some overlapping uses with C++17 `if constexpr`.
-template <bool Condition>
-struct If;
-
-template <>
-struct If</*Condition =*/false> {
-  template <class Fun, class... P>
-  static void Invoke(const Fun& /*fun*/, P&&... /*args*/) {}
-};
-
-template <>
-struct If</*Condition =*/true> {
-  template <class Fun, class... P>
-  static void Invoke(const Fun& fun, P&&... args) {
-    // TODO(calabrese) Use std::invoke equivalent instead of function-call.
-    fun(y_absl::forward<P>(args)...);
-  }
-};
-
-//
-// ABSL_INTERNAL_STRINGIZE(...)
-//
-// This variadic macro transforms its arguments into a c-string literal after
-// expansion.
-//
-// Example:
-//
-//   ABSL_INTERNAL_STRINGIZE(std::array<int, 10>)
-//
-// Results in:
-//
-//   "std::array<int, 10>"
-#define ABSL_INTERNAL_STRINGIZE(...) ABSL_INTERNAL_STRINGIZE_IMPL((__VA_ARGS__))
-#define ABSL_INTERNAL_STRINGIZE_IMPL(arg) ABSL_INTERNAL_STRINGIZE_IMPL2 arg
-#define ABSL_INTERNAL_STRINGIZE_IMPL2(...) #__VA_ARGS__
-
-}  // namespace types_internal
-ABSL_NAMESPACE_END
-}  // namespace y_absl
-
-#endif  // ABSL_TYPES_INTERNAL_CONFORMANCE_TESTING_HELPERS_H_
+// Copyright 2019 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_TYPES_INTERNAL_CONFORMANCE_TESTING_HELPERS_H_ 
+#define ABSL_TYPES_INTERNAL_CONFORMANCE_TESTING_HELPERS_H_ 
+ 
+// Checks to determine whether or not we can use abi::__cxa_demangle 
+#if (defined(__ANDROID__) || defined(ANDROID)) && !defined(OS_ANDROID) 
+#define ABSL_INTERNAL_OS_ANDROID 
+#endif 
+ 
+// We support certain compilers only.  See demangle.h for details. 
+#if defined(OS_ANDROID) && (defined(__i386__) || defined(__x86_64__)) 
+#define ABSL_TYPES_INTERNAL_HAS_CXA_DEMANGLE 0 
+#elif (__GNUC__ >= 4 || (__GNUC__ >= 3 && __GNUC_MINOR__ >= 4)) && \ 
+    !defined(__mips__) 
+#define ABSL_TYPES_INTERNAL_HAS_CXA_DEMANGLE 1 
+#elif defined(__clang__) && !defined(_MSC_VER) 
+#define ABSL_TYPES_INTERNAL_HAS_CXA_DEMANGLE 1 
+#else 
+#define ABSL_TYPES_INTERNAL_HAS_CXA_DEMANGLE 0 
+#endif 
+ 
+#include <tuple> 
+#include <type_traits> 
+#include <utility> 
+ 
+#include "y_absl/meta/type_traits.h" 
+#include "y_absl/strings/string_view.h" 
+#include "y_absl/utility/utility.h" 
+ 
+#if ABSL_TYPES_INTERNAL_HAS_CXA_DEMANGLE 
+#include <cxxabi.h> 
+ 
+#include <cstdlib> 
+#endif 
+ 
+namespace y_absl { 
+ABSL_NAMESPACE_BEGIN 
+namespace types_internal { 
+ 
+// Return a readable name for type T. 
+template <class T> 
+y_absl::string_view NameOfImpl() { 
+// TODO(calabrese) Investigate using debugging:internal_demangle as a fallback. 
+#if ABSL_TYPES_INTERNAL_HAS_CXA_DEMANGLE 
+  int status = 0; 
+  char* demangled_name = nullptr; 
+ 
+  demangled_name = 
+      abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, &status); 
+ 
+  if (status == 0 && demangled_name != nullptr) { 
+    return demangled_name; 
+  } else { 
+    return typeid(T).name(); 
+  } 
+#else 
+  return typeid(T).name(); 
+#endif 
+  // NOTE: We intentionally leak demangled_name so that it remains valid 
+  // throughout the remainder of the program. 
+} 
+ 
+// Given a type, returns as nice of a type name as we can produce (demangled). 
+// 
+// Note: This currently strips cv-qualifiers and references, but that is okay 
+// because we only use this internally with unqualified object types. 
+template <class T> 
+TString NameOf() { 
+  static const y_absl::string_view result = NameOfImpl<T>(); 
+  return TString(result); 
+} 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+// 
+// Metafunction to check if a type is callable with no explicit arguments 
+template <class Fun, class /*Enabler*/ = void> 
+struct IsNullaryCallableImpl : std::false_type {}; 
+ 
+template <class Fun> 
+struct IsNullaryCallableImpl< 
+    Fun, y_absl::void_t<decltype(std::declval<const Fun&>()())>> 
+    : std::true_type { 
+  using result_type = decltype(std::declval<const Fun&>()()); 
+ 
+  template <class ValueType> 
+  using for_type = std::is_same<ValueType, result_type>; 
+ 
+  using void_if_true = void; 
+}; 
+ 
+template <class Fun> 
+struct IsNullaryCallable : IsNullaryCallableImpl<Fun> {}; 
+// 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+// A type that contains a function object that returns an instance of a type 
+// that is undergoing conformance testing. This function is required to always 
+// return the same value upon invocation. 
+template <class Fun> 
+struct GeneratorType; 
+ 
+// A type that contains a tuple of GeneratorType<Fun> where each Fun has the 
+// same return type. The result of each of the different generators should all 
+// be equal values, though the underlying object representation may differ (such 
+// as if one returns 0.0 and another return -0.0, or if one returns an empty 
+// vector and another returns an empty vector with a different capacity. 
+template <class... Funs> 
+struct EquivalenceClassType; 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+// 
+// A metafunction to check if a type is a specialization of EquivalenceClassType 
+template <class T> 
+struct IsEquivalenceClass : std::false_type {}; 
+ 
+template <> 
+struct IsEquivalenceClass<EquivalenceClassType<>> : std::true_type { 
+  using self = IsEquivalenceClass; 
+ 
+  // A metafunction to check if this EquivalenceClassType is a valid 
+  // EquivalenceClassType for a type `ValueType` that is undergoing testing 
+  template <class ValueType> 
+  using for_type = std::true_type; 
+}; 
+ 
+template <class Head, class... Tail> 
+struct IsEquivalenceClass<EquivalenceClassType<Head, Tail...>> 
+    : std::true_type { 
+  using self = IsEquivalenceClass; 
+ 
+  // The type undergoing conformance testing that this EquivalenceClass 
+  // corresponds to 
+  using result_type = typename IsNullaryCallable<Head>::result_type; 
+ 
+  // A metafunction to check if this EquivalenceClassType is a valid 
+  // EquivalenceClassType for a type `ValueType` that is undergoing testing 
+  template <class ValueType> 
+  using for_type = std::is_same<ValueType, result_type>; 
+}; 
+// 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+// A type that contains an ordered series of EquivalenceClassTypes, where the 
+// the function object of each underlying GeneratorType has the same return type 
+// 
+// These equivalence classes are required to be in a logical ascending order 
+// that is consistent with comparison operators that are defined for the return 
+// type of each GeneratorType, if any. 
+template <class... EqClasses> 
+struct OrderedEquivalenceClasses; 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+// 
+// A metafunction to determine the return type of the function object contained 
+// in a GeneratorType specialization. 
+template <class T> 
+struct ResultOfGenerator {}; 
+ 
+template <class Fun> 
+struct ResultOfGenerator<GeneratorType<Fun>> { 
+  using type = decltype(std::declval<const Fun&>()()); 
+}; 
+ 
+template <class Fun> 
+using ResultOfGeneratorT = typename ResultOfGenerator<GeneratorType<Fun>>::type; 
+// 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+// 
+// A metafunction that yields true iff each of Funs is a GeneratorType 
+// specialization and they all contain functions with the same return type 
+template <class /*Enabler*/, class... Funs> 
+struct AreGeneratorsWithTheSameReturnTypeImpl : std::false_type {}; 
+ 
+template <> 
+struct AreGeneratorsWithTheSameReturnTypeImpl<void> : std::true_type {}; 
+ 
+template <class Head, class... Tail> 
+struct AreGeneratorsWithTheSameReturnTypeImpl< 
+    typename std::enable_if<y_absl::conjunction<std::is_same< 
+        ResultOfGeneratorT<Head>, ResultOfGeneratorT<Tail>>...>::value>::type, 
+    Head, Tail...> : std::true_type {}; 
+ 
+template <class... Funs> 
+struct AreGeneratorsWithTheSameReturnType 
+    : AreGeneratorsWithTheSameReturnTypeImpl<void, Funs...>::type {}; 
+// 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+// 
+// A metafunction that yields true iff each of Funs is an EquivalenceClassType 
+// specialization and they all contain GeneratorType specializations that have 
+// the same return type 
+template <class... EqClasses> 
+struct AreEquivalenceClassesOfTheSameType { 
+  static_assert(sizeof...(EqClasses) != sizeof...(EqClasses), ""); 
+}; 
+ 
+template <> 
+struct AreEquivalenceClassesOfTheSameType<> : std::true_type { 
+  using self = AreEquivalenceClassesOfTheSameType; 
+ 
+  // Metafunction to check that a type is the same as all of the equivalence 
+  // classes, if any. 
+  // Note: In this specialization there are no equivalence classes, so the 
+  // value type is always compatible. 
+  template <class /*ValueType*/> 
+  using for_type = std::true_type; 
+}; 
+ 
+template <class... Funs> 
+struct AreEquivalenceClassesOfTheSameType<EquivalenceClassType<Funs...>> 
+    : std::true_type { 
+  using self = AreEquivalenceClassesOfTheSameType; 
+ 
+  // Metafunction to check that a type is the same as all of the equivalence 
+  // classes, if any. 
+  template <class ValueType> 
+  using for_type = typename IsEquivalenceClass< 
+      EquivalenceClassType<Funs...>>::template for_type<ValueType>; 
+}; 
+ 
+template <class... TailEqClasses> 
+struct AreEquivalenceClassesOfTheSameType< 
+    EquivalenceClassType<>, EquivalenceClassType<>, TailEqClasses...> 
+    : AreEquivalenceClassesOfTheSameType<TailEqClasses...>::self {}; 
+ 
+template <class HeadNextFun, class... TailNextFuns, class... TailEqClasses> 
+struct AreEquivalenceClassesOfTheSameType< 
+    EquivalenceClassType<>, EquivalenceClassType<HeadNextFun, TailNextFuns...>, 
+    TailEqClasses...> 
+    : AreEquivalenceClassesOfTheSameType< 
+          EquivalenceClassType<HeadNextFun, TailNextFuns...>, 
+          TailEqClasses...>::self {}; 
+ 
+template <class HeadHeadFun, class... TailHeadFuns, class... TailEqClasses> 
+struct AreEquivalenceClassesOfTheSameType< 
+    EquivalenceClassType<HeadHeadFun, TailHeadFuns...>, EquivalenceClassType<>, 
+    TailEqClasses...> 
+    : AreEquivalenceClassesOfTheSameType< 
+          EquivalenceClassType<HeadHeadFun, TailHeadFuns...>, 
+          TailEqClasses...>::self {}; 
+ 
+template <class HeadHeadFun, class... TailHeadFuns, class HeadNextFun, 
+          class... TailNextFuns, class... TailEqClasses> 
+struct AreEquivalenceClassesOfTheSameType< 
+    EquivalenceClassType<HeadHeadFun, TailHeadFuns...>, 
+    EquivalenceClassType<HeadNextFun, TailNextFuns...>, TailEqClasses...> 
+    : y_absl::conditional_t< 
+          IsNullaryCallable<HeadNextFun>::template for_type< 
+              typename IsNullaryCallable<HeadHeadFun>::result_type>::value, 
+          AreEquivalenceClassesOfTheSameType< 
+              EquivalenceClassType<HeadHeadFun, TailHeadFuns...>, 
+              TailEqClasses...>, 
+          std::false_type> {}; 
+// 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+// Execute a function for each passed-in parameter. 
+template <class Fun, class... Cases> 
+void ForEachParameter(const Fun& fun, const Cases&... cases) { 
+  const std::initializer_list<bool> results = { 
+      (static_cast<void>(fun(cases)), true)...}; 
+ 
+  (void)results; 
+} 
+ 
+// Execute a function on each passed-in parameter (using a bound function). 
+template <class Fun> 
+struct ForEachParameterFun { 
+  template <class... T> 
+  void operator()(const T&... cases) const { 
+    (ForEachParameter)(fun, cases...); 
+  } 
+ 
+  Fun fun; 
+}; 
+ 
+// Execute a function on each element of a tuple. 
+template <class Fun, class Tup> 
+void ForEachTupleElement(const Fun& fun, const Tup& tup) { 
+  y_absl::apply(ForEachParameterFun<Fun>{fun}, tup); 
+} 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+// 
+// Execute a function for each combination of two elements of a tuple, including 
+// combinations of an element with itself. 
+template <class Fun, class... T> 
+struct ForEveryTwoImpl { 
+  template <class Lhs> 
+  struct WithBoundLhs { 
+    template <class Rhs> 
+    void operator()(const Rhs& rhs) const { 
+      fun(lhs, rhs); 
+    } 
+ 
+    Fun fun; 
+    Lhs lhs; 
+  }; 
+ 
+  template <class Lhs> 
+  void operator()(const Lhs& lhs) const { 
+    (ForEachTupleElement)(WithBoundLhs<Lhs>{fun, lhs}, args); 
+  } 
+ 
+  Fun fun; 
+  std::tuple<T...> args; 
+}; 
+ 
+template <class Fun, class... T> 
+void ForEveryTwo(const Fun& fun, std::tuple<T...> args) { 
+  (ForEachTupleElement)(ForEveryTwoImpl<Fun, T...>{fun, args}, args); 
+} 
+// 
+//////////////////////////////////////////////////////////////////////////////// 
+ 
+//////////////////////////////////////////////////////////////////////////////// 
+// 
+// Insert all values into an associative container 
+template<class Container> 
+void InsertEach(Container* cont) { 
+} 
+ 
+template<class Container, class H, class... T> 
+void InsertEach(Container* cont, H&& head, T&&... tail) { 
+  cont->insert(head); 
+  (InsertEach)(cont, tail...); 
+} 
+// 
+//////////////////////////////////////////////////////////////////////////////// 
+// A template with a nested "Invoke" static-member-function that executes a 
+// passed-in Callable when `Condition` is true, otherwise it ignores the 
+// Callable. This is useful for executing a function object with a condition 
+// that corresponds to whether or not the Callable can be safely instantiated. 
+// It has some overlapping uses with C++17 `if constexpr`. 
+template <bool Condition> 
+struct If; 
+ 
+template <> 
+struct If</*Condition =*/false> { 
+  template <class Fun, class... P> 
+  static void Invoke(const Fun& /*fun*/, P&&... /*args*/) {} 
+}; 
+ 
+template <> 
+struct If</*Condition =*/true> { 
+  template <class Fun, class... P> 
+  static void Invoke(const Fun& fun, P&&... args) { 
+    // TODO(calabrese) Use std::invoke equivalent instead of function-call. 
+    fun(y_absl::forward<P>(args)...); 
+  } 
+}; 
+ 
+// 
+// ABSL_INTERNAL_STRINGIZE(...) 
+// 
+// This variadic macro transforms its arguments into a c-string literal after 
+// expansion. 
+// 
+// Example: 
+// 
+//   ABSL_INTERNAL_STRINGIZE(std::array<int, 10>) 
+// 
+// Results in: 
+// 
+//   "std::array<int, 10>" 
+#define ABSL_INTERNAL_STRINGIZE(...) ABSL_INTERNAL_STRINGIZE_IMPL((__VA_ARGS__)) 
+#define ABSL_INTERNAL_STRINGIZE_IMPL(arg) ABSL_INTERNAL_STRINGIZE_IMPL2 arg 
+#define ABSL_INTERNAL_STRINGIZE_IMPL2(...) #__VA_ARGS__ 
+ 
+}  // namespace types_internal 
+ABSL_NAMESPACE_END 
+}  // namespace y_absl 
+ 
+#endif  // ABSL_TYPES_INTERNAL_CONFORMANCE_TESTING_HELPERS_H_ 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/parentheses.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/parentheses.h
index 5aebee8fde..1a5e108a21 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/parentheses.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/parentheses.h
@@ -1,34 +1,34 @@
-// Copyright 2019 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.
-//
-// -----------------------------------------------------------------------------
-// parentheses.h
-// -----------------------------------------------------------------------------
-//
-// This file contains macros that expand to a left parenthesis and a right
-// parenthesis. These are in their own file and are generated from macros
-// because otherwise clang-format gets confused and clang-format off directives
-// do not help.
-//
-// The parentheses macros are used when wanting to require a rescan before
-// expansion of parenthesized text appearing after a function-style macro name.
-
-#ifndef ABSL_TYPES_INTERNAL_PARENTHESES_H_
-#define ABSL_TYPES_INTERNAL_PARENTHESES_H_
-
-#define ABSL_INTERNAL_LPAREN (
-
-#define ABSL_INTERNAL_RPAREN )
-
-#endif  // ABSL_TYPES_INTERNAL_PARENTHESES_H_
+// Copyright 2019 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. 
+// 
+// ----------------------------------------------------------------------------- 
+// parentheses.h 
+// ----------------------------------------------------------------------------- 
+// 
+// This file contains macros that expand to a left parenthesis and a right 
+// parenthesis. These are in their own file and are generated from macros 
+// because otherwise clang-format gets confused and clang-format off directives 
+// do not help. 
+// 
+// The parentheses macros are used when wanting to require a rescan before 
+// expansion of parenthesized text appearing after a function-style macro name. 
+ 
+#ifndef ABSL_TYPES_INTERNAL_PARENTHESES_H_ 
+#define ABSL_TYPES_INTERNAL_PARENTHESES_H_ 
+ 
+#define ABSL_INTERNAL_LPAREN ( 
+ 
+#define ABSL_INTERNAL_RPAREN ) 
+ 
+#endif  // ABSL_TYPES_INTERNAL_PARENTHESES_H_ 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/transform_args.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/transform_args.h
index 4a0ab42ac4..c89f4992fd 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/transform_args.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/transform_args.h
@@ -1,246 +1,246 @@
-// Copyright 2019 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.
-//
-// -----------------------------------------------------------------------------
-// transform_args.h
-// -----------------------------------------------------------------------------
-//
-// This file contains a higher-order macro that "transforms" each element of a
-// a variadic argument by a provided secondary macro.
-
-#ifndef ABSL_TYPES_INTERNAL_TRANSFORM_ARGS_H_
-#define ABSL_TYPES_INTERNAL_TRANSFORM_ARGS_H_
-
-//
-// ABSL_INTERNAL_CAT(a, b)
-//
-// This macro takes two arguments and concatenates them together via ## after
-// expansion.
-//
-// Example:
-//
-//   ABSL_INTERNAL_CAT(foo_, bar)
-//
-// Results in:
-//
-//   foo_bar
-#define ABSL_INTERNAL_CAT(a, b) ABSL_INTERNAL_CAT_IMPL(a, b)
-#define ABSL_INTERNAL_CAT_IMPL(a, b) a##b
-
-//
-// ABSL_INTERNAL_TRANSFORM_ARGS(m, ...)
-//
-// This macro takes another macro as an argument followed by a trailing series
-// of additional parameters (up to 32 additional arguments). It invokes the
-// passed-in macro once for each of the additional arguments, with the
-// expansions separated by commas.
-//
-// Example:
-//
-//   ABSL_INTERNAL_TRANSFORM_ARGS(MY_MACRO, a, b, c)
-//
-// Results in:
-//
-//   MY_MACRO(a), MY_MACRO(b), MY_MACRO(c)
-//
-// TODO(calabrese) Handle no arguments as a special case.
-#define ABSL_INTERNAL_TRANSFORM_ARGS(m, ...)             \
-  ABSL_INTERNAL_CAT(ABSL_INTERNAL_TRANSFORM_ARGS,        \
-                    ABSL_INTERNAL_NUM_ARGS(__VA_ARGS__)) \
-  (m, __VA_ARGS__)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS1(m, a0) m(a0)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS2(m, a0, a1) m(a0), m(a1)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS3(m, a0, a1, a2) m(a0), m(a1), m(a2)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS4(m, a0, a1, a2, a3) \
-  m(a0), m(a1), m(a2), m(a3)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS5(m, a0, a1, a2, a3, a4) \
-  m(a0), m(a1), m(a2), m(a3), m(a4)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS6(m, a0, a1, a2, a3, a4, a5) \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS7(m, a0, a1, a2, a3, a4, a5, a6) \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS8(m, a0, a1, a2, a3, a4, a5, a6, a7) \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS9(m, a0, a1, a2, a3, a4, a5, a6, a7, a8) \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS10(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
-                                       a9)                                    \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS11(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
-                                       a9, a10)                               \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9), m(a10)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS12(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
-                                       a9, a10, a11)                          \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS13(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
-                                       a9, a10, a11, a12)                     \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS14(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
-                                       a9, a10, a11, a12, a13)                \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS15(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
-                                       a9, a10, a11, a12, a13, a14)           \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13), m(a14)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS16(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
-                                       a9, a10, a11, a12, a13, a14, a15)      \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS17(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
-                                       a9, a10, a11, a12, a13, a14, a15, a16) \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS18(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
-                                       a9, a10, a11, a12, a13, a14, a15, a16, \
-                                       a17)                                   \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS19(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
-                                       a9, a10, a11, a12, a13, a14, a15, a16, \
-                                       a17, a18)                              \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS20(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
-                                       a9, a10, a11, a12, a13, a14, a15, a16, \
-                                       a17, a18, a19)                         \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
-      m(a19)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS21(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
-                                       a9, a10, a11, a12, a13, a14, a15, a16, \
-                                       a17, a18, a19, a20)                    \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
-      m(a19), m(a20)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS22(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
-                                       a9, a10, a11, a12, a13, a14, a15, a16, \
-                                       a17, a18, a19, a20, a21)               \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
-      m(a19), m(a20), m(a21)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS23(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
-                                       a9, a10, a11, a12, a13, a14, a15, a16, \
-                                       a17, a18, a19, a20, a21, a22)          \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
-      m(a19), m(a20), m(a21), m(a22)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS24(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
-                                       a9, a10, a11, a12, a13, a14, a15, a16, \
-                                       a17, a18, a19, a20, a21, a22, a23)     \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
-      m(a19), m(a20), m(a21), m(a22), m(a23)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS25(m, a0, a1, a2, a3, a4, a5, a6, a7, a8,  \
-                                       a9, a10, a11, a12, a13, a14, a15, a16,  \
-                                       a17, a18, a19, a20, a21, a22, a23, a24) \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),        \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18),  \
-      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS26(                                       \
-    m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,  \
-    a16, a17, a18, a19, a20, a21, a22, a23, a24, a25)                         \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
-      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS27(                                       \
-    m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,  \
-    a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26)                    \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
-      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS28(                                       \
-    m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,  \
-    a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27)               \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
-      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26), m(a27)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS29(                                       \
-    m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,  \
-    a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28)          \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
-      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26), m(a27), \
-      m(a28)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS30(                                       \
-    m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,  \
-    a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29)     \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
-      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26), m(a27), \
-      m(a28), m(a29)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS31(                                        \
-    m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,   \
-    a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30) \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),        \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18),  \
-      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26), m(a27),  \
-      m(a28), m(a29), m(a30)
-
-#define ABSL_INTERNAL_TRANSFORM_ARGS32(m, a0, a1, a2, a3, a4, a5, a6, a7, a8,  \
-                                       a9, a10, a11, a12, a13, a14, a15, a16,  \
-                                       a17, a18, a19, a20, a21, a22, a23, a24, \
-                                       a25, a26, a27, a28, a29, a30, a31)      \
-  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),        \
-      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18),  \
-      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26), m(a27),  \
-      m(a28), m(a29), m(a30), m(a31)
-
-#define ABSL_INTERNAL_NUM_ARGS_IMPL(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,    \
-                                    a10, a11, a12, a13, a14, a15, a16, a17,    \
-                                    a18, a19, a20, a21, a22, a23, a24, a25,    \
-                                    a26, a27, a28, a29, a30, a31, result, ...) \
-  result
-
-#define ABSL_INTERNAL_FORCE_EXPANSION(...) __VA_ARGS__
-
-#define ABSL_INTERNAL_NUM_ARGS(...)                                            \
-  ABSL_INTERNAL_FORCE_EXPANSION(ABSL_INTERNAL_NUM_ARGS_IMPL(                   \
-      __VA_ARGS__, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, \
-      17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, ))
-
-#endif  // ABSL_TYPES_INTERNAL_TRANSFORM_ARGS_H_
+// Copyright 2019 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. 
+// 
+// ----------------------------------------------------------------------------- 
+// transform_args.h 
+// ----------------------------------------------------------------------------- 
+// 
+// This file contains a higher-order macro that "transforms" each element of a 
+// a variadic argument by a provided secondary macro. 
+ 
+#ifndef ABSL_TYPES_INTERNAL_TRANSFORM_ARGS_H_ 
+#define ABSL_TYPES_INTERNAL_TRANSFORM_ARGS_H_ 
+ 
+// 
+// ABSL_INTERNAL_CAT(a, b) 
+// 
+// This macro takes two arguments and concatenates them together via ## after 
+// expansion. 
+// 
+// Example: 
+// 
+//   ABSL_INTERNAL_CAT(foo_, bar) 
+// 
+// Results in: 
+// 
+//   foo_bar 
+#define ABSL_INTERNAL_CAT(a, b) ABSL_INTERNAL_CAT_IMPL(a, b) 
+#define ABSL_INTERNAL_CAT_IMPL(a, b) a##b 
+ 
+// 
+// ABSL_INTERNAL_TRANSFORM_ARGS(m, ...) 
+// 
+// This macro takes another macro as an argument followed by a trailing series 
+// of additional parameters (up to 32 additional arguments). It invokes the 
+// passed-in macro once for each of the additional arguments, with the 
+// expansions separated by commas. 
+// 
+// Example: 
+// 
+//   ABSL_INTERNAL_TRANSFORM_ARGS(MY_MACRO, a, b, c) 
+// 
+// Results in: 
+// 
+//   MY_MACRO(a), MY_MACRO(b), MY_MACRO(c) 
+// 
+// TODO(calabrese) Handle no arguments as a special case. 
+#define ABSL_INTERNAL_TRANSFORM_ARGS(m, ...)             \ 
+  ABSL_INTERNAL_CAT(ABSL_INTERNAL_TRANSFORM_ARGS,        \ 
+                    ABSL_INTERNAL_NUM_ARGS(__VA_ARGS__)) \ 
+  (m, __VA_ARGS__) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS1(m, a0) m(a0) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS2(m, a0, a1) m(a0), m(a1) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS3(m, a0, a1, a2) m(a0), m(a1), m(a2) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS4(m, a0, a1, a2, a3) \ 
+  m(a0), m(a1), m(a2), m(a3) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS5(m, a0, a1, a2, a3, a4) \ 
+  m(a0), m(a1), m(a2), m(a3), m(a4) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS6(m, a0, a1, a2, a3, a4, a5) \ 
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS7(m, a0, a1, a2, a3, a4, a5, a6) \ 
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS8(m, a0, a1, a2, a3, a4, a5, a6, a7) \ 
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS9(m, a0, a1, a2, a3, a4, a5, a6, a7, a8) \ 
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS10(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \ 
+                                       a9)                                    \ 
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS11(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \ 
+                                       a9, a10)                               \ 
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9), m(a10) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS12(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \ 
+                                       a9, a10, a11)                          \ 
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \ 
+      m(a10), m(a11) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS13(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \ 
+                                       a9, a10, a11, a12)                     \ 
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \ 
+      m(a10), m(a11), m(a12) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS14(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \ 
+                                       a9, a10, a11, a12, a13)                \ 
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \ 
+      m(a10), m(a11), m(a12), m(a13) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS15(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \ 
+                                       a9, a10, a11, a12, a13, a14)           \ 
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \ 
+      m(a10), m(a11), m(a12), m(a13), m(a14) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS16(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \ 
+                                       a9, a10, a11, a12, a13, a14, a15)      \ 
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \ 
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS17(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \ 
+                                       a9, a10, a11, a12, a13, a14, a15, a16) \ 
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \ 
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS18(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \ 
+                                       a9, a10, a11, a12, a13, a14, a15, a16, \ 
+                                       a17)                                   \ 
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \ 
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS19(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \ 
+                                       a9, a10, a11, a12, a13, a14, a15, a16, \ 
+                                       a17, a18)                              \ 
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \ 
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS20(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \ 
+                                       a9, a10, a11, a12, a13, a14, a15, a16, \ 
+                                       a17, a18, a19)                         \ 
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \ 
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \ 
+      m(a19) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS21(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \ 
+                                       a9, a10, a11, a12, a13, a14, a15, a16, \ 
+                                       a17, a18, a19, a20)                    \ 
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \ 
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \ 
+      m(a19), m(a20) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS22(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \ 
+                                       a9, a10, a11, a12, a13, a14, a15, a16, \ 
+                                       a17, a18, a19, a20, a21)               \ 
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \ 
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \ 
+      m(a19), m(a20), m(a21) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS23(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \ 
+                                       a9, a10, a11, a12, a13, a14, a15, a16, \ 
+                                       a17, a18, a19, a20, a21, a22)          \ 
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \ 
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \ 
+      m(a19), m(a20), m(a21), m(a22) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS24(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \ 
+                                       a9, a10, a11, a12, a13, a14, a15, a16, \ 
+                                       a17, a18, a19, a20, a21, a22, a23)     \ 
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \ 
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \ 
+      m(a19), m(a20), m(a21), m(a22), m(a23) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS25(m, a0, a1, a2, a3, a4, a5, a6, a7, a8,  \ 
+                                       a9, a10, a11, a12, a13, a14, a15, a16,  \ 
+                                       a17, a18, a19, a20, a21, a22, a23, a24) \ 
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),        \ 
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18),  \ 
+      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS26(                                       \ 
+    m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,  \ 
+    a16, a17, a18, a19, a20, a21, a22, a23, a24, a25)                         \ 
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \ 
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \ 
+      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS27(                                       \ 
+    m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,  \ 
+    a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26)                    \ 
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \ 
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \ 
+      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS28(                                       \ 
+    m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,  \ 
+    a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27)               \ 
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \ 
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \ 
+      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26), m(a27) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS29(                                       \ 
+    m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,  \ 
+    a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28)          \ 
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \ 
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \ 
+      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26), m(a27), \ 
+      m(a28) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS30(                                       \ 
+    m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,  \ 
+    a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29)     \ 
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \ 
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \ 
+      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26), m(a27), \ 
+      m(a28), m(a29) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS31(                                        \ 
+    m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,   \ 
+    a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30) \ 
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),        \ 
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18),  \ 
+      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26), m(a27),  \ 
+      m(a28), m(a29), m(a30) 
+ 
+#define ABSL_INTERNAL_TRANSFORM_ARGS32(m, a0, a1, a2, a3, a4, a5, a6, a7, a8,  \ 
+                                       a9, a10, a11, a12, a13, a14, a15, a16,  \ 
+                                       a17, a18, a19, a20, a21, a22, a23, a24, \ 
+                                       a25, a26, a27, a28, a29, a30, a31)      \ 
+  m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),        \ 
+      m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18),  \ 
+      m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26), m(a27),  \ 
+      m(a28), m(a29), m(a30), m(a31) 
+ 
+#define ABSL_INTERNAL_NUM_ARGS_IMPL(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,    \ 
+                                    a10, a11, a12, a13, a14, a15, a16, a17,    \ 
+                                    a18, a19, a20, a21, a22, a23, a24, a25,    \ 
+                                    a26, a27, a28, a29, a30, a31, result, ...) \ 
+  result 
+ 
+#define ABSL_INTERNAL_FORCE_EXPANSION(...) __VA_ARGS__ 
+ 
+#define ABSL_INTERNAL_NUM_ARGS(...)                                            \ 
+  ABSL_INTERNAL_FORCE_EXPANSION(ABSL_INTERNAL_NUM_ARGS_IMPL(                   \ 
+      __VA_ARGS__, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, \ 
+      17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, )) 
+ 
+#endif  // ABSL_TYPES_INTERNAL_TRANSFORM_ARGS_H_ 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/variant.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/variant.h
index 4495fb4de6..1f224dc51f 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/variant.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/variant.h
@@ -45,7 +45,7 @@ ABSL_NAMESPACE_BEGIN
 template <class... Types>
 class variant;
 
-ABSL_INTERNAL_INLINE_CONSTEXPR(size_t, variant_npos, static_cast<size_t>(-1));
+ABSL_INTERNAL_INLINE_CONSTEXPR(size_t, variant_npos, static_cast<size_t>(-1)); 
 
 template <class T>
 struct variant_size;
@@ -292,7 +292,7 @@ struct UnreachableSwitchCase {
 template <class Op, std::size_t I>
 struct ReachableSwitchCase {
   static VisitIndicesResultT<Op, std::size_t> Run(Op&& op) {
-    return y_absl::base_internal::invoke(y_absl::forward<Op>(op), SizeT<I>());
+    return y_absl::base_internal::invoke(y_absl::forward<Op>(op), SizeT<I>()); 
   }
 };
 
@@ -424,7 +424,7 @@ struct VisitIndicesSwitch {
         return PickCase<Op, 32, EndIndex>::Run(y_absl::forward<Op>(op));
       default:
         ABSL_ASSERT(i == variant_npos);
-        return y_absl::base_internal::invoke(y_absl::forward<Op>(op), NPos());
+        return y_absl::base_internal::invoke(y_absl::forward<Op>(op), NPos()); 
     }
   }
 };
@@ -488,7 +488,7 @@ struct VisitIndicesVariadicImpl<y_absl::index_sequence<N...>, EndIndices...> {
     template <std::size_t I>
     VisitIndicesResultT<Op, decltype(EndIndices)...> operator()(
         SizeT<I> /*index*/) && {
-      return base_internal::invoke(
+      return base_internal::invoke( 
           y_absl::forward<Op>(op),
           SizeT<UnflattenIndex<I, N, (EndIndices + 1)...>::value -
                 std::size_t{1}>()...);
@@ -930,7 +930,7 @@ struct PerformVisitation {
                      y_absl::result_of_t<Op(VariantAccessResult<
                                           Is, QualifiedVariants>...)>>::value,
         "All visitation overloads must have the same return type.");
-    return y_absl::base_internal::invoke(
+    return y_absl::base_internal::invoke( 
         y_absl::forward<Op>(op),
         VariantCoreAccess::Access<Is>(
             y_absl::forward<QualifiedVariants>(std::get<TupIs>(variant_tup)))...);
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/optional.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/optional.h
index d4ef0bb57b..028e51de8f 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/optional.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/optional.h
@@ -136,10 +136,10 @@ class optional : private optional_internal::optional_data<T>,
   constexpr optional(nullopt_t) noexcept {}  // NOLINT(runtime/explicit)
 
   // Copy constructor, standard semantics
-  optional(const optional&) = default;
+  optional(const optional&) = default; 
 
   // Move constructor, standard semantics
-  optional(optional&&) = default;
+  optional(optional&&) = default; 
 
   // Constructs a non-empty `optional` direct-initialized value of type `T` from
   // the arguments `std::forward<Args>(args)...`  within the `optional`.
@@ -412,11 +412,11 @@ class optional : private optional_internal::optional_data<T>,
   //
   // If you need myOpt->foo in constexpr, use (*myOpt).foo instead.
   const T* operator->() const {
-    ABSL_HARDENING_ASSERT(this->engaged_);
+    ABSL_HARDENING_ASSERT(this->engaged_); 
     return std::addressof(this->data_);
   }
   T* operator->() {
-    ABSL_HARDENING_ASSERT(this->engaged_);
+    ABSL_HARDENING_ASSERT(this->engaged_); 
     return std::addressof(this->data_);
   }
 
@@ -425,17 +425,17 @@ class optional : private optional_internal::optional_data<T>,
   // Accesses the underlying `T` value of an `optional`. If the `optional` is
   // empty, behavior is undefined.
   constexpr const T& operator*() const& {
-    return ABSL_HARDENING_ASSERT(this->engaged_), reference();
+    return ABSL_HARDENING_ASSERT(this->engaged_), reference(); 
   }
   T& operator*() & {
-    ABSL_HARDENING_ASSERT(this->engaged_);
+    ABSL_HARDENING_ASSERT(this->engaged_); 
     return reference();
   }
   constexpr const T&& operator*() const && {
-    return ABSL_HARDENING_ASSERT(this->engaged_), y_absl::move(reference());
+    return ABSL_HARDENING_ASSERT(this->engaged_), y_absl::move(reference()); 
   }
   T&& operator*() && {
-    ABSL_HARDENING_ASSERT(this->engaged_);
+    ABSL_HARDENING_ASSERT(this->engaged_); 
     return std::move(reference());
   }
 
@@ -444,7 +444,7 @@ class optional : private optional_internal::optional_data<T>,
   // Returns false if and only if the `optional` is empty.
   //
   //   if (opt) {
-  //     // do something with *opt or opt->;
+  //     // do something with *opt or opt->; 
   //   } else {
   //     // opt is empty.
   //   }
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/span.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/span.h
index 1490b2f1b2..9c8165f0a8 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/span.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/span.h
@@ -17,23 +17,23 @@
 // span.h
 // -----------------------------------------------------------------------------
 //
-// This header file defines a `Span<T>` type for holding a reference to existing
-// array data. The `Span` object, much like the `y_absl::string_view` object,
-// does not own such data itself, and the data being referenced by the span must
-// outlive the span itself. Unlike `view` type references, a span can hold a
-// reference to mutable data (and can mutate it for underlying types of
-// non-const T.) A span provides a lightweight way to pass a reference to such
-// data.
+// This header file defines a `Span<T>` type for holding a reference to existing 
+// array data. The `Span` object, much like the `y_absl::string_view` object, 
+// does not own such data itself, and the data being referenced by the span must 
+// outlive the span itself. Unlike `view` type references, a span can hold a 
+// reference to mutable data (and can mutate it for underlying types of 
+// non-const T.) A span provides a lightweight way to pass a reference to such 
+// data. 
 //
 // Additionally, this header file defines `MakeSpan()` and `MakeConstSpan()`
 // factory functions, for clearly creating spans of type `Span<T>` or read-only
 // `Span<const T>` when such types may be difficult to identify due to issues
 // with implicit conversion.
 //
-// The C++20 draft standard includes a `std::span` type. As of June 2020, the
-// differences between `y_absl::Span` and `std::span` are:
-//    * `y_absl::Span` has `operator==` (which is likely a design bug,
-//       per https://abseil.io/blog/20180531-regular-types)
+// The C++20 draft standard includes a `std::span` type. As of June 2020, the 
+// differences between `y_absl::Span` and `std::span` are: 
+//    * `y_absl::Span` has `operator==` (which is likely a design bug, 
+//       per https://abseil.io/blog/20180531-regular-types) 
 //    * `y_absl::Span` has the factory functions `MakeSpan()` and
 //      `MakeConstSpan()`
 //    * bounds-checked access to `y_absl::Span` is accomplished with `at()`
@@ -74,9 +74,9 @@ ABSL_NAMESPACE_BEGIN
 // Span
 //------------------------------------------------------------------------------
 //
-// A `Span` is an "array reference" type for holding a reference of contiguous
-// array data; the `Span` object does not and cannot own such data itself. A
-// span provides an easy way to provide overloads for anything operating on
+// A `Span` is an "array reference" type for holding a reference of contiguous 
+// array data; the `Span` object does not and cannot own such data itself. A 
+// span provides an easy way to provide overloads for anything operating on 
 // contiguous sequences without needing to manage pointers and array lengths
 // manually.
 
@@ -94,8 +94,8 @@ ABSL_NAMESPACE_BEGIN
 // constructors.
 //
 // A `Span<T>` is somewhat analogous to an `y_absl::string_view`, but for an array
-// of elements of type `T`, and unlike an `y_absl::string_view`, a span can hold a
-// reference to mutable data. A user of `Span` must ensure that the data being
+// of elements of type `T`, and unlike an `y_absl::string_view`, a span can hold a 
+// reference to mutable data. A user of `Span` must ensure that the data being 
 // pointed to outlives the `Span` itself.
 //
 // You can construct a `Span<T>` in several ways:
@@ -125,7 +125,7 @@ ABSL_NAMESPACE_BEGIN
 // Note that `Span` objects, in addition to requiring that the memory they
 // point to remains alive, must also ensure that such memory does not get
 // reallocated. Therefore, to avoid undefined behavior, containers with
-// associated spans should not invoke operations that may reallocate memory
+// associated spans should not invoke operations that may reallocate memory 
 // (such as resizing) or invalidate iterators into the container.
 //
 // One common use for a `Span` is when passing arguments to a routine that can
@@ -275,7 +275,7 @@ class Span {
   // Returns a reference to the i'th element of this span.
   constexpr reference operator[](size_type i) const noexcept {
     // MSVC 2015 accepts this as constexpr, but not ptr_[i]
-    return ABSL_HARDENING_ASSERT(i < size()), *(data() + i);
+    return ABSL_HARDENING_ASSERT(i < size()), *(data() + i); 
   }
 
   // Span::at()
@@ -291,74 +291,74 @@ class Span {
 
   // Span::front()
   //
-  // Returns a reference to the first element of this span. The span must not
-  // be empty.
+  // Returns a reference to the first element of this span. The span must not 
+  // be empty. 
   constexpr reference front() const noexcept {
-    return ABSL_HARDENING_ASSERT(size() > 0), *data();
+    return ABSL_HARDENING_ASSERT(size() > 0), *data(); 
   }
 
   // Span::back()
   //
-  // Returns a reference to the last element of this span. The span must not
-  // be empty.
+  // Returns a reference to the last element of this span. The span must not 
+  // be empty. 
   constexpr reference back() const noexcept {
-    return ABSL_HARDENING_ASSERT(size() > 0), *(data() + size() - 1);
+    return ABSL_HARDENING_ASSERT(size() > 0), *(data() + size() - 1); 
   }
 
   // Span::begin()
   //
-  // Returns an iterator pointing to the first element of this span, or `end()`
-  // if the span is empty.
+  // Returns an iterator pointing to the first element of this span, or `end()` 
+  // if the span is empty. 
   constexpr iterator begin() const noexcept { return data(); }
 
   // Span::cbegin()
   //
-  // Returns a const iterator pointing to the first element of this span, or
-  // `end()` if the span is empty.
+  // Returns a const iterator pointing to the first element of this span, or 
+  // `end()` if the span is empty. 
   constexpr const_iterator cbegin() const noexcept { return begin(); }
 
   // Span::end()
   //
-  // Returns an iterator pointing just beyond the last element at the
-  // end of this span. This iterator acts as a placeholder; attempting to
-  // access it results in undefined behavior.
+  // Returns an iterator pointing just beyond the last element at the 
+  // end of this span. This iterator acts as a placeholder; attempting to 
+  // access it results in undefined behavior. 
   constexpr iterator end() const noexcept { return data() + size(); }
 
   // Span::cend()
   //
-  // Returns a const iterator pointing just beyond the last element at the
-  // end of this span. This iterator acts as a placeholder; attempting to
-  // access it results in undefined behavior.
+  // Returns a const iterator pointing just beyond the last element at the 
+  // end of this span. This iterator acts as a placeholder; attempting to 
+  // access it results in undefined behavior. 
   constexpr const_iterator cend() const noexcept { return end(); }
 
   // Span::rbegin()
   //
-  // Returns a reverse iterator pointing to the last element at the end of this
-  // span, or `rend()` if the span is empty.
+  // Returns a reverse iterator pointing to the last element at the end of this 
+  // span, or `rend()` if the span is empty. 
   constexpr reverse_iterator rbegin() const noexcept {
     return reverse_iterator(end());
   }
 
   // Span::crbegin()
   //
-  // Returns a const reverse iterator pointing to the last element at the end of
-  // this span, or `crend()` if the span is empty.
+  // Returns a const reverse iterator pointing to the last element at the end of 
+  // this span, or `crend()` if the span is empty. 
   constexpr const_reverse_iterator crbegin() const noexcept { return rbegin(); }
 
   // Span::rend()
   //
-  // Returns a reverse iterator pointing just before the first element
-  // at the beginning of this span. This pointer acts as a placeholder;
-  // attempting to access its element results in undefined behavior.
+  // Returns a reverse iterator pointing just before the first element 
+  // at the beginning of this span. This pointer acts as a placeholder; 
+  // attempting to access its element results in undefined behavior. 
   constexpr reverse_iterator rend() const noexcept {
     return reverse_iterator(begin());
   }
 
   // Span::crend()
   //
-  // Returns a reverse const iterator pointing just before the first element
-  // at the beginning of this span. This pointer acts as a placeholder;
-  // attempting to access its element results in undefined behavior.
+  // Returns a reverse const iterator pointing just before the first element 
+  // at the beginning of this span. This pointer acts as a placeholder; 
+  // attempting to access its element results in undefined behavior. 
   constexpr const_reverse_iterator crend() const noexcept { return rend(); }
 
   // Span mutations
@@ -367,7 +367,7 @@ class Span {
   //
   // Removes the first `n` elements from the span.
   void remove_prefix(size_type n) noexcept {
-    ABSL_HARDENING_ASSERT(size() >= n);
+    ABSL_HARDENING_ASSERT(size() >= n); 
     ptr_ += n;
     len_ -= n;
   }
@@ -376,7 +376,7 @@ class Span {
   //
   // Removes the last `n` elements from the span.
   void remove_suffix(size_type n) noexcept {
-    ABSL_HARDENING_ASSERT(size() >= n);
+    ABSL_HARDENING_ASSERT(size() >= n); 
     len_ -= n;
   }
 
@@ -664,7 +664,7 @@ constexpr Span<T> MakeSpan(T* ptr, size_t size) noexcept {
 
 template <int&... ExplicitArgumentBarrier, typename T>
 Span<T> MakeSpan(T* begin, T* end) noexcept {
-  return ABSL_HARDENING_ASSERT(begin <= end), Span<T>(begin, end - begin);
+  return ABSL_HARDENING_ASSERT(begin <= end), Span<T>(begin, end - begin); 
 }
 
 template <int&... ExplicitArgumentBarrier, typename C>
@@ -709,7 +709,7 @@ constexpr Span<const T> MakeConstSpan(T* ptr, size_t size) noexcept {
 
 template <int&... ExplicitArgumentBarrier, typename T>
 Span<const T> MakeConstSpan(T* begin, T* end) noexcept {
-  return ABSL_HARDENING_ASSERT(begin <= end), Span<const T>(begin, end - begin);
+  return ABSL_HARDENING_ASSERT(begin <= end), Span<const T>(begin, end - begin); 
 }
 
 template <int&... ExplicitArgumentBarrier, typename C>
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/variant.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/variant.h
index b3d7235018..c57a668f74 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/variant.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_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
-  // `y_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 
+  // `y_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 `y_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 `y_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
-  // `y_absl::valueless_by_exception()` is false) and constructs a new value at
+  // `y_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
-  // `y_absl::valueless_by_exception()` is false) and constructs a new value at
+  // `y_absl::valueless_by_exception()` is false) and constructs a new value at 
   // the given index using an initializer list and the provided arguments.
   //
   // Example:
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/types/ya.make
index b5ead45856..9a44988749 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/ya.make
@@ -1,14 +1,14 @@
-# Generated by devtools/yamaker.
-
-LIBRARY()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
-
-LICENSE(Apache-2.0)
-
-LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
-
-END()
+# Generated by devtools/yamaker. 
+ 
+LIBRARY() 
+ 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
+LICENSE(Apache-2.0) 
+ 
+LICENSE_TEXTS(.yandex_meta/licenses.list.txt) 
+ 
+END() 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/utility/.yandex_meta/licenses.list.txt b/contrib/restricted/abseil-cpp-tstring/y_absl/utility/.yandex_meta/licenses.list.txt
index 7be6b42848..4335862815 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/utility/.yandex_meta/licenses.list.txt
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/utility/.yandex_meta/licenses.list.txt
@@ -1,16 +1,16 @@
-====================Apache-2.0====================
-// 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====================
-// Copyright 2017 The Abseil Authors.
+====================Apache-2.0==================== 
+// 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==================== 
+// Copyright 2017 The Abseil Authors. 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/utility/utility.h b/contrib/restricted/abseil-cpp-tstring/y_absl/utility/utility.h
index c2e4d91d43..fbf61b55be 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/utility/utility.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/utility/utility.h
@@ -236,10 +236,10 @@ namespace utility_internal {
 // Helper method for expanding tuple into a called method.
 template <typename Functor, typename Tuple, std::size_t... Indexes>
 auto apply_helper(Functor&& functor, Tuple&& t, index_sequence<Indexes...>)
-    -> decltype(y_absl::base_internal::invoke(
+    -> decltype(y_absl::base_internal::invoke( 
         y_absl::forward<Functor>(functor),
         std::get<Indexes>(y_absl::forward<Tuple>(t))...)) {
-  return y_absl::base_internal::invoke(
+  return y_absl::base_internal::invoke( 
       y_absl::forward<Functor>(functor),
       std::get<Indexes>(y_absl::forward<Tuple>(t))...);
 }
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/utility/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/utility/ya.make
index b5ead45856..9a44988749 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/utility/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/utility/ya.make
@@ -1,14 +1,14 @@
-# Generated by devtools/yamaker.
-
-LIBRARY()
-
-OWNER(
-    somov
-    g:cpp-contrib
-)
-
-LICENSE(Apache-2.0)
-
-LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
-
-END()
+# Generated by devtools/yamaker. 
+ 
+LIBRARY() 
+ 
+OWNER( 
+    somov 
+    g:cpp-contrib 
+) 
+ 
+LICENSE(Apache-2.0) 
+ 
+LICENSE_TEXTS(.yandex_meta/licenses.list.txt) 
+ 
+END()