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

43 files changed, 1974 insertions, 1974 deletions

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