Restoring authorship annotation for <heretic@yandex-team.ru>. Commit 2 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 6730fe7683..8321acda51 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) 
+#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)) 
-#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 be338b43ca..5d80e4e7ca 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 9fa964584f..6270ede21e 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 fc20249d89..162843aa00 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 23bfaf2cd4..50b3122cf7 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 
+// 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
 #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 
-#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) 
+
+// -------------------------------------------------------------------------
+// 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 3f8a1eb8de..82be9f94ab 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 56c5963e0e..75f0022683 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 d11a9a5ae8..0f7adb8bf6 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 1ab47fc376..c82cba7b4a 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 21f6c309a1..928666ff44 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 e1e439cc04..0c477d1b28 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 77fcf095a4..fabba74677 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() 
+WITHOUT_LICENSE_TEXTS()
+
+OWNER(
+    somov
+    g:cpp-contrib
+)
 
-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 012b199385..61eb4ac643 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 4fe222e723..ea9a48c2c0 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 cd6603335b..4d5c77003f 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 dbfdc41134..e7cfe7d216 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() 
+WITHOUT_LICENSE_TEXTS()
+
+OWNER(
+    somov
+    g:cpp-contrib
+)
 
-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 ee7e4476c1..2ee7cde432 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; 
+static constexpr int kProfileTimestampShift = 7;
+
+// We currently reserve the lower 3 bits.
+static constexpr int kLockwordReservedShift = 3;
 
-// 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 3b636840d2..ef88cb52c0 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 bf2bfcac7c..69955dc765 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 a2237a3f48..5b4480d133 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 0c692f2d3d..12a9b86599 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 782361d0c0..2e34d7026b 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 a31df9455b..902ffe394f 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() 
+WITHOUT_LICENSE_TEXTS()
+
+OWNER(
+    somov
+    g:cpp-contrib
+)
 
-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 3d5d662335..648f74134f 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 5d8deec11a..fe50d84a03 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 00479ab9eb..a80a7b9c35 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 ab4bcee26c..9eb0cf3f8c 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 bb20639029..0fd7207a38 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 5182ae164d..b5e88ae302 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 9e9da41303..09a6c0bce1 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 489993d30d..dcce5aedc3 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 843d4bf838..1b956ad494 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() 
+WITHOUT_LICENSE_TEXTS()
+
+OWNER(
+    somov
+    g:cpp-contrib
+)
 
-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 3777338512..69a61d0814 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 f3035252a5..072a9852fa 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 ef3df43616..618c5c7e73 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 e6850cb189..26f20ad8e1 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 2e8412dd6f..3e4b5634c2 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() 
+WITHOUT_LICENSE_TEXTS()
+
+OWNER(
+    somov
+    g:cpp-contrib
+)
 
-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 7c541c249f..b09a81877d 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 02e465c2b9..501530ae30 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 6bb7000f1e..906310cde0 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 c1cdca12f5..06b3243916 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 f50c0b8e48..aba5d58dc3 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 6c2fd0516e..9e0d53060e 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