intermediate changes

ref:c67faec740b4d59ed47c6dfdc7076c904650af60

337 files changed, 4457 insertions, 4457 deletions

diff --git a/build/platform/test_tool/host.ya.make.inc b/build/platform/test_tool/host.ya.make.inc
index 533eba9453..dd1e166b06 100644
--- a/build/platform/test_tool/host.ya.make.inc
+++ b/build/platform/test_tool/host.ya.make.inc
@@ -1,13 +1,13 @@
 IF (HOST_OS_DARWIN AND HOST_ARCH_X86_64)
-    DECLARE_EXTERNAL_RESOURCE(TEST_TOOL_HOST sbr:2817784890)
-    DECLARE_EXTERNAL_RESOURCE(TEST_TOOL3_HOST sbr:2817782630)
+    DECLARE_EXTERNAL_RESOURCE(TEST_TOOL_HOST sbr:2843823836)
+    DECLARE_EXTERNAL_RESOURCE(TEST_TOOL3_HOST sbr:2843788983)
 ELSEIF (HOST_OS_LINUX AND HOST_ARCH_PPC64LE)
-    DECLARE_EXTERNAL_RESOURCE(TEST_TOOL_HOST sbr:2817784718)
-    DECLARE_EXTERNAL_RESOURCE(TEST_TOOL3_HOST sbr:2817782347)
+    DECLARE_EXTERNAL_RESOURCE(TEST_TOOL_HOST sbr:2843823704)
+    DECLARE_EXTERNAL_RESOURCE(TEST_TOOL3_HOST sbr:2843788560)
 ELSEIF (HOST_OS_LINUX AND HOST_ARCH_X86_64)
-    DECLARE_EXTERNAL_RESOURCE(TEST_TOOL_HOST sbr:2817785117)
-    DECLARE_EXTERNAL_RESOURCE(TEST_TOOL3_HOST sbr:2817783133)
+    DECLARE_EXTERNAL_RESOURCE(TEST_TOOL_HOST sbr:2843824017)
+    DECLARE_EXTERNAL_RESOURCE(TEST_TOOL3_HOST sbr:2843789281)
 ELSEIF (HOST_OS_WINDOWS AND HOST_ARCH_X86_64)
-    DECLARE_EXTERNAL_RESOURCE(TEST_TOOL_HOST sbr:2817784371)
-    DECLARE_EXTERNAL_RESOURCE(TEST_TOOL3_HOST sbr:2817782042)
+    DECLARE_EXTERNAL_RESOURCE(TEST_TOOL_HOST sbr:2843823282)
+    DECLARE_EXTERNAL_RESOURCE(TEST_TOOL3_HOST sbr:2843788069)
 ENDIF()
diff --git a/contrib/libs/grpc/grpc_unsecure/ya.make b/contrib/libs/grpc/grpc_unsecure/ya.make
index 38ef63eb18..3c0d33fec1 100644
--- a/contrib/libs/grpc/grpc_unsecure/ya.make
+++ b/contrib/libs/grpc/grpc_unsecure/ya.make
@@ -23,7 +23,7 @@ PEERDIR(
 
 ADDINCL(
     GLOBAL contrib/libs/grpc/include
-    contrib/libs/c-ares
+    contrib/libs/c-ares/include
     ${ARCADIA_BUILD_ROOT}/contrib/libs/grpc
     contrib/libs/grpc
     contrib/libs/grpc/src/core/ext/upb-generated
diff --git a/contrib/libs/grpc/src/core/lib/gpr/sync_abseil.cc b/contrib/libs/grpc/src/core/lib/gpr/sync_abseil.cc
index c224be2eee..86b0d03b67 100644
--- a/contrib/libs/grpc/src/core/lib/gpr/sync_abseil.cc
+++ b/contrib/libs/grpc/src/core/lib/gpr/sync_abseil.cc
@@ -50,12 +50,12 @@ void gpr_mu_destroy(gpr_mu* mu) {
   reinterpret_cast<y_absl::Mutex*>(mu)->~Mutex();
 }
 
-void gpr_mu_lock(gpr_mu* mu) ABSL_NO_THREAD_SAFETY_ANALYSIS {
+void gpr_mu_lock(gpr_mu* mu) Y_ABSL_NO_THREAD_SAFETY_ANALYSIS {
   GPR_TIMER_SCOPE("gpr_mu_lock", 0);
   reinterpret_cast<y_absl::Mutex*>(mu)->Lock();
 }
 
-void gpr_mu_unlock(gpr_mu* mu) ABSL_NO_THREAD_SAFETY_ANALYSIS {
+void gpr_mu_unlock(gpr_mu* mu) Y_ABSL_NO_THREAD_SAFETY_ANALYSIS {
   GPR_TIMER_SCOPE("gpr_mu_unlock", 0);
   reinterpret_cast<y_absl::Mutex*>(mu)->Unlock();
 }
diff --git a/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/statusor.h b/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/statusor.h
index 2002d814c9..805184614d 100644
--- a/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/statusor.h
+++ b/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/statusor.h
@@ -28,7 +28,7 @@ namespace mock_cel {
 // Once gRPC imports the CEL library, this file will be removed.
 
 template <typename T>
-class ABSL_MUST_USE_RESULT StatusOr;
+class Y_ABSL_MUST_USE_RESULT StatusOr;
 
 template <typename T>
 class StatusOr {
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/algorithm/algorithm.h b/contrib/restricted/abseil-cpp-tstring/y_absl/algorithm/algorithm.h
index b1003bd0a9..8cbd179072 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/algorithm/algorithm.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/algorithm/algorithm.h
@@ -19,8 +19,8 @@
 // This header file contains Google extensions to the standard <algorithm> C++
 // header.
 
-#ifndef ABSL_ALGORITHM_ALGORITHM_H_
-#define ABSL_ALGORITHM_ALGORITHM_H_
+#ifndef Y_ABSL_ALGORITHM_ALGORITHM_H_
+#define Y_ABSL_ALGORITHM_ALGORITHM_H_
 
 #include <algorithm>
 #include <iterator>
@@ -29,7 +29,7 @@
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 namespace algorithm_internal {
 
@@ -153,7 +153,7 @@ ForwardIterator rotate(ForwardIterator first, ForwardIterator middle,
                    ForwardIterator>());
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_ALGORITHM_ALGORITHM_H_
+#endif  // Y_ABSL_ALGORITHM_ALGORITHM_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/algorithm/container.h b/contrib/restricted/abseil-cpp-tstring/y_absl/algorithm/container.h
index d6bf385964..3abb26f1b3 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/algorithm/container.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/algorithm/container.h
@@ -37,8 +37,8 @@
 // to which the function is applied, `Pred` indicates the predicate object type
 // to be used by the function and `T` indicates the applicable element type.
 
-#ifndef ABSL_ALGORITHM_CONTAINER_H_
-#define ABSL_ALGORITHM_CONTAINER_H_
+#ifndef Y_ABSL_ALGORITHM_CONTAINER_H_
+#define Y_ABSL_ALGORITHM_CONTAINER_H_
 
 #include <algorithm>
 #include <cassert>
@@ -55,7 +55,7 @@
 #include "y_absl/meta/type_traits.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_algorithm_internal {
 
 // NOTE: it is important to defer to ADL lookup for building with C++ modules,
@@ -1768,7 +1768,7 @@ OutputIt c_partial_sum(const InputSequence& input, OutputIt output_first,
                           output_first, std::forward<BinaryOp>(op));
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_ALGORITHM_CONTAINER_H_
+#endif  // Y_ABSL_ALGORITHM_CONTAINER_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/attributes.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/attributes.h
index 8321acda51..66751eaddf 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/attributes.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/attributes.h
@@ -31,12 +31,12 @@
 // `__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_
+#ifndef Y_ABSL_BASE_ATTRIBUTES_H_
+#define Y_ABSL_BASE_ATTRIBUTES_H_
 
 #include "y_absl/base/config.h"
 
-// ABSL_HAVE_ATTRIBUTE
+// Y_ABSL_HAVE_ATTRIBUTE
 //
 // A function-like feature checking macro that is a wrapper around
 // `__has_attribute`, which is defined by GCC 5+ and Clang and evaluates to a
@@ -47,12 +47,12 @@
 // GCC: https://gcc.gnu.org/gcc-5/changes.html
 // Clang: https://clang.llvm.org/docs/LanguageExtensions.html
 #ifdef __has_attribute
-#define ABSL_HAVE_ATTRIBUTE(x) __has_attribute(x)
+#define Y_ABSL_HAVE_ATTRIBUTE(x) __has_attribute(x)
 #else
-#define ABSL_HAVE_ATTRIBUTE(x) 0
+#define Y_ABSL_HAVE_ATTRIBUTE(x) 0
 #endif
 
-// ABSL_HAVE_CPP_ATTRIBUTE
+// Y_ABSL_HAVE_CPP_ATTRIBUTE
 //
 // A function-like feature checking macro that accepts C++11 style attributes.
 // It's a wrapper around `__has_cpp_attribute`, defined by ISO C++ SD-6
@@ -61,9 +61,9 @@
 #if defined(__cplusplus) && defined(__has_cpp_attribute)
 // NOTE: requiring __cplusplus above should not be necessary, but
 // works around https://bugs.llvm.org/show_bug.cgi?id=23435.
-#define ABSL_HAVE_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
+#define Y_ABSL_HAVE_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
 #else
-#define ABSL_HAVE_CPP_ATTRIBUTE(x) 0
+#define Y_ABSL_HAVE_CPP_ATTRIBUTE(x) 0
 #endif
 
 // -----------------------------------------------------------------------------
@@ -73,8 +73,8 @@
 // GCC: https://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
 // Clang: https://clang.llvm.org/docs/AttributeReference.html
 
-// ABSL_PRINTF_ATTRIBUTE
-// ABSL_SCANF_ATTRIBUTE
+// Y_ABSL_PRINTF_ATTRIBUTE
+// Y_ABSL_SCANF_ATTRIBUTE
 //
 // Tells the compiler to perform `printf` format string checking if the
 // compiler supports it; see the 'format' attribute in
@@ -83,52 +83,52 @@
 // Note: As the GCC manual states, "[s]ince non-static C++ methods
 // have an implicit 'this' argument, the arguments of such methods
 // should be counted from two, not one."
-#if ABSL_HAVE_ATTRIBUTE(format) || (defined(__GNUC__) && !defined(__clang__))
-#define ABSL_PRINTF_ATTRIBUTE(string_index, first_to_check) \
+#if Y_ABSL_HAVE_ATTRIBUTE(format) || (defined(__GNUC__) && !defined(__clang__))
+#define Y_ABSL_PRINTF_ATTRIBUTE(string_index, first_to_check) \
   __attribute__((__format__(__printf__, string_index, first_to_check)))
-#define ABSL_SCANF_ATTRIBUTE(string_index, first_to_check) \
+#define Y_ABSL_SCANF_ATTRIBUTE(string_index, first_to_check) \
   __attribute__((__format__(__scanf__, string_index, first_to_check)))
 #else
-#define ABSL_PRINTF_ATTRIBUTE(string_index, first_to_check)
-#define ABSL_SCANF_ATTRIBUTE(string_index, first_to_check)
+#define Y_ABSL_PRINTF_ATTRIBUTE(string_index, first_to_check)
+#define Y_ABSL_SCANF_ATTRIBUTE(string_index, first_to_check)
 #endif
 
-// ABSL_ATTRIBUTE_ALWAYS_INLINE
-// ABSL_ATTRIBUTE_NOINLINE
+// Y_ABSL_ATTRIBUTE_ALWAYS_INLINE
+// Y_ABSL_ATTRIBUTE_NOINLINE
 //
 // Forces functions to either inline or not inline. Introduced in gcc 3.1.
-#if ABSL_HAVE_ATTRIBUTE(always_inline) || \
+#if Y_ABSL_HAVE_ATTRIBUTE(always_inline) || \
     (defined(__GNUC__) && !defined(__clang__))
-#define ABSL_ATTRIBUTE_ALWAYS_INLINE __attribute__((always_inline))
-#define ABSL_HAVE_ATTRIBUTE_ALWAYS_INLINE 1
+#define Y_ABSL_ATTRIBUTE_ALWAYS_INLINE __attribute__((always_inline))
+#define Y_ABSL_HAVE_ATTRIBUTE_ALWAYS_INLINE 1
 #else
-#define ABSL_ATTRIBUTE_ALWAYS_INLINE
+#define Y_ABSL_ATTRIBUTE_ALWAYS_INLINE
 #endif
 
-#if ABSL_HAVE_ATTRIBUTE(noinline) || (defined(__GNUC__) && !defined(__clang__))
-#define ABSL_ATTRIBUTE_NOINLINE __attribute__((noinline))
-#define ABSL_HAVE_ATTRIBUTE_NOINLINE 1
+#if Y_ABSL_HAVE_ATTRIBUTE(noinline) || (defined(__GNUC__) && !defined(__clang__))
+#define Y_ABSL_ATTRIBUTE_NOINLINE __attribute__((noinline))
+#define Y_ABSL_HAVE_ATTRIBUTE_NOINLINE 1
 #else
-#define ABSL_ATTRIBUTE_NOINLINE
+#define Y_ABSL_ATTRIBUTE_NOINLINE
 #endif
 
-// ABSL_ATTRIBUTE_NO_TAIL_CALL
+// Y_ABSL_ATTRIBUTE_NO_TAIL_CALL
 //
 // Prevents the compiler from optimizing away stack frames for functions which
 // end in a call to another function.
-#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))
+#if Y_ABSL_HAVE_ATTRIBUTE(disable_tail_calls)
+#define Y_ABSL_HAVE_ATTRIBUTE_NO_TAIL_CALL 1
+#define Y_ABSL_ATTRIBUTE_NO_TAIL_CALL __attribute__((disable_tail_calls))
 #elif defined(__GNUC__) && !defined(__clang__) && !defined(__e2k__)
-#define ABSL_HAVE_ATTRIBUTE_NO_TAIL_CALL 1
-#define ABSL_ATTRIBUTE_NO_TAIL_CALL \
+#define Y_ABSL_HAVE_ATTRIBUTE_NO_TAIL_CALL 1
+#define Y_ABSL_ATTRIBUTE_NO_TAIL_CALL \
   __attribute__((optimize("no-optimize-sibling-calls")))
 #else
-#define ABSL_ATTRIBUTE_NO_TAIL_CALL
-#define ABSL_HAVE_ATTRIBUTE_NO_TAIL_CALL 0
+#define Y_ABSL_ATTRIBUTE_NO_TAIL_CALL
+#define Y_ABSL_HAVE_ATTRIBUTE_NO_TAIL_CALL 0
 #endif
 
-// ABSL_ATTRIBUTE_WEAK
+// Y_ABSL_ATTRIBUTE_WEAK
 //
 // Tags a function as weak for the purposes of compilation and linking.
 // Weak attributes did not work properly in LLVM's Windows backend before
@@ -136,18 +136,18 @@
 // for further information.
 // The MinGW compiler doesn't complain about the weak attribute until the link
 // step, presumably because Windows doesn't use ELF binaries.
-#if (ABSL_HAVE_ATTRIBUTE(weak) ||                   \
+#if (Y_ABSL_HAVE_ATTRIBUTE(weak) ||                   \
      (defined(__GNUC__) && !defined(__clang__))) && \
     (!defined(_WIN32) || __clang_major__ < 9) && !defined(__MINGW32__)
-#undef ABSL_ATTRIBUTE_WEAK
-#define ABSL_ATTRIBUTE_WEAK __attribute__((weak))
-#define ABSL_HAVE_ATTRIBUTE_WEAK 1
+#undef Y_ABSL_ATTRIBUTE_WEAK
+#define Y_ABSL_ATTRIBUTE_WEAK __attribute__((weak))
+#define Y_ABSL_HAVE_ATTRIBUTE_WEAK 1
 #else
-#define ABSL_ATTRIBUTE_WEAK
-#define ABSL_HAVE_ATTRIBUTE_WEAK 0
+#define Y_ABSL_ATTRIBUTE_WEAK
+#define Y_ABSL_HAVE_ATTRIBUTE_WEAK 0
 #endif
 
-// ABSL_ATTRIBUTE_NONNULL
+// Y_ABSL_ATTRIBUTE_NONNULL
 //
 // Tells the compiler either (a) that a particular function parameter
 // should be a non-null pointer, or (b) that all pointer arguments should
@@ -167,42 +167,42 @@
 // Example:
 //
 //   /* arg_a cannot be null, but arg_b can */
-//   void Function(void* arg_a, void* arg_b) ABSL_ATTRIBUTE_NONNULL(1);
+//   void Function(void* arg_a, void* arg_b) Y_ABSL_ATTRIBUTE_NONNULL(1);
 //
 //   class C {
 //     /* arg_a cannot be null, but arg_b can */
-//     void Method(void* arg_a, void* arg_b) ABSL_ATTRIBUTE_NONNULL(2);
+//     void Method(void* arg_a, void* arg_b) Y_ABSL_ATTRIBUTE_NONNULL(2);
 //
 //     /* arg_a cannot be null, but arg_b can */
 //     static void StaticMethod(void* arg_a, void* arg_b)
-//     ABSL_ATTRIBUTE_NONNULL(1);
+//     Y_ABSL_ATTRIBUTE_NONNULL(1);
 //   };
 //
 // If no arguments are provided, then all pointer arguments should be non-null.
 //
 //  /* No pointer arguments may be null. */
-//  void Function(void* arg_a, void* arg_b, int arg_c) ABSL_ATTRIBUTE_NONNULL();
+//  void Function(void* arg_a, void* arg_b, int arg_c) Y_ABSL_ATTRIBUTE_NONNULL();
 //
 // NOTE: The GCC nonnull attribute actually accepts a list of arguments, but
-// ABSL_ATTRIBUTE_NONNULL does not.
-#if ABSL_HAVE_ATTRIBUTE(nonnull) || (defined(__GNUC__) && !defined(__clang__))
-#define ABSL_ATTRIBUTE_NONNULL(arg_index) __attribute__((nonnull(arg_index)))
+// Y_ABSL_ATTRIBUTE_NONNULL does not.
+#if Y_ABSL_HAVE_ATTRIBUTE(nonnull) || (defined(__GNUC__) && !defined(__clang__))
+#define Y_ABSL_ATTRIBUTE_NONNULL(arg_index) __attribute__((nonnull(arg_index)))
 #else
-#define ABSL_ATTRIBUTE_NONNULL(...)
+#define Y_ABSL_ATTRIBUTE_NONNULL(...)
 #endif
 
-// ABSL_ATTRIBUTE_NORETURN
+// Y_ABSL_ATTRIBUTE_NORETURN
 //
 // Tells the compiler that a given function never returns.
-#if ABSL_HAVE_ATTRIBUTE(noreturn) || (defined(__GNUC__) && !defined(__clang__))
-#define ABSL_ATTRIBUTE_NORETURN __attribute__((noreturn))
+#if Y_ABSL_HAVE_ATTRIBUTE(noreturn) || (defined(__GNUC__) && !defined(__clang__))
+#define Y_ABSL_ATTRIBUTE_NORETURN __attribute__((noreturn))
 #elif defined(_MSC_VER)
-#define ABSL_ATTRIBUTE_NORETURN __declspec(noreturn)
+#define Y_ABSL_ATTRIBUTE_NORETURN __declspec(noreturn)
 #else
-#define ABSL_ATTRIBUTE_NORETURN
+#define Y_ABSL_ATTRIBUTE_NORETURN
 #endif
 
-// ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS
+// Y_ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS
 //
 // Tells the AddressSanitizer (or other memory testing tools) to ignore a given
 // function. Useful for cases when a function reads random locations on stack,
@@ -210,193 +210,193 @@
 // 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)
-#define ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS __attribute__((no_sanitize_address))
+#if Y_ABSL_HAVE_ATTRIBUTE(no_sanitize_address)
+#define Y_ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS __attribute__((no_sanitize_address))
 #else
-#define ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS
+#define Y_ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS
 #endif
 
-// ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY
+// Y_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
+// attribute is similar to the Y_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)
-#define ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY __attribute__((no_sanitize_memory))
+#if Y_ABSL_HAVE_ATTRIBUTE(no_sanitize_memory)
+#define Y_ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY __attribute__((no_sanitize_memory))
 #else
-#define ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY
+#define Y_ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY
 #endif
 
-// ABSL_ATTRIBUTE_NO_SANITIZE_THREAD
+// Y_ABSL_ATTRIBUTE_NO_SANITIZE_THREAD
 //
 // 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)
-#define ABSL_ATTRIBUTE_NO_SANITIZE_THREAD __attribute__((no_sanitize_thread))
+#if Y_ABSL_HAVE_ATTRIBUTE(no_sanitize_thread)
+#define Y_ABSL_ATTRIBUTE_NO_SANITIZE_THREAD __attribute__((no_sanitize_thread))
 #else
-#define ABSL_ATTRIBUTE_NO_SANITIZE_THREAD
+#define Y_ABSL_ATTRIBUTE_NO_SANITIZE_THREAD
 #endif
 
-// ABSL_ATTRIBUTE_NO_SANITIZE_UNDEFINED
+// Y_ABSL_ATTRIBUTE_NO_SANITIZE_UNDEFINED
 //
 // Tells the UndefinedSanitizer to ignore a given function. Useful for cases
 // where certain behavior (eg. division by zero) is being used intentionally.
 // NOTE: GCC supports UndefinedBehaviorSanitizer(ubsan) since 4.9.
 // https://gcc.gnu.org/gcc-4.9/changes.html
-#if ABSL_HAVE_ATTRIBUTE(no_sanitize_undefined)
-#define ABSL_ATTRIBUTE_NO_SANITIZE_UNDEFINED \
+#if Y_ABSL_HAVE_ATTRIBUTE(no_sanitize_undefined)
+#define Y_ABSL_ATTRIBUTE_NO_SANITIZE_UNDEFINED \
   __attribute__((no_sanitize_undefined))
-#elif ABSL_HAVE_ATTRIBUTE(no_sanitize)
-#define ABSL_ATTRIBUTE_NO_SANITIZE_UNDEFINED \
+#elif Y_ABSL_HAVE_ATTRIBUTE(no_sanitize)
+#define Y_ABSL_ATTRIBUTE_NO_SANITIZE_UNDEFINED \
   __attribute__((no_sanitize("undefined")))
 #else
-#define ABSL_ATTRIBUTE_NO_SANITIZE_UNDEFINED
+#define Y_ABSL_ATTRIBUTE_NO_SANITIZE_UNDEFINED
 #endif
 
-// ABSL_ATTRIBUTE_NO_SANITIZE_CFI
+// Y_ABSL_ATTRIBUTE_NO_SANITIZE_CFI
 //
 // 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)
-#define ABSL_ATTRIBUTE_NO_SANITIZE_CFI __attribute__((no_sanitize("cfi")))
+#if Y_ABSL_HAVE_ATTRIBUTE(no_sanitize)
+#define Y_ABSL_ATTRIBUTE_NO_SANITIZE_CFI __attribute__((no_sanitize("cfi")))
 #else
-#define ABSL_ATTRIBUTE_NO_SANITIZE_CFI
+#define Y_ABSL_ATTRIBUTE_NO_SANITIZE_CFI
 #endif
 
-// ABSL_ATTRIBUTE_NO_SANITIZE_SAFESTACK
+// Y_ABSL_ATTRIBUTE_NO_SANITIZE_SAFESTACK
 //
 // 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)
-#define ABSL_ATTRIBUTE_NO_SANITIZE_SAFESTACK \
+#if Y_ABSL_HAVE_ATTRIBUTE(no_sanitize)
+#define Y_ABSL_ATTRIBUTE_NO_SANITIZE_SAFESTACK \
   __attribute__((no_sanitize("safe-stack")))
 #else
-#define ABSL_ATTRIBUTE_NO_SANITIZE_SAFESTACK
+#define Y_ABSL_ATTRIBUTE_NO_SANITIZE_SAFESTACK
 #endif
 
-// ABSL_ATTRIBUTE_RETURNS_NONNULL
+// Y_ABSL_ATTRIBUTE_RETURNS_NONNULL
 //
 // Tells the compiler that a particular function never returns a null pointer.
-#if ABSL_HAVE_ATTRIBUTE(returns_nonnull)
-#define ABSL_ATTRIBUTE_RETURNS_NONNULL __attribute__((returns_nonnull))
+#if Y_ABSL_HAVE_ATTRIBUTE(returns_nonnull)
+#define Y_ABSL_ATTRIBUTE_RETURNS_NONNULL __attribute__((returns_nonnull))
 #else
-#define ABSL_ATTRIBUTE_RETURNS_NONNULL
+#define Y_ABSL_ATTRIBUTE_RETURNS_NONNULL
 #endif
 
-// ABSL_HAVE_ATTRIBUTE_SECTION
+// Y_ABSL_HAVE_ATTRIBUTE_SECTION
 //
 // Indicates whether labeled sections are supported. Weak symbol support is
 // a prerequisite. Labeled sections are not supported on Darwin/iOS.
-#ifdef ABSL_HAVE_ATTRIBUTE_SECTION
-#error ABSL_HAVE_ATTRIBUTE_SECTION cannot be directly set
-#elif (ABSL_HAVE_ATTRIBUTE(section) ||                \
+#ifdef Y_ABSL_HAVE_ATTRIBUTE_SECTION
+#error Y_ABSL_HAVE_ATTRIBUTE_SECTION cannot be directly set
+#elif (Y_ABSL_HAVE_ATTRIBUTE(section) ||                \
        (defined(__GNUC__) && !defined(__clang__))) && \
-    !defined(__APPLE__) && ABSL_HAVE_ATTRIBUTE_WEAK
-#define ABSL_HAVE_ATTRIBUTE_SECTION 1
+    !defined(__APPLE__) && Y_ABSL_HAVE_ATTRIBUTE_WEAK
+#define Y_ABSL_HAVE_ATTRIBUTE_SECTION 1
 
-// ABSL_ATTRIBUTE_SECTION
+// Y_ABSL_ATTRIBUTE_SECTION
 //
 // Tells the compiler/linker to put a given function into a section and define
 // `__start_ ## name` and `__stop_ ## name` symbols to bracket the section.
 // This functionality is supported by GNU linker.  Any function annotated with
-// `ABSL_ATTRIBUTE_SECTION` must not be inlined, or it will be placed into
+// `Y_ABSL_ATTRIBUTE_SECTION` must not be inlined, or it will be placed into
 // whatever section its caller is placed into.
 //
-#ifndef ABSL_ATTRIBUTE_SECTION
-#define ABSL_ATTRIBUTE_SECTION(name) \
+#ifndef Y_ABSL_ATTRIBUTE_SECTION
+#define Y_ABSL_ATTRIBUTE_SECTION(name) \
   __attribute__((section(#name))) __attribute__((noinline))
 #endif
 
 
-// ABSL_ATTRIBUTE_SECTION_VARIABLE
+// Y_ABSL_ATTRIBUTE_SECTION_VARIABLE
 //
 // Tells the compiler/linker to put a given variable into a section and define
 // `__start_ ## name` and `__stop_ ## name` symbols to bracket the section.
 // This functionality is supported by GNU linker.
-#ifndef ABSL_ATTRIBUTE_SECTION_VARIABLE
+#ifndef Y_ABSL_ATTRIBUTE_SECTION_VARIABLE
 #ifdef _AIX
 // __attribute__((section(#name))) on AIX is achived by using the `.csect` psudo
 // op which includes an additional integer as part of its syntax indcating
 // alignment. If data fall under different alignments then you might get a
 // compilation error indicating a `Section type conflict`.
-#define ABSL_ATTRIBUTE_SECTION_VARIABLE(name)
+#define Y_ABSL_ATTRIBUTE_SECTION_VARIABLE(name)
 #else
-#define ABSL_ATTRIBUTE_SECTION_VARIABLE(name) __attribute__((section(#name)))
+#define Y_ABSL_ATTRIBUTE_SECTION_VARIABLE(name) __attribute__((section(#name)))
 #endif
 #endif
 
-// ABSL_DECLARE_ATTRIBUTE_SECTION_VARS
+// Y_ABSL_DECLARE_ATTRIBUTE_SECTION_VARS
 //
 // A weak section declaration to be used as a global declaration
-// for ABSL_ATTRIBUTE_SECTION_START|STOP(name) to compile and link
-// even without functions with ABSL_ATTRIBUTE_SECTION(name).
-// ABSL_DEFINE_ATTRIBUTE_SECTION should be in the exactly one file; it's
+// for Y_ABSL_ATTRIBUTE_SECTION_START|STOP(name) to compile and link
+// even without functions with Y_ABSL_ATTRIBUTE_SECTION(name).
+// Y_ABSL_DEFINE_ATTRIBUTE_SECTION should be in the exactly one file; it's
 // a no-op on ELF but not on Mach-O.
 //
-#ifndef ABSL_DECLARE_ATTRIBUTE_SECTION_VARS
-#define ABSL_DECLARE_ATTRIBUTE_SECTION_VARS(name) \
-  extern char __start_##name[] ABSL_ATTRIBUTE_WEAK;    \
-  extern char __stop_##name[] ABSL_ATTRIBUTE_WEAK
+#ifndef Y_ABSL_DECLARE_ATTRIBUTE_SECTION_VARS
+#define Y_ABSL_DECLARE_ATTRIBUTE_SECTION_VARS(name) \
+  extern char __start_##name[] Y_ABSL_ATTRIBUTE_WEAK;    \
+  extern char __stop_##name[] Y_ABSL_ATTRIBUTE_WEAK
 #endif
-#ifndef ABSL_DEFINE_ATTRIBUTE_SECTION_VARS
-#define ABSL_INIT_ATTRIBUTE_SECTION_VARS(name)
-#define ABSL_DEFINE_ATTRIBUTE_SECTION_VARS(name)
+#ifndef Y_ABSL_DEFINE_ATTRIBUTE_SECTION_VARS
+#define Y_ABSL_INIT_ATTRIBUTE_SECTION_VARS(name)
+#define Y_ABSL_DEFINE_ATTRIBUTE_SECTION_VARS(name)
 #endif
 
-// ABSL_ATTRIBUTE_SECTION_START
+// Y_ABSL_ATTRIBUTE_SECTION_START
 //
 // Returns `void*` pointers to start/end of a section of code with
-// functions having ABSL_ATTRIBUTE_SECTION(name).
+// functions having Y_ABSL_ATTRIBUTE_SECTION(name).
 // Returns 0 if no such functions exist.
-// One must ABSL_DECLARE_ATTRIBUTE_SECTION_VARS(name) for this to compile and
+// One must Y_ABSL_DECLARE_ATTRIBUTE_SECTION_VARS(name) for this to compile and
 // link.
 //
-#define ABSL_ATTRIBUTE_SECTION_START(name) \
+#define Y_ABSL_ATTRIBUTE_SECTION_START(name) \
   (reinterpret_cast<void *>(__start_##name))
-#define ABSL_ATTRIBUTE_SECTION_STOP(name) \
+#define Y_ABSL_ATTRIBUTE_SECTION_STOP(name) \
   (reinterpret_cast<void *>(__stop_##name))
 
-#else  // !ABSL_HAVE_ATTRIBUTE_SECTION
+#else  // !Y_ABSL_HAVE_ATTRIBUTE_SECTION
 
-#define ABSL_HAVE_ATTRIBUTE_SECTION 0
+#define Y_ABSL_HAVE_ATTRIBUTE_SECTION 0
 
 // provide dummy definitions
-#define ABSL_ATTRIBUTE_SECTION(name)
-#define ABSL_ATTRIBUTE_SECTION_VARIABLE(name)
-#define ABSL_INIT_ATTRIBUTE_SECTION_VARS(name)
-#define ABSL_DEFINE_ATTRIBUTE_SECTION_VARS(name)
-#define ABSL_DECLARE_ATTRIBUTE_SECTION_VARS(name)
-#define ABSL_ATTRIBUTE_SECTION_START(name) (reinterpret_cast<void *>(0))
-#define ABSL_ATTRIBUTE_SECTION_STOP(name) (reinterpret_cast<void *>(0))
+#define Y_ABSL_ATTRIBUTE_SECTION(name)
+#define Y_ABSL_ATTRIBUTE_SECTION_VARIABLE(name)
+#define Y_ABSL_INIT_ATTRIBUTE_SECTION_VARS(name)
+#define Y_ABSL_DEFINE_ATTRIBUTE_SECTION_VARS(name)
+#define Y_ABSL_DECLARE_ATTRIBUTE_SECTION_VARS(name)
+#define Y_ABSL_ATTRIBUTE_SECTION_START(name) (reinterpret_cast<void *>(0))
+#define Y_ABSL_ATTRIBUTE_SECTION_STOP(name) (reinterpret_cast<void *>(0))
 
-#endif  // ABSL_ATTRIBUTE_SECTION
+#endif  // Y_ABSL_ATTRIBUTE_SECTION
 
-// ABSL_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC
+// Y_ABSL_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC
 //
 // Support for aligning the stack on 32-bit x86.
-#if ABSL_HAVE_ATTRIBUTE(force_align_arg_pointer) || \
+#if Y_ABSL_HAVE_ATTRIBUTE(force_align_arg_pointer) || \
     (defined(__GNUC__) && !defined(__clang__))
 #if defined(__i386__)
-#define ABSL_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC \
+#define Y_ABSL_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC \
   __attribute__((force_align_arg_pointer))
-#define ABSL_REQUIRE_STACK_ALIGN_TRAMPOLINE (0)
+#define Y_ABSL_REQUIRE_STACK_ALIGN_TRAMPOLINE (0)
 #elif defined(__x86_64__)
-#define ABSL_REQUIRE_STACK_ALIGN_TRAMPOLINE (1)
-#define ABSL_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC
+#define Y_ABSL_REQUIRE_STACK_ALIGN_TRAMPOLINE (1)
+#define Y_ABSL_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC
 #else  // !__i386__ && !__x86_64
-#define ABSL_REQUIRE_STACK_ALIGN_TRAMPOLINE (0)
-#define ABSL_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC
+#define Y_ABSL_REQUIRE_STACK_ALIGN_TRAMPOLINE (0)
+#define Y_ABSL_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC
 #endif  // __i386__
 #else
-#define ABSL_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC
-#define ABSL_REQUIRE_STACK_ALIGN_TRAMPOLINE (0)
+#define Y_ABSL_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC
+#define Y_ABSL_REQUIRE_STACK_ALIGN_TRAMPOLINE (0)
 #endif
 
-// ABSL_MUST_USE_RESULT
+// Y_ABSL_MUST_USE_RESULT
 //
 // Tells the compiler to warn about unused results.
 //
@@ -404,13 +404,13 @@
 // declaration or definition. The compiler will warn if the return value from
 // such a function is unused:
 //
-//   ABSL_MUST_USE_RESULT Sprocket* AllocateSprocket();
+//   Y_ABSL_MUST_USE_RESULT Sprocket* AllocateSprocket();
 //   AllocateSprocket();  // Triggers a warning.
 //
 // When annotating a class, it is equivalent to annotating every function which
 // returns an instance.
 //
-//   class ABSL_MUST_USE_RESULT Sprocket {};
+//   class Y_ABSL_MUST_USE_RESULT Sprocket {};
 //   Sprocket();  // Triggers a warning.
 //
 //   Sprocket MakeSprocket();
@@ -421,20 +421,20 @@
 //   Sprocket* SprocketPointer();
 //   SprocketPointer();  // Does *not* trigger a warning.
 //
-// ABSL_MUST_USE_RESULT allows using cast-to-void to suppress the unused result
+// Y_ABSL_MUST_USE_RESULT allows using cast-to-void to suppress the unused result
 // warning. For that, warn_unused_result is used only for clang but not for gcc.
 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66425
 //
 // Note: past advice was to place the macro after the argument list.
-#if ABSL_HAVE_ATTRIBUTE(nodiscard)
-#define ABSL_MUST_USE_RESULT [[nodiscard]]
-#elif defined(__clang__) && ABSL_HAVE_ATTRIBUTE(warn_unused_result)
-#define ABSL_MUST_USE_RESULT __attribute__((warn_unused_result))
+#if Y_ABSL_HAVE_ATTRIBUTE(nodiscard)
+#define Y_ABSL_MUST_USE_RESULT [[nodiscard]]
+#elif defined(__clang__) && Y_ABSL_HAVE_ATTRIBUTE(warn_unused_result)
+#define Y_ABSL_MUST_USE_RESULT __attribute__((warn_unused_result))
 #else
-#define ABSL_MUST_USE_RESULT
+#define Y_ABSL_MUST_USE_RESULT
 #endif
 
-// ABSL_ATTRIBUTE_HOT, ABSL_ATTRIBUTE_COLD
+// Y_ABSL_ATTRIBUTE_HOT, Y_ABSL_ATTRIBUTE_COLD
 //
 // Tells GCC that a function is hot or cold. GCC can use this information to
 // improve static analysis, i.e. a conditional branch to a cold function
@@ -443,22 +443,22 @@
 //
 // Example:
 //
-//   int foo() ABSL_ATTRIBUTE_HOT;
-#if ABSL_HAVE_ATTRIBUTE(hot) || (defined(__GNUC__) && !defined(__clang__))
-#define ABSL_ATTRIBUTE_HOT __attribute__((hot))
+//   int foo() Y_ABSL_ATTRIBUTE_HOT;
+#if Y_ABSL_HAVE_ATTRIBUTE(hot) || (defined(__GNUC__) && !defined(__clang__))
+#define Y_ABSL_ATTRIBUTE_HOT __attribute__((hot))
 #else
-#define ABSL_ATTRIBUTE_HOT
+#define Y_ABSL_ATTRIBUTE_HOT
 #endif
 
-#if ABSL_HAVE_ATTRIBUTE(cold) || (defined(__GNUC__) && !defined(__clang__))
-#define ABSL_ATTRIBUTE_COLD __attribute__((cold))
+#if Y_ABSL_HAVE_ATTRIBUTE(cold) || (defined(__GNUC__) && !defined(__clang__))
+#define Y_ABSL_ATTRIBUTE_COLD __attribute__((cold))
 #else
-#define ABSL_ATTRIBUTE_COLD
+#define Y_ABSL_ATTRIBUTE_COLD
 #endif
 
-// ABSL_XRAY_ALWAYS_INSTRUMENT, ABSL_XRAY_NEVER_INSTRUMENT, ABSL_XRAY_LOG_ARGS
+// Y_ABSL_XRAY_ALWAYS_INSTRUMENT, Y_ABSL_XRAY_NEVER_INSTRUMENT, Y_ABSL_XRAY_LOG_ARGS
 //
-// We define the ABSL_XRAY_ALWAYS_INSTRUMENT and ABSL_XRAY_NEVER_INSTRUMENT
+// We define the Y_ABSL_XRAY_ALWAYS_INSTRUMENT and Y_ABSL_XRAY_NEVER_INSTRUMENT
 // macro used as an attribute to mark functions that must always or never be
 // instrumented by XRay. Currently, this is only supported in Clang/LLVM.
 //
@@ -486,29 +486,29 @@
 // attributes in source take precedence over these special-case lists.
 //
 // To disable the XRay attributes at build-time, users may define
-// ABSL_NO_XRAY_ATTRIBUTES. Do NOT define ABSL_NO_XRAY_ATTRIBUTES on specific
+// Y_ABSL_NO_XRAY_ATTRIBUTES. Do NOT define Y_ABSL_NO_XRAY_ATTRIBUTES on specific
 // 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
-#if ABSL_HAVE_CPP_ATTRIBUTE(clang::xray_always_instrument) && \
-    !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)
-#define ABSL_XRAY_LOG_ARGS(N) \
+#if Y_ABSL_HAVE_CPP_ATTRIBUTE(clang::xray_always_instrument) && \
+    !defined(Y_ABSL_NO_XRAY_ATTRIBUTES) && !defined(__ANDROID__)
+#define Y_ABSL_XRAY_ALWAYS_INSTRUMENT [[clang::xray_always_instrument]]
+#define Y_ABSL_XRAY_NEVER_INSTRUMENT [[clang::xray_never_instrument]]
+#if Y_ABSL_HAVE_CPP_ATTRIBUTE(clang::xray_log_args)
+#define Y_ABSL_XRAY_LOG_ARGS(N) \
     [[clang::xray_always_instrument, clang::xray_log_args(N)]]
 #else
-#define ABSL_XRAY_LOG_ARGS(N) [[clang::xray_always_instrument]]
+#define Y_ABSL_XRAY_LOG_ARGS(N) [[clang::xray_always_instrument]]
 #endif
 #else
-#define ABSL_XRAY_ALWAYS_INSTRUMENT
-#define ABSL_XRAY_NEVER_INSTRUMENT
-#define ABSL_XRAY_LOG_ARGS(N)
+#define Y_ABSL_XRAY_ALWAYS_INSTRUMENT
+#define Y_ABSL_XRAY_NEVER_INSTRUMENT
+#define Y_ABSL_XRAY_LOG_ARGS(N)
 #endif
 
-// ABSL_ATTRIBUTE_REINITIALIZES
+// Y_ABSL_ATTRIBUTE_REINITIALIZES
 //
 // Indicates that a member function reinitializes the entire object to a known
 // state, independent of the previous state of the object.
@@ -516,17 +516,17 @@
 // The clang-tidy check bugprone-use-after-move allows member functions marked
 // with this attribute to be called on objects that have been moved from;
 // without the attribute, this would result in a use-after-move warning.
-#if ABSL_HAVE_CPP_ATTRIBUTE(clang::reinitializes)
-#define ABSL_ATTRIBUTE_REINITIALIZES [[clang::reinitializes]]
+#if Y_ABSL_HAVE_CPP_ATTRIBUTE(clang::reinitializes)
+#define Y_ABSL_ATTRIBUTE_REINITIALIZES [[clang::reinitializes]]
 #else
-#define ABSL_ATTRIBUTE_REINITIALIZES
+#define Y_ABSL_ATTRIBUTE_REINITIALIZES
 #endif
 
 // -----------------------------------------------------------------------------
 // Variable Attributes
 // -----------------------------------------------------------------------------
 
-// ABSL_ATTRIBUTE_UNUSED
+// Y_ABSL_ATTRIBUTE_UNUSED
 //
 // Prevents the compiler from complaining about variables that appear unused.
 //
@@ -536,24 +536,24 @@
 // Due to differences in positioning requirements between the old, compiler
 // specific __attribute__ syntax and the now standard [[maybe_unused]], this
 // macro does not attempt to take advantage of '[[maybe_unused]]'.
-#if ABSL_HAVE_ATTRIBUTE(unused) || (defined(__GNUC__) && !defined(__clang__))
-#undef ABSL_ATTRIBUTE_UNUSED
-#define ABSL_ATTRIBUTE_UNUSED __attribute__((__unused__))
+#if Y_ABSL_HAVE_ATTRIBUTE(unused) || (defined(__GNUC__) && !defined(__clang__))
+#undef Y_ABSL_ATTRIBUTE_UNUSED
+#define Y_ABSL_ATTRIBUTE_UNUSED __attribute__((__unused__))
 #else
-#define ABSL_ATTRIBUTE_UNUSED
+#define Y_ABSL_ATTRIBUTE_UNUSED
 #endif
 
-// ABSL_ATTRIBUTE_INITIAL_EXEC
+// Y_ABSL_ATTRIBUTE_INITIAL_EXEC
 //
 // Tells the compiler to use "initial-exec" mode for a thread-local variable.
 // See http://people.redhat.com/drepper/tls.pdf for the gory details.
-#if ABSL_HAVE_ATTRIBUTE(tls_model) || (defined(__GNUC__) && !defined(__clang__))
-#define ABSL_ATTRIBUTE_INITIAL_EXEC __attribute__((tls_model("initial-exec")))
+#if Y_ABSL_HAVE_ATTRIBUTE(tls_model) || (defined(__GNUC__) && !defined(__clang__))
+#define Y_ABSL_ATTRIBUTE_INITIAL_EXEC __attribute__((tls_model("initial-exec")))
 #else
-#define ABSL_ATTRIBUTE_INITIAL_EXEC
+#define Y_ABSL_ATTRIBUTE_INITIAL_EXEC
 #endif
 
-// ABSL_ATTRIBUTE_PACKED
+// Y_ABSL_ATTRIBUTE_PACKED
 //
 // Instructs the compiler not to use natural alignment for a tagged data
 // structure, but instead to reduce its alignment to 1.
@@ -570,31 +570,31 @@
 // structure. Instead, apply this attribute only to structure members that need
 // it.
 //
-// When applying ABSL_ATTRIBUTE_PACKED only to specific structure members the
+// When applying Y_ABSL_ATTRIBUTE_PACKED only to specific structure members the
 // natural alignment of structure members not annotated is preserved. Aligned
 // member accesses are faster than non-aligned member accesses even if the
 // targeted microprocessor supports non-aligned accesses.
-#if ABSL_HAVE_ATTRIBUTE(packed) || (defined(__GNUC__) && !defined(__clang__))
-#define ABSL_ATTRIBUTE_PACKED __attribute__((__packed__))
+#if Y_ABSL_HAVE_ATTRIBUTE(packed) || (defined(__GNUC__) && !defined(__clang__))
+#define Y_ABSL_ATTRIBUTE_PACKED __attribute__((__packed__))
 #else
-#define ABSL_ATTRIBUTE_PACKED
+#define Y_ABSL_ATTRIBUTE_PACKED
 #endif
 
-// ABSL_ATTRIBUTE_FUNC_ALIGN
+// Y_ABSL_ATTRIBUTE_FUNC_ALIGN
 //
 // Tells the compiler to align the function start at least to certain
 // alignment boundary
-#if ABSL_HAVE_ATTRIBUTE(aligned) || (defined(__GNUC__) && !defined(__clang__))
-#define ABSL_ATTRIBUTE_FUNC_ALIGN(bytes) __attribute__((aligned(bytes)))
+#if Y_ABSL_HAVE_ATTRIBUTE(aligned) || (defined(__GNUC__) && !defined(__clang__))
+#define Y_ABSL_ATTRIBUTE_FUNC_ALIGN(bytes) __attribute__((aligned(bytes)))
 #else
-#define ABSL_ATTRIBUTE_FUNC_ALIGN(bytes)
+#define Y_ABSL_ATTRIBUTE_FUNC_ALIGN(bytes)
 #endif
 
-// ABSL_FALLTHROUGH_INTENDED
+// Y_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
+// `break` statement. The Y_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.
 //
@@ -605,7 +605,7 @@
 //    case 41:
 //      if (truth_is_out_there) {
 //        ++x;
-//        ABSL_FALLTHROUGH_INTENDED;  // Use instead of/along with annotations
+//        Y_ABSL_FALLTHROUGH_INTENDED;  // Use instead of/along with annotations
 //                                    // in comments
 //      } else {
 //        return x;
@@ -618,25 +618,25 @@
 // clang documentation on language extensions for details:
 // https://clang.llvm.org/docs/AttributeReference.html#fallthrough-clang-fallthrough
 //
-// When used with unsupported compilers, the ABSL_FALLTHROUGH_INTENDED macro has
+// When used with unsupported compilers, the Y_ABSL_FALLTHROUGH_INTENDED macro has
 // no effect on diagnostics. In any case this macro has no effect on runtime
 // behavior and performance of code.
 
-#ifdef ABSL_FALLTHROUGH_INTENDED
-#error "ABSL_FALLTHROUGH_INTENDED should not be defined."
-#elif ABSL_HAVE_CPP_ATTRIBUTE(fallthrough)
-#define ABSL_FALLTHROUGH_INTENDED [[fallthrough]]
-#elif ABSL_HAVE_CPP_ATTRIBUTE(clang::fallthrough)
-#define ABSL_FALLTHROUGH_INTENDED [[clang::fallthrough]]
-#elif ABSL_HAVE_CPP_ATTRIBUTE(gnu::fallthrough)
-#define ABSL_FALLTHROUGH_INTENDED [[gnu::fallthrough]]
+#ifdef Y_ABSL_FALLTHROUGH_INTENDED
+#error "Y_ABSL_FALLTHROUGH_INTENDED should not be defined."
+#elif Y_ABSL_HAVE_CPP_ATTRIBUTE(fallthrough)
+#define Y_ABSL_FALLTHROUGH_INTENDED [[fallthrough]]
+#elif Y_ABSL_HAVE_CPP_ATTRIBUTE(clang::fallthrough)
+#define Y_ABSL_FALLTHROUGH_INTENDED [[clang::fallthrough]]
+#elif Y_ABSL_HAVE_CPP_ATTRIBUTE(gnu::fallthrough)
+#define Y_ABSL_FALLTHROUGH_INTENDED [[gnu::fallthrough]]
 #else
-#define ABSL_FALLTHROUGH_INTENDED \
+#define Y_ABSL_FALLTHROUGH_INTENDED \
   do {                            \
   } while (0)
 #endif
 
-// ABSL_DEPRECATED()
+// Y_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.
@@ -644,28 +644,28 @@
 //
 // Examples:
 //
-//   class ABSL_DEPRECATED("Use Bar instead") Foo {...};
+//   class Y_ABSL_DEPRECATED("Use Bar instead") Foo {...};
 //
-//   ABSL_DEPRECATED("Use Baz() instead") void Bar() {...}
+//   Y_ABSL_DEPRECATED("Use Baz() instead") void Bar() {...}
 //
 //   template <typename T>
-//   ABSL_DEPRECATED("Use DoThat() instead")
+//   Y_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)))
+#define Y_ABSL_DEPRECATED(message) __attribute__((deprecated(message)))
 #endif
 
-#ifndef ABSL_DEPRECATED
-#define ABSL_DEPRECATED(message)
+#ifndef Y_ABSL_DEPRECATED
+#define Y_ABSL_DEPRECATED(message)
 #endif
 
-// ABSL_CONST_INIT
+// Y_ABSL_CONST_INIT
 //
-// A variable declaration annotated with the `ABSL_CONST_INIT` attribute will
+// A variable declaration annotated with the `Y_ABSL_CONST_INIT` attribute will
 // not compile (on supported platforms) unless the variable has a constant
 // initializer. This is useful for variables with static and thread storage
 // duration, because it guarantees that they will not suffer from the so-called
@@ -677,21 +677,21 @@
 //
 //   class MyClass {
 //    public:
-//     ABSL_CONST_INIT static MyType my_var;
+//     Y_ABSL_CONST_INIT static MyType my_var;
 //   };
 //
 //   MyType MyClass::my_var = MakeMyType(...);
 //
 // Note that this attribute is redundant if the variable is declared constexpr.
-#if ABSL_HAVE_CPP_ATTRIBUTE(clang::require_constant_initialization)
-#define ABSL_CONST_INIT [[clang::require_constant_initialization]]
+#if Y_ABSL_HAVE_CPP_ATTRIBUTE(clang::require_constant_initialization)
+#define Y_ABSL_CONST_INIT [[clang::require_constant_initialization]]
 #else
-#define ABSL_CONST_INIT
-#endif  // ABSL_HAVE_CPP_ATTRIBUTE(clang::require_constant_initialization)
+#define Y_ABSL_CONST_INIT
+#endif  // Y_ABSL_HAVE_CPP_ATTRIBUTE(clang::require_constant_initialization)
 
-// ABSL_ATTRIBUTE_PURE_FUNCTION
+// Y_ABSL_ATTRIBUTE_PURE_FUNCTION
 //
-// ABSL_ATTRIBUTE_PURE_FUNCTION is used to annotate declarations of "pure"
+// Y_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
@@ -701,16 +701,16 @@
 //
 // 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))
+//  Y_ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Milliseconds(Duration d);
+#if Y_ABSL_HAVE_CPP_ATTRIBUTE(gnu::pure)
+#define Y_ABSL_ATTRIBUTE_PURE_FUNCTION [[gnu::pure]]
+#elif Y_ABSL_HAVE_ATTRIBUTE(pure)
+#define Y_ABSL_ATTRIBUTE_PURE_FUNCTION __attribute__((pure))
 #else
-#define ABSL_ATTRIBUTE_PURE_FUNCTION
+#define Y_ABSL_ATTRIBUTE_PURE_FUNCTION
 #endif
 
-// ABSL_ATTRIBUTE_LIFETIME_BOUND indicates that a resource owned by a function
+// Y_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
 // constructed object). This attribute causes warnings to be produced if a
@@ -724,12 +724,12 @@
 //
 // See also the upstream documentation:
 // https://clang.llvm.org/docs/AttributeReference.html#lifetimebound
-#if ABSL_HAVE_CPP_ATTRIBUTE(clang::lifetimebound)
-#define ABSL_ATTRIBUTE_LIFETIME_BOUND [[clang::lifetimebound]]
-#elif ABSL_HAVE_ATTRIBUTE(lifetimebound)
-#define ABSL_ATTRIBUTE_LIFETIME_BOUND __attribute__((lifetimebound))
+#if Y_ABSL_HAVE_CPP_ATTRIBUTE(clang::lifetimebound)
+#define Y_ABSL_ATTRIBUTE_LIFETIME_BOUND [[clang::lifetimebound]]
+#elif Y_ABSL_HAVE_ATTRIBUTE(lifetimebound)
+#define Y_ABSL_ATTRIBUTE_LIFETIME_BOUND __attribute__((lifetimebound))
 #else
-#define ABSL_ATTRIBUTE_LIFETIME_BOUND
+#define Y_ABSL_ATTRIBUTE_LIFETIME_BOUND
 #endif
 
-#endif  // ABSL_BASE_ATTRIBUTES_H_
+#endif  // Y_ABSL_BASE_ATTRIBUTES_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/call_once.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/call_once.h
index 5d80e4e7ca..93239f29e4 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
@@ -22,8 +22,8 @@
 // fix, so that (for example) non-const references may be passed to the invoked
 // function.
 
-#ifndef ABSL_BASE_CALL_ONCE_H_
-#define ABSL_BASE_CALL_ONCE_H_
+#ifndef Y_ABSL_BASE_CALL_ONCE_H_
+#define Y_ABSL_BASE_CALL_ONCE_H_
 
 #include <algorithm>
 #include <atomic>
@@ -41,7 +41,7 @@
 #include "y_absl/base/port.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 class once_flag;
 
@@ -143,7 +143,7 @@ enum {
 };
 
 template <typename Callable, typename... Args>
-ABSL_ATTRIBUTE_NOINLINE
+Y_ABSL_ATTRIBUTE_NOINLINE
 void CallOnceImpl(std::atomic<uint32_t>* control,
                   base_internal::SchedulingMode scheduling_mode, Callable&& fn,
                   Args&&... args) {
@@ -154,7 +154,7 @@ void CallOnceImpl(std::atomic<uint32_t>* control,
         old_control != kOnceRunning &&
         old_control != kOnceWaiter &&
         old_control != kOnceDone) {
-      ABSL_RAW_LOG(FATAL, "Unexpected value for control word: 0x%lx",
+      Y_ABSL_RAW_LOG(FATAL, "Unexpected value for control word: 0x%lx",
                    static_cast<unsigned long>(old_control));  // NOLINT
     }
   }
@@ -173,7 +173,7 @@ void CallOnceImpl(std::atomic<uint32_t>* control,
   uint32_t old_control = kOnceInit;
   if (control->compare_exchange_strong(old_control, kOnceRunning,
                                        std::memory_order_relaxed) ||
-      base_internal::SpinLockWait(control, ABSL_ARRAYSIZE(trans), trans,
+      base_internal::SpinLockWait(control, Y_ABSL_ARRAYSIZE(trans), trans,
                                   scheduling_mode) == kOnceInit) {
     base_internal::invoke(std::forward<Callable>(fn),
                           std::forward<Args>(args)...);
@@ -193,7 +193,7 @@ template <typename Callable, typename... Args>
 void LowLevelCallOnce(y_absl::once_flag* flag, Callable&& fn, Args&&... args) {
   std::atomic<uint32_t>* once = base_internal::ControlWord(flag);
   uint32_t s = once->load(std::memory_order_acquire);
-  if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
+  if (Y_ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
     base_internal::CallOnceImpl(once, base_internal::SCHEDULE_KERNEL_ONLY,
                                 std::forward<Callable>(fn),
                                 std::forward<Args>(args)...);
@@ -206,14 +206,14 @@ template <typename Callable, typename... Args>
 void call_once(y_absl::once_flag& flag, Callable&& fn, Args&&... args) {
   std::atomic<uint32_t>* once = base_internal::ControlWord(&flag);
   uint32_t s = once->load(std::memory_order_acquire);
-  if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
+  if (Y_ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
     base_internal::CallOnceImpl(
         once, base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL,
         std::forward<Callable>(fn), std::forward<Args>(args)...);
   }
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_BASE_CALL_ONCE_H_
+#endif  // Y_ABSL_BASE_CALL_ONCE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/casts.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/casts.h
index 6270ede21e..4ea832f441 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/casts.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/casts.h
@@ -21,8 +21,8 @@
 // the standard casts provided in the C++ standard. As with all cast operations,
 // use these with caution and only if alternatives do not exist.
 
-#ifndef ABSL_BASE_CASTS_H_
-#define ABSL_BASE_CASTS_H_
+#ifndef Y_ABSL_BASE_CASTS_H_
+#define Y_ABSL_BASE_CASTS_H_
 
 #include <cstring>
 #include <memory>
@@ -34,7 +34,7 @@
 #include "y_absl/meta/type_traits.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 namespace internal_casts {
 
@@ -168,7 +168,7 @@ template <
     typename std::enable_if<
         !internal_casts::is_bitcastable<Dest, Source>::value,
         int>::type = 0>
-ABSL_DEPRECATED(
+Y_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.")
@@ -181,7 +181,7 @@ inline Dest bit_cast(const Source& source) {
   return dest;
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_BASE_CASTS_H_
+#endif  // Y_ABSL_BASE_CASTS_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/config.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/config.h
index 162843aa00..cb0bf305c9 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/config.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/config.h
@@ -29,24 +29,24 @@
 // Example:
 //
 // Suppose a programmer wants to write a program that uses the 'mmap()' system
-// call. The Abseil macro for that feature (`ABSL_HAVE_MMAP`) allows you to
+// call. The Abseil macro for that feature (`Y_ABSL_HAVE_MMAP`) allows you to
 // selectively include the `mmap.h` header and bracket code using that feature
 // in the macro:
 //
 //   #include "y_absl/base/config.h"
 //
-//   #ifdef ABSL_HAVE_MMAP
+//   #ifdef Y_ABSL_HAVE_MMAP
 //   #include "sys/mman.h"
-//   #endif  //ABSL_HAVE_MMAP
+//   #endif  //Y_ABSL_HAVE_MMAP
 //
 //   ...
-//   #ifdef ABSL_HAVE_MMAP
+//   #ifdef Y_ABSL_HAVE_MMAP
 //   void *ptr = mmap(...);
 //   ...
-//   #endif  // ABSL_HAVE_MMAP
+//   #endif  // Y_ABSL_HAVE_MMAP
 
-#ifndef ABSL_BASE_CONFIG_H_
-#define ABSL_BASE_CONFIG_H_
+#ifndef Y_ABSL_BASE_CONFIG_H_
+#define Y_ABSL_BASE_CONFIG_H_
 
 // Included for the __GLIBC__ macro (or similar macros on other systems).
 #include <limits.h>
@@ -67,12 +67,12 @@
 #include "y_absl/base/policy_checks.h"
 
 // Abseil long-term support (LTS) releases will define
-// `ABSL_LTS_RELEASE_VERSION` to the integer representing the date string of the
-// LTS release version, and will define `ABSL_LTS_RELEASE_PATCH_LEVEL` to the
+// `Y_ABSL_LTS_RELEASE_VERSION` to the integer representing the date string of the
+// LTS release version, and will define `Y_ABSL_LTS_RELEASE_PATCH_LEVEL` to the
 // integer representing the patch-level for that release.
 //
 // For example, for LTS release version "20300401.2", this would give us
-// ABSL_LTS_RELEASE_VERSION == 20300401 && ABSL_LTS_RELEASE_PATCH_LEVEL == 2
+// Y_ABSL_LTS_RELEASE_VERSION == 20300401 && Y_ABSL_LTS_RELEASE_PATCH_LEVEL == 2
 //
 // These symbols will not be defined in non-LTS code.
 //
@@ -80,11 +80,11 @@
 // these symbols to assert a minimum version requirement, we recommend you do it
 // as
 //
-// #if defined(ABSL_LTS_RELEASE_VERSION) && ABSL_LTS_RELEASE_VERSION < 20300401
+// #if defined(Y_ABSL_LTS_RELEASE_VERSION) && Y_ABSL_LTS_RELEASE_VERSION < 20300401
 // #error Project foo requires Abseil LTS version >= 20300401
 // #endif
 //
-// The `defined(ABSL_LTS_RELEASE_VERSION)` part of the check excludes
+// The `defined(Y_ABSL_LTS_RELEASE_VERSION)` part of the check excludes
 // live-at-head clients from the minimum version assertion.
 //
 // See https://abseil.io/about/releases for more information on Abseil release
@@ -92,18 +92,18 @@
 //
 // LTS releases can be obtained from
 // https://github.com/abseil/abseil-cpp/releases.
-#define ABSL_LTS_RELEASE_VERSION 20211102
-#define ABSL_LTS_RELEASE_PATCH_LEVEL 0
+#define Y_ABSL_LTS_RELEASE_VERSION 20211102
+#define Y_ABSL_LTS_RELEASE_PATCH_LEVEL 0
 
 // Helper macro to convert a CPP variable to a string literal.
-#define ABSL_INTERNAL_DO_TOKEN_STR(x) #x
-#define ABSL_INTERNAL_TOKEN_STR(x) ABSL_INTERNAL_DO_TOKEN_STR(x)
+#define Y_ABSL_INTERNAL_DO_TOKEN_STR(x) #x
+#define Y_ABSL_INTERNAL_TOKEN_STR(x) Y_ABSL_INTERNAL_DO_TOKEN_STR(x)
 
 // -----------------------------------------------------------------------------
 // Abseil namespace annotations
 // -----------------------------------------------------------------------------
 
-// ABSL_NAMESPACE_BEGIN/ABSL_NAMESPACE_END
+// Y_ABSL_NAMESPACE_BEGIN/Y_ABSL_NAMESPACE_END
 //
 // An annotation placed at the beginning/end of each `namespace y_absl` scope.
 // This is used to inject an inline namespace.
@@ -111,11 +111,11 @@
 // The proper way to write Abseil code in the `y_absl` namespace is:
 //
 // namespace y_absl {
-// ABSL_NAMESPACE_BEGIN
+// Y_ABSL_NAMESPACE_BEGIN
 //
 // void Foo();  // y_absl::Foo().
 //
-// ABSL_NAMESPACE_END
+// Y_ABSL_NAMESPACE_END
 // }  // namespace y_absl
 //
 // Users of Abseil should not use these macros, because users of Abseil should
@@ -123,43 +123,43 @@
 // not support forward declarations of its own types, nor does it support
 // user-provided specialization of Abseil templates.  Code that violates these
 // rules may be broken without warning.)
-#if !defined(ABSL_OPTION_USE_INLINE_NAMESPACE) || \
-    !defined(ABSL_OPTION_INLINE_NAMESPACE_NAME)
+#if !defined(Y_ABSL_OPTION_USE_INLINE_NAMESPACE) || \
+    !defined(Y_ABSL_OPTION_INLINE_NAMESPACE_NAME)
 #error options.h is misconfigured.
 #endif
 
-// Check that ABSL_OPTION_INLINE_NAMESPACE_NAME is neither "head" nor ""
-#if defined(__cplusplus) && ABSL_OPTION_USE_INLINE_NAMESPACE == 1
+// Check that Y_ABSL_OPTION_INLINE_NAMESPACE_NAME is neither "head" nor ""
+#if defined(__cplusplus) && Y_ABSL_OPTION_USE_INLINE_NAMESPACE == 1
 
-#define ABSL_INTERNAL_INLINE_NAMESPACE_STR \
-  ABSL_INTERNAL_TOKEN_STR(ABSL_OPTION_INLINE_NAMESPACE_NAME)
+#define Y_ABSL_INTERNAL_INLINE_NAMESPACE_STR \
+  Y_ABSL_INTERNAL_TOKEN_STR(Y_ABSL_OPTION_INLINE_NAMESPACE_NAME)
 
-static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != '\0',
-              "options.h misconfigured: ABSL_OPTION_INLINE_NAMESPACE_NAME must "
+static_assert(Y_ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != '\0',
+              "options.h misconfigured: Y_ABSL_OPTION_INLINE_NAMESPACE_NAME must "
               "not be empty.");
-static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
-                  ABSL_INTERNAL_INLINE_NAMESPACE_STR[1] != 'e' ||
-                  ABSL_INTERNAL_INLINE_NAMESPACE_STR[2] != 'a' ||
-                  ABSL_INTERNAL_INLINE_NAMESPACE_STR[3] != 'd' ||
-                  ABSL_INTERNAL_INLINE_NAMESPACE_STR[4] != '\0',
-              "options.h misconfigured: ABSL_OPTION_INLINE_NAMESPACE_NAME must "
+static_assert(Y_ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
+                  Y_ABSL_INTERNAL_INLINE_NAMESPACE_STR[1] != 'e' ||
+                  Y_ABSL_INTERNAL_INLINE_NAMESPACE_STR[2] != 'a' ||
+                  Y_ABSL_INTERNAL_INLINE_NAMESPACE_STR[3] != 'd' ||
+                  Y_ABSL_INTERNAL_INLINE_NAMESPACE_STR[4] != '\0',
+              "options.h misconfigured: Y_ABSL_OPTION_INLINE_NAMESPACE_NAME must "
               "be changed to a new, unique identifier name.");
 
 #endif
 
-#if ABSL_OPTION_USE_INLINE_NAMESPACE == 0
-#define ABSL_NAMESPACE_BEGIN
-#define ABSL_NAMESPACE_END
-#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)
+#if Y_ABSL_OPTION_USE_INLINE_NAMESPACE == 0
+#define Y_ABSL_NAMESPACE_BEGIN
+#define Y_ABSL_NAMESPACE_END
+#define Y_ABSL_INTERNAL_C_SYMBOL(x) x
+#elif Y_ABSL_OPTION_USE_INLINE_NAMESPACE == 1
+#define Y_ABSL_NAMESPACE_BEGIN \
+  inline namespace Y_ABSL_OPTION_INLINE_NAMESPACE_NAME {
+#define Y_ABSL_NAMESPACE_END }
+#define Y_ABSL_INTERNAL_C_SYMBOL_HELPER_2(x, v) x##_##v
+#define Y_ABSL_INTERNAL_C_SYMBOL_HELPER_1(x, v) \
+  Y_ABSL_INTERNAL_C_SYMBOL_HELPER_2(x, v)
+#define Y_ABSL_INTERNAL_C_SYMBOL(x) \
+  Y_ABSL_INTERNAL_C_SYMBOL_HELPER_1(x, Y_ABSL_OPTION_INLINE_NAMESPACE_NAME)
 #else
 #error options.h is misconfigured.
 #endif
@@ -168,7 +168,7 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 // Compiler Feature Checks
 // -----------------------------------------------------------------------------
 
-// ABSL_HAVE_BUILTIN()
+// Y_ABSL_HAVE_BUILTIN()
 //
 // Checks whether the compiler supports a Clang Feature Checking Macro, and if
 // so, checks whether it supports the provided builtin function "x" where x
@@ -178,106 +178,106 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 // Note: Use this macro to avoid an extra level of #ifdef __has_builtin check.
 // http://releases.llvm.org/3.3/tools/clang/docs/LanguageExtensions.html
 #ifdef __has_builtin
-#define ABSL_HAVE_BUILTIN(x) __has_builtin(x)
+#define Y_ABSL_HAVE_BUILTIN(x) __has_builtin(x)
 #else
-#define ABSL_HAVE_BUILTIN(x) 0
+#define Y_ABSL_HAVE_BUILTIN(x) 0
 #endif
 
 #if defined(__is_identifier)
-#define ABSL_INTERNAL_HAS_KEYWORD(x) !(__is_identifier(x))
+#define Y_ABSL_INTERNAL_HAS_KEYWORD(x) !(__is_identifier(x))
 #else
-#define ABSL_INTERNAL_HAS_KEYWORD(x) 0
+#define Y_ABSL_INTERNAL_HAS_KEYWORD(x) 0
 #endif
 
 #ifdef __has_feature
-#define ABSL_HAVE_FEATURE(f) __has_feature(f)
+#define Y_ABSL_HAVE_FEATURE(f) __has_feature(f)
 #else
-#define ABSL_HAVE_FEATURE(f) 0
+#define Y_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__)
-#define ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(x, y) \
+#define Y_ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(x, y) \
   (__GNUC__ > (x) || __GNUC__ == (x) && __GNUC_MINOR__ >= (y))
 #else
-#define ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(x, y) 0
+#define Y_ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(x, y) 0
 #endif
 
 #if defined(__clang__) && defined(__clang_major__) && defined(__clang_minor__)
-#define ABSL_INTERNAL_HAVE_MIN_CLANG_VERSION(x, y) \
+#define Y_ABSL_INTERNAL_HAVE_MIN_CLANG_VERSION(x, y) \
   (__clang_major__ > (x) || __clang_major__ == (x) && __clang_minor__ >= (y))
 #else
-#define ABSL_INTERNAL_HAVE_MIN_CLANG_VERSION(x, y) 0
+#define Y_ABSL_INTERNAL_HAVE_MIN_CLANG_VERSION(x, y) 0
 #endif
 
-// ABSL_HAVE_TLS is defined to 1 when __thread should be supported.
+// Y_ABSL_HAVE_TLS is defined to 1 when __thread should be supported.
 // We assume __thread is supported on Linux when compiled with Clang or compiled
 // against libstdc++ with _GLIBCXX_HAVE_TLS defined.
-#ifdef ABSL_HAVE_TLS
-#error ABSL_HAVE_TLS cannot be directly set
+#ifdef Y_ABSL_HAVE_TLS
+#error Y_ABSL_HAVE_TLS cannot be directly set
 #elif defined(__linux__) && (defined(__clang__) || defined(_GLIBCXX_HAVE_TLS))
-#define ABSL_HAVE_TLS 1
+#define Y_ABSL_HAVE_TLS 1
 #endif
 
-// ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE
+// Y_ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE
 //
 // Checks whether `std::is_trivially_destructible<T>` is supported.
 //
 // Notes: All supported compilers using libc++ support this feature, as does
 // gcc >= 4.8.1 using libstdc++, and Visual Studio.
-#ifdef ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE
-#error ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE cannot be directly set
+#ifdef Y_ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE
+#error Y_ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE cannot be directly set
 #elif defined(_LIBCPP_VERSION) || defined(_MSC_VER) || \
     (!defined(__clang__) && defined(__GLIBCXX__) &&    \
-     ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(4, 8))
-#define ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE 1
+     Y_ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(4, 8))
+#define Y_ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE 1
 #endif
 
-// ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE
+// Y_ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE
 //
 // Checks whether `std::is_trivially_default_constructible<T>` and
 // `std::is_trivially_copy_constructible<T>` are supported.
 
-// ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE
+// Y_ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE
 //
 // Checks whether `std::is_trivially_copy_assignable<T>` is supported.
 
 // Notes: Clang with libc++ supports these features, as does gcc >= 7.4 with
 // libstdc++, or gcc >= 8.2 with libc++, and Visual Studio (but not NVCC).
-#if defined(ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE)
-#error ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE cannot be directly set
-#elif defined(ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE)
-#error ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE cannot directly set
+#if defined(Y_ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE)
+#error Y_ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE cannot be directly set
+#elif defined(Y_ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE)
+#error Y_ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE cannot directly set
 #elif (defined(__clang__) && defined(_LIBCPP_VERSION)) ||                    \
     (!defined(__clang__) &&                                                  \
-     ((ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(7, 4) && defined(__GLIBCXX__)) || \
-      (ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(8, 2) &&                          \
+     ((Y_ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(7, 4) && defined(__GLIBCXX__)) || \
+      (Y_ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(8, 2) &&                          \
        defined(_LIBCPP_VERSION)))) ||                                        \
     (defined(_MSC_VER) && !defined(__NVCC__))
-#define ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE 1
-#define ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE 1
+#define Y_ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE 1
+#define Y_ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE 1
 #endif
 
-// ABSL_HAVE_SOURCE_LOCATION_CURRENT
+// Y_ABSL_HAVE_SOURCE_LOCATION_CURRENT
 //
 // Indicates whether `y_absl::SourceLocation::current()` will return useful
 // information in some contexts.
-#ifndef ABSL_HAVE_SOURCE_LOCATION_CURRENT
-#if ABSL_INTERNAL_HAS_KEYWORD(__builtin_LINE) && \
-    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
+#ifndef Y_ABSL_HAVE_SOURCE_LOCATION_CURRENT
+#if Y_ABSL_INTERNAL_HAS_KEYWORD(__builtin_LINE) && \
+    Y_ABSL_INTERNAL_HAS_KEYWORD(__builtin_FILE)
+#define Y_ABSL_HAVE_SOURCE_LOCATION_CURRENT 1
+#elif Y_ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(5, 0)
+#define Y_ABSL_HAVE_SOURCE_LOCATION_CURRENT 1
 #endif
 #endif
 
-// ABSL_HAVE_THREAD_LOCAL
+// Y_ABSL_HAVE_THREAD_LOCAL
 //
 // Checks whether C++11's `thread_local` storage duration specifier is
 // supported.
-#ifdef ABSL_HAVE_THREAD_LOCAL
-#error ABSL_HAVE_THREAD_LOCAL cannot be directly set
+#ifdef Y_ABSL_HAVE_THREAD_LOCAL
+#error Y_ABSL_HAVE_THREAD_LOCAL cannot be directly set
 #elif defined(__APPLE__)
 // Notes:
 // * Xcode's clang did not support `thread_local` until version 8, and
@@ -285,14 +285,14 @@ 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 Y_ABSL_HAVE_FEATURE unreliable there.
 //
-#if ABSL_HAVE_FEATURE(cxx_thread_local) && \
+#if Y_ABSL_HAVE_FEATURE(cxx_thread_local) && \
     !(TARGET_OS_IPHONE && __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_9_0)
-#define ABSL_HAVE_THREAD_LOCAL 1
+#define Y_ABSL_HAVE_THREAD_LOCAL 1
 #endif
 #else  // !defined(__APPLE__)
-#define ABSL_HAVE_THREAD_LOCAL 1
+#define Y_ABSL_HAVE_THREAD_LOCAL 1
 #endif
 
 // There are platforms for which TLS should not be used even though the compiler
@@ -314,12 +314,12 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 #if defined(__ANDROID__) && defined(__clang__) && defined(__NDK_MAJOR__) && \
     defined(__NDK_MINOR__) &&                                               \
     ((__NDK_MAJOR__ < 12) || ((__NDK_MAJOR__ == 12) && (__NDK_MINOR__ < 1)))
-#undef ABSL_HAVE_TLS
-#undef ABSL_HAVE_THREAD_LOCAL
+#undef Y_ABSL_HAVE_TLS
+#undef Y_ABSL_HAVE_THREAD_LOCAL
 #endif
 #endif  // defined(__ANDROID__) && defined(__clang__)
 
-// ABSL_HAVE_INTRINSIC_INT128
+// Y_ABSL_HAVE_INTRINSIC_INT128
 //
 // Checks whether the __int128 compiler extension for a 128-bit integral type is
 // supported.
@@ -332,55 +332,55 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 // * On Nvidia's nvcc:
 //   * nvcc also defines __GNUC__ and __SIZEOF_INT128__, but not all versions
 //     actually support __int128.
-#ifdef ABSL_HAVE_INTRINSIC_INT128
-#error ABSL_HAVE_INTRINSIC_INT128 cannot be directly set
+#ifdef Y_ABSL_HAVE_INTRINSIC_INT128
+#error Y_ABSL_HAVE_INTRINSIC_INT128 cannot be directly set
 #elif defined(__SIZEOF_INT128__)
 #if (defined(__clang__) && !defined(_WIN32)) || \
     (defined(__CUDACC__) && __CUDACC_VER_MAJOR__ >= 9) ||                \
     (defined(__GNUC__) && !defined(__clang__) && !defined(__CUDACC__))
-#define ABSL_HAVE_INTRINSIC_INT128 1
+#define Y_ABSL_HAVE_INTRINSIC_INT128 1
 #elif defined(__CUDACC__)
 // __CUDACC_VER__ is a full version number before CUDA 9, and is defined to a
 // string explaining that it has been removed starting with CUDA 9. We use
 // nested #ifs because there is no short-circuiting in the preprocessor.
 // NOTE: `__CUDACC__` could be undefined while `__CUDACC_VER__` is defined.
 #if __CUDACC_VER__ >= 70000
-#define ABSL_HAVE_INTRINSIC_INT128 1
+#define Y_ABSL_HAVE_INTRINSIC_INT128 1
 #endif  // __CUDACC_VER__ >= 70000
 #endif  // defined(__CUDACC__)
-#endif  // ABSL_HAVE_INTRINSIC_INT128
+#endif  // Y_ABSL_HAVE_INTRINSIC_INT128
 
-// ABSL_HAVE_EXCEPTIONS
+// Y_ABSL_HAVE_EXCEPTIONS
 //
 // Checks whether the compiler both supports and enables exceptions. Many
 // compilers support a "no exceptions" mode that disables exceptions.
 //
-// Generally, when ABSL_HAVE_EXCEPTIONS is not defined:
+// Generally, when Y_ABSL_HAVE_EXCEPTIONS is not defined:
 //
 // * Code using `throw` and `try` may not compile.
 // * The `noexcept` specifier will still compile and behave as normal.
 // * The `noexcept` operator may still return `false`.
 //
 // For further details, consult the compiler's documentation.
-#ifdef ABSL_HAVE_EXCEPTIONS
-#error ABSL_HAVE_EXCEPTIONS cannot be directly set.
-#elif ABSL_INTERNAL_HAVE_MIN_CLANG_VERSION(3, 6)
+#ifdef Y_ABSL_HAVE_EXCEPTIONS
+#error Y_ABSL_HAVE_EXCEPTIONS cannot be directly set.
+#elif Y_ABSL_INTERNAL_HAVE_MIN_CLANG_VERSION(3, 6)
 // Clang >= 3.6
-#if ABSL_HAVE_FEATURE(cxx_exceptions)
-#define ABSL_HAVE_EXCEPTIONS 1
-#endif  // ABSL_HAVE_FEATURE(cxx_exceptions)
+#if Y_ABSL_HAVE_FEATURE(cxx_exceptions)
+#define Y_ABSL_HAVE_EXCEPTIONS 1
+#endif  // Y_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)
-#define ABSL_HAVE_EXCEPTIONS 1
-#endif  // defined(__EXCEPTIONS) && ABSL_HAVE_FEATURE(cxx_exceptions)
+#if defined(__EXCEPTIONS) && Y_ABSL_HAVE_FEATURE(cxx_exceptions)
+#define Y_ABSL_HAVE_EXCEPTIONS 1
+#endif  // defined(__EXCEPTIONS) && Y_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) &&                        \
+    !(Y_ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(5, 0) &&                        \
       !defined(__cpp_exceptions)) &&                                      \
     !(defined(_MSC_VER) && !defined(_CPPUNWIND))
-#define ABSL_HAVE_EXCEPTIONS 1
+#define Y_ABSL_HAVE_EXCEPTIONS 1
 #endif
 
 // -----------------------------------------------------------------------------
@@ -404,51 +404,51 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 // Note that since Android defines both __ANDROID__ and __linux__, one
 // may probe for either Linux or Android by simply testing for __linux__.
 
-// ABSL_HAVE_MMAP
+// Y_ABSL_HAVE_MMAP
 //
 // Checks whether the platform has an mmap(2) implementation as defined in
 // POSIX.1-2001.
-#ifdef ABSL_HAVE_MMAP
-#error ABSL_HAVE_MMAP cannot be directly set
+#ifdef Y_ABSL_HAVE_MMAP
+#error Y_ABSL_HAVE_MMAP cannot be directly set
 #elif defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__) || \
     defined(_AIX) || defined(__ros__) || defined(__native_client__) ||    \
     defined(__asmjs__) || defined(__wasm__) || defined(__Fuchsia__) ||    \
     defined(__sun) || defined(__ASYLO__) || defined(__myriad2__) ||       \
     defined(__HAIKU__)
-#define ABSL_HAVE_MMAP 1
+#define Y_ABSL_HAVE_MMAP 1
 #endif
 
-// ABSL_HAVE_PTHREAD_GETSCHEDPARAM
+// Y_ABSL_HAVE_PTHREAD_GETSCHEDPARAM
 //
 // Checks whether the platform implements the pthread_(get|set)schedparam(3)
 // functions as defined in POSIX.1-2001.
-#ifdef ABSL_HAVE_PTHREAD_GETSCHEDPARAM
-#error ABSL_HAVE_PTHREAD_GETSCHEDPARAM cannot be directly set
+#ifdef Y_ABSL_HAVE_PTHREAD_GETSCHEDPARAM
+#error Y_ABSL_HAVE_PTHREAD_GETSCHEDPARAM cannot be directly set
 #elif defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__) || \
     defined(_AIX) || defined(__ros__)
-#define ABSL_HAVE_PTHREAD_GETSCHEDPARAM 1
+#define Y_ABSL_HAVE_PTHREAD_GETSCHEDPARAM 1
 #endif
 
-// ABSL_HAVE_SCHED_GETCPU
+// Y_ABSL_HAVE_SCHED_GETCPU
 //
 // Checks whether sched_getcpu is available.
-#ifdef ABSL_HAVE_SCHED_GETCPU
-#error ABSL_HAVE_SCHED_GETCPU cannot be directly set
+#ifdef Y_ABSL_HAVE_SCHED_GETCPU
+#error Y_ABSL_HAVE_SCHED_GETCPU cannot be directly set
 #elif defined(__linux__)
-#define ABSL_HAVE_SCHED_GETCPU 1
+#define Y_ABSL_HAVE_SCHED_GETCPU 1
 #endif
 
-// ABSL_HAVE_SCHED_YIELD
+// Y_ABSL_HAVE_SCHED_YIELD
 //
 // Checks whether the platform implements sched_yield(2) as defined in
 // POSIX.1-2001.
-#ifdef ABSL_HAVE_SCHED_YIELD
-#error ABSL_HAVE_SCHED_YIELD cannot be directly set
+#ifdef Y_ABSL_HAVE_SCHED_YIELD
+#error Y_ABSL_HAVE_SCHED_YIELD cannot be directly set
 #elif defined(__linux__) || defined(__ros__) || defined(__native_client__)
-#define ABSL_HAVE_SCHED_YIELD 1
+#define Y_ABSL_HAVE_SCHED_YIELD 1
 #endif
 
-// ABSL_HAVE_SEMAPHORE_H
+// Y_ABSL_HAVE_SEMAPHORE_H
 //
 // Checks whether the platform supports the <semaphore.h> header and sem_init(3)
 // family of functions as standardized in POSIX.1-2001.
@@ -457,24 +457,24 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 // explicitly deprecated and will cause build failures if enabled for those
 // platforms.  We side-step the issue by not defining it here for Apple
 // platforms.
-#ifdef ABSL_HAVE_SEMAPHORE_H
-#error ABSL_HAVE_SEMAPHORE_H cannot be directly set
+#ifdef Y_ABSL_HAVE_SEMAPHORE_H
+#error Y_ABSL_HAVE_SEMAPHORE_H cannot be directly set
 #elif defined(__linux__) || defined(__ros__)
-#define ABSL_HAVE_SEMAPHORE_H 1
+#define Y_ABSL_HAVE_SEMAPHORE_H 1
 #endif
 
-// ABSL_HAVE_ALARM
+// Y_ABSL_HAVE_ALARM
 //
 // Checks whether the platform supports the <signal.h> header and alarm(2)
 // function as standardized in POSIX.1-2001.
-#ifdef ABSL_HAVE_ALARM
-#error ABSL_HAVE_ALARM cannot be directly set
+#ifdef Y_ABSL_HAVE_ALARM
+#error Y_ABSL_HAVE_ALARM cannot be directly set
 #elif defined(__GOOGLE_GRTE_VERSION__)
 // feature tests for Google's GRTE
-#define ABSL_HAVE_ALARM 1
+#define Y_ABSL_HAVE_ALARM 1
 #elif defined(__GLIBC__)
 // feature test for glibc
-#define ABSL_HAVE_ALARM 1
+#define Y_ABSL_HAVE_ALARM 1
 #elif defined(_MSC_VER)
 // feature tests for Microsoft's library
 #elif defined(__MINGW32__)
@@ -489,11 +489,11 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 #elif defined(__native_client__)
 #else
 // other standard libraries
-#define ABSL_HAVE_ALARM 1
+#define Y_ABSL_HAVE_ALARM 1
 #endif
 
-// ABSL_IS_LITTLE_ENDIAN
-// ABSL_IS_BIG_ENDIAN
+// Y_ABSL_IS_LITTLE_ENDIAN
+// Y_ABSL_IS_BIG_ENDIAN
 //
 // Checks the endianness of the platform.
 //
@@ -501,21 +501,21 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 // Clang (since 3.2); see
 // https://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html.
 // Otherwise, if _WIN32, assume little endian. Otherwise, bail with an error.
-#if defined(ABSL_IS_BIG_ENDIAN)
-#error "ABSL_IS_BIG_ENDIAN cannot be directly set."
+#if defined(Y_ABSL_IS_BIG_ENDIAN)
+#error "Y_ABSL_IS_BIG_ENDIAN cannot be directly set."
 #endif
-#if defined(ABSL_IS_LITTLE_ENDIAN)
-#error "ABSL_IS_LITTLE_ENDIAN cannot be directly set."
+#if defined(Y_ABSL_IS_LITTLE_ENDIAN)
+#error "Y_ABSL_IS_LITTLE_ENDIAN cannot be directly set."
 #endif
 
 #if (defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && \
      __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
-#define ABSL_IS_LITTLE_ENDIAN 1
+#define Y_ABSL_IS_LITTLE_ENDIAN 1
 #elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && \
     __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-#define ABSL_IS_BIG_ENDIAN 1
+#define Y_ABSL_IS_BIG_ENDIAN 1
 #elif defined(_WIN32)
-#define ABSL_IS_LITTLE_ENDIAN 1
+#define Y_ABSL_IS_LITTLE_ENDIAN 1
 #else
 #error "y_absl endian detection needs to be set up for your compiler"
 #endif
@@ -536,61 +536,61 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
    __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 50000) || \
   (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && \
    __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 120000))
-#define ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE 1
+#define Y_ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE 1
 #else
-#define ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE 0
+#define Y_ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE 0
 #endif
 
-// ABSL_HAVE_STD_ANY
+// Y_ABSL_HAVE_STD_ANY
 //
 // Checks whether C++17 std::any is available by checking whether <any> exists.
-#ifdef ABSL_HAVE_STD_ANY
-#error "ABSL_HAVE_STD_ANY cannot be directly set."
+#ifdef Y_ABSL_HAVE_STD_ANY
+#error "Y_ABSL_HAVE_STD_ANY cannot be directly set."
 #endif
 
 #ifdef __has_include
 #if __has_include(<any>) && defined(__cplusplus) && __cplusplus >= 201703L && \
-    !ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE
-#define ABSL_HAVE_STD_ANY 1
+    !Y_ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE
+#define Y_ABSL_HAVE_STD_ANY 1
 #endif
 #endif
 
-// ABSL_HAVE_STD_OPTIONAL
+// Y_ABSL_HAVE_STD_OPTIONAL
 //
 // Checks whether C++17 std::optional is available.
-#ifdef ABSL_HAVE_STD_OPTIONAL
-#error "ABSL_HAVE_STD_OPTIONAL cannot be directly set."
+#ifdef Y_ABSL_HAVE_STD_OPTIONAL
+#error "Y_ABSL_HAVE_STD_OPTIONAL cannot be directly set."
 #endif
 
 #ifdef __has_include
 #if __has_include(<optional>) && defined(__cplusplus) && \
-    __cplusplus >= 201703L && !ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE
-#define ABSL_HAVE_STD_OPTIONAL 1
+    __cplusplus >= 201703L && !Y_ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE
+#define Y_ABSL_HAVE_STD_OPTIONAL 1
 #endif
 #endif
 
-// ABSL_HAVE_STD_VARIANT
+// Y_ABSL_HAVE_STD_VARIANT
 //
 // Checks whether C++17 std::variant is available.
-#ifdef ABSL_HAVE_STD_VARIANT
-#error "ABSL_HAVE_STD_VARIANT cannot be directly set."
+#ifdef Y_ABSL_HAVE_STD_VARIANT
+#error "Y_ABSL_HAVE_STD_VARIANT cannot be directly set."
 #endif
 
 #ifdef __has_include
 #if __has_include(<variant>) && defined(__cplusplus) && \
-    __cplusplus >= 201703L && !ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE
-#define ABSL_HAVE_STD_VARIANT 1
+    __cplusplus >= 201703L && !Y_ABSL_INTERNAL_APPLE_CXX17_TYPES_UNAVAILABLE
+#define Y_ABSL_HAVE_STD_VARIANT 1
 #endif
 #endif
 
-// ABSL_HAVE_STD_STRING_VIEW
+// Y_ABSL_HAVE_STD_STRING_VIEW
 //
 // Checks whether C++17 std::string_view is available.
-#ifdef ABSL_HAVE_STD_STRING_VIEW
-#error "ABSL_HAVE_STD_STRING_VIEW cannot be directly set."
+#ifdef Y_ABSL_HAVE_STD_STRING_VIEW
+#error "Y_ABSL_HAVE_STD_STRING_VIEW cannot be directly set."
 #endif
 
-#define ABSL_HAVE_STD_STRING_VIEW 1
+#define Y_ABSL_HAVE_STD_STRING_VIEW 1
 
 // For MSVC, `__has_include` is supported in VS 2017 15.3, which is later than
 // the support for <optional>, <any>, <string_view>, <variant>. So we use
@@ -602,70 +602,70 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 #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
-#define ABSL_HAVE_STD_STRING_VIEW 1
+// #define Y_ABSL_HAVE_STD_ANY 1
+#define Y_ABSL_HAVE_STD_OPTIONAL 1
+#define Y_ABSL_HAVE_STD_VARIANT 1
+#define Y_ABSL_HAVE_STD_STRING_VIEW 1
 #endif
 
-// ABSL_USES_STD_ANY
+// Y_ABSL_USES_STD_ANY
 //
 // Indicates whether y_absl::any is an alias for std::any.
-#if !defined(ABSL_OPTION_USE_STD_ANY)
+#if !defined(Y_ABSL_OPTION_USE_STD_ANY)
 #error options.h is misconfigured.
-#elif ABSL_OPTION_USE_STD_ANY == 0 || \
-    (ABSL_OPTION_USE_STD_ANY == 2 && !defined(ABSL_HAVE_STD_ANY))
-#undef ABSL_USES_STD_ANY
-#elif ABSL_OPTION_USE_STD_ANY == 1 || \
-    (ABSL_OPTION_USE_STD_ANY == 2 && defined(ABSL_HAVE_STD_ANY))
-#define ABSL_USES_STD_ANY 1
+#elif Y_ABSL_OPTION_USE_STD_ANY == 0 || \
+    (Y_ABSL_OPTION_USE_STD_ANY == 2 && !defined(Y_ABSL_HAVE_STD_ANY))
+#undef Y_ABSL_USES_STD_ANY
+#elif Y_ABSL_OPTION_USE_STD_ANY == 1 || \
+    (Y_ABSL_OPTION_USE_STD_ANY == 2 && defined(Y_ABSL_HAVE_STD_ANY))
+#define Y_ABSL_USES_STD_ANY 1
 #else
 #error options.h is misconfigured.
 #endif
 
-// ABSL_USES_STD_OPTIONAL
+// Y_ABSL_USES_STD_OPTIONAL
 //
 // Indicates whether y_absl::optional is an alias for std::optional.
-#if !defined(ABSL_OPTION_USE_STD_OPTIONAL)
+#if !defined(Y_ABSL_OPTION_USE_STD_OPTIONAL)
 #error options.h is misconfigured.
-#elif ABSL_OPTION_USE_STD_OPTIONAL == 0 || \
-    (ABSL_OPTION_USE_STD_OPTIONAL == 2 && !defined(ABSL_HAVE_STD_OPTIONAL))
-#undef ABSL_USES_STD_OPTIONAL
-#elif ABSL_OPTION_USE_STD_OPTIONAL == 1 || \
-    (ABSL_OPTION_USE_STD_OPTIONAL == 2 && defined(ABSL_HAVE_STD_OPTIONAL))
-#define ABSL_USES_STD_OPTIONAL 1
+#elif Y_ABSL_OPTION_USE_STD_OPTIONAL == 0 || \
+    (Y_ABSL_OPTION_USE_STD_OPTIONAL == 2 && !defined(Y_ABSL_HAVE_STD_OPTIONAL))
+#undef Y_ABSL_USES_STD_OPTIONAL
+#elif Y_ABSL_OPTION_USE_STD_OPTIONAL == 1 || \
+    (Y_ABSL_OPTION_USE_STD_OPTIONAL == 2 && defined(Y_ABSL_HAVE_STD_OPTIONAL))
+#define Y_ABSL_USES_STD_OPTIONAL 1
 #else
 #error options.h is misconfigured.
 #endif
 
-// ABSL_USES_STD_VARIANT
+// Y_ABSL_USES_STD_VARIANT
 //
 // Indicates whether y_absl::variant is an alias for std::variant.
-#if !defined(ABSL_OPTION_USE_STD_VARIANT)
+#if !defined(Y_ABSL_OPTION_USE_STD_VARIANT)
 #error options.h is misconfigured.
-#elif ABSL_OPTION_USE_STD_VARIANT == 0 || \
-    (ABSL_OPTION_USE_STD_VARIANT == 2 && !defined(ABSL_HAVE_STD_VARIANT))
-#undef ABSL_USES_STD_VARIANT
-#elif ABSL_OPTION_USE_STD_VARIANT == 1 || \
-    (ABSL_OPTION_USE_STD_VARIANT == 2 && defined(ABSL_HAVE_STD_VARIANT))
-#define ABSL_USES_STD_VARIANT 1
+#elif Y_ABSL_OPTION_USE_STD_VARIANT == 0 || \
+    (Y_ABSL_OPTION_USE_STD_VARIANT == 2 && !defined(Y_ABSL_HAVE_STD_VARIANT))
+#undef Y_ABSL_USES_STD_VARIANT
+#elif Y_ABSL_OPTION_USE_STD_VARIANT == 1 || \
+    (Y_ABSL_OPTION_USE_STD_VARIANT == 2 && defined(Y_ABSL_HAVE_STD_VARIANT))
+#define Y_ABSL_USES_STD_VARIANT 1
 #else
 #error options.h is misconfigured.
 #endif
 
-// ABSL_USES_STD_STRING_VIEW
+// Y_ABSL_USES_STD_STRING_VIEW
 //
 // Indicates whether y_absl::string_view is an alias for std::string_view.
-#if !defined(ABSL_OPTION_USE_STD_STRING_VIEW)
+#if !defined(Y_ABSL_OPTION_USE_STD_STRING_VIEW)
 #error options.h is misconfigured.
-#elif ABSL_OPTION_USE_STD_STRING_VIEW == 0 || \
-    (ABSL_OPTION_USE_STD_STRING_VIEW == 2 &&  \
-     !defined(ABSL_HAVE_STD_STRING_VIEW))
-#undef ABSL_USES_STD_STRING_VIEW
-#elif ABSL_OPTION_USE_STD_STRING_VIEW == 1 || \
-    (ABSL_OPTION_USE_STD_STRING_VIEW == 2 &&  \
-     defined(ABSL_HAVE_STD_STRING_VIEW))
-#define ABSL_USES_STD_STRING_VIEW 1
+#elif Y_ABSL_OPTION_USE_STD_STRING_VIEW == 0 || \
+    (Y_ABSL_OPTION_USE_STD_STRING_VIEW == 2 &&  \
+     !defined(Y_ABSL_HAVE_STD_STRING_VIEW))
+#undef Y_ABSL_USES_STD_STRING_VIEW
+#elif Y_ABSL_OPTION_USE_STD_STRING_VIEW == 1 || \
+    (Y_ABSL_OPTION_USE_STD_STRING_VIEW == 2 &&  \
+     defined(Y_ABSL_HAVE_STD_STRING_VIEW))
+#define Y_ABSL_USES_STD_STRING_VIEW 1
 #else
 #error options.h is misconfigured.
 #endif
@@ -675,34 +675,34 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 // struct can throw. This defeats some of variant_test and
 // variant_exception_safety_test.
 #if defined(_MSC_VER) && _MSC_VER >= 1700 && defined(_DEBUG)
-#define ABSL_INTERNAL_MSVC_2017_DBG_MODE
+#define Y_ABSL_INTERNAL_MSVC_2017_DBG_MODE
 #endif
 
-// ABSL_INTERNAL_MANGLED_NS
-// ABSL_INTERNAL_MANGLED_BACKREFERENCE
+// Y_ABSL_INTERNAL_MANGLED_NS
+// Y_ABSL_INTERNAL_MANGLED_BACKREFERENCE
 //
 // Internal macros for building up mangled names in our internal fork of CCTZ.
 // This implementation detail is only needed and provided for the MSVC build.
 //
-// These macros both expand to string literals.  ABSL_INTERNAL_MANGLED_NS is
+// These macros both expand to string literals.  Y_ABSL_INTERNAL_MANGLED_NS is
 // the mangled spelling of the `y_absl` namespace, and
-// ABSL_INTERNAL_MANGLED_BACKREFERENCE is a back-reference integer representing
+// Y_ABSL_INTERNAL_MANGLED_BACKREFERENCE is a back-reference integer representing
 // the proper count to skip past the CCTZ fork namespace names.  (This number
 // is one larger when there is an inline namespace name to skip.)
 #if defined(_MSC_VER)
-#if ABSL_OPTION_USE_INLINE_NAMESPACE == 0
-#define ABSL_INTERNAL_MANGLED_NS "y_absl"
-#define ABSL_INTERNAL_MANGLED_BACKREFERENCE "5"
+#if Y_ABSL_OPTION_USE_INLINE_NAMESPACE == 0
+#define Y_ABSL_INTERNAL_MANGLED_NS "y_absl"
+#define Y_ABSL_INTERNAL_MANGLED_BACKREFERENCE "5"
 #else
-#define ABSL_INTERNAL_MANGLED_NS \
-  ABSL_INTERNAL_TOKEN_STR(ABSL_OPTION_INLINE_NAMESPACE_NAME) "@y_absl"
-#define ABSL_INTERNAL_MANGLED_BACKREFERENCE "6"
+#define Y_ABSL_INTERNAL_MANGLED_NS \
+  Y_ABSL_INTERNAL_TOKEN_STR(Y_ABSL_OPTION_INLINE_NAMESPACE_NAME) "@y_absl"
+#define Y_ABSL_INTERNAL_MANGLED_BACKREFERENCE "6"
 #endif
 #endif
 
-#undef ABSL_INTERNAL_HAS_KEYWORD
+#undef Y_ABSL_INTERNAL_HAS_KEYWORD
 
-// ABSL_DLL
+// Y_ABSL_DLL
 //
 // When building Abseil as a DLL, this macro expands to `__declspec(dllexport)`
 // so we can annotate symbols appropriately as being exported. When used in
@@ -710,58 +710,58 @@ static_assert(ABSL_INTERNAL_INLINE_NAMESPACE_STR[0] != 'h' ||
 // that consumers know the symbol is defined inside the DLL. In all other cases,
 // the macro expands to nothing.
 #if defined(_MSC_VER)
-#if defined(ABSL_BUILD_DLL)
-#define ABSL_DLL __declspec(dllexport)
-#elif defined(ABSL_CONSUME_DLL)
-#define ABSL_DLL __declspec(dllimport)
+#if defined(Y_ABSL_BUILD_DLL)
+#define Y_ABSL_DLL __declspec(dllexport)
+#elif defined(Y_ABSL_CONSUME_DLL)
+#define Y_ABSL_DLL __declspec(dllimport)
 #else
-#define ABSL_DLL
+#define Y_ABSL_DLL
 #endif
 #else
-#define ABSL_DLL
+#define Y_ABSL_DLL
 #endif  // defined(_MSC_VER)
 
-// ABSL_HAVE_MEMORY_SANITIZER
+// Y_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."
+#ifdef Y_ABSL_HAVE_MEMORY_SANITIZER
+#error "Y_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
+#define Y_ABSL_HAVE_MEMORY_SANITIZER 1
+#elif !defined(__native_client__) && Y_ABSL_HAVE_FEATURE(memory_sanitizer)
+#define Y_ABSL_HAVE_MEMORY_SANITIZER 1
 #endif
 
-// ABSL_HAVE_THREAD_SANITIZER
+// Y_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."
+#ifdef Y_ABSL_HAVE_THREAD_SANITIZER
+#error "Y_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
+#define Y_ABSL_HAVE_THREAD_SANITIZER 1
+#elif Y_ABSL_HAVE_FEATURE(thread_sanitizer)
+#define Y_ABSL_HAVE_THREAD_SANITIZER 1
 #endif
 
-// ABSL_HAVE_ADDRESS_SANITIZER
+// Y_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."
+#ifdef Y_ABSL_HAVE_ADDRESS_SANITIZER
+#error "Y_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
+#define Y_ABSL_HAVE_ADDRESS_SANITIZER 1
+#elif Y_ABSL_HAVE_FEATURE(address_sanitizer)
+#define Y_ABSL_HAVE_ADDRESS_SANITIZER 1
 #endif
 
-// ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION
+// Y_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."
+#ifdef Y_ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION
+#error "Y_ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION cannot be directly set."
 #elif defined(__cpp_deduction_guides)
-#define ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION 1
+#define Y_ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION 1
 #endif
 
-#endif  // ABSL_BASE_CONFIG_H_
+#endif  // Y_ABSL_BASE_CONFIG_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/const_init.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/const_init.h
index 4bab055dda..e08c42155f 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/const_init.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/const_init.h
@@ -19,8 +19,8 @@
 // A constructor tag used to mark an object as safe for use as a global
 // variable, avoiding the usual lifetime issues that can affect globals.
 
-#ifndef ABSL_BASE_CONST_INIT_H_
-#define ABSL_BASE_CONST_INIT_H_
+#ifndef Y_ABSL_BASE_CONST_INIT_H_
+#define Y_ABSL_BASE_CONST_INIT_H_
 
 #include "y_absl/base/config.h"
 
@@ -36,7 +36,7 @@
 // Constant initialization is guaranteed to occur before any other code
 // executes.  Constructors that are declared 'constexpr' are eligible for
 // constant initialization.  You can annotate a variable declaration with the
-// ABSL_CONST_INIT macro to express this intent.  For compilers that support
+// Y_ABSL_CONST_INIT macro to express this intent.  For compilers that support
 // it, this annotation will cause a compilation error for declarations that
 // aren't subject to constant initialization (perhaps because a runtime value
 // was passed as a constructor argument).
@@ -52,7 +52,7 @@
 // For a few core Abseil classes, we make a best effort to allow for safe global
 // instances, even though these classes have non-trivial destructors.  These
 // objects can be created with the y_absl::kConstInit tag.  For example:
-//   ABSL_CONST_INIT y_absl::Mutex global_mutex(y_absl::kConstInit);
+//   Y_ABSL_CONST_INIT y_absl::Mutex global_mutex(y_absl::kConstInit);
 //
 // The line above declares a global variable of type y_absl::Mutex which can be
 // accessed at any point during startup or shutdown.  global_mutex's destructor
@@ -64,13 +64,13 @@
 // or thread_local storage duration.
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 enum ConstInitType {
   kConstInit,
 };
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_BASE_CONST_INIT_H_
+#endif  // Y_ABSL_BASE_CONST_INIT_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/dynamic_annotations.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/dynamic_annotations.h
index 50b3122cf7..1baab26165 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
@@ -21,7 +21,7 @@
 // in the program.
 //
 // The annotations that should be used by users are macros in all upper-case
-// (e.g., ABSL_ANNOTATE_THREAD_NAME).
+// (e.g., Y_ABSL_ANNOTATE_THREAD_NAME).
 //
 // Actual implementation of these macros may differ depending on the dynamic
 // analysis tool being used.
@@ -42,8 +42,8 @@
 //   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_
+#ifndef Y_ABSL_BASE_DYNAMIC_ANNOTATIONS_H_
+#define Y_ABSL_BASE_DYNAMIC_ANNOTATIONS_H_
 
 #include <stddef.h>
 
@@ -59,19 +59,19 @@
 // -------------------------------------------------------------------------
 // Decide which features are enabled.
 
-#ifdef ABSL_HAVE_THREAD_SANITIZER
+#ifdef Y_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
+#define Y_ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED 1
+#define Y_ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED 1
+#define Y_ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED 1
+#define Y_ABSL_INTERNAL_ANNOTALYSIS_ENABLED 0
+#define Y_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
+#define Y_ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED 0
+#define Y_ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED 0
+#define Y_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
@@ -80,39 +80,39 @@
 // when compiling using Clang.
 
 #if defined(__clang__)
-#define ABSL_INTERNAL_ANNOTALYSIS_ENABLED 1
+#define Y_ABSL_INTERNAL_ANNOTALYSIS_ENABLED 1
 #if !defined(SWIG)
-#define ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED 1
+#define Y_ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED 1
 #endif
 #else
-#define ABSL_INTERNAL_ANNOTALYSIS_ENABLED 0
+#define Y_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
+#define Y_ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED \
+  Y_ABSL_INTERNAL_ANNOTALYSIS_ENABLED
 
-#endif  // ABSL_HAVE_THREAD_SANITIZER
+#endif  // Y_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
+#define Y_ABSL_INTERNAL_BEGIN_EXTERN_C extern "C" {
+#define Y_ABSL_INTERNAL_END_EXTERN_C }  // extern "C"
+#define Y_ABSL_INTERNAL_GLOBAL_SCOPED(F) ::F
+#define Y_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
+#define Y_ABSL_INTERNAL_BEGIN_EXTERN_C  // empty
+#define Y_ABSL_INTERNAL_END_EXTERN_C    // empty
+#define Y_ABSL_INTERNAL_GLOBAL_SCOPED(F) F
+#define Y_ABSL_INTERNAL_STATIC_INLINE static inline
 #endif
 
 // -------------------------------------------------------------------------
 // Define race annotations.
 
-#if ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED == 1
+#if Y_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.
+// library. Therefore they do not use Y_ABSL_INTERNAL_C_SYMBOL.
 
 // -------------------------------------------------------------
 // Annotations that suppress errors. It is usually better to express the
@@ -122,30 +122,30 @@
 // 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)  \
+// where the race happens. See also Y_ABSL_ANNOTATE_BENIGN_RACE_STATIC.
+#define Y_ABSL_ANNOTATE_BENIGN_RACE(pointer, description) \
+  Y_ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateBenignRaceSized)  \
   (__FILE__, __LINE__, pointer, sizeof(*(pointer)), description)
 
-// Same as ABSL_ANNOTATE_BENIGN_RACE(`address`, `description`), but applies to
+// Same as Y_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)              \
+#define Y_ABSL_ANNOTATE_BENIGN_RACE_SIZED(address, size, description) \
+  Y_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) \
+#define Y_ABSL_ANNOTATE_ENABLE_RACE_DETECTION(enable)        \
+  Y_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)
+#define Y_ABSL_ANNOTATE_THREAD_NAME(name) \
+  Y_ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateThreadName)(__FILE__, __LINE__, name)
 
 // -------------------------------------------------------------
 // Annotations useful when implementing locks. They are not normally needed by
@@ -153,42 +153,42 @@
 // 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)
+#define Y_ABSL_ANNOTATE_RWLOCK_CREATE(lock) \
+  Y_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) \
+#ifdef Y_ABSL_HAVE_THREAD_SANITIZER
+#define Y_ABSL_ANNOTATE_RWLOCK_CREATE_STATIC(lock)          \
+  Y_ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockCreateStatic) \
   (__FILE__, __LINE__, lock)
 #else
-#define ABSL_ANNOTATE_RWLOCK_CREATE_STATIC(lock) \
-  ABSL_ANNOTATE_RWLOCK_CREATE(lock)
+#define Y_ABSL_ANNOTATE_RWLOCK_CREATE_STATIC(lock) \
+  Y_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)
+#define Y_ABSL_ANNOTATE_RWLOCK_DESTROY(lock) \
+  Y_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) \
+#define Y_ABSL_ANNOTATE_RWLOCK_ACQUIRED(lock, is_w)     \
+  Y_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) \
+#define Y_ABSL_ANNOTATE_RWLOCK_RELEASED(lock, is_w)     \
+  Y_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)      \
+// Apply Y_ABSL_ANNOTATE_BENIGN_RACE_SIZED to a static variable `static_var`.
+#define Y_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), \
+      Y_ABSL_ANNOTATE_BENIGN_RACE_SIZED(&static_var, sizeof(static_var), \
                                       #static_var ": " description);   \
     }                                                                  \
   };                                                                   \
@@ -197,7 +197,7 @@
 
 // Function prototypes of annotations provided by the compiler-based sanitizer
 // implementation.
-ABSL_INTERNAL_BEGIN_EXTERN_C
+Y_ABSL_INTERNAL_BEGIN_EXTERN_C
 void AnnotateRWLockCreate(const char* file, int line,
                           const volatile void* lock);
 void AnnotateRWLockCreateStatic(const char* file, int line,
@@ -215,107 +215,107 @@ void AnnotateBenignRaceSized(const char* file, int line,
                              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
+Y_ABSL_INTERNAL_END_EXTERN_C
 
-#else  // ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED == 0
+#else  // Y_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
+#define Y_ABSL_ANNOTATE_RWLOCK_CREATE(lock)                            // empty
+#define Y_ABSL_ANNOTATE_RWLOCK_CREATE_STATIC(lock)                     // empty
+#define Y_ABSL_ANNOTATE_RWLOCK_DESTROY(lock)                           // empty
+#define Y_ABSL_ANNOTATE_RWLOCK_ACQUIRED(lock, is_w)                    // empty
+#define Y_ABSL_ANNOTATE_RWLOCK_RELEASED(lock, is_w)                    // empty
+#define Y_ABSL_ANNOTATE_BENIGN_RACE(address, description)              // empty
+#define Y_ABSL_ANNOTATE_BENIGN_RACE_SIZED(address, size, description)  // empty
+#define Y_ABSL_ANNOTATE_THREAD_NAME(name)                              // empty
+#define Y_ABSL_ANNOTATE_ENABLE_RACE_DETECTION(enable)                  // empty
+#define Y_ABSL_ANNOTATE_BENIGN_RACE_STATIC(static_var, description)    // empty
 
-#endif  // ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED
+#endif  // Y_ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED
 
 // -------------------------------------------------------------------------
 // Define memory annotations.
 
-#ifdef ABSL_HAVE_MEMORY_SANITIZER
+#ifdef Y_ABSL_HAVE_MEMORY_SANITIZER
 
 #include <sanitizer/msan_interface.h>
 
-#define ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(address, size) \
+#define Y_ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(address, size) \
   __msan_unpoison(address, size)
 
-#define ABSL_ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size) \
+#define Y_ABSL_ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size) \
   __msan_allocated_memory(address, size)
 
-#else  // !defined(ABSL_HAVE_MEMORY_SANITIZER)
+#else  // !defined(Y_ABSL_HAVE_MEMORY_SANITIZER)
 
 // TODO(rogeeff): remove this branch
-#ifdef ABSL_HAVE_THREAD_SANITIZER
-#define ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(address, size) \
+#ifdef Y_ABSL_HAVE_THREAD_SANITIZER
+#define Y_ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(address, size) \
   do {                                                     \
     (void)(address);                                       \
     (void)(size);                                          \
   } while (0)
-#define ABSL_ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size) \
+#define Y_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 Y_ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(address, size)    // empty
+#define Y_ABSL_ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size)  // empty
 
 #endif
 
-#endif  // ABSL_HAVE_MEMORY_SANITIZER
+#endif  // Y_ABSL_HAVE_MEMORY_SANITIZER
 
 // -------------------------------------------------------------------------
 // Define IGNORE_READS_BEGIN/_END attributes.
 
-#if defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
+#if defined(Y_ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
 
-#define ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE \
+#define Y_ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE \
   __attribute((exclusive_lock_function("*")))
-#define ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE \
+#define Y_ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE \
   __attribute((unlock_function("*")))
 
-#else  // !defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
+#else  // !defined(Y_ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
 
-#define ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE  // empty
-#define ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE    // empty
+#define Y_ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE  // empty
+#define Y_ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE    // empty
 
-#endif  // defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
+#endif  // defined(Y_ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
 
 // -------------------------------------------------------------------------
 // Define IGNORE_READS_BEGIN/_END annotations.
 
-#if ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED == 1
+#if Y_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.
+// library. Therefore they do not use Y_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
+// Y_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) \
+// See also Y_ABSL_ANNOTATE_UNPROTECTED_READ.
+#define Y_ABSL_ANNOTATE_IGNORE_READS_BEGIN()              \
+  Y_ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsBegin) \
   (__FILE__, __LINE__)
 
 // Stop ignoring reads.
-#define ABSL_ANNOTATE_IGNORE_READS_END()              \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsEnd) \
+#define Y_ABSL_ANNOTATE_IGNORE_READS_END()              \
+  Y_ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsEnd) \
   (__FILE__, __LINE__)
 
 // Function prototypes of annotations provided by the compiler-based sanitizer
 // implementation.
-ABSL_INTERNAL_BEGIN_EXTERN_C
+Y_ABSL_INTERNAL_BEGIN_EXTERN_C
 void AnnotateIgnoreReadsBegin(const char* file, int line)
-    ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE;
+    Y_ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE;
 void AnnotateIgnoreReadsEnd(const char* file,
-                            int line) ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE;
-ABSL_INTERNAL_END_EXTERN_C
+                            int line) Y_ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE;
+Y_ABSL_INTERNAL_END_EXTERN_C
 
-#elif defined(ABSL_INTERNAL_ANNOTALYSIS_ENABLED)
+#elif defined(Y_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,
@@ -324,148 +324,148 @@ ABSL_INTERNAL_END_EXTERN_C
 // TODO(delesley) -- The exclusive lock here ignores writes as well, but
 // allows IGNORE_READS_AND_WRITES to work properly.
 
-#define ABSL_ANNOTATE_IGNORE_READS_BEGIN()                          \
-  ABSL_INTERNAL_GLOBAL_SCOPED(                                      \
-      ABSL_INTERNAL_C_SYMBOL(AbslInternalAnnotateIgnoreReadsBegin)) \
+#define Y_ABSL_ANNOTATE_IGNORE_READS_BEGIN()                          \
+  Y_ABSL_INTERNAL_GLOBAL_SCOPED(                                      \
+      Y_ABSL_INTERNAL_C_SYMBOL(AbslInternalAnnotateIgnoreReadsBegin)) \
   ()
 
-#define ABSL_ANNOTATE_IGNORE_READS_END()                          \
-  ABSL_INTERNAL_GLOBAL_SCOPED(                                    \
-      ABSL_INTERNAL_C_SYMBOL(AbslInternalAnnotateIgnoreReadsEnd)) \
+#define Y_ABSL_ANNOTATE_IGNORE_READS_END()                          \
+  Y_ABSL_INTERNAL_GLOBAL_SCOPED(                                    \
+      Y_ABSL_INTERNAL_C_SYMBOL(AbslInternalAnnotateIgnoreReadsEnd)) \
   ()
 
-ABSL_INTERNAL_STATIC_INLINE void ABSL_INTERNAL_C_SYMBOL(
+Y_ABSL_INTERNAL_STATIC_INLINE void Y_ABSL_INTERNAL_C_SYMBOL(
     AbslInternalAnnotateIgnoreReadsBegin)()
-    ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE {}
+    Y_ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE {}
 
-ABSL_INTERNAL_STATIC_INLINE void ABSL_INTERNAL_C_SYMBOL(
+Y_ABSL_INTERNAL_STATIC_INLINE void Y_ABSL_INTERNAL_C_SYMBOL(
     AbslInternalAnnotateIgnoreReadsEnd)()
-    ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE {}
+    Y_ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE {}
 
 #else
 
-#define ABSL_ANNOTATE_IGNORE_READS_BEGIN()  // empty
-#define ABSL_ANNOTATE_IGNORE_READS_END()    // empty
+#define Y_ABSL_ANNOTATE_IGNORE_READS_BEGIN()  // empty
+#define Y_ABSL_ANNOTATE_IGNORE_READS_END()    // empty
 
 #endif
 
 // -------------------------------------------------------------------------
 // Define IGNORE_WRITES_BEGIN/_END annotations.
 
-#if ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED == 1
+#if Y_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__)
+// Similar to Y_ABSL_ANNOTATE_IGNORE_READS_BEGIN, but ignore writes instead.
+#define Y_ABSL_ANNOTATE_IGNORE_WRITES_BEGIN() \
+  Y_ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreWritesBegin)(__FILE__, __LINE__)
 
 // Stop ignoring writes.
-#define ABSL_ANNOTATE_IGNORE_WRITES_END() \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreWritesEnd)(__FILE__, __LINE__)
+#define Y_ABSL_ANNOTATE_IGNORE_WRITES_END() \
+  Y_ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreWritesEnd)(__FILE__, __LINE__)
 
 // Function prototypes of annotations provided by the compiler-based sanitizer
 // implementation.
-ABSL_INTERNAL_BEGIN_EXTERN_C
+Y_ABSL_INTERNAL_BEGIN_EXTERN_C
 void AnnotateIgnoreWritesBegin(const char* file, int line);
 void AnnotateIgnoreWritesEnd(const char* file, int line);
-ABSL_INTERNAL_END_EXTERN_C
+Y_ABSL_INTERNAL_END_EXTERN_C
 
 #else
 
-#define ABSL_ANNOTATE_IGNORE_WRITES_BEGIN()  // empty
-#define ABSL_ANNOTATE_IGNORE_WRITES_END()    // empty
+#define Y_ABSL_ANNOTATE_IGNORE_WRITES_BEGIN()  // empty
+#define Y_ABSL_ANNOTATE_IGNORE_WRITES_END()    // empty
 
 #endif
 
 // -------------------------------------------------------------------------
-// Define the ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_* annotations using the more
+// Define the Y_ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_* annotations using the more
 // primitive annotations defined above.
 //
 //     Instead of doing
-//        ABSL_ANNOTATE_IGNORE_READS_BEGIN();
+//        Y_ABSL_ANNOTATE_IGNORE_READS_BEGIN();
 //        ... = x;
-//        ABSL_ANNOTATE_IGNORE_READS_END();
+//        Y_ABSL_ANNOTATE_IGNORE_READS_END();
 //     one can use
-//        ... = ABSL_ANNOTATE_UNPROTECTED_READ(x);
+//        ... = Y_ABSL_ANNOTATE_UNPROTECTED_READ(x);
 
-#if defined(ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED)
+#if defined(Y_ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED)
 
 // Start ignoring all memory accesses (both reads and writes).
-#define ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN() \
+#define Y_ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN() \
   do {                                                \
-    ABSL_ANNOTATE_IGNORE_READS_BEGIN();               \
-    ABSL_ANNOTATE_IGNORE_WRITES_BEGIN();              \
+    Y_ABSL_ANNOTATE_IGNORE_READS_BEGIN();               \
+    Y_ABSL_ANNOTATE_IGNORE_WRITES_BEGIN();              \
   } while (0)
 
 // Stop ignoring both reads and writes.
-#define ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_END() \
+#define Y_ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_END() \
   do {                                              \
-    ABSL_ANNOTATE_IGNORE_WRITES_END();              \
-    ABSL_ANNOTATE_IGNORE_READS_END();               \
+    Y_ABSL_ANNOTATE_IGNORE_WRITES_END();              \
+    Y_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_ANNOTATE_UNPROTECTED_READ is the preferred way to annotate racey reads.
+#define Y_ABSL_ANNOTATE_UNPROTECTED_READ(x) \
   y_absl::base_internal::AnnotateUnprotectedRead(x)
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 
 template <typename T>
 inline T AnnotateUnprotectedRead(const volatile T& x) {  // NOLINT
-  ABSL_ANNOTATE_IGNORE_READS_BEGIN();
+  Y_ABSL_ANNOTATE_IGNORE_READS_BEGIN();
   T res = x;
-  ABSL_ANNOTATE_IGNORE_READS_END();
+  Y_ABSL_ANNOTATE_IGNORE_READS_END();
   return res;
 }
 
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_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 Y_ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN()  // empty
+#define Y_ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_END()    // empty
+#define Y_ABSL_ANNOTATE_UNPROTECTED_READ(x) (x)
 
 #endif
 
 // -------------------------------------------------------------------------
 // Address sanitizer annotations
 
-#ifdef ABSL_HAVE_ADDRESS_SANITIZER
+#ifdef Y_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 Y_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) \
+#define Y_ABSL_ADDRESS_SANITIZER_REDZONE(name) \
   struct {                                   \
     alignas(8) char x[8];                    \
   } name
 
 #else
 
-#define ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(beg, end, old_mid, new_mid)  // empty
-#define ABSL_ADDRESS_SANITIZER_REDZONE(name) static_assert(true, "")
+#define Y_ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(beg, end, old_mid, new_mid)  // empty
+#define Y_ABSL_ADDRESS_SANITIZER_REDZONE(name) static_assert(true, "")
 
-#endif  // ABSL_HAVE_ADDRESS_SANITIZER
+#endif  // Y_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
+#undef Y_ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED
+#undef Y_ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED
+#undef Y_ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED
+#undef Y_ABSL_INTERNAL_ANNOTALYSIS_ENABLED
+#undef Y_ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED
+#undef Y_ABSL_INTERNAL_BEGIN_EXTERN_C
+#undef Y_ABSL_INTERNAL_END_EXTERN_C
+#undef Y_ABSL_INTERNAL_STATIC_INLINE
 
-#endif  // ABSL_BASE_DYNAMIC_ANNOTATIONS_H_
+#endif  // Y_ABSL_BASE_DYNAMIC_ANNOTATIONS_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/atomic_hook.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/atomic_hook.h
index 5bdf360a57..462879f494 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/atomic_hook.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/atomic_hook.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_BASE_INTERNAL_ATOMIC_HOOK_H_
-#define ABSL_BASE_INTERNAL_ATOMIC_HOOK_H_
+#ifndef Y_ABSL_BASE_INTERNAL_ATOMIC_HOOK_H_
+#define Y_ABSL_BASE_INTERNAL_ATOMIC_HOOK_H_
 
 #include <atomic>
 #include <cassert>
@@ -24,31 +24,31 @@
 #include "y_absl/base/config.h"
 
 #if defined(_MSC_VER) && !defined(__clang__)
-#define ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT 0
+#define Y_ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT 0
 #else
-#define ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT 1
+#define Y_ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT 1
 #endif
 
 #if defined(_MSC_VER)
-#define ABSL_HAVE_WORKING_ATOMIC_POINTER 0
+#define Y_ABSL_HAVE_WORKING_ATOMIC_POINTER 0
 #else
-#define ABSL_HAVE_WORKING_ATOMIC_POINTER 1
+#define Y_ABSL_HAVE_WORKING_ATOMIC_POINTER 1
 #endif
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 
 template <typename T>
 class AtomicHook;
 
 // To workaround AtomicHook not being constant-initializable on some platforms,
-// prefer to annotate instances with `ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES`
-// instead of `ABSL_CONST_INIT`.
-#if ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT
-#define ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES ABSL_CONST_INIT
+// prefer to annotate instances with `Y_ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES`
+// instead of `Y_ABSL_CONST_INIT`.
+#if Y_ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT
+#define Y_ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES Y_ABSL_CONST_INIT
 #else
-#define ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES
+#define Y_ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES
 #endif
 
 // `AtomicHook` is a helper class, templatized on a raw function pointer type,
@@ -61,7 +61,7 @@ class AtomicHook;
 //
 // Hooks can be pre-registered via constant initialization, for example:
 //
-// ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES static AtomicHook<void(*)()>
+// Y_ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES static AtomicHook<void(*)()>
 //     my_hook(DefaultAction);
 //
 // and then changed at runtime via a call to `Store()`.
@@ -79,10 +79,10 @@ class AtomicHook<ReturnType (*)(Args...)> {
 
   // Constructs an object that by default dispatches to/returns the
   // pre-registered default_fn when no hook has been registered at runtime.
-#if ABSL_HAVE_WORKING_ATOMIC_POINTER && ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT
+#if Y_ABSL_HAVE_WORKING_ATOMIC_POINTER && Y_ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT
   explicit constexpr AtomicHook(FnPtr default_fn)
       : hook_(default_fn), default_fn_(default_fn) {}
-#elif ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT
+#elif Y_ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT
   explicit constexpr AtomicHook(FnPtr default_fn)
       : hook_(kUninitialized), default_fn_(default_fn) {}
 #else
@@ -143,7 +143,7 @@ class AtomicHook<ReturnType (*)(Args...)> {
   //
   // This causes an issue when building with LLVM under Windows.  To avoid this,
   // we use a less-efficient, intptr_t-based implementation on Windows.
-#if ABSL_HAVE_WORKING_ATOMIC_POINTER
+#if Y_ABSL_HAVE_WORKING_ATOMIC_POINTER
   // Return the stored value, or DummyFunction if no value has been stored.
   FnPtr DoLoad() const { return hook_.load(std::memory_order_acquire); }
 
@@ -159,7 +159,7 @@ class AtomicHook<ReturnType (*)(Args...)> {
   }
 
   std::atomic<FnPtr> hook_;
-#else  // !ABSL_HAVE_WORKING_ATOMIC_POINTER
+#else  // !Y_ABSL_HAVE_WORKING_ATOMIC_POINTER
   // Use a sentinel value unlikely to be the address of an actual function.
   static constexpr intptr_t kUninitialized = 0;
 
@@ -190,11 +190,11 @@ class AtomicHook<ReturnType (*)(Args...)> {
   const FnPtr default_fn_;
 };
 
-#undef ABSL_HAVE_WORKING_ATOMIC_POINTER
-#undef ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT
+#undef Y_ABSL_HAVE_WORKING_ATOMIC_POINTER
+#undef Y_ABSL_HAVE_WORKING_CONSTEXPR_STATIC_INIT
 
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_BASE_INTERNAL_ATOMIC_HOOK_H_
+#endif  // Y_ABSL_BASE_INTERNAL_ATOMIC_HOOK_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/atomic_hook_test_helper.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/atomic_hook_test_helper.h
index e600d27f4f..6600c8fb69 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/atomic_hook_test_helper.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/atomic_hook_test_helper.h
@@ -12,13 +12,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_BASE_ATOMIC_HOOK_TEST_HELPER_H_
-#define ABSL_BASE_ATOMIC_HOOK_TEST_HELPER_H_
+#ifndef Y_ABSL_BASE_ATOMIC_HOOK_TEST_HELPER_H_
+#define Y_ABSL_BASE_ATOMIC_HOOK_TEST_HELPER_H_
 
 #include "y_absl/base/internal/atomic_hook.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace atomic_hook_internal {
 
 using VoidF = void (*)();
@@ -28,7 +28,7 @@ void DefaultFunc();
 void RegisterFunc(VoidF func);
 
 }  // namespace atomic_hook_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_BASE_ATOMIC_HOOK_TEST_HELPER_H_
+#endif  // Y_ABSL_BASE_ATOMIC_HOOK_TEST_HELPER_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/cycleclock.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/cycleclock.cc
index 6b43f7c184..f12104f9e4 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/cycleclock.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/cycleclock.cc
@@ -28,15 +28,15 @@
 #include "y_absl/base/internal/unscaledcycleclock.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 
-#if ABSL_USE_UNSCALED_CYCLECLOCK
+#if Y_ABSL_USE_UNSCALED_CYCLECLOCK
 
 namespace {
 
 #ifdef NDEBUG
-#ifdef ABSL_INTERNAL_UNSCALED_CYCLECLOCK_FREQUENCY_IS_CPU_FREQUENCY
+#ifdef Y_ABSL_INTERNAL_UNSCALED_CYCLECLOCK_FREQUENCY_IS_CPU_FREQUENCY
 // Not debug mode and the UnscaledCycleClock frequency is the CPU
 // frequency.  Scale the CycleClock to prevent overflow if someone
 // tries to represent the time as cycles since the Unix epoch.
@@ -103,5 +103,5 @@ double CycleClock::Frequency() {
 #endif
 
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/cycleclock.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/cycleclock.h
index 389c9093e3..9777d214da 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/cycleclock.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/cycleclock.h
@@ -39,15 +39,15 @@
 // The CPU is not required to maintain the ordering of a cycle counter read
 // with respect to surrounding instructions.
 
-#ifndef ABSL_BASE_INTERNAL_CYCLECLOCK_H_
-#define ABSL_BASE_INTERNAL_CYCLECLOCK_H_
+#ifndef Y_ABSL_BASE_INTERNAL_CYCLECLOCK_H_
+#define Y_ABSL_BASE_INTERNAL_CYCLECLOCK_H_
 
 #include <cstdint>
 
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 
 // -----------------------------------------------------------------------------
@@ -88,7 +88,7 @@ class CycleClockSource {
 };
 
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_BASE_INTERNAL_CYCLECLOCK_H_
+#endif  // Y_ABSL_BASE_INTERNAL_CYCLECLOCK_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/direct_mmap.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/direct_mmap.h
index 82be9f94ab..805ae82873 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
@@ -15,12 +15,12 @@
 // Functions for directly invoking mmap() via syscall, avoiding the case where
 // mmap() has been locally overridden.
 
-#ifndef ABSL_BASE_INTERNAL_DIRECT_MMAP_H_
-#define ABSL_BASE_INTERNAL_DIRECT_MMAP_H_
+#ifndef Y_ABSL_BASE_INTERNAL_DIRECT_MMAP_H_
+#define Y_ABSL_BASE_INTERNAL_DIRECT_MMAP_H_
 
 #include "y_absl/base/config.h"
 
-#if ABSL_HAVE_MMAP
+#if Y_ABSL_HAVE_MMAP
 
 #include <sys/mman.h>
 
@@ -66,7 +66,7 @@ extern "C" void* __mmap2(void*, size_t, int, int, int, size_t);
 #endif
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 
 // Platform specific logic extracted from
@@ -137,7 +137,7 @@ inline int DirectMunmap(void* start, size_t length) {
 }
 
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 #else  // !__linux__
@@ -146,7 +146,7 @@ ABSL_NAMESPACE_END
 // actual mmap()/munmap() methods.
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 
 inline void* DirectMmap(void* start, size_t length, int prot, int flags, int fd,
@@ -159,11 +159,11 @@ inline int DirectMunmap(void* start, size_t length) {
 }
 
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 #endif  // __linux__
 
-#endif  // ABSL_HAVE_MMAP
+#endif  // Y_ABSL_HAVE_MMAP
 
-#endif  // ABSL_BASE_INTERNAL_DIRECT_MMAP_H_
+#endif  // Y_ABSL_BASE_INTERNAL_DIRECT_MMAP_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/dynamic_annotations.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/dynamic_annotations.h
index 75f0022683..2ac2679133 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
@@ -42,8 +42,8 @@
 //   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_
+#ifndef Y_ABSL_BASE_INTERNAL_DYNAMIC_ANNOTATIONS_H_
+#define Y_ABSL_BASE_INTERNAL_DYNAMIC_ANNOTATIONS_H_
 
 #include <stddef.h>
 
@@ -57,22 +57,22 @@
 #endif
 
 #if defined(__clang__) && !defined(SWIG)
-#define ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED 1
+#define Y_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
+#define Y_ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED 1
+#define Y_ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED 1
+#define Y_ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED 1
+#define Y_ABSL_INTERNAL_ANNOTALYSIS_ENABLED 0
+#define Y_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
+#define Y_ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED 0
+#define Y_ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED 0
+#define Y_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
@@ -81,38 +81,38 @@
 // 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)
+#define Y_ABSL_INTERNAL_ANNOTALYSIS_ENABLED \
+  defined(Y_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
+#define Y_ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED \
+  Y_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
+#if defined(Y_ABSL_HAVE_MEMORY_SANITIZER) && !defined(__native_client__)
+#define Y_ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED 1
 #endif
 
-#ifndef ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED
-#define ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED 0
+#ifndef Y_ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED
+#define Y_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
+#define Y_ABSL_INTERNAL_BEGIN_EXTERN_C extern "C" {
+#define Y_ABSL_INTERNAL_END_EXTERN_C }  // extern "C"
+#define Y_ABSL_INTERNAL_GLOBAL_SCOPED(F) ::F
+#define Y_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
+#define Y_ABSL_INTERNAL_BEGIN_EXTERN_C  // empty
+#define Y_ABSL_INTERNAL_END_EXTERN_C    // empty
+#define Y_ABSL_INTERNAL_GLOBAL_SCOPED(F) F
+#define Y_ABSL_INTERNAL_STATIC_INLINE static inline
 #endif
 
 // -------------------------------------------------------------------------
 // Define race annotations.
 
-#if ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED == 1
+#if Y_ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED == 1
 
 // -------------------------------------------------------------
 // Annotations that suppress errors. It is usually better to express the
@@ -124,20 +124,20 @@
 // 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) \
+  Y_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)         \
+  Y_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) \
+  Y_ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateEnableRaceDetection) \
   (__FILE__, __LINE__, enable)
 
 // -------------------------------------------------------------
@@ -145,7 +145,7 @@
 
 // Report the current thread `name` to a race detector.
 #define ANNOTATE_THREAD_NAME(name) \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateThreadName)(__FILE__, __LINE__, name)
+  Y_ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateThreadName)(__FILE__, __LINE__, name)
 
 // -------------------------------------------------------------
 // Annotations useful when implementing locks. They are not normally needed by
@@ -154,12 +154,12 @@
 
 // Report that a lock has been created at address `lock`.
 #define ANNOTATE_RWLOCK_CREATE(lock) \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockCreate)(__FILE__, __LINE__, lock)
+  Y_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
+#ifdef Y_ABSL_HAVE_THREAD_SANITIZER
 #define ANNOTATE_RWLOCK_CREATE_STATIC(lock)               \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockCreateStatic) \
+  Y_ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockCreateStatic) \
   (__FILE__, __LINE__, lock)
 #else
 #define ANNOTATE_RWLOCK_CREATE_STATIC(lock) ANNOTATE_RWLOCK_CREATE(lock)
@@ -167,18 +167,18 @@
 
 // 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)
+  Y_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) \
+  Y_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) \
+  Y_ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateRWLockReleased) \
   (__FILE__, __LINE__, lock, is_w)
 
 // Apply ANNOTATE_BENIGN_RACE_SIZED to a static variable `static_var`.
@@ -194,7 +194,7 @@
   static static_var##_annotator the##static_var##_annotator;      \
   }  // namespace
 
-#else  // ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED == 0
+#else  // Y_ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED == 0
 
 #define ANNOTATE_RWLOCK_CREATE(lock)                            // empty
 #define ANNOTATE_RWLOCK_CREATE_STATIC(lock)                     // empty
@@ -207,12 +207,12 @@
 #define ANNOTATE_ENABLE_RACE_DETECTION(enable)                  // empty
 #define ANNOTATE_BENIGN_RACE_STATIC(static_var, description)    // empty
 
-#endif  // ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED
+#endif  // Y_ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED
 
 // -------------------------------------------------------------------------
 // Define memory annotations.
 
-#if ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED == 1
+#if Y_ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED == 1
 
 #include <sanitizer/msan_interface.h>
 
@@ -222,7 +222,7 @@
 #define ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size) \
   __msan_allocated_memory(address, size)
 
-#else  // ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED == 0
+#else  // Y_ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED == 0
 
 #if DYNAMIC_ANNOTATIONS_ENABLED == 1
 #define ANNOTATE_MEMORY_IS_INITIALIZED(address, size) \
@@ -240,42 +240,42 @@
 #define ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size)  // empty
 #endif
 
-#endif  // ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED
+#endif  // Y_ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED
 
 // -------------------------------------------------------------------------
 // Define IGNORE_READS_BEGIN/_END attributes.
 
-#if defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
+#if defined(Y_ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
 
-#define ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE \
+#define Y_ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE \
   __attribute((exclusive_lock_function("*")))
-#define ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE \
+#define Y_ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE \
   __attribute((unlock_function("*")))
 
-#else  // !defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
+#else  // !defined(Y_ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
 
-#define ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE  // empty
-#define ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE    // empty
+#define Y_ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE  // empty
+#define Y_ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE    // empty
 
-#endif  // defined(ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
+#endif  // defined(Y_ABSL_INTERNAL_IGNORE_READS_ATTRIBUTE_ENABLED)
 
 // -------------------------------------------------------------------------
 // Define IGNORE_READS_BEGIN/_END annotations.
 
-#if ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED == 1
+#if Y_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__)
+  Y_ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsBegin)(__FILE__, __LINE__)
 
 // Stop ignoring reads.
 #define ANNOTATE_IGNORE_READS_END() \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsEnd)(__FILE__, __LINE__)
+  Y_ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreReadsEnd)(__FILE__, __LINE__)
 
-#elif defined(ABSL_INTERNAL_ANNOTALYSIS_ENABLED)
+#elif defined(Y_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,
@@ -285,10 +285,10 @@
 // allows IGNORE_READS_AND_WRITES to work properly.
 
 #define ANNOTATE_IGNORE_READS_BEGIN() \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AbslInternalAnnotateIgnoreReadsBegin)()
+  Y_ABSL_INTERNAL_GLOBAL_SCOPED(AbslInternalAnnotateIgnoreReadsBegin)()
 
 #define ANNOTATE_IGNORE_READS_END() \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AbslInternalAnnotateIgnoreReadsEnd)()
+  Y_ABSL_INTERNAL_GLOBAL_SCOPED(AbslInternalAnnotateIgnoreReadsEnd)()
 
 #else
 
@@ -300,15 +300,15 @@
 // -------------------------------------------------------------------------
 // Define IGNORE_WRITES_BEGIN/_END annotations.
 
-#if ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED == 1
+#if Y_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__)
+  Y_ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreWritesBegin)(__FILE__, __LINE__)
 
 // Stop ignoring writes.
 #define ANNOTATE_IGNORE_WRITES_END() \
-  ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreWritesEnd)(__FILE__, __LINE__)
+  Y_ABSL_INTERNAL_GLOBAL_SCOPED(AnnotateIgnoreWritesEnd)(__FILE__, __LINE__)
 
 #else
 
@@ -328,7 +328,7 @@
 //     one can use
 //        ... = ANNOTATE_UNPROTECTED_READ(x);
 
-#if defined(ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED)
+#if defined(Y_ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED)
 
 // Start ignoring all memory accesses (both reads and writes).
 #define ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN() \
@@ -362,7 +362,7 @@
 // -------------------------------------------------------------------------
 // Address sanitizer annotations
 
-#ifdef ABSL_HAVE_ADDRESS_SANITIZER
+#ifdef Y_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.
@@ -380,19 +380,19 @@
 #define ANNOTATE_CONTIGUOUS_CONTAINER(beg, end, old_mid, new_mid)
 #define ADDRESS_SANITIZER_REDZONE(name) static_assert(true, "")
 
-#endif  // ABSL_HAVE_ADDRESS_SANITIZER
+#endif  // Y_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_
+#undef Y_ABSL_INTERNAL_RACE_ANNOTATIONS_ENABLED
+#undef Y_ABSL_INTERNAL_MEMORY_ANNOTATIONS_ENABLED
+#undef Y_ABSL_INTERNAL_READS_ANNOTATIONS_ENABLED
+#undef Y_ABSL_INTERNAL_WRITES_ANNOTATIONS_ENABLED
+#undef Y_ABSL_INTERNAL_ANNOTALYSIS_ENABLED
+#undef Y_ABSL_INTERNAL_READS_WRITES_ANNOTATIONS_ENABLED
+#undef Y_ABSL_INTERNAL_BEGIN_EXTERN_C
+#undef Y_ABSL_INTERNAL_END_EXTERN_C
+#undef Y_ABSL_INTERNAL_STATIC_INLINE
+
+#endif  // Y_ABSL_BASE_INTERNAL_DYNAMIC_ANNOTATIONS_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/endian.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/endian.h
index 0f7adb8bf6..d450704225 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
@@ -13,8 +13,8 @@
 // limitations under the License.
 //
 
-#ifndef ABSL_BASE_INTERNAL_ENDIAN_H_
-#define ABSL_BASE_INTERNAL_ENDIAN_H_
+#ifndef Y_ABSL_BASE_INTERNAL_ENDIAN_H_
+#define Y_ABSL_BASE_INTERNAL_ENDIAN_H_
 
 // The following guarantees declaration of the byte swap functions
 #ifdef _MSC_VER
@@ -32,7 +32,7 @@
 #include "y_absl/base/port.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // Use compiler byte-swapping intrinsics if they are available.  32-bit
 // and 64-bit versions are available in Clang and GCC as of GCC 4.3.0.
@@ -109,7 +109,7 @@ inline uint16_t gbswap_16(uint16_t host_int) {
 
 #endif  // intrinsics available
 
-#ifdef ABSL_IS_LITTLE_ENDIAN
+#ifdef Y_ABSL_IS_LITTLE_ENDIAN
 
 // Definitions for ntohl etc. that don't require us to include
 // netinet/in.h. We wrap gbswap_32 and gbswap_16 in functions rather
@@ -121,7 +121,7 @@ inline uint16_t ghtons(uint16_t x) { return gbswap_16(x); }
 inline uint32_t ghtonl(uint32_t x) { return gbswap_32(x); }
 inline uint64_t ghtonll(uint64_t x) { return gbswap_64(x); }
 
-#elif defined ABSL_IS_BIG_ENDIAN
+#elif defined Y_ABSL_IS_BIG_ENDIAN
 
 // These definitions are simpler on big-endian machines
 // These are functions instead of macros to avoid self-assignment warnings
@@ -132,8 +132,8 @@ inline uint64_t ghtonll(uint64_t x) { return x; }
 
 #else
 #error \
-    "Unsupported byte order: Either ABSL_IS_BIG_ENDIAN or " \
-       "ABSL_IS_LITTLE_ENDIAN must be defined"
+    "Unsupported byte order: Either Y_ABSL_IS_BIG_ENDIAN or " \
+       "Y_ABSL_IS_LITTLE_ENDIAN must be defined"
 #endif  // byte order
 
 inline uint16_t gntohs(uint16_t x) { return ghtons(x); }
@@ -146,7 +146,7 @@ inline uint64_t gntohll(uint64_t x) { return ghtonll(x); }
 // Load/Store methods are alignment safe
 namespace little_endian {
 // Conversion functions.
-#ifdef ABSL_IS_LITTLE_ENDIAN
+#ifdef Y_ABSL_IS_LITTLE_ENDIAN
 
 inline uint16_t FromHost16(uint16_t x) { return x; }
 inline uint16_t ToHost16(uint16_t x) { return x; }
@@ -159,7 +159,7 @@ inline uint64_t ToHost64(uint64_t x) { return x; }
 
 inline constexpr bool IsLittleEndian() { return true; }
 
-#elif defined ABSL_IS_BIG_ENDIAN
+#elif defined Y_ABSL_IS_BIG_ENDIAN
 
 inline uint16_t FromHost16(uint16_t x) { return gbswap_16(x); }
 inline uint16_t ToHost16(uint16_t x) { return gbswap_16(x); }
@@ -206,27 +206,27 @@ inline int64_t ToHost(int64_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));
+  return ToHost16(Y_ABSL_INTERNAL_UNALIGNED_LOAD16(p));
 }
 
 inline void Store16(void *p, uint16_t v) {
-  ABSL_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v));
+  Y_ABSL_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v));
 }
 
 inline uint32_t Load32(const void *p) {
-  return ToHost32(ABSL_INTERNAL_UNALIGNED_LOAD32(p));
+  return ToHost32(Y_ABSL_INTERNAL_UNALIGNED_LOAD32(p));
 }
 
 inline void Store32(void *p, uint32_t v) {
-  ABSL_INTERNAL_UNALIGNED_STORE32(p, FromHost32(v));
+  Y_ABSL_INTERNAL_UNALIGNED_STORE32(p, FromHost32(v));
 }
 
 inline uint64_t Load64(const void *p) {
-  return ToHost64(ABSL_INTERNAL_UNALIGNED_LOAD64(p));
+  return ToHost64(Y_ABSL_INTERNAL_UNALIGNED_LOAD64(p));
 }
 
 inline void Store64(void *p, uint64_t v) {
-  ABSL_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
+  Y_ABSL_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
 }
 
 }  // namespace little_endian
@@ -236,7 +236,7 @@ inline void Store64(void *p, uint64_t v) {
 //
 // Load/Store methods are alignment safe
 namespace big_endian {
-#ifdef ABSL_IS_LITTLE_ENDIAN
+#ifdef Y_ABSL_IS_LITTLE_ENDIAN
 
 inline uint16_t FromHost16(uint16_t x) { return gbswap_16(x); }
 inline uint16_t ToHost16(uint16_t x) { return gbswap_16(x); }
@@ -249,7 +249,7 @@ inline uint64_t ToHost64(uint64_t x) { return gbswap_64(x); }
 
 inline constexpr bool IsLittleEndian() { return true; }
 
-#elif defined ABSL_IS_BIG_ENDIAN
+#elif defined Y_ABSL_IS_BIG_ENDIAN
 
 inline uint16_t FromHost16(uint16_t x) { return x; }
 inline uint16_t ToHost16(uint16_t x) { return x; }
@@ -296,32 +296,32 @@ inline int64_t ToHost(int64_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));
+  return ToHost16(Y_ABSL_INTERNAL_UNALIGNED_LOAD16(p));
 }
 
 inline void Store16(void *p, uint16_t v) {
-  ABSL_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v));
+  Y_ABSL_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v));
 }
 
 inline uint32_t Load32(const void *p) {
-  return ToHost32(ABSL_INTERNAL_UNALIGNED_LOAD32(p));
+  return ToHost32(Y_ABSL_INTERNAL_UNALIGNED_LOAD32(p));
 }
 
 inline void Store32(void *p, uint32_t v) {
-  ABSL_INTERNAL_UNALIGNED_STORE32(p, FromHost32(v));
+  Y_ABSL_INTERNAL_UNALIGNED_STORE32(p, FromHost32(v));
 }
 
 inline uint64_t Load64(const void *p) {
-  return ToHost64(ABSL_INTERNAL_UNALIGNED_LOAD64(p));
+  return ToHost64(Y_ABSL_INTERNAL_UNALIGNED_LOAD64(p));
 }
 
 inline void Store64(void *p, uint64_t v) {
-  ABSL_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
+  Y_ABSL_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
 }
 
 }  // namespace big_endian
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_BASE_INTERNAL_ENDIAN_H_
+#endif  // Y_ABSL_BASE_INTERNAL_ENDIAN_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/errno_saver.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/errno_saver.h
index 94202a4ed6..6221958769 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/errno_saver.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/errno_saver.h
@@ -12,15 +12,15 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_BASE_INTERNAL_ERRNO_SAVER_H_
-#define ABSL_BASE_INTERNAL_ERRNO_SAVER_H_
+#ifndef Y_ABSL_BASE_INTERNAL_ERRNO_SAVER_H_
+#define Y_ABSL_BASE_INTERNAL_ERRNO_SAVER_H_
 
 #include <cerrno>
 
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 
 // `ErrnoSaver` captures the value of `errno` upon construction and restores it
@@ -37,7 +37,7 @@ class ErrnoSaver {
 };
 
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_BASE_INTERNAL_ERRNO_SAVER_H_
+#endif  // Y_ABSL_BASE_INTERNAL_ERRNO_SAVER_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/exception_safety_testing.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/exception_safety_testing.h
index 3009f17875..1e33f3bee9 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/exception_safety_testing.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/exception_safety_testing.h
@@ -14,12 +14,12 @@
 
 // Utilities for testing exception-safety
 
-#ifndef ABSL_BASE_INTERNAL_EXCEPTION_SAFETY_TESTING_H_
-#define ABSL_BASE_INTERNAL_EXCEPTION_SAFETY_TESTING_H_
+#ifndef Y_ABSL_BASE_INTERNAL_EXCEPTION_SAFETY_TESTING_H_
+#define Y_ABSL_BASE_INTERNAL_EXCEPTION_SAFETY_TESTING_H_
 
 #include "y_absl/base/config.h"
 
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef Y_ABSL_HAVE_EXCEPTIONS
 
 #include <cstddef>
 #include <cstdint>
@@ -214,7 +214,7 @@ class ThrowingBool {
  public:
   ThrowingBool(bool b) noexcept : b_(b) {}  // NOLINT(runtime/explicit)
   operator bool() const {                   // NOLINT
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     return b_;
   }
 
@@ -264,7 +264,7 @@ class ThrowingValue : private exceptions_internal::TrackedObject {
 
  public:
   ThrowingValue() : TrackedObject(GetInstanceString(kDefaultValue)) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     dummy_ = kDefaultValue;
   }
 
@@ -272,7 +272,7 @@ class ThrowingValue : private exceptions_internal::TrackedObject {
       IsSpecified(TypeSpec::kNoThrowCopy))
       : TrackedObject(GetInstanceString(other.dummy_)) {
     if (!IsSpecified(TypeSpec::kNoThrowCopy)) {
-      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+      exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     }
     dummy_ = other.dummy_;
   }
@@ -281,13 +281,13 @@ class ThrowingValue : private exceptions_internal::TrackedObject {
       IsSpecified(TypeSpec::kNoThrowMove))
       : TrackedObject(GetInstanceString(other.dummy_)) {
     if (!IsSpecified(TypeSpec::kNoThrowMove)) {
-      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+      exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     }
     dummy_ = other.dummy_;
   }
 
   explicit ThrowingValue(int i) : TrackedObject(GetInstanceString(i)) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     dummy_ = i;
   }
 
@@ -301,7 +301,7 @@ class ThrowingValue : private exceptions_internal::TrackedObject {
       IsSpecified(TypeSpec::kNoThrowCopy)) {
     dummy_ = kBadValue;
     if (!IsSpecified(TypeSpec::kNoThrowCopy)) {
-      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+      exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     }
     dummy_ = other.dummy_;
     return *this;
@@ -311,7 +311,7 @@ class ThrowingValue : private exceptions_internal::TrackedObject {
       IsSpecified(TypeSpec::kNoThrowMove)) {
     dummy_ = kBadValue;
     if (!IsSpecified(TypeSpec::kNoThrowMove)) {
-      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+      exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     }
     dummy_ = other.dummy_;
     return *this;
@@ -319,73 +319,73 @@ class ThrowingValue : private exceptions_internal::TrackedObject {
 
   // Arithmetic Operators
   ThrowingValue operator+(const ThrowingValue& other) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     return ThrowingValue(dummy_ + other.dummy_, nothrow_ctor);
   }
 
   ThrowingValue operator+() const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     return ThrowingValue(dummy_, nothrow_ctor);
   }
 
   ThrowingValue operator-(const ThrowingValue& other) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     return ThrowingValue(dummy_ - other.dummy_, nothrow_ctor);
   }
 
   ThrowingValue operator-() const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     return ThrowingValue(-dummy_, nothrow_ctor);
   }
 
   ThrowingValue& operator++() {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     ++dummy_;
     return *this;
   }
 
   ThrowingValue operator++(int) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     auto out = ThrowingValue(dummy_, nothrow_ctor);
     ++dummy_;
     return out;
   }
 
   ThrowingValue& operator--() {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     --dummy_;
     return *this;
   }
 
   ThrowingValue operator--(int) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     auto out = ThrowingValue(dummy_, nothrow_ctor);
     --dummy_;
     return out;
   }
 
   ThrowingValue operator*(const ThrowingValue& other) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     return ThrowingValue(dummy_ * other.dummy_, nothrow_ctor);
   }
 
   ThrowingValue operator/(const ThrowingValue& other) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     return ThrowingValue(dummy_ / other.dummy_, nothrow_ctor);
   }
 
   ThrowingValue operator%(const ThrowingValue& other) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     return ThrowingValue(dummy_ % other.dummy_, nothrow_ctor);
   }
 
   ThrowingValue operator<<(int shift) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     return ThrowingValue(dummy_ << shift, nothrow_ctor);
   }
 
   ThrowingValue operator>>(int shift) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     return ThrowingValue(dummy_ >> shift, nothrow_ctor);
   }
 
@@ -394,129 +394,129 @@ class ThrowingValue : private exceptions_internal::TrackedObject {
   // types/containers requires T to be convertible to bool.
   friend ThrowingBool operator==(const ThrowingValue& a,
                                  const ThrowingValue& b) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     return a.dummy_ == b.dummy_;
   }
   friend ThrowingBool operator!=(const ThrowingValue& a,
                                  const ThrowingValue& b) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     return a.dummy_ != b.dummy_;
   }
   friend ThrowingBool operator<(const ThrowingValue& a,
                                 const ThrowingValue& b) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     return a.dummy_ < b.dummy_;
   }
   friend ThrowingBool operator<=(const ThrowingValue& a,
                                  const ThrowingValue& b) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     return a.dummy_ <= b.dummy_;
   }
   friend ThrowingBool operator>(const ThrowingValue& a,
                                 const ThrowingValue& b) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     return a.dummy_ > b.dummy_;
   }
   friend ThrowingBool operator>=(const ThrowingValue& a,
                                  const ThrowingValue& b) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     return a.dummy_ >= b.dummy_;
   }
 
   // Logical Operators
   ThrowingBool operator!() const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     return !dummy_;
   }
 
   ThrowingBool operator&&(const ThrowingValue& other) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     return dummy_ && other.dummy_;
   }
 
   ThrowingBool operator||(const ThrowingValue& other) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     return dummy_ || other.dummy_;
   }
 
   // Bitwise Logical Operators
   ThrowingValue operator~() const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     return ThrowingValue(~dummy_, nothrow_ctor);
   }
 
   ThrowingValue operator&(const ThrowingValue& other) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     return ThrowingValue(dummy_ & other.dummy_, nothrow_ctor);
   }
 
   ThrowingValue operator|(const ThrowingValue& other) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     return ThrowingValue(dummy_ | other.dummy_, nothrow_ctor);
   }
 
   ThrowingValue operator^(const ThrowingValue& other) const {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     return ThrowingValue(dummy_ ^ other.dummy_, nothrow_ctor);
   }
 
   // Compound Assignment operators
   ThrowingValue& operator+=(const ThrowingValue& other) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     dummy_ += other.dummy_;
     return *this;
   }
 
   ThrowingValue& operator-=(const ThrowingValue& other) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     dummy_ -= other.dummy_;
     return *this;
   }
 
   ThrowingValue& operator*=(const ThrowingValue& other) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     dummy_ *= other.dummy_;
     return *this;
   }
 
   ThrowingValue& operator/=(const ThrowingValue& other) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     dummy_ /= other.dummy_;
     return *this;
   }
 
   ThrowingValue& operator%=(const ThrowingValue& other) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     dummy_ %= other.dummy_;
     return *this;
   }
 
   ThrowingValue& operator&=(const ThrowingValue& other) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     dummy_ &= other.dummy_;
     return *this;
   }
 
   ThrowingValue& operator|=(const ThrowingValue& other) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     dummy_ |= other.dummy_;
     return *this;
   }
 
   ThrowingValue& operator^=(const ThrowingValue& other) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     dummy_ ^= other.dummy_;
     return *this;
   }
 
   ThrowingValue& operator<<=(int shift) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     dummy_ <<= shift;
     return *this;
   }
 
   ThrowingValue& operator>>=(int shift) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     dummy_ >>= shift;
     return *this;
   }
@@ -526,12 +526,12 @@ class ThrowingValue : private exceptions_internal::TrackedObject {
 
   // Stream operators
   friend std::ostream& operator<<(std::ostream& os, const ThrowingValue& tv) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     return os << GetInstanceString(tv.dummy_);
   }
 
   friend std::istream& operator>>(std::istream& is, const ThrowingValue&) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     return is;
   }
 
@@ -539,7 +539,7 @@ class ThrowingValue : private exceptions_internal::TrackedObject {
   static void* operator new(size_t s) noexcept(
       IsSpecified(TypeSpec::kNoThrowNew)) {
     if (!IsSpecified(TypeSpec::kNoThrowNew)) {
-      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true);
+      exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION, true);
     }
     return ::operator new(s);
   }
@@ -547,7 +547,7 @@ class ThrowingValue : private exceptions_internal::TrackedObject {
   static void* operator new[](size_t s) noexcept(
       IsSpecified(TypeSpec::kNoThrowNew)) {
     if (!IsSpecified(TypeSpec::kNoThrowNew)) {
-      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true);
+      exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION, true);
     }
     return ::operator new[](s);
   }
@@ -556,7 +556,7 @@ class ThrowingValue : private exceptions_internal::TrackedObject {
   static void* operator new(size_t s, Args&&... args) noexcept(
       IsSpecified(TypeSpec::kNoThrowNew)) {
     if (!IsSpecified(TypeSpec::kNoThrowNew)) {
-      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true);
+      exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION, true);
     }
     return ::operator new(s, std::forward<Args>(args)...);
   }
@@ -565,7 +565,7 @@ class ThrowingValue : private exceptions_internal::TrackedObject {
   static void* operator new[](size_t s, Args&&... args) noexcept(
       IsSpecified(TypeSpec::kNoThrowNew)) {
     if (!IsSpecified(TypeSpec::kNoThrowNew)) {
-      exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true);
+      exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION, true);
     }
     return ::operator new[](s, std::forward<Args>(args)...);
   }
@@ -623,7 +623,7 @@ enum class AllocSpec {
  * An allocator type which is instrumented to throw at a controlled time, or not
  * to throw, using AllocSpec. The supported settings are the default of every
  * function which is allowed to throw in a conforming allocator possibly
- * throwing, or nothing throws, in line with the ABSL_ALLOCATOR_THROWS
+ * throwing, or nothing throws, in line with the Y_ABSL_ALLOCATOR_THROWS
  * configuration macro.
  */
 template <typename T, AllocSpec Spec = AllocSpec::kEverythingThrows>
@@ -651,7 +651,7 @@ class ThrowingAllocator : private exceptions_internal::TrackedObject {
   using is_always_equal = std::false_type;
 
   ThrowingAllocator() : TrackedObject(GetInstanceString(next_id_)) {
-    exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+    exceptions_internal::MaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     dummy_ = std::make_shared<const int>(next_id_++);
   }
 
@@ -702,7 +702,7 @@ class ThrowingAllocator : private exceptions_internal::TrackedObject {
 
   pointer allocate(size_type n) noexcept(
       IsSpecified(AllocSpec::kNoThrowAllocate)) {
-    ReadStateAndMaybeThrow(ABSL_PRETTY_FUNCTION);
+    ReadStateAndMaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     return static_cast<pointer>(::operator new(n * sizeof(T)));
   }
 
@@ -719,7 +719,7 @@ class ThrowingAllocator : private exceptions_internal::TrackedObject {
   template <typename U, typename... Args>
   void construct(U* ptr, Args&&... args) noexcept(
       IsSpecified(AllocSpec::kNoThrowAllocate)) {
-    ReadStateAndMaybeThrow(ABSL_PRETTY_FUNCTION);
+    ReadStateAndMaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     ::new (static_cast<void*>(ptr)) U(std::forward<Args>(args)...);
   }
 
@@ -735,7 +735,7 @@ class ThrowingAllocator : private exceptions_internal::TrackedObject {
 
   ThrowingAllocator select_on_container_copy_construction() noexcept(
       IsSpecified(AllocSpec::kNoThrowAllocate)) {
-    ReadStateAndMaybeThrow(ABSL_PRETTY_FUNCTION);
+    ReadStateAndMaybeThrow(Y_ABSL_PRETTY_FUNCTION);
     return *this;
   }
 
@@ -1104,6 +1104,6 @@ class ExceptionSafetyTestBuilder {
 
 }  // namespace testing
 
-#endif  // ABSL_HAVE_EXCEPTIONS
+#endif  // Y_ABSL_HAVE_EXCEPTIONS
 
-#endif  // ABSL_BASE_INTERNAL_EXCEPTION_SAFETY_TESTING_H_
+#endif  // Y_ABSL_BASE_INTERNAL_EXCEPTION_SAFETY_TESTING_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/exception_testing.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/exception_testing.h
index f2dd04b9d6..0e9696ffa4 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/exception_testing.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/exception_testing.h
@@ -14,29 +14,29 @@
 
 // Testing utilities for ABSL types which throw exceptions.
 
-#ifndef ABSL_BASE_INTERNAL_EXCEPTION_TESTING_H_
-#define ABSL_BASE_INTERNAL_EXCEPTION_TESTING_H_
+#ifndef Y_ABSL_BASE_INTERNAL_EXCEPTION_TESTING_H_
+#define Y_ABSL_BASE_INTERNAL_EXCEPTION_TESTING_H_
 
 #include "gtest/gtest.h"
 #include "y_absl/base/config.h"
 
-// ABSL_BASE_INTERNAL_EXPECT_FAIL tests either for a specified thrown exception
+// Y_ABSL_BASE_INTERNAL_EXPECT_FAIL tests either for a specified thrown exception
 // if exceptions are enabled, or for death with a specified text in the error
 // message
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef Y_ABSL_HAVE_EXCEPTIONS
 
-#define ABSL_BASE_INTERNAL_EXPECT_FAIL(expr, exception_t, text) \
+#define Y_ABSL_BASE_INTERNAL_EXPECT_FAIL(expr, exception_t, text) \
   EXPECT_THROW(expr, exception_t)
 
 #elif defined(__ANDROID__)
 // Android asserts do not log anywhere that gtest can currently inspect.
 // So we expect exit, but cannot match the message.
-#define ABSL_BASE_INTERNAL_EXPECT_FAIL(expr, exception_t, text) \
+#define Y_ABSL_BASE_INTERNAL_EXPECT_FAIL(expr, exception_t, text) \
   EXPECT_DEATH(expr, ".*")
 #else
-#define ABSL_BASE_INTERNAL_EXPECT_FAIL(expr, exception_t, text) \
+#define Y_ABSL_BASE_INTERNAL_EXPECT_FAIL(expr, exception_t, text) \
   EXPECT_DEATH_IF_SUPPORTED(expr, text)
 
 #endif
 
-#endif  // ABSL_BASE_INTERNAL_EXCEPTION_TESTING_H_
+#endif  // Y_ABSL_BASE_INTERNAL_EXCEPTION_TESTING_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/fast_type_id.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/fast_type_id.h
index c82cba7b4a..4fa0cf8ea6 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
@@ -14,13 +14,13 @@
 // limitations under the License.
 //
 
-#ifndef ABSL_BASE_INTERNAL_FAST_TYPE_ID_H_
-#define ABSL_BASE_INTERNAL_FAST_TYPE_ID_H_
+#ifndef Y_ABSL_BASE_INTERNAL_FAST_TYPE_ID_H_
+#define Y_ABSL_BASE_INTERNAL_FAST_TYPE_ID_H_
 
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 
 template <typename Type>
@@ -42,7 +42,7 @@ constexpr inline FastTypeIdType FastTypeId() {
 }
 
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_BASE_INTERNAL_FAST_TYPE_ID_H_
+#endif  // Y_ABSL_BASE_INTERNAL_FAST_TYPE_ID_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/hide_ptr.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/hide_ptr.h
index ccdad25cb7..1bd356cffd 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/hide_ptr.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/hide_ptr.h
@@ -12,15 +12,15 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_BASE_INTERNAL_HIDE_PTR_H_
-#define ABSL_BASE_INTERNAL_HIDE_PTR_H_
+#ifndef Y_ABSL_BASE_INTERNAL_HIDE_PTR_H_
+#define Y_ABSL_BASE_INTERNAL_HIDE_PTR_H_
 
 #include <cstdint>
 
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 
 // Arbitrary value with high bits set. Xor'ing with it is unlikely
@@ -45,7 +45,7 @@ inline T* UnhidePtr(uintptr_t hidden) {
 }
 
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_BASE_INTERNAL_HIDE_PTR_H_
+#endif  // Y_ABSL_BASE_INTERNAL_HIDE_PTR_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/identity.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/identity.h
index 2360afeed2..edf314d798 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/identity.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/identity.h
@@ -13,13 +13,13 @@
 // limitations under the License.
 //
 
-#ifndef ABSL_BASE_INTERNAL_IDENTITY_H_
-#define ABSL_BASE_INTERNAL_IDENTITY_H_
+#ifndef Y_ABSL_BASE_INTERNAL_IDENTITY_H_
+#define Y_ABSL_BASE_INTERNAL_IDENTITY_H_
 
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace internal {
 
 template <typename T>
@@ -31,7 +31,7 @@ template <typename T>
 using identity_t = typename identity<T>::type;
 
 }  // namespace internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_BASE_INTERNAL_IDENTITY_H_
+#endif  // Y_ABSL_BASE_INTERNAL_IDENTITY_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/inline_variable.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/inline_variable.h
index 38799c5722..895727ec87 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/inline_variable.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/inline_variable.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_BASE_INTERNAL_INLINE_VARIABLE_EMULATION_H_
-#define ABSL_BASE_INTERNAL_INLINE_VARIABLE_EMULATION_H_
+#ifndef Y_ABSL_BASE_INTERNAL_INLINE_VARIABLE_EMULATION_H_
+#define Y_ABSL_BASE_INTERNAL_INLINE_VARIABLE_EMULATION_H_
 
 #include <type_traits>
 
@@ -24,7 +24,7 @@
 //   inline variables based on whether or not the feature is supported.
 
 ////////////////////////////////////////////////////////////////////////////////
-// Macro: ABSL_INTERNAL_INLINE_CONSTEXPR(type, name, init)
+// Macro: Y_ABSL_INTERNAL_INLINE_CONSTEXPR(type, name, init)
 //
 // Description:
 //   Expands to the equivalent of an inline constexpr instance of the specified
@@ -44,7 +44,7 @@
 // Usage:
 //
 //   // Equivalent to: `inline constexpr size_t variant_npos = -1;`
-//   ABSL_INTERNAL_INLINE_CONSTEXPR(size_t, variant_npos, -1);
+//   Y_ABSL_INTERNAL_INLINE_CONSTEXPR(size_t, variant_npos, -1);
 //
 // Differences in implementation:
 //   For a direct, language-level inline variable, decltype(name) will be the
@@ -67,15 +67,15 @@
 //   appropriate place for pointer types, reference types, function pointer
 //   types, etc..
 #if defined(__clang__)
-#define ABSL_INTERNAL_EXTERN_DECL(type, name) \
+#define Y_ABSL_INTERNAL_EXTERN_DECL(type, name) \
   extern const ::y_absl::internal::identity_t<type> name;
 #else  // Otherwise, just define the macro to do nothing.
-#define ABSL_INTERNAL_EXTERN_DECL(type, name)
+#define Y_ABSL_INTERNAL_EXTERN_DECL(type, name)
 #endif  // defined(__clang__)
 
 // See above comment at top of file for details.
-#define ABSL_INTERNAL_INLINE_CONSTEXPR(type, name, init) \
-  ABSL_INTERNAL_EXTERN_DECL(type, name)                  \
+#define Y_ABSL_INTERNAL_INLINE_CONSTEXPR(type, name, init) \
+  Y_ABSL_INTERNAL_EXTERN_DECL(type, name)                  \
   inline constexpr ::y_absl::internal::identity_t<type> name = init
 
 #else
@@ -86,7 +86,7 @@
 //   identity_t is used here so that the const and name are in the
 //   appropriate place for pointer types, reference types, function pointer
 //   types, etc..
-#define ABSL_INTERNAL_INLINE_CONSTEXPR(var_type, name, init)                  \
+#define Y_ABSL_INTERNAL_INLINE_CONSTEXPR(var_type, name, init)                  \
   template <class /*AbslInternalDummy*/ = void>                               \
   struct AbslInternalInlineVariableHolder##name {                             \
     static constexpr ::y_absl::internal::identity_t<var_type> kInstance = init; \
@@ -104,4 +104,4 @@
 
 #endif  // __cpp_inline_variables
 
-#endif  // ABSL_BASE_INTERNAL_INLINE_VARIABLE_EMULATION_H_
+#endif  // Y_ABSL_BASE_INTERNAL_INLINE_VARIABLE_EMULATION_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/inline_variable_testing.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/inline_variable_testing.h
index 190e74e643..a705cd6b60 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/inline_variable_testing.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/inline_variable_testing.h
@@ -12,26 +12,26 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_BASE_INLINE_VARIABLE_TESTING_H_
-#define ABSL_BASE_INLINE_VARIABLE_TESTING_H_
+#ifndef Y_ABSL_BASE_INLINE_VARIABLE_TESTING_H_
+#define Y_ABSL_BASE_INLINE_VARIABLE_TESTING_H_
 
 #include "y_absl/base/internal/inline_variable.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace inline_variable_testing_internal {
 
 struct Foo {
   int value = 5;
 };
 
-ABSL_INTERNAL_INLINE_CONSTEXPR(Foo, inline_variable_foo, {});
-ABSL_INTERNAL_INLINE_CONSTEXPR(Foo, other_inline_variable_foo, {});
+Y_ABSL_INTERNAL_INLINE_CONSTEXPR(Foo, inline_variable_foo, {});
+Y_ABSL_INTERNAL_INLINE_CONSTEXPR(Foo, other_inline_variable_foo, {});
 
-ABSL_INTERNAL_INLINE_CONSTEXPR(int, inline_variable_int, 5);
-ABSL_INTERNAL_INLINE_CONSTEXPR(int, other_inline_variable_int, 5);
+Y_ABSL_INTERNAL_INLINE_CONSTEXPR(int, inline_variable_int, 5);
+Y_ABSL_INTERNAL_INLINE_CONSTEXPR(int, other_inline_variable_int, 5);
 
-ABSL_INTERNAL_INLINE_CONSTEXPR(void(*)(), inline_variable_fun_ptr, nullptr);
+Y_ABSL_INTERNAL_INLINE_CONSTEXPR(void(*)(), inline_variable_fun_ptr, nullptr);
 
 const Foo& get_foo_a();
 const Foo& get_foo_b();
@@ -40,7 +40,7 @@ const int& get_int_a();
 const int& get_int_b();
 
 }  // namespace inline_variable_testing_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_BASE_INLINE_VARIABLE_TESTING_H_
+#endif  // Y_ABSL_BASE_INLINE_VARIABLE_TESTING_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/invoke.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/invoke.h
index 928666ff44..5d5348c377 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
@@ -32,8 +32,8 @@
 // The implementation is SFINAE-friendly: substitution failure within invoke()
 // isn't an error.
 
-#ifndef ABSL_BASE_INTERNAL_INVOKE_H_
-#define ABSL_BASE_INTERNAL_INVOKE_H_
+#ifndef Y_ABSL_BASE_INTERNAL_INVOKE_H_
+#define Y_ABSL_BASE_INTERNAL_INVOKE_H_
 
 #include <algorithm>
 #include <type_traits>
@@ -45,7 +45,7 @@
 // top of this file for the API documentation.
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 
 // The five classes below each implement one of the clauses from the definition
@@ -181,7 +181,7 @@ invoke_result_t<F, Args...> invoke(F&& f, Args&&... args) {
                                            std::forward<Args>(args)...);
 }
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_BASE_INTERNAL_INVOKE_H_
+#endif  // Y_ABSL_BASE_INTERNAL_INVOKE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc.cc
index 0c477d1b28..3d96472b27 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
@@ -31,7 +31,7 @@
 // LowLevelAlloc requires that the platform support low-level
 // allocation of virtual memory. Platforms lacking this cannot use
 // LowLevelAlloc.
-#ifndef ABSL_LOW_LEVEL_ALLOC_MISSING
+#ifndef Y_ABSL_LOW_LEVEL_ALLOC_MISSING
 
 #ifndef _WIN32
 #include <pthread.h>
@@ -63,7 +63,7 @@
 #endif  // __APPLE__
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 
 // A first-fit allocator with amortized logarithmic free() time.
@@ -145,7 +145,7 @@ static int LLA_SkiplistLevels(size_t size, size_t base, uint32_t *random) {
   int level = IntLog2(size, base) + (random != nullptr ? Random(random) : 1);
   if (static_cast<size_t>(level) > max_fit) level = static_cast<int>(max_fit);
   if (level > kMaxLevel-1) level = kMaxLevel - 1;
-  ABSL_RAW_CHECK(level >= 1, "block not big enough for even one level");
+  Y_ABSL_RAW_CHECK(level >= 1, "block not big enough for even one level");
   return level;
 }
 
@@ -185,7 +185,7 @@ static void LLA_SkiplistInsert(AllocList *head, AllocList *e,
 static void LLA_SkiplistDelete(AllocList *head, AllocList *e,
                                AllocList **prev) {
   AllocList *found = LLA_SkiplistSearch(head, e, prev);
-  ABSL_RAW_CHECK(e == found, "element not in freelist");
+  Y_ABSL_RAW_CHECK(e == found, "element not in freelist");
   for (int i = 0; i != e->levels && prev[i]->next[i] == e; i++) {
     prev[i]->next[i] = e->next[i];
   }
@@ -204,9 +204,9 @@ struct LowLevelAlloc::Arena {
 
   base_internal::SpinLock mu;
   // Head of free list, sorted by address
-  AllocList freelist ABSL_GUARDED_BY(mu);
+  AllocList freelist Y_ABSL_GUARDED_BY(mu);
   // Count of allocated blocks
-  int32_t allocation_count ABSL_GUARDED_BY(mu);
+  int32_t allocation_count Y_ABSL_GUARDED_BY(mu);
   // flags passed to NewArena
   const uint32_t flags;
   // Result of sysconf(_SC_PAGESIZE)
@@ -216,7 +216,7 @@ struct LowLevelAlloc::Arena {
   // Smallest allocation block size
   const size_t min_size;
   // PRNG state
-  uint32_t random ABSL_GUARDED_BY(mu);
+  uint32_t random Y_ABSL_GUARDED_BY(mu);
 };
 
 namespace {
@@ -227,7 +227,7 @@ alignas(LowLevelAlloc::Arena) unsigned char default_arena_storage[sizeof(
     LowLevelAlloc::Arena)];
 alignas(LowLevelAlloc::Arena) unsigned char unhooked_arena_storage[sizeof(
     LowLevelAlloc::Arena)];
-#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
+#ifndef Y_ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
 alignas(
     LowLevelAlloc::Arena) unsigned char unhooked_async_sig_safe_arena_storage
     [sizeof(LowLevelAlloc::Arena)];
@@ -241,7 +241,7 @@ void CreateGlobalArenas() {
   new (&default_arena_storage)
       LowLevelAlloc::Arena(LowLevelAlloc::kCallMallocHook);
   new (&unhooked_arena_storage) LowLevelAlloc::Arena(0);
-#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
+#ifndef Y_ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
   new (&unhooked_async_sig_safe_arena_storage)
       LowLevelAlloc::Arena(LowLevelAlloc::kAsyncSignalSafe);
 #endif
@@ -254,7 +254,7 @@ LowLevelAlloc::Arena* UnhookedArena() {
   return reinterpret_cast<LowLevelAlloc::Arena*>(&unhooked_arena_storage);
 }
 
-#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
+#ifndef Y_ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
 // Returns a global arena that is async-signal safe.  Used by NewArena() when
 // kAsyncSignalSafe is set.
 LowLevelAlloc::Arena *UnhookedAsyncSigSafeArena() {
@@ -277,12 +277,12 @@ static const uintptr_t kMagicAllocated = 0x4c833e95U;
 static const uintptr_t kMagicUnallocated = ~kMagicAllocated;
 
 namespace {
-class ABSL_SCOPED_LOCKABLE ArenaLock {
+class Y_ABSL_SCOPED_LOCKABLE ArenaLock {
  public:
   explicit ArenaLock(LowLevelAlloc::Arena *arena)
-      ABSL_EXCLUSIVE_LOCK_FUNCTION(arena->mu)
+      Y_ABSL_EXCLUSIVE_LOCK_FUNCTION(arena->mu)
       : arena_(arena) {
-#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
+#ifndef Y_ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
     if ((arena->flags & LowLevelAlloc::kAsyncSignalSafe) != 0) {
       sigset_t all;
       sigfillset(&all);
@@ -291,14 +291,14 @@ class ABSL_SCOPED_LOCKABLE ArenaLock {
 #endif
     arena_->mu.Lock();
   }
-  ~ArenaLock() { ABSL_RAW_CHECK(left_, "haven't left Arena region"); }
-  void Leave() ABSL_UNLOCK_FUNCTION() {
+  ~ArenaLock() { Y_ABSL_RAW_CHECK(left_, "haven't left Arena region"); }
+  void Leave() Y_ABSL_UNLOCK_FUNCTION() {
     arena_->mu.Unlock();
-#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
+#ifndef Y_ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
     if (mask_valid_) {
       const int err = pthread_sigmask(SIG_SETMASK, &mask_, nullptr);
       if (err != 0) {
-        ABSL_RAW_LOG(FATAL, "pthread_sigmask failed: %d", err);
+        Y_ABSL_RAW_LOG(FATAL, "pthread_sigmask failed: %d", err);
       }
     }
 #endif
@@ -307,7 +307,7 @@ class ABSL_SCOPED_LOCKABLE ArenaLock {
 
  private:
   bool left_ = false;  // whether left region
-#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
+#ifndef Y_ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
   bool mask_valid_ = false;
   sigset_t mask_;  // old mask of blocked signals
 #endif
@@ -366,7 +366,7 @@ LowLevelAlloc::Arena::Arena(uint32_t flags_value)
 // L < meta_data_arena->mu
 LowLevelAlloc::Arena *LowLevelAlloc::NewArena(int32_t flags) {
   Arena *meta_data_arena = DefaultArena();
-#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
+#ifndef Y_ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
   if ((flags & LowLevelAlloc::kAsyncSignalSafe) != 0) {
     meta_data_arena = UnhookedAsyncSigSafeArena();
   } else  // NOLINT(readability/braces)
@@ -381,7 +381,7 @@ LowLevelAlloc::Arena *LowLevelAlloc::NewArena(int32_t flags) {
 
 // L < arena->mu, L < arena->arena->mu
 bool LowLevelAlloc::DeleteArena(Arena *arena) {
-  ABSL_RAW_CHECK(
+  Y_ABSL_RAW_CHECK(
       arena != nullptr && arena != DefaultArena() && arena != UnhookedArena(),
       "may not delete default arena");
   ArenaLock section(arena);
@@ -393,22 +393,22 @@ bool LowLevelAlloc::DeleteArena(Arena *arena) {
     AllocList *region = arena->freelist.next[0];
     size_t size = region->header.size;
     arena->freelist.next[0] = region->next[0];
-    ABSL_RAW_CHECK(
+    Y_ABSL_RAW_CHECK(
         region->header.magic == Magic(kMagicUnallocated, &region->header),
         "bad magic number in DeleteArena()");
-    ABSL_RAW_CHECK(region->header.arena == arena,
+    Y_ABSL_RAW_CHECK(region->header.arena == arena,
                    "bad arena pointer in DeleteArena()");
-    ABSL_RAW_CHECK(size % arena->pagesize == 0,
+    Y_ABSL_RAW_CHECK(size % arena->pagesize == 0,
                    "empty arena has non-page-aligned block size");
-    ABSL_RAW_CHECK(reinterpret_cast<uintptr_t>(region) % arena->pagesize == 0,
+    Y_ABSL_RAW_CHECK(reinterpret_cast<uintptr_t>(region) % arena->pagesize == 0,
                    "empty arena has non-page-aligned block");
     int munmap_result;
 #ifdef _WIN32
     munmap_result = VirtualFree(region, 0, MEM_RELEASE);
-    ABSL_RAW_CHECK(munmap_result != 0,
+    Y_ABSL_RAW_CHECK(munmap_result != 0,
                    "LowLevelAlloc::DeleteArena: VitualFree failed");
 #else
-#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
+#ifndef Y_ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
     if ((arena->flags & LowLevelAlloc::kAsyncSignalSafe) == 0) {
       munmap_result = munmap(region, size);
     } else {
@@ -416,9 +416,9 @@ bool LowLevelAlloc::DeleteArena(Arena *arena) {
     }
 #else
     munmap_result = munmap(region, size);
-#endif  // ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
+#endif  // Y_ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
     if (munmap_result != 0) {
-      ABSL_RAW_LOG(FATAL, "LowLevelAlloc::DeleteArena: munmap failed: %d",
+      Y_ABSL_RAW_LOG(FATAL, "LowLevelAlloc::DeleteArena: munmap failed: %d",
                    errno);
     }
 #endif  // _WIN32
@@ -435,7 +435,7 @@ bool LowLevelAlloc::DeleteArena(Arena *arena) {
 // manages to push through a request that would cause arithmetic to fail.
 static inline uintptr_t CheckedAdd(uintptr_t a, uintptr_t b) {
   uintptr_t sum = a + b;
-  ABSL_RAW_CHECK(sum >= a, "LowLevelAlloc arithmetic overflow");
+  Y_ABSL_RAW_CHECK(sum >= a, "LowLevelAlloc arithmetic overflow");
   return sum;
 }
 
@@ -451,16 +451,16 @@ static inline uintptr_t RoundUp(uintptr_t addr, uintptr_t align) {
 // are adjacent in memory (they should have been coalesced).
 // L >= arena->mu
 static AllocList *Next(int i, AllocList *prev, LowLevelAlloc::Arena *arena) {
-  ABSL_RAW_CHECK(i < prev->levels, "too few levels in Next()");
+  Y_ABSL_RAW_CHECK(i < prev->levels, "too few levels in Next()");
   AllocList *next = prev->next[i];
   if (next != nullptr) {
-    ABSL_RAW_CHECK(
+    Y_ABSL_RAW_CHECK(
         next->header.magic == Magic(kMagicUnallocated, &next->header),
         "bad magic number in Next()");
-    ABSL_RAW_CHECK(next->header.arena == arena, "bad arena pointer in Next()");
+    Y_ABSL_RAW_CHECK(next->header.arena == arena, "bad arena pointer in Next()");
     if (prev != &arena->freelist) {
-      ABSL_RAW_CHECK(prev < next, "unordered freelist");
-      ABSL_RAW_CHECK(reinterpret_cast<char *>(prev) + prev->header.size <
+      Y_ABSL_RAW_CHECK(prev < next, "unordered freelist");
+      Y_ABSL_RAW_CHECK(reinterpret_cast<char *>(prev) + prev->header.size <
                          reinterpret_cast<char *>(next),
                      "malformed freelist");
     }
@@ -491,9 +491,9 @@ static void Coalesce(AllocList *a) {
 static void AddToFreelist(void *v, LowLevelAlloc::Arena *arena) {
   AllocList *f = reinterpret_cast<AllocList *>(
                         reinterpret_cast<char *>(v) - sizeof (f->header));
-  ABSL_RAW_CHECK(f->header.magic == Magic(kMagicAllocated, &f->header),
+  Y_ABSL_RAW_CHECK(f->header.magic == Magic(kMagicAllocated, &f->header),
                  "bad magic number in AddToFreelist()");
-  ABSL_RAW_CHECK(f->header.arena == arena,
+  Y_ABSL_RAW_CHECK(f->header.arena == arena,
                  "bad arena pointer in AddToFreelist()");
   f->levels = LLA_SkiplistLevels(f->header.size, arena->min_size,
                                  &arena->random);
@@ -513,7 +513,7 @@ void LowLevelAlloc::Free(void *v) {
     LowLevelAlloc::Arena *arena = f->header.arena;
     ArenaLock section(arena);
     AddToFreelist(v, arena);
-    ABSL_RAW_CHECK(arena->allocation_count > 0, "nothing in arena to free");
+    Y_ABSL_RAW_CHECK(arena->allocation_count > 0, "nothing in arena to free");
     arena->allocation_count--;
     section.Leave();
   }
@@ -552,9 +552,9 @@ static void *DoAllocWithArena(size_t request, LowLevelAlloc::Arena *arena) {
 #ifdef _WIN32
       new_pages = VirtualAlloc(0, new_pages_size,
                                MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
-      ABSL_RAW_CHECK(new_pages != nullptr, "VirtualAlloc failed");
+      Y_ABSL_RAW_CHECK(new_pages != nullptr, "VirtualAlloc failed");
 #else
-#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
+#ifndef Y_ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
       if ((arena->flags & LowLevelAlloc::kAsyncSignalSafe) != 0) {
         new_pages = base_internal::DirectMmap(nullptr, new_pages_size,
             PROT_WRITE|PROT_READ, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
@@ -565,9 +565,9 @@ static void *DoAllocWithArena(size_t request, LowLevelAlloc::Arena *arena) {
 #else
       new_pages = mmap(nullptr, new_pages_size, PROT_WRITE | PROT_READ,
                        MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
-#endif  // ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
+#endif  // Y_ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
       if (new_pages == MAP_FAILED) {
-        ABSL_RAW_LOG(FATAL, "mmap error: %d", errno);
+        Y_ABSL_RAW_LOG(FATAL, "mmap error: %d", errno);
       }
 
 #endif  // _WIN32
@@ -593,12 +593,12 @@ static void *DoAllocWithArena(size_t request, LowLevelAlloc::Arena *arena) {
       AddToFreelist(&n->levels, arena);
     }
     s->header.magic = Magic(kMagicAllocated, &s->header);
-    ABSL_RAW_CHECK(s->header.arena == arena, "");
+    Y_ABSL_RAW_CHECK(s->header.arena == arena, "");
     arena->allocation_count++;
     section.Leave();
     result = &s->levels;
   }
-  ABSL_ANNOTATE_MEMORY_IS_UNINITIALIZED(result, request);
+  Y_ABSL_ANNOTATE_MEMORY_IS_UNINITIALIZED(result, request);
   return result;
 }
 
@@ -608,13 +608,13 @@ void *LowLevelAlloc::Alloc(size_t request) {
 }
 
 void *LowLevelAlloc::AllocWithArena(size_t request, Arena *arena) {
-  ABSL_RAW_CHECK(arena != nullptr, "must pass a valid arena");
+  Y_ABSL_RAW_CHECK(arena != nullptr, "must pass a valid arena");
   void *result = DoAllocWithArena(request, arena);
   return result;
 }
 
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_LOW_LEVEL_ALLOC_MISSING
+#endif  // Y_ABSL_LOW_LEVEL_ALLOC_MISSING
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc.h
index fa109d53ec..c70d4fd226 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_alloc.h
@@ -13,8 +13,8 @@
 // limitations under the License.
 //
 
-#ifndef ABSL_BASE_INTERNAL_LOW_LEVEL_ALLOC_H_
-#define ABSL_BASE_INTERNAL_LOW_LEVEL_ALLOC_H_
+#ifndef Y_ABSL_BASE_INTERNAL_LOW_LEVEL_ALLOC_H_
+#define Y_ABSL_BASE_INTERNAL_LOW_LEVEL_ALLOC_H_
 
 // A simple thread-safe memory allocator that does not depend on
 // mutexes or thread-specific data.  It is intended to be used
@@ -34,20 +34,20 @@
 // LowLevelAlloc requires that the platform support low-level
 // allocation of virtual memory. Platforms lacking this cannot use
 // LowLevelAlloc.
-#ifdef ABSL_LOW_LEVEL_ALLOC_MISSING
-#error ABSL_LOW_LEVEL_ALLOC_MISSING cannot be directly set
-#elif !defined(ABSL_HAVE_MMAP) && !defined(_WIN32)
-#define ABSL_LOW_LEVEL_ALLOC_MISSING 1
+#ifdef Y_ABSL_LOW_LEVEL_ALLOC_MISSING
+#error Y_ABSL_LOW_LEVEL_ALLOC_MISSING cannot be directly set
+#elif !defined(Y_ABSL_HAVE_MMAP) && !defined(_WIN32)
+#define Y_ABSL_LOW_LEVEL_ALLOC_MISSING 1
 #endif
 
 // Using LowLevelAlloc with kAsyncSignalSafe isn't supported on Windows or
 // asm.js / WebAssembly.
 // See https://kripken.github.io/emscripten-site/docs/porting/pthreads.html
 // for more information.
-#ifdef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
-#error ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING cannot be directly set
+#ifdef Y_ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
+#error Y_ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING cannot be directly set
 #elif defined(_WIN32) || defined(__asmjs__) || defined(__wasm__)
-#define ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING 1
+#define Y_ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING 1
 #endif
 
 #include <cstddef>
@@ -55,7 +55,7 @@
 #include "y_absl/base/port.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 
 class LowLevelAlloc {
@@ -68,18 +68,18 @@ class LowLevelAlloc {
   // Returns 0 if passed request==0.
   // Does not return 0 under other circumstances; it crashes if memory
   // is not available.
-  static void *Alloc(size_t request) ABSL_ATTRIBUTE_SECTION(malloc_hook);
+  static void *Alloc(size_t request) Y_ABSL_ATTRIBUTE_SECTION(malloc_hook);
   static void *AllocWithArena(size_t request, Arena *arena)
-      ABSL_ATTRIBUTE_SECTION(malloc_hook);
+      Y_ABSL_ATTRIBUTE_SECTION(malloc_hook);
 
   // Deallocates a region of memory that was previously allocated with
   // Alloc().   Does nothing if passed 0.   "s" must be either 0,
   // or must have been returned from a call to Alloc() and not yet passed to
   // Free() since that call to Alloc().  The space is returned to the arena
   // from which it was allocated.
-  static void Free(void *s) ABSL_ATTRIBUTE_SECTION(malloc_hook);
+  static void Free(void *s) Y_ABSL_ATTRIBUTE_SECTION(malloc_hook);
 
-  // ABSL_ATTRIBUTE_SECTION(malloc_hook) for Alloc* and Free
+  // Y_ABSL_ATTRIBUTE_SECTION(malloc_hook) for Alloc* and Free
   // are to put all callers of MallocHook::Invoke* in this module
   // into special section,
   // so that MallocHook::GetCallerStackTrace can function accurately.
@@ -93,7 +93,7 @@ class LowLevelAlloc {
     // Set in the DefaultArena.
     kCallMallocHook = 0x0001,
 
-#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
+#ifndef Y_ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
     // Make calls to Alloc(), Free() be async-signal-safe. Not set in
     // DefaultArena(). Not supported on all platforms.
     kAsyncSignalSafe = 0x0002,
@@ -120,7 +120,7 @@ class LowLevelAlloc {
 };
 
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_BASE_INTERNAL_LOW_LEVEL_ALLOC_H_
+#endif  // Y_ABSL_BASE_INTERNAL_LOW_LEVEL_ALLOC_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_scheduling.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/low_level_scheduling.h
index 61eb4ac643..cfbe1625f4 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
@@ -15,8 +15,8 @@
 // Core interfaces and definitions used by by low-level interfaces such as
 // SpinLock.
 
-#ifndef ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_
-#define ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_
+#ifndef Y_ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_
+#define Y_ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_
 
 #include "y_absl/base/internal/raw_logging.h"
 #include "y_absl/base/internal/scheduling_mode.h"
@@ -29,7 +29,7 @@ extern "C" bool __google_disable_rescheduling(void);
 extern "C" void __google_enable_rescheduling(bool disable_result);
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 class CondVar;
 class Mutex;
 
@@ -124,11 +124,11 @@ inline void SchedulingGuard::EnableRescheduling(bool /* disable_result */) {
 inline SchedulingGuard::ScopedEnable::ScopedEnable()
     : scheduling_disabled_depth_(0) {}
 inline SchedulingGuard::ScopedEnable::~ScopedEnable() {
-  ABSL_RAW_CHECK(scheduling_disabled_depth_ == 0, "disable unused warning");
+  Y_ABSL_RAW_CHECK(scheduling_disabled_depth_ == 0, "disable unused warning");
 }
 
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_
+#endif  // Y_ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/per_thread_tls.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/per_thread_tls.h
index 943f72a433..ebc5ad4bb8 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/per_thread_tls.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/per_thread_tls.h
@@ -12,41 +12,41 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_BASE_INTERNAL_PER_THREAD_TLS_H_
-#define ABSL_BASE_INTERNAL_PER_THREAD_TLS_H_
+#ifndef Y_ABSL_BASE_INTERNAL_PER_THREAD_TLS_H_
+#define Y_ABSL_BASE_INTERNAL_PER_THREAD_TLS_H_
 
 // This header defines two macros:
 //
 // If the platform supports thread-local storage:
 //
-// * ABSL_PER_THREAD_TLS_KEYWORD is the C keyword needed to declare a
+// * Y_ABSL_PER_THREAD_TLS_KEYWORD is the C keyword needed to declare a
 //   thread-local variable
-// * ABSL_PER_THREAD_TLS is 1
+// * Y_ABSL_PER_THREAD_TLS is 1
 //
 // Otherwise:
 //
-// * ABSL_PER_THREAD_TLS_KEYWORD is empty
-// * ABSL_PER_THREAD_TLS is 0
+// * Y_ABSL_PER_THREAD_TLS_KEYWORD is empty
+// * Y_ABSL_PER_THREAD_TLS is 0
 //
 // Microsoft C supports thread-local storage.
 // GCC supports it if the appropriate version of glibc is available,
-// which the programmer can indicate by defining ABSL_HAVE_TLS
+// which the programmer can indicate by defining Y_ABSL_HAVE_TLS
 
-#include "y_absl/base/port.h"  // For ABSL_HAVE_TLS
+#include "y_absl/base/port.h"  // For Y_ABSL_HAVE_TLS
 
-#if defined(ABSL_PER_THREAD_TLS)
-#error ABSL_PER_THREAD_TLS cannot be directly set
-#elif defined(ABSL_PER_THREAD_TLS_KEYWORD)
-#error ABSL_PER_THREAD_TLS_KEYWORD cannot be directly set
-#elif defined(ABSL_HAVE_TLS)
-#define ABSL_PER_THREAD_TLS_KEYWORD __thread
-#define ABSL_PER_THREAD_TLS 1
+#if defined(Y_ABSL_PER_THREAD_TLS)
+#error Y_ABSL_PER_THREAD_TLS cannot be directly set
+#elif defined(Y_ABSL_PER_THREAD_TLS_KEYWORD)
+#error Y_ABSL_PER_THREAD_TLS_KEYWORD cannot be directly set
+#elif defined(Y_ABSL_HAVE_TLS)
+#define Y_ABSL_PER_THREAD_TLS_KEYWORD __thread
+#define Y_ABSL_PER_THREAD_TLS 1
 #elif defined(_MSC_VER)
-#define ABSL_PER_THREAD_TLS_KEYWORD __declspec(thread)
-#define ABSL_PER_THREAD_TLS 1
+#define Y_ABSL_PER_THREAD_TLS_KEYWORD __declspec(thread)
+#define Y_ABSL_PER_THREAD_TLS 1
 #else
-#define ABSL_PER_THREAD_TLS_KEYWORD
-#define ABSL_PER_THREAD_TLS 0
+#define Y_ABSL_PER_THREAD_TLS_KEYWORD
+#define Y_ABSL_PER_THREAD_TLS 0
 #endif
 
-#endif  // ABSL_BASE_INTERNAL_PER_THREAD_TLS_H_
+#endif  // Y_ABSL_BASE_INTERNAL_PER_THREAD_TLS_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/pretty_function.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/pretty_function.h
index 35d51676dc..552b379dbf 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/pretty_function.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/pretty_function.h
@@ -12,22 +12,22 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_BASE_INTERNAL_PRETTY_FUNCTION_H_
-#define ABSL_BASE_INTERNAL_PRETTY_FUNCTION_H_
+#ifndef Y_ABSL_BASE_INTERNAL_PRETTY_FUNCTION_H_
+#define Y_ABSL_BASE_INTERNAL_PRETTY_FUNCTION_H_
 
-// ABSL_PRETTY_FUNCTION
+// Y_ABSL_PRETTY_FUNCTION
 //
 // In C++11, __func__ gives the undecorated name of the current function.  That
 // is, "main", not "int main()".  Various compilers give extra macros to get the
 // decorated function name, including return type and arguments, to
-// differentiate between overload sets.  ABSL_PRETTY_FUNCTION is a portable
+// differentiate between overload sets.  Y_ABSL_PRETTY_FUNCTION is a portable
 // version of these macros which forwards to the correct macro on each compiler.
 #if defined(_MSC_VER)
-#define ABSL_PRETTY_FUNCTION __FUNCSIG__
+#define Y_ABSL_PRETTY_FUNCTION __FUNCSIG__
 #elif defined(__GNUC__)
-#define ABSL_PRETTY_FUNCTION __PRETTY_FUNCTION__
+#define Y_ABSL_PRETTY_FUNCTION __PRETTY_FUNCTION__
 #else
 #error "Unsupported compiler"
 #endif
 
-#endif  // ABSL_BASE_INTERNAL_PRETTY_FUNCTION_H_
+#endif  // Y_ABSL_BASE_INTERNAL_PRETTY_FUNCTION_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging.cc
index ea9a48c2c0..75af4543d5 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
@@ -26,11 +26,11 @@
 #include "y_absl/base/log_severity.h"
 
 // We know how to perform low-level writes to stderr in POSIX and Windows.  For
-// these platforms, we define the token ABSL_LOW_LEVEL_WRITE_SUPPORTED.
+// these platforms, we define the token Y_ABSL_LOW_LEVEL_WRITE_SUPPORTED.
 // Much of raw_logging.cc becomes a no-op when we can't output messages,
-// although a FATAL ABSL_RAW_LOG message will still abort the process.
+// although a FATAL Y_ABSL_RAW_LOG message will still abort the process.
 
-// ABSL_HAVE_POSIX_WRITE is defined when the platform provides posix write()
+// Y_ABSL_HAVE_POSIX_WRITE is defined when the platform provides posix write()
 // (as from unistd.h)
 //
 // This preprocessor token is also defined in raw_io.cc.  If you need to copy
@@ -41,49 +41,49 @@
 
 #include <unistd.h>
 
-#define ABSL_HAVE_POSIX_WRITE 1
-#define ABSL_LOW_LEVEL_WRITE_SUPPORTED 1
+#define Y_ABSL_HAVE_POSIX_WRITE 1
+#define Y_ABSL_LOW_LEVEL_WRITE_SUPPORTED 1
 #else
-#undef ABSL_HAVE_POSIX_WRITE
+#undef Y_ABSL_HAVE_POSIX_WRITE
 #endif
 
-// ABSL_HAVE_SYSCALL_WRITE is defined when the platform provides the syscall
+// Y_ABSL_HAVE_SYSCALL_WRITE is defined when the platform provides the syscall
 //   syscall(SYS_write, /*int*/ fd, /*char* */ buf, /*size_t*/ len);
 // for low level operations that want to avoid libc.
 #if (defined(__linux__) || defined(__FreeBSD__)) && !defined(__ANDROID__)
 #include <sys/syscall.h>
-#define ABSL_HAVE_SYSCALL_WRITE 1
-#define ABSL_LOW_LEVEL_WRITE_SUPPORTED 1
+#define Y_ABSL_HAVE_SYSCALL_WRITE 1
+#define Y_ABSL_LOW_LEVEL_WRITE_SUPPORTED 1
 #else
-#undef ABSL_HAVE_SYSCALL_WRITE
+#undef Y_ABSL_HAVE_SYSCALL_WRITE
 #endif
 
 #ifdef _WIN32
 #include <io.h>
 
-#define ABSL_HAVE_RAW_IO 1
-#define ABSL_LOW_LEVEL_WRITE_SUPPORTED 1
+#define Y_ABSL_HAVE_RAW_IO 1
+#define Y_ABSL_LOW_LEVEL_WRITE_SUPPORTED 1
 #else
-#undef ABSL_HAVE_RAW_IO
+#undef Y_ABSL_HAVE_RAW_IO
 #endif
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_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
+// Explicitly `#error` out when not `Y_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_INTERNAL_ATOMIC_HOOK_ATTRIBUTES
     y_absl::base_internal::AtomicHook<LogPrefixHook>
         log_prefix_hook;
-ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES
+Y_ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES
     y_absl::base_internal::AtomicHook<AbortHook>
         abort_hook;
 
-#ifdef ABSL_LOW_LEVEL_WRITE_SUPPORTED
+#ifdef Y_ABSL_LOW_LEVEL_WRITE_SUPPORTED
 constexpr char kTruncated[] = " ... (message truncated)\n";
 
 // sprintf the format to the buffer, adjusting *buf and *size to reflect the
@@ -91,7 +91,7 @@ constexpr char kTruncated[] = " ... (message truncated)\n";
 // 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);
+    Y_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;
@@ -107,7 +107,7 @@ bool VADoRawLog(char** buf, int* size, const char* format, va_list ap) {
   *buf += n;
   return result;
 }
-#endif  // ABSL_LOW_LEVEL_WRITE_SUPPORTED
+#endif  // Y_ABSL_LOW_LEVEL_WRITE_SUPPORTED
 
 constexpr int kLogBufSize = 3000;
 
@@ -118,7 +118,7 @@ constexpr int kLogBufSize = 3000;
 // *DoRawLog writes to *buf of *size and move them past the written portion.
 // It returns true iff there was no overflow or error.
 bool DoRawLog(char** buf, int* size, const char* format, ...)
-    ABSL_PRINTF_ATTRIBUTE(3, 4);
+    Y_ABSL_PRINTF_ATTRIBUTE(3, 4);
 bool DoRawLog(char** buf, int* size, const char* format, ...) {
   va_list ap;
   va_start(ap, format);
@@ -131,20 +131,20 @@ bool DoRawLog(char** buf, int* size, const char* format, ...) {
 }
 
 void RawLogVA(y_absl::LogSeverity severity, const char* file, int line,
-              const char* format, va_list ap) ABSL_PRINTF_ATTRIBUTE(4, 0);
+              const char* format, va_list ap) Y_ABSL_PRINTF_ATTRIBUTE(4, 0);
 void RawLogVA(y_absl::LogSeverity severity, const char* file, int line,
               const char* format, va_list ap) {
   char buffer[kLogBufSize];
   char* buf = buffer;
   int size = sizeof(buffer);
-#ifdef ABSL_LOW_LEVEL_WRITE_SUPPORTED
+#ifdef Y_ABSL_LOW_LEVEL_WRITE_SUPPORTED
   bool enabled = true;
 #else
   bool enabled = false;
 #endif
 
-#ifdef ABSL_MIN_LOG_LEVEL
-  if (severity < static_cast<y_absl::LogSeverity>(ABSL_MIN_LOG_LEVEL) &&
+#ifdef Y_ABSL_MIN_LOG_LEVEL
+  if (severity < static_cast<y_absl::LogSeverity>(Y_ABSL_MIN_LOG_LEVEL) &&
       severity < y_absl::LogSeverity::kFatal) {
     enabled = false;
   }
@@ -160,7 +160,7 @@ void RawLogVA(y_absl::LogSeverity severity, const char* file, int line,
   }
   const char* const prefix_end = buf;
 
-#ifdef ABSL_LOW_LEVEL_WRITE_SUPPORTED
+#ifdef Y_ABSL_LOW_LEVEL_WRITE_SUPPORTED
   if (enabled) {
     bool no_chop = VADoRawLog(&buf, &size, format, ap);
     if (no_chop) {
@@ -196,11 +196,11 @@ void DefaultInternalLog(y_absl::LogSeverity severity, const char* file, int line
 }  // namespace
 
 void SafeWriteToStderr(const char *s, size_t len) {
-#if defined(ABSL_HAVE_SYSCALL_WRITE)
+#if defined(Y_ABSL_HAVE_SYSCALL_WRITE)
   syscall(SYS_write, STDERR_FILENO, s, len);
-#elif defined(ABSL_HAVE_POSIX_WRITE)
+#elif defined(Y_ABSL_HAVE_POSIX_WRITE)
   write(STDERR_FILENO, s, len);
-#elif defined(ABSL_HAVE_RAW_IO)
+#elif defined(Y_ABSL_HAVE_RAW_IO)
   _write(/* stderr */ 2, s, len);
 #else
   // stderr logging unsupported on this platform
@@ -218,14 +218,14 @@ void RawLog(y_absl::LogSeverity severity, const char* file, int line,
 }
 
 bool RawLoggingFullySupported() {
-#ifdef ABSL_LOW_LEVEL_WRITE_SUPPORTED
+#ifdef Y_ABSL_LOW_LEVEL_WRITE_SUPPORTED
   return true;
-#else  // !ABSL_LOW_LEVEL_WRITE_SUPPORTED
+#else  // !Y_ABSL_LOW_LEVEL_WRITE_SUPPORTED
   return false;
-#endif  // !ABSL_LOW_LEVEL_WRITE_SUPPORTED
+#endif  // !Y_ABSL_LOW_LEVEL_WRITE_SUPPORTED
 }
 
-ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES ABSL_DLL
+Y_ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES Y_ABSL_DLL
     y_absl::base_internal::AtomicHook<InternalLogFunction>
         internal_log_function(DefaultInternalLog);
 
@@ -238,5 +238,5 @@ void RegisterInternalLogFunction(InternalLogFunction func) {
 }
 
 }  // namespace raw_logging_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging.h
index 4d5c77003f..8febc13fc3 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
@@ -16,8 +16,8 @@
 // acquire any locks, and can therefore be used by low-level memory
 // allocation, synchronization, and signal-handling code.
 
-#ifndef ABSL_BASE_INTERNAL_RAW_LOGGING_H_
-#define ABSL_BASE_INTERNAL_RAW_LOGGING_H_
+#ifndef Y_ABSL_BASE_INTERNAL_RAW_LOGGING_H_
+#define Y_ABSL_BASE_INTERNAL_RAW_LOGGING_H_
 
 #include <util/generic/string.h>
 
@@ -37,33 +37,33 @@
 // * it uses an explicit printf-format and arguments list
 // * it will silently chop off really long message strings
 // Usage example:
-//   ABSL_RAW_LOG(ERROR, "Failed foo with %i: %s", status, error);
+//   Y_ABSL_RAW_LOG(ERROR, "Failed foo with %i: %s", status, error);
 // This will print an almost standard log line like this to stderr only:
 //   E0821 211317 file.cc:123] RAW: Failed foo with 22: bad_file
 
-#define ABSL_RAW_LOG(severity, ...)                                            \
+#define Y_ABSL_RAW_LOG(severity, ...)                                            \
   do {                                                                         \
     constexpr const char* absl_raw_logging_internal_basename =                 \
         ::y_absl::raw_logging_internal::Basename(__FILE__,                       \
                                                sizeof(__FILE__) - 1);          \
-    ::y_absl::raw_logging_internal::RawLog(ABSL_RAW_LOGGING_INTERNAL_##severity, \
+    ::y_absl::raw_logging_internal::RawLog(Y_ABSL_RAW_LOGGING_INTERNAL_##severity, \
                                          absl_raw_logging_internal_basename,   \
                                          __LINE__, __VA_ARGS__);               \
   } while (0)
 
 // Similar to CHECK(condition) << message, but for low-level modules:
-// we use only ABSL_RAW_LOG that does not allocate memory.
+// we use only Y_ABSL_RAW_LOG that does not allocate memory.
 // We do not want to provide args list here to encourage this usage:
-//   if (!cond)  ABSL_RAW_LOG(FATAL, "foo ...", hard_to_compute_args);
+//   if (!cond)  Y_ABSL_RAW_LOG(FATAL, "foo ...", hard_to_compute_args);
 // so that the args are not computed when not needed.
-#define ABSL_RAW_CHECK(condition, message)                             \
+#define Y_ABSL_RAW_CHECK(condition, message)                             \
   do {                                                                 \
-    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
-      ABSL_RAW_LOG(FATAL, "Check %s failed: %s", #condition, message); \
+    if (Y_ABSL_PREDICT_FALSE(!(condition))) {                            \
+      Y_ABSL_RAW_LOG(FATAL, "Check %s failed: %s", #condition, message); \
     }                                                                  \
   } while (0)
 
-// ABSL_INTERNAL_LOG and ABSL_INTERNAL_CHECK work like the RAW variants above,
+// Y_ABSL_INTERNAL_LOG and Y_ABSL_INTERNAL_CHECK work like the RAW variants above,
 // except that if the richer log library is linked into the binary, we dispatch
 // to that instead.  This is potentially useful for internal logging and
 // assertions, where we are using RAW_LOG neither for its async-signal-safety
@@ -72,42 +72,42 @@
 //
 // 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)                                 \
+#define Y_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,                                \
+        Y_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;                                             \
+    if (Y_ABSL_RAW_LOGGING_INTERNAL_##severity == ::y_absl::LogSeverity::kFatal) \
+      Y_ABSL_INTERNAL_UNREACHABLE;                                             \
   } while (0)
 
-#define ABSL_INTERNAL_CHECK(condition, message)                    \
+#define Y_ABSL_INTERNAL_CHECK(condition, message)                    \
   do {                                                             \
-    if (ABSL_PREDICT_FALSE(!(condition))) {                        \
+    if (Y_ABSL_PREDICT_FALSE(!(condition))) {                        \
       TString death_message = "Check " #condition " failed: "; \
       death_message += TString(message);                       \
-      ABSL_INTERNAL_LOG(FATAL, death_message);                     \
+      Y_ABSL_INTERNAL_LOG(FATAL, death_message);                     \
     }                                                              \
   } while (0)
 
-#define ABSL_RAW_LOGGING_INTERNAL_INFO ::y_absl::LogSeverity::kInfo
-#define ABSL_RAW_LOGGING_INTERNAL_WARNING ::y_absl::LogSeverity::kWarning
-#define ABSL_RAW_LOGGING_INTERNAL_ERROR ::y_absl::LogSeverity::kError
-#define ABSL_RAW_LOGGING_INTERNAL_FATAL ::y_absl::LogSeverity::kFatal
-#define ABSL_RAW_LOGGING_INTERNAL_LEVEL(severity) \
+#define Y_ABSL_RAW_LOGGING_INTERNAL_INFO ::y_absl::LogSeverity::kInfo
+#define Y_ABSL_RAW_LOGGING_INTERNAL_WARNING ::y_absl::LogSeverity::kWarning
+#define Y_ABSL_RAW_LOGGING_INTERNAL_ERROR ::y_absl::LogSeverity::kError
+#define Y_ABSL_RAW_LOGGING_INTERNAL_FATAL ::y_absl::LogSeverity::kFatal
+#define Y_ABSL_RAW_LOGGING_INTERNAL_LEVEL(severity) \
   ::y_absl::NormalizeLogSeverity(severity)
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace raw_logging_internal {
 
-// Helper function to implement ABSL_RAW_LOG
+// Helper function to implement Y_ABSL_RAW_LOG
 // Logs format... at "severity" level, reporting it
 // as called from file:line.
 // This does not allocate memory or acquire locks.
 void RawLog(y_absl::LogSeverity severity, const char* file, int line,
-            const char* format, ...) ABSL_PRINTF_ATTRIBUTE(4, 5);
+            const char* format, ...) Y_ABSL_PRINTF_ATTRIBUTE(4, 5);
 
 // Writes the provided buffer directly to stderr, in a safe, low-level manner.
 //
@@ -146,7 +146,7 @@ bool RawLoggingFullySupported();
 // hooks must avoid these operations, and must not throw exceptions.
 //
 // 'severity' is the severity level of the message being written.
-// 'file' and 'line' are the file and line number where the ABSL_RAW_LOG macro
+// 'file' and 'line' are the file and line number where the Y_ABSL_RAW_LOG macro
 // was located.
 // 'buffer' and 'buf_size' are pointers to the buffer and buffer size.  If the
 // hook writes a prefix, it must increment *buffer and decrement *buf_size
@@ -158,7 +158,7 @@ using LogPrefixHook = bool (*)(y_absl::LogSeverity severity, const char* file,
 // when a FATAL message is logged.  If the provided AbortHook() returns, the
 // logging system will call abort().
 //
-// 'file' and 'line' are the file and line number where the ABSL_RAW_LOG macro
+// 'file' and 'line' are the file and line number where the Y_ABSL_RAW_LOG macro
 // was located.
 // The NUL-terminated logged message lives in the buffer between 'buf_start'
 // and 'buf_end'.  'prefix_end' points to the first non-prefix character of the
@@ -166,7 +166,7 @@ using LogPrefixHook = bool (*)(y_absl::LogSeverity severity, const char* file,
 using AbortHook = void (*)(const char* file, int line, const char* buf_start,
                            const char* prefix_end, const char* buf_end);
 
-// Internal logging function for ABSL_INTERNAL_LOG to dispatch to.
+// Internal logging function for Y_ABSL_INTERNAL_LOG to dispatch to.
 //
 // TODO(gfalcon): When string_view no longer depends on base, change this
 // interface to take its message as a string_view instead.
@@ -174,7 +174,7 @@ 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<
+Y_ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES Y_ABSL_DLL extern base_internal::AtomicHook<
     InternalLogFunction>
     internal_log_function;
 
@@ -189,7 +189,7 @@ void RegisterAbortHook(AbortHook func);
 void RegisterInternalLogFunction(InternalLogFunction func);
 
 }  // namespace raw_logging_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_BASE_INTERNAL_RAW_LOGGING_H_
+#endif  // Y_ABSL_BASE_INTERNAL_RAW_LOGGING_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/scheduling_mode.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/scheduling_mode.h
index 0165e7233b..5a52ccf6fe 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/scheduling_mode.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/scheduling_mode.h
@@ -15,13 +15,13 @@
 // Core interfaces and definitions used by by low-level interfaces such as
 // SpinLock.
 
-#ifndef ABSL_BASE_INTERNAL_SCHEDULING_MODE_H_
-#define ABSL_BASE_INTERNAL_SCHEDULING_MODE_H_
+#ifndef Y_ABSL_BASE_INTERNAL_SCHEDULING_MODE_H_
+#define Y_ABSL_BASE_INTERNAL_SCHEDULING_MODE_H_
 
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 
 // Used to describe how a thread may be scheduled.  Typically associated with
@@ -52,7 +52,7 @@ enum SchedulingMode {
 };
 
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_BASE_INTERNAL_SCHEDULING_MODE_H_
+#endif  // Y_ABSL_BASE_INTERNAL_SCHEDULING_MODE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/scoped_set_env.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/scoped_set_env.cc
index e489272b45..ad48ddbcee 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/scoped_set_env.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/scoped_set_env.cc
@@ -23,7 +23,7 @@
 #include "y_absl/base/internal/raw_logging.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 
 namespace {
@@ -51,7 +51,7 @@ ScopedSetEnv::ScopedSetEnv(const char* var_name, const char* new_value)
 #ifdef _WIN32
   char buf[kMaxEnvVarValueSize];
   auto get_res = GetEnvironmentVariableA(var_name_.c_str(), buf, sizeof(buf));
-  ABSL_INTERNAL_CHECK(get_res < sizeof(buf), "value exceeds buffer size");
+  Y_ABSL_INTERNAL_CHECK(get_res < sizeof(buf), "value exceeds buffer size");
 
   if (get_res == 0) {
     was_unset_ = (GetLastError() == ERROR_ENVVAR_NOT_FOUND);
@@ -77,5 +77,5 @@ ScopedSetEnv::~ScopedSetEnv() {
 }
 
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/scoped_set_env.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/scoped_set_env.h
index 5641562f1b..f414235b28 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/scoped_set_env.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/scoped_set_env.h
@@ -14,15 +14,15 @@
 // limitations under the License.
 //
 
-#ifndef ABSL_BASE_INTERNAL_SCOPED_SET_ENV_H_
-#define ABSL_BASE_INTERNAL_SCOPED_SET_ENV_H_
+#ifndef Y_ABSL_BASE_INTERNAL_SCOPED_SET_ENV_H_
+#define Y_ABSL_BASE_INTERNAL_SCOPED_SET_ENV_H_
 
 #include <util/generic/string.h>
 
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 
 class ScopedSetEnv {
@@ -39,7 +39,7 @@ class ScopedSetEnv {
 };
 
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_BASE_INTERNAL_SCOPED_SET_ENV_H_
+#endif  // Y_ABSL_BASE_INTERNAL_SCOPED_SET_ENV_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock.cc
index 2ee7cde432..efffecdb7e 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
@@ -54,10 +54,10 @@
 //          holder to acquire the lock.  There may be outstanding waiter(s).
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 
-ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES static base_internal::AtomicHook<void (*)(
+Y_ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES static base_internal::AtomicHook<void (*)(
     const void *lock, int64_t wait_cycles)>
     submit_profile_data;
 
@@ -76,7 +76,7 @@ constexpr uint32_t SpinLock::kWaitTimeMask;
 // Uncommon constructors.
 SpinLock::SpinLock(base_internal::SchedulingMode mode)
     : lockword_(IsCooperative(mode) ? kSpinLockCooperative : 0) {
-  ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
+  Y_ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
 }
 
 // Monitor the lock to see if its value changes within some time period
@@ -85,8 +85,8 @@ SpinLock::SpinLock(base_internal::SchedulingMode mode)
 uint32_t SpinLock::SpinLoop() {
   // We are already in the slow path of SpinLock, initialize the
   // adaptive_spin_count here.
-  ABSL_CONST_INIT static y_absl::once_flag init_adaptive_spin_count;
-  ABSL_CONST_INIT static int adaptive_spin_count = 0;
+  Y_ABSL_CONST_INIT static y_absl::once_flag init_adaptive_spin_count;
+  Y_ABSL_CONST_INIT static int adaptive_spin_count = 0;
   base_internal::LowLevelCallOnce(&init_adaptive_spin_count, []() {
     adaptive_spin_count = base_internal::NumCPUs() > 1 ? 1000 : 1;
   });
@@ -154,11 +154,11 @@ void SpinLock::SlowLock() {
 
     // SpinLockDelay() calls into fiber scheduler, we need to see
     // synchronization there to avoid false positives.
-    ABSL_TSAN_MUTEX_PRE_DIVERT(this, 0);
+    Y_ABSL_TSAN_MUTEX_PRE_DIVERT(this, 0);
     // Wait for an OS specific delay.
     base_internal::SpinLockDelay(&lockword_, lock_value, ++lock_wait_call_count,
                                  scheduling_mode);
-    ABSL_TSAN_MUTEX_POST_DIVERT(this, 0);
+    Y_ABSL_TSAN_MUTEX_POST_DIVERT(this, 0);
     // Spin again after returning from the wait routine to give this thread
     // some chance of obtaining the lock.
     lock_value = SpinLoop();
@@ -176,9 +176,9 @@ void SpinLock::SlowUnlock(uint32_t lock_value) {
   // own acquisition having been contended.
   if ((lock_value & kWaitTimeMask) != kSpinLockSleeper) {
     const uint64_t wait_cycles = DecodeWaitCycles(lock_value);
-    ABSL_TSAN_MUTEX_PRE_DIVERT(this, 0);
+    Y_ABSL_TSAN_MUTEX_PRE_DIVERT(this, 0);
     submit_profile_data(this, wait_cycles);
-    ABSL_TSAN_MUTEX_POST_DIVERT(this, 0);
+    Y_ABSL_TSAN_MUTEX_POST_DIVERT(this, 0);
   }
 }
 
@@ -225,5 +225,5 @@ uint64_t SpinLock::DecodeWaitCycles(uint32_t lock_value) {
 }
 
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock.h
index ef88cb52c0..a570699d68 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
@@ -26,8 +26,8 @@
 //
 // Threads waiting on a SpinLock may be woken in an arbitrary order.
 
-#ifndef ABSL_BASE_INTERNAL_SPINLOCK_H_
-#define ABSL_BASE_INTERNAL_SPINLOCK_H_
+#ifndef Y_ABSL_BASE_INTERNAL_SPINLOCK_H_
+#define Y_ABSL_BASE_INTERNAL_SPINLOCK_H_
 
 #include <stdint.h>
 #include <sys/types.h>
@@ -46,13 +46,13 @@
 #include "y_absl/base/thread_annotations.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 
-class ABSL_LOCKABLE SpinLock {
+class Y_ABSL_LOCKABLE SpinLock {
  public:
   SpinLock() : lockword_(kSpinLockCooperative) {
-    ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
+    Y_ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
   }
 
   // Constructors that allow non-cooperative spinlocks to be created for use
@@ -66,37 +66,37 @@ class ABSL_LOCKABLE SpinLock {
   // 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); }
+#ifdef Y_ABSL_INTERNAL_HAVE_TSAN_INTERFACE
+  ~SpinLock() { Y_ABSL_TSAN_MUTEX_DESTROY(this, __tsan_mutex_not_static); }
 #else
   ~SpinLock() = default;
 #endif
 
   // Acquire this SpinLock.
-  inline void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() {
-    ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
+  inline void Lock() Y_ABSL_EXCLUSIVE_LOCK_FUNCTION() {
+    Y_ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
     if (!TryLockImpl()) {
       SlowLock();
     }
-    ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
+    Y_ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
   }
 
   // Try to acquire this SpinLock without blocking and return true if the
   // acquisition was successful.  If the lock was not acquired, false is
   // returned.  If this SpinLock is free at the time of the call, TryLock
   // will return true with high probability.
-  inline bool TryLock() ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(true) {
-    ABSL_TSAN_MUTEX_PRE_LOCK(this, __tsan_mutex_try_lock);
+  inline bool TryLock() Y_ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(true) {
+    Y_ABSL_TSAN_MUTEX_PRE_LOCK(this, __tsan_mutex_try_lock);
     bool res = TryLockImpl();
-    ABSL_TSAN_MUTEX_POST_LOCK(
+    Y_ABSL_TSAN_MUTEX_POST_LOCK(
         this, __tsan_mutex_try_lock | (res ? 0 : __tsan_mutex_try_lock_failed),
         0);
     return res;
   }
 
   // Release this SpinLock, which must be held by the calling thread.
-  inline void Unlock() ABSL_UNLOCK_FUNCTION() {
-    ABSL_TSAN_MUTEX_PRE_UNLOCK(this, 0);
+  inline void Unlock() Y_ABSL_UNLOCK_FUNCTION() {
+    Y_ABSL_TSAN_MUTEX_PRE_UNLOCK(this, 0);
     uint32_t lock_value = lockword_.load(std::memory_order_relaxed);
     lock_value = lockword_.exchange(lock_value & kSpinLockCooperative,
                                     std::memory_order_release);
@@ -110,7 +110,7 @@ class ABSL_LOCKABLE SpinLock {
       // for the lock.
       SlowUnlock(lock_value);
     }
-    ABSL_TSAN_MUTEX_POST_UNLOCK(this, 0);
+    Y_ABSL_TSAN_MUTEX_POST_UNLOCK(this, 0);
   }
 
   // Determine if the lock is held.  When the lock is held by the invoking
@@ -168,8 +168,8 @@ class ABSL_LOCKABLE SpinLock {
   }
 
   uint32_t TryLockInternal(uint32_t lock_value, uint32_t wait_cycles);
-  void SlowLock() ABSL_ATTRIBUTE_COLD;
-  void SlowUnlock(uint32_t lock_value) ABSL_ATTRIBUTE_COLD;
+  void SlowLock() Y_ABSL_ATTRIBUTE_COLD;
+  void SlowUnlock(uint32_t lock_value) Y_ABSL_ATTRIBUTE_COLD;
   uint32_t SpinLoop();
 
   inline bool TryLockImpl() {
@@ -185,13 +185,13 @@ class ABSL_LOCKABLE SpinLock {
 
 // Corresponding locker object that arranges to acquire a spinlock for
 // the duration of a C++ scope.
-class ABSL_SCOPED_LOCKABLE SpinLockHolder {
+class Y_ABSL_SCOPED_LOCKABLE SpinLockHolder {
  public:
-  inline explicit SpinLockHolder(SpinLock* l) ABSL_EXCLUSIVE_LOCK_FUNCTION(l)
+  inline explicit SpinLockHolder(SpinLock* l) Y_ABSL_EXCLUSIVE_LOCK_FUNCTION(l)
       : lock_(l) {
     l->Lock();
   }
-  inline ~SpinLockHolder() ABSL_UNLOCK_FUNCTION() { lock_->Unlock(); }
+  inline ~SpinLockHolder() Y_ABSL_UNLOCK_FUNCTION() { lock_->Unlock(); }
 
   SpinLockHolder(const SpinLockHolder&) = delete;
   SpinLockHolder& operator=(const SpinLockHolder&) = delete;
@@ -242,7 +242,7 @@ inline uint32_t SpinLock::TryLockInternal(uint32_t lock_value,
 }
 
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_BASE_INTERNAL_SPINLOCK_H_
+#endif  // Y_ABSL_BASE_INTERNAL_SPINLOCK_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_akaros.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_akaros.inc
index 69955dc765..f6687cc3b6 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)(
+Y_ABSL_ATTRIBUTE_WEAK void Y_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)(
+Y_ABSL_ATTRIBUTE_WEAK void Y_ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)(
     std::atomic<uint32_t>* /* lock_word */, bool /* all */) {}
 
 }  // extern "C"
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_linux.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_linux.inc
index 5b4480d133..5d2bbbcd15 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
@@ -56,7 +56,7 @@ static_assert(sizeof(std::atomic<uint32_t>) == sizeof(int),
 
 extern "C" {
 
-ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)(
+Y_ABSL_ATTRIBUTE_WEAK void Y_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,7 +66,7 @@ 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)(
+Y_ABSL_ATTRIBUTE_WEAK void Y_ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)(
     std::atomic<uint32_t> *w, bool all) {
   syscall(SYS_futex, w, FUTEX_WAKE | FUTEX_PRIVATE_FLAG, all ? INT_MAX : 1, 0);
 }
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_posix.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_posix.inc
index 12a9b86599..c629c981fe 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)(
+Y_ABSL_ATTRIBUTE_WEAK void Y_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)(
+Y_ABSL_ATTRIBUTE_WEAK void Y_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.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait.cc
index 138cb3c5f0..81dcd0757e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait.cc
@@ -32,7 +32,7 @@
 #endif
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 
 // See spinlock_wait.h for spec.
@@ -77,5 +77,5 @@ int SpinLockSuggestedDelayNS(int loop) {
 }
 
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait.h
index 2e34d7026b..0fd08f5260 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
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_BASE_INTERNAL_SPINLOCK_WAIT_H_
-#define ABSL_BASE_INTERNAL_SPINLOCK_WAIT_H_
+#ifndef Y_ABSL_BASE_INTERNAL_SPINLOCK_WAIT_H_
+#define Y_ABSL_BASE_INTERNAL_SPINLOCK_WAIT_H_
 
 // Operations to make atomic transitions on a word, and to allow
 // waiting for those transitions to become possible.
@@ -24,7 +24,7 @@
 #include "y_absl/base/internal/scheduling_mode.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 
 // SpinLockWait() waits until it can perform one of several transitions from
@@ -63,7 +63,7 @@ void SpinLockDelay(std::atomic<uint32_t> *w, uint32_t value, int loop,
 int SpinLockSuggestedDelayNS(int loop);
 
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 // In some build configurations we pass --detect-odr-violations to the
@@ -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,
+void Y_ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)(std::atomic<uint32_t> *w,
                                                       bool all);
-void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)(
+void Y_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);
+  Y_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)
+  Y_ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)
   (w, value, loop, scheduling_mode);
 }
 
-#endif  // ABSL_BASE_INTERNAL_SPINLOCK_WAIT_H_
+#endif  // Y_ABSL_BASE_INTERNAL_SPINLOCK_WAIT_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_win32.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_win32.inc
index 648f74134f..c80dfdf05c 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,7 +20,7 @@
 
 extern "C" {
 
-void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)(
+void Y_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) {
@@ -31,7 +31,7 @@ void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockDelay)(
   }
 }
 
-void ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)(
+void Y_ABSL_INTERNAL_C_SYMBOL(AbslInternalSpinLockWake)(
     std::atomic<uint32_t>* /* lock_word */, bool /* all */) {}
 
 }  // extern "C"
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/strerror.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/strerror.cc
index fe50d84a03..ae1e09f791 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
@@ -25,7 +25,7 @@
 #include "y_absl/base/internal/errno_saver.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 namespace {
 
@@ -84,5 +84,5 @@ TString StrError(int errnum) {
 }
 
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/strerror.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/strerror.h
index a80a7b9c35..941c030616 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
@@ -12,15 +12,15 @@
 // 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_
+#ifndef Y_ABSL_BASE_INTERNAL_STRERROR_H_
+#define Y_ABSL_BASE_INTERNAL_STRERROR_H_
 
 #include <util/generic/string.h>
 
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 
 // A portable and thread-safe alternative to C89's `strerror`.
@@ -33,7 +33,7 @@ namespace base_internal {
 TString StrError(int errnum);
 
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_BASE_INTERNAL_STRERROR_H_
+#endif  // Y_ABSL_BASE_INTERNAL_STRERROR_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/sysinfo.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/sysinfo.cc
index 9eb0cf3f8c..6a1ef60711 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
@@ -58,7 +58,7 @@
 #include "y_absl/base/thread_annotations.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 
 namespace {
@@ -210,7 +210,7 @@ static bool ReadLongFromFile(const char *file, long *value) {
   return ret;
 }
 
-#if defined(ABSL_INTERNAL_UNSCALED_CYCLECLOCK_FREQUENCY_IS_CPU_FREQUENCY)
+#if defined(Y_ABSL_INTERNAL_UNSCALED_CYCLECLOCK_FREQUENCY_IS_CPU_FREQUENCY)
 
 // Reads a monotonic time source and returns a value in
 // nanoseconds. The returned value uses an arbitrary epoch, not the
@@ -295,7 +295,7 @@ static double MeasureTscFrequency() {
   return last_measurement;
 }
 
-#endif  // ABSL_INTERNAL_UNSCALED_CYCLECLOCK_FREQUENCY_IS_CPU_FREQUENCY
+#endif  // Y_ABSL_INTERNAL_UNSCALED_CYCLECLOCK_FREQUENCY_IS_CPU_FREQUENCY
 
 static double GetNominalCPUFrequency() {
   long freq = 0;
@@ -312,7 +312,7 @@ static double GetNominalCPUFrequency() {
     return freq * 1e3;  // Value is kHz.
   }
 
-#if defined(ABSL_INTERNAL_UNSCALED_CYCLECLOCK_FREQUENCY_IS_CPU_FREQUENCY)
+#if defined(Y_ABSL_INTERNAL_UNSCALED_CYCLECLOCK_FREQUENCY_IS_CPU_FREQUENCY)
   // On these platforms, the TSC frequency is the nominal CPU
   // frequency.  But without having the kernel export it directly
   // though /sys/devices/system/cpu/cpu0/tsc_freq_khz, there is no
@@ -335,13 +335,13 @@ static double GetNominalCPUFrequency() {
   }
 
   return 1.0;
-#endif  // !ABSL_INTERNAL_UNSCALED_CYCLECLOCK_FREQUENCY_IS_CPU_FREQUENCY
+#endif  // !Y_ABSL_INTERNAL_UNSCALED_CYCLECLOCK_FREQUENCY_IS_CPU_FREQUENCY
 }
 
 #endif
 
-ABSL_CONST_INIT static once_flag init_num_cpus_once;
-ABSL_CONST_INIT static int num_cpus = 0;
+Y_ABSL_CONST_INIT static once_flag init_num_cpus_once;
+Y_ABSL_CONST_INIT static int num_cpus = 0;
 
 // NumCPUs() may be called before main() and before malloc is properly
 // initialized, therefore this must not allocate memory.
@@ -352,8 +352,8 @@ int NumCPUs() {
 }
 
 // A default frequency of 0.0 might be dangerous if it is used in division.
-ABSL_CONST_INIT static once_flag init_nominal_cpu_frequency_once;
-ABSL_CONST_INIT static double nominal_cpu_frequency = 1.0;
+Y_ABSL_CONST_INIT static once_flag init_nominal_cpu_frequency_once;
+Y_ABSL_CONST_INIT static double nominal_cpu_frequency = 1.0;
 
 // NominalCPUFrequency() may be called before main() and before malloc is
 // properly initialized, therefore this must not allocate memory.
@@ -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_CONST_INIT static once_flag tid_once;
+Y_ABSL_CONST_INIT static pthread_key_t tid_key;
+Y_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;
+Y_ABSL_CONST_INIT static std::vector<uint32_t> *tid_array
+    Y_ABSL_GUARDED_BY(tid_lock) = nullptr;
 static constexpr int kBitsPerWord = 32;  // tid_array is uint32_t.
 
 // Returns the TID to tid_array.
@@ -495,14 +495,14 @@ pid_t GetTID() {
 // userspace construct) to avoid unnecessary system calls. Without this caching,
 // it can take roughly 98ns, while it takes roughly 1ns with this caching.
 pid_t GetCachedTID() {
-#ifdef ABSL_HAVE_THREAD_LOCAL
+#ifdef Y_ABSL_HAVE_THREAD_LOCAL
   static thread_local pid_t thread_id = GetTID();
   return thread_id;
 #else
   return GetTID();
-#endif  // ABSL_HAVE_THREAD_LOCAL
+#endif  // Y_ABSL_HAVE_THREAD_LOCAL
 }
 
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/sysinfo.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/sysinfo.h
index 0fd7207a38..026b4bffc9 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
@@ -21,8 +21,8 @@
 // All functions here are thread-hostile due to file caching unless
 // commented otherwise.
 
-#ifndef ABSL_BASE_INTERNAL_SYSINFO_H_
-#define ABSL_BASE_INTERNAL_SYSINFO_H_
+#ifndef Y_ABSL_BASE_INTERNAL_SYSINFO_H_
+#define Y_ABSL_BASE_INTERNAL_SYSINFO_H_
 
 #ifndef _WIN32
 #include <sys/types.h>
@@ -34,7 +34,7 @@
 #include "y_absl/base/port.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 
 // Nominal core processor cycles per second of each processor.   This is _not_
@@ -68,7 +68,7 @@ pid_t GetTID();
 pid_t GetCachedTID();
 
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_BASE_INTERNAL_SYSINFO_H_
+#endif  // Y_ABSL_BASE_INTERNAL_SYSINFO_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/thread_annotations.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/thread_annotations.h
index b4b01a8fb4..248affd621 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/thread_annotations.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/thread_annotations.h
@@ -35,8 +35,8 @@
 // you want to refer to is not in scope, you may use a member pointer
 // (e.g. &MyClass::mutex_) to refer to a mutex in some (unknown) object.
 
-#ifndef ABSL_BASE_INTERNAL_THREAD_ANNOTATIONS_H_
-#define ABSL_BASE_INTERNAL_THREAD_ANNOTATIONS_H_
+#ifndef Y_ABSL_BASE_INTERNAL_THREAD_ANNOTATIONS_H_
+#define Y_ABSL_BASE_INTERNAL_THREAD_ANNOTATIONS_H_
 
 #if defined(__clang__)
 #define THREAD_ANNOTATION_ATTRIBUTE__(x)   __attribute__((x))
@@ -249,7 +249,7 @@
 // Disables warnings for a single read operation.  This can be used to avoid
 // warnings when it is known that the read is not actually involved in a race,
 // but the compiler cannot confirm that.
-#define TS_UNCHECKED_READ(x) thread_safety_analysis::ts_unchecked_read(x)
+#define Y_TS_UNCHECKED_READ(x) thread_safety_analysis::y_ts_unchecked_read(x)
 
 
 namespace thread_safety_analysis {
@@ -257,15 +257,15 @@ namespace thread_safety_analysis {
 // Takes a reference to a guarded data member, and returns an unguarded
 // reference.
 template <typename T>
-inline const T& ts_unchecked_read(const T& v) NO_THREAD_SAFETY_ANALYSIS {
+inline const T& y_ts_unchecked_read(const T& v) NO_THREAD_SAFETY_ANALYSIS {
   return v;
 }
 
 template <typename T>
-inline T& ts_unchecked_read(T& v) NO_THREAD_SAFETY_ANALYSIS {
+inline T& y_ts_unchecked_read(T& v) NO_THREAD_SAFETY_ANALYSIS {
   return v;
 }
 
 }  // namespace thread_safety_analysis
 
-#endif  // ABSL_BASE_INTERNAL_THREAD_ANNOTATIONS_H_
+#endif  // Y_ABSL_BASE_INTERNAL_THREAD_ANNOTATIONS_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/thread_identity.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/thread_identity.cc
index b5e88ae302..9e67f0b964 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
@@ -29,10 +29,10 @@
 #include "y_absl/base/internal/spinlock.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 
-#if ABSL_THREAD_IDENTITY_MODE != ABSL_THREAD_IDENTITY_MODE_USE_CPP11
+#if Y_ABSL_THREAD_IDENTITY_MODE != Y_ABSL_THREAD_IDENTITY_MODE_USE_CPP11
 namespace {
 // Used to co-ordinate one-time creation of our pthread_key
 y_absl::once_flag init_thread_identity_key_once;
@@ -46,8 +46,8 @@ void AllocateThreadIdentityKey(ThreadIdentityReclaimerFunction reclaimer) {
 }  // namespace
 #endif
 
-#if ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_TLS || \
-    ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_CPP11
+#if Y_ABSL_THREAD_IDENTITY_MODE == Y_ABSL_THREAD_IDENTITY_MODE_USE_TLS || \
+    Y_ABSL_THREAD_IDENTITY_MODE == Y_ABSL_THREAD_IDENTITY_MODE_USE_CPP11
 // The actual TLS storage for a thread's currently associated ThreadIdentity.
 // This is referenced by inline accessors in the header.
 // "protected" visibility ensures that if multiple instances of Abseil code
@@ -56,15 +56,15 @@ void AllocateThreadIdentityKey(ThreadIdentityReclaimerFunction reclaimer) {
 // *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__)
+#if Y_ABSL_HAVE_ATTRIBUTE(visibility) && !defined(__APPLE__)
 __attribute__((visibility("protected")))
-#endif  // ABSL_HAVE_ATTRIBUTE(visibility) && !defined(__APPLE__)
-#if ABSL_PER_THREAD_TLS
+#endif  // Y_ABSL_HAVE_ATTRIBUTE(visibility) && !defined(__APPLE__)
+#if Y_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;
-#elif defined(ABSL_HAVE_THREAD_LOCAL)
+Y_ABSL_PER_THREAD_TLS_KEYWORD ThreadIdentity* thread_identity_ptr = nullptr;
+#elif defined(Y_ABSL_HAVE_THREAD_LOCAL)
 thread_local ThreadIdentity* thread_identity_ptr = nullptr;
-#endif  // ABSL_PER_THREAD_TLS
+#endif  // Y_ABSL_PER_THREAD_TLS
 #endif  // TLS or CPP11
 
 void SetCurrentThreadIdentity(
@@ -73,7 +73,7 @@ void SetCurrentThreadIdentity(
   // Associate our destructor.
   // NOTE: This call to pthread_setspecific is currently the only immovable
   // barrier to CurrentThreadIdentity() always being async signal safe.
-#if ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC
+#if Y_ABSL_THREAD_IDENTITY_MODE == Y_ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC
   // NOTE: Not async-safe.  But can be open-coded.
   y_absl::call_once(init_thread_identity_key_once, AllocateThreadIdentityKey,
                   reclaimer);
@@ -100,46 +100,46 @@ void SetCurrentThreadIdentity(
   pthread_sigmask(SIG_SETMASK, &curr_signals, nullptr);
 #endif  // !__EMSCRIPTEN__ && !__MINGW32__
 
-#elif ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_TLS
+#elif Y_ABSL_THREAD_IDENTITY_MODE == Y_ABSL_THREAD_IDENTITY_MODE_USE_TLS
   // NOTE: Not async-safe.  But can be open-coded.
   y_absl::call_once(init_thread_identity_key_once, AllocateThreadIdentityKey,
                   reclaimer);
   pthread_setspecific(thread_identity_pthread_key,
                       reinterpret_cast<void*>(identity));
   thread_identity_ptr = identity;
-#elif ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_CPP11
+#elif Y_ABSL_THREAD_IDENTITY_MODE == Y_ABSL_THREAD_IDENTITY_MODE_USE_CPP11
   thread_local std::unique_ptr<ThreadIdentity, ThreadIdentityReclaimerFunction>
       holder(identity, reclaimer);
   thread_identity_ptr = identity;
 #else
-#error Unimplemented ABSL_THREAD_IDENTITY_MODE
+#error Unimplemented Y_ABSL_THREAD_IDENTITY_MODE
 #endif
 }
 
-#if ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_TLS || \
-    ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_CPP11
+#if Y_ABSL_THREAD_IDENTITY_MODE == Y_ABSL_THREAD_IDENTITY_MODE_USE_TLS || \
+    Y_ABSL_THREAD_IDENTITY_MODE == Y_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
+#ifndef Y_ABSL_INTERNAL_INLINE_CURRENT_THREAD_IDENTITY_IF_PRESENT
 ThreadIdentity* CurrentThreadIdentityIfPresent() { return thread_identity_ptr; }
 #endif
 #endif
 
 void ClearCurrentThreadIdentity() {
-#if ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_TLS || \
-    ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_CPP11
+#if Y_ABSL_THREAD_IDENTITY_MODE == Y_ABSL_THREAD_IDENTITY_MODE_USE_TLS || \
+    Y_ABSL_THREAD_IDENTITY_MODE == Y_ABSL_THREAD_IDENTITY_MODE_USE_CPP11
   thread_identity_ptr = nullptr;
-#elif ABSL_THREAD_IDENTITY_MODE == \
-      ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC
+#elif Y_ABSL_THREAD_IDENTITY_MODE == \
+      Y_ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC
   // pthread_setspecific expected to clear value on destruction
   assert(CurrentThreadIdentityIfPresent() == nullptr);
 #endif
 }
 
-#if ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC
+#if Y_ABSL_THREAD_IDENTITY_MODE == Y_ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC
 ThreadIdentity* CurrentThreadIdentityIfPresent() {
   bool initialized = pthread_key_initialized.load(std::memory_order_acquire);
   if (!initialized) {
@@ -151,5 +151,5 @@ ThreadIdentity* CurrentThreadIdentityIfPresent() {
 #endif
 
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/thread_identity.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/thread_identity.h
index 09a6c0bce1..5556ba40b5 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
@@ -17,8 +17,8 @@
 // When a thread terminates, its ThreadIdentity object may be reused for a
 // thread created later.
 
-#ifndef ABSL_BASE_INTERNAL_THREAD_IDENTITY_H_
-#define ABSL_BASE_INTERNAL_THREAD_IDENTITY_H_
+#ifndef Y_ABSL_BASE_INTERNAL_THREAD_IDENTITY_H_
+#define Y_ABSL_BASE_INTERNAL_THREAD_IDENTITY_H_
 
 #ifndef _WIN32
 #include <pthread.h>
@@ -35,7 +35,7 @@
 #include "y_absl/base/optimization.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 struct SynchLocksHeld;
 struct SynchWaitParams;
@@ -187,51 +187,51 @@ void ClearCurrentThreadIdentity();
 
 // May be chosen at compile time via: -DABSL_FORCE_THREAD_IDENTITY_MODE=<mode
 // index>
-#ifdef ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC
-#error ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC cannot be directly set
+#ifdef Y_ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC
+#error Y_ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC cannot be directly set
 #else
-#define ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC 0
+#define Y_ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC 0
 #endif
 
-#ifdef ABSL_THREAD_IDENTITY_MODE_USE_TLS
-#error ABSL_THREAD_IDENTITY_MODE_USE_TLS cannot be directly set
+#ifdef Y_ABSL_THREAD_IDENTITY_MODE_USE_TLS
+#error Y_ABSL_THREAD_IDENTITY_MODE_USE_TLS cannot be directly set
 #else
-#define ABSL_THREAD_IDENTITY_MODE_USE_TLS 1
+#define Y_ABSL_THREAD_IDENTITY_MODE_USE_TLS 1
 #endif
 
-#ifdef ABSL_THREAD_IDENTITY_MODE_USE_CPP11
-#error ABSL_THREAD_IDENTITY_MODE_USE_CPP11 cannot be directly set
+#ifdef Y_ABSL_THREAD_IDENTITY_MODE_USE_CPP11
+#error Y_ABSL_THREAD_IDENTITY_MODE_USE_CPP11 cannot be directly set
 #else
-#define ABSL_THREAD_IDENTITY_MODE_USE_CPP11 2
+#define Y_ABSL_THREAD_IDENTITY_MODE_USE_CPP11 2
 #endif
 
-#ifdef ABSL_THREAD_IDENTITY_MODE
-#error ABSL_THREAD_IDENTITY_MODE cannot be directly set
-#elif defined(ABSL_FORCE_THREAD_IDENTITY_MODE)
-#define ABSL_THREAD_IDENTITY_MODE ABSL_FORCE_THREAD_IDENTITY_MODE
+#ifdef Y_ABSL_THREAD_IDENTITY_MODE
+#error Y_ABSL_THREAD_IDENTITY_MODE cannot be directly set
+#elif defined(Y_ABSL_FORCE_THREAD_IDENTITY_MODE)
+#define Y_ABSL_THREAD_IDENTITY_MODE Y_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__) &&        \
+#define Y_ABSL_THREAD_IDENTITY_MODE Y_ABSL_THREAD_IDENTITY_MODE_USE_CPP11
+#elif defined(__APPLE__) && defined(Y_ABSL_HAVE_THREAD_LOCAL)
+#define Y_ABSL_THREAD_IDENTITY_MODE Y_ABSL_THREAD_IDENTITY_MODE_USE_CPP11
+#elif Y_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.
 // Note:  Current default for production systems.
-#define ABSL_THREAD_IDENTITY_MODE ABSL_THREAD_IDENTITY_MODE_USE_TLS
+#define Y_ABSL_THREAD_IDENTITY_MODE Y_ABSL_THREAD_IDENTITY_MODE_USE_TLS
 #else
-#define ABSL_THREAD_IDENTITY_MODE \
-  ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC
+#define Y_ABSL_THREAD_IDENTITY_MODE \
+  Y_ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC
 #endif
 
-#if ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_TLS || \
-    ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_CPP11
+#if Y_ABSL_THREAD_IDENTITY_MODE == Y_ABSL_THREAD_IDENTITY_MODE_USE_TLS || \
+    Y_ABSL_THREAD_IDENTITY_MODE == Y_ABSL_THREAD_IDENTITY_MODE_USE_CPP11
 
-#if ABSL_PER_THREAD_TLS
-ABSL_CONST_INIT extern ABSL_PER_THREAD_TLS_KEYWORD ThreadIdentity*
+#if Y_ABSL_PER_THREAD_TLS
+Y_ABSL_CONST_INIT extern Y_ABSL_PER_THREAD_TLS_KEYWORD ThreadIdentity*
     thread_identity_ptr;
-#elif defined(ABSL_HAVE_THREAD_LOCAL)
-ABSL_CONST_INIT extern thread_local ThreadIdentity* thread_identity_ptr;
+#elif defined(Y_ABSL_HAVE_THREAD_LOCAL)
+Y_ABSL_CONST_INIT extern thread_local ThreadIdentity* thread_identity_ptr;
 #else
 #error Thread-local storage not detected on this platform
 #endif
@@ -242,24 +242,24 @@ ABSL_CONST_INIT extern thread_local ThreadIdentity* thread_identity_ptr;
 // 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
+#if !defined(__APPLE__) && !defined(Y_ABSL_BUILD_DLL) && \
+    !defined(Y_ABSL_CONSUME_DLL)
+#define Y_ABSL_INTERNAL_INLINE_CURRENT_THREAD_IDENTITY_IF_PRESENT 1
 #endif
 
-#ifdef ABSL_INTERNAL_INLINE_CURRENT_THREAD_IDENTITY_IF_PRESENT
+#ifdef Y_ABSL_INTERNAL_INLINE_CURRENT_THREAD_IDENTITY_IF_PRESENT
 inline ThreadIdentity* CurrentThreadIdentityIfPresent() {
   return thread_identity_ptr;
 }
 #endif
 
-#elif ABSL_THREAD_IDENTITY_MODE != \
-    ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC
-#error Unknown ABSL_THREAD_IDENTITY_MODE
+#elif Y_ABSL_THREAD_IDENTITY_MODE != \
+    Y_ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC
+#error Unknown Y_ABSL_THREAD_IDENTITY_MODE
 #endif
 
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_BASE_INTERNAL_THREAD_IDENTITY_H_
+#endif  // Y_ABSL_BASE_INTERNAL_THREAD_IDENTITY_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate.cc
index dcce5aedc3..e938d7dcc2 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
@@ -23,7 +23,7 @@
 #include "y_absl/base/internal/raw_logging.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 
 // NOTE: The various STL exception throwing functions are placed within the
@@ -31,7 +31,7 @@ namespace base_internal {
 // 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 Y_ABSL_HAVE_EXCEPTIONS
 template <typename T>
 [[noreturn]] void Throw(const T& error) {
   throw error;
@@ -40,159 +40,159 @@ template <typename T>
 }  // namespace
 
 void ThrowStdLogicError(const TString& what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef Y_ABSL_HAVE_EXCEPTIONS
   Throw(std::logic_error(what_arg));
 #else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str());
+  Y_ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str());
   std::abort();
 #endif
 }
 void ThrowStdLogicError(const char* what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef Y_ABSL_HAVE_EXCEPTIONS
   Throw(std::logic_error(what_arg));
 #else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg);
+  Y_ABSL_RAW_LOG(FATAL, "%s", what_arg);
   std::abort();
 #endif
 }
 void ThrowStdInvalidArgument(const TString& what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef Y_ABSL_HAVE_EXCEPTIONS
   Throw(std::invalid_argument(what_arg));
 #else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str());
+  Y_ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str());
   std::abort();
 #endif
 }
 void ThrowStdInvalidArgument(const char* what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef Y_ABSL_HAVE_EXCEPTIONS
   Throw(std::invalid_argument(what_arg));
 #else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg);
+  Y_ABSL_RAW_LOG(FATAL, "%s", what_arg);
   std::abort();
 #endif
 }
 
 void ThrowStdDomainError(const TString& what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef Y_ABSL_HAVE_EXCEPTIONS
   Throw(std::domain_error(what_arg));
 #else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str());
+  Y_ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str());
   std::abort();
 #endif
 }
 void ThrowStdDomainError(const char* what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef Y_ABSL_HAVE_EXCEPTIONS
   Throw(std::domain_error(what_arg));
 #else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg);
+  Y_ABSL_RAW_LOG(FATAL, "%s", what_arg);
   std::abort();
 #endif
 }
 
 void ThrowStdLengthError(const TString& what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef Y_ABSL_HAVE_EXCEPTIONS
   Throw(std::length_error(what_arg));
 #else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str());
+  Y_ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str());
   std::abort();
 #endif
 }
 void ThrowStdLengthError(const char* what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef Y_ABSL_HAVE_EXCEPTIONS
   Throw(std::length_error(what_arg));
 #else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg);
+  Y_ABSL_RAW_LOG(FATAL, "%s", what_arg);
   std::abort();
 #endif
 }
 
 void ThrowStdOutOfRange(const TString& what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef Y_ABSL_HAVE_EXCEPTIONS
   Throw(std::out_of_range(what_arg));
 #else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str());
+  Y_ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str());
   std::abort();
 #endif
 }
 void ThrowStdOutOfRange(const char* what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef Y_ABSL_HAVE_EXCEPTIONS
   Throw(std::out_of_range(what_arg));
 #else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg);
+  Y_ABSL_RAW_LOG(FATAL, "%s", what_arg);
   std::abort();
 #endif
 }
 
 void ThrowStdRuntimeError(const TString& what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef Y_ABSL_HAVE_EXCEPTIONS
   Throw(std::runtime_error(what_arg));
 #else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str());
+  Y_ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str());
   std::abort();
 #endif
 }
 void ThrowStdRuntimeError(const char* what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef Y_ABSL_HAVE_EXCEPTIONS
   Throw(std::runtime_error(what_arg));
 #else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg);
+  Y_ABSL_RAW_LOG(FATAL, "%s", what_arg);
   std::abort();
 #endif
 }
 
 void ThrowStdRangeError(const TString& what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef Y_ABSL_HAVE_EXCEPTIONS
   Throw(std::range_error(what_arg));
 #else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str());
+  Y_ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str());
   std::abort();
 #endif
 }
 void ThrowStdRangeError(const char* what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef Y_ABSL_HAVE_EXCEPTIONS
   Throw(std::range_error(what_arg));
 #else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg);
+  Y_ABSL_RAW_LOG(FATAL, "%s", what_arg);
   std::abort();
 #endif
 }
 
 void ThrowStdOverflowError(const TString& what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef Y_ABSL_HAVE_EXCEPTIONS
   Throw(std::overflow_error(what_arg));
 #else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str());
+  Y_ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str());
   std::abort();
 #endif
 }
 void ThrowStdOverflowError(const char* what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef Y_ABSL_HAVE_EXCEPTIONS
   Throw(std::overflow_error(what_arg));
 #else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg);
+  Y_ABSL_RAW_LOG(FATAL, "%s", what_arg);
   std::abort();
 #endif
 }
 
 void ThrowStdUnderflowError(const TString& what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef Y_ABSL_HAVE_EXCEPTIONS
   Throw(std::underflow_error(what_arg));
 #else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str());
+  Y_ABSL_RAW_LOG(FATAL, "%s", what_arg.c_str());
   std::abort();
 #endif
 }
 void ThrowStdUnderflowError(const char* what_arg) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef Y_ABSL_HAVE_EXCEPTIONS
   Throw(std::underflow_error(what_arg));
 #else
-  ABSL_RAW_LOG(FATAL, "%s", what_arg);
+  Y_ABSL_RAW_LOG(FATAL, "%s", what_arg);
   std::abort();
 #endif
 }
 
 void ThrowStdBadFunctionCall() {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef Y_ABSL_HAVE_EXCEPTIONS
   Throw(std::bad_function_call());
 #else
   std::abort();
@@ -200,7 +200,7 @@ void ThrowStdBadFunctionCall() {
 }
 
 void ThrowStdBadAlloc() {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef Y_ABSL_HAVE_EXCEPTIONS
   Throw(std::bad_alloc());
 #else
   std::abort();
@@ -208,5 +208,5 @@ void ThrowStdBadAlloc() {
 }
 
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate.h
index fda03a5db3..8f784fb115 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate.h
@@ -14,15 +14,15 @@
 // limitations under the License.
 //
 
-#ifndef ABSL_BASE_INTERNAL_THROW_DELEGATE_H_
-#define ABSL_BASE_INTERNAL_THROW_DELEGATE_H_
+#ifndef Y_ABSL_BASE_INTERNAL_THROW_DELEGATE_H_
+#define Y_ABSL_BASE_INTERNAL_THROW_DELEGATE_H_
 
 #include <util/generic/string.h>
 
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 
 // Helper functions that allow throwing exceptions consistently from anywhere.
@@ -69,7 +69,7 @@ namespace base_internal {
 // [[noreturn]] void ThrowStdBadArrayNewLength();
 
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_BASE_INTERNAL_THROW_DELEGATE_H_
+#endif  // Y_ABSL_BASE_INTERNAL_THROW_DELEGATE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/tsan_mutex_interface.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/tsan_mutex_interface.h
index 69a61d0814..7bdaf57dd7 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
@@ -16,53 +16,53 @@
 // It provides ThreadSanitizer annotations for custom mutexes.
 // See <sanitizer/tsan_interface.h> for meaning of these annotations.
 
-#ifndef ABSL_BASE_INTERNAL_TSAN_MUTEX_INTERFACE_H_
-#define ABSL_BASE_INTERNAL_TSAN_MUTEX_INTERFACE_H_
+#ifndef Y_ABSL_BASE_INTERNAL_TSAN_MUTEX_INTERFACE_H_
+#define Y_ABSL_BASE_INTERNAL_TSAN_MUTEX_INTERFACE_H_
 
 #include "y_absl/base/config.h"
 
-// ABSL_INTERNAL_HAVE_TSAN_INTERFACE
+// Y_ABSL_INTERNAL_HAVE_TSAN_INTERFACE
 // Macro intended only for internal use.
 //
 // Checks whether LLVM Thread Sanitizer interfaces are available.
 // First made available in LLVM 5.0 (Sep 2017).
-#ifdef ABSL_INTERNAL_HAVE_TSAN_INTERFACE
-#error "ABSL_INTERNAL_HAVE_TSAN_INTERFACE cannot be directly set."
+#ifdef Y_ABSL_INTERNAL_HAVE_TSAN_INTERFACE
+#error "Y_ABSL_INTERNAL_HAVE_TSAN_INTERFACE cannot be directly set."
 #endif
 
-#if defined(ABSL_HAVE_THREAD_SANITIZER) && defined(__has_include)
+#if defined(Y_ABSL_HAVE_THREAD_SANITIZER) && defined(__has_include)
 #if __has_include(<sanitizer/tsan_interface.h>)
-#define ABSL_INTERNAL_HAVE_TSAN_INTERFACE 1
+#define Y_ABSL_INTERNAL_HAVE_TSAN_INTERFACE 1
 #endif
 #endif
 
-#ifdef ABSL_INTERNAL_HAVE_TSAN_INTERFACE
+#ifdef Y_ABSL_INTERNAL_HAVE_TSAN_INTERFACE
 #include <sanitizer/tsan_interface.h>
 
-#define ABSL_TSAN_MUTEX_CREATE __tsan_mutex_create
-#define ABSL_TSAN_MUTEX_DESTROY __tsan_mutex_destroy
-#define ABSL_TSAN_MUTEX_PRE_LOCK __tsan_mutex_pre_lock
-#define ABSL_TSAN_MUTEX_POST_LOCK __tsan_mutex_post_lock
-#define ABSL_TSAN_MUTEX_PRE_UNLOCK __tsan_mutex_pre_unlock
-#define ABSL_TSAN_MUTEX_POST_UNLOCK __tsan_mutex_post_unlock
-#define ABSL_TSAN_MUTEX_PRE_SIGNAL __tsan_mutex_pre_signal
-#define ABSL_TSAN_MUTEX_POST_SIGNAL __tsan_mutex_post_signal
-#define ABSL_TSAN_MUTEX_PRE_DIVERT __tsan_mutex_pre_divert
-#define ABSL_TSAN_MUTEX_POST_DIVERT __tsan_mutex_post_divert
+#define Y_ABSL_TSAN_MUTEX_CREATE __tsan_mutex_create
+#define Y_ABSL_TSAN_MUTEX_DESTROY __tsan_mutex_destroy
+#define Y_ABSL_TSAN_MUTEX_PRE_LOCK __tsan_mutex_pre_lock
+#define Y_ABSL_TSAN_MUTEX_POST_LOCK __tsan_mutex_post_lock
+#define Y_ABSL_TSAN_MUTEX_PRE_UNLOCK __tsan_mutex_pre_unlock
+#define Y_ABSL_TSAN_MUTEX_POST_UNLOCK __tsan_mutex_post_unlock
+#define Y_ABSL_TSAN_MUTEX_PRE_SIGNAL __tsan_mutex_pre_signal
+#define Y_ABSL_TSAN_MUTEX_POST_SIGNAL __tsan_mutex_post_signal
+#define Y_ABSL_TSAN_MUTEX_PRE_DIVERT __tsan_mutex_pre_divert
+#define Y_ABSL_TSAN_MUTEX_POST_DIVERT __tsan_mutex_post_divert
 
 #else
 
-#define ABSL_TSAN_MUTEX_CREATE(...)
-#define ABSL_TSAN_MUTEX_DESTROY(...)
-#define ABSL_TSAN_MUTEX_PRE_LOCK(...)
-#define ABSL_TSAN_MUTEX_POST_LOCK(...)
-#define ABSL_TSAN_MUTEX_PRE_UNLOCK(...)
-#define ABSL_TSAN_MUTEX_POST_UNLOCK(...)
-#define ABSL_TSAN_MUTEX_PRE_SIGNAL(...)
-#define ABSL_TSAN_MUTEX_POST_SIGNAL(...)
-#define ABSL_TSAN_MUTEX_PRE_DIVERT(...)
-#define ABSL_TSAN_MUTEX_POST_DIVERT(...)
+#define Y_ABSL_TSAN_MUTEX_CREATE(...)
+#define Y_ABSL_TSAN_MUTEX_DESTROY(...)
+#define Y_ABSL_TSAN_MUTEX_PRE_LOCK(...)
+#define Y_ABSL_TSAN_MUTEX_POST_LOCK(...)
+#define Y_ABSL_TSAN_MUTEX_PRE_UNLOCK(...)
+#define Y_ABSL_TSAN_MUTEX_POST_UNLOCK(...)
+#define Y_ABSL_TSAN_MUTEX_PRE_SIGNAL(...)
+#define Y_ABSL_TSAN_MUTEX_POST_SIGNAL(...)
+#define Y_ABSL_TSAN_MUTEX_PRE_DIVERT(...)
+#define Y_ABSL_TSAN_MUTEX_POST_DIVERT(...)
 
 #endif
 
-#endif  // ABSL_BASE_INTERNAL_TSAN_MUTEX_INTERFACE_H_
+#endif  // Y_ABSL_BASE_INTERNAL_TSAN_MUTEX_INTERFACE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/unaligned_access.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/unaligned_access.h
index 7dbb23b1de..3820dde737 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/unaligned_access.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/unaligned_access.h
@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef ABSL_BASE_INTERNAL_UNALIGNED_ACCESS_H_
-#define ABSL_BASE_INTERNAL_UNALIGNED_ACCESS_H_
+#ifndef Y_ABSL_BASE_INTERNAL_UNALIGNED_ACCESS_H_
+#define Y_ABSL_BASE_INTERNAL_UNALIGNED_ACCESS_H_
 
 #include <string.h>
 
@@ -32,7 +32,7 @@
 // (namespaces, inline) which are absent or incompatible in C.
 #if defined(__cplusplus)
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 
 inline uint16_t UnalignedLoad16(const void *p) {
@@ -60,23 +60,23 @@ inline void UnalignedStore32(void *p, uint32_t v) { memcpy(p, &v, sizeof v); }
 inline void UnalignedStore64(void *p, uint64_t v) { memcpy(p, &v, sizeof v); }
 
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#define ABSL_INTERNAL_UNALIGNED_LOAD16(_p) \
+#define Y_ABSL_INTERNAL_UNALIGNED_LOAD16(_p) \
   (y_absl::base_internal::UnalignedLoad16(_p))
-#define ABSL_INTERNAL_UNALIGNED_LOAD32(_p) \
+#define Y_ABSL_INTERNAL_UNALIGNED_LOAD32(_p) \
   (y_absl::base_internal::UnalignedLoad32(_p))
-#define ABSL_INTERNAL_UNALIGNED_LOAD64(_p) \
+#define Y_ABSL_INTERNAL_UNALIGNED_LOAD64(_p) \
   (y_absl::base_internal::UnalignedLoad64(_p))
 
-#define ABSL_INTERNAL_UNALIGNED_STORE16(_p, _val) \
+#define Y_ABSL_INTERNAL_UNALIGNED_STORE16(_p, _val) \
   (y_absl::base_internal::UnalignedStore16(_p, _val))
-#define ABSL_INTERNAL_UNALIGNED_STORE32(_p, _val) \
+#define Y_ABSL_INTERNAL_UNALIGNED_STORE32(_p, _val) \
   (y_absl::base_internal::UnalignedStore32(_p, _val))
-#define ABSL_INTERNAL_UNALIGNED_STORE64(_p, _val) \
+#define Y_ABSL_INTERNAL_UNALIGNED_STORE64(_p, _val) \
   (y_absl::base_internal::UnalignedStore64(_p, _val))
 
 #endif  // defined(__cplusplus), end of unaligned API
 
-#endif  // ABSL_BASE_INTERNAL_UNALIGNED_ACCESS_H_
+#endif  // Y_ABSL_BASE_INTERNAL_UNALIGNED_ACCESS_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/unscaledcycleclock.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/unscaledcycleclock.cc
index 072a9852fa..dcbcb0c24d 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
@@ -14,7 +14,7 @@
 
 #include "y_absl/base/internal/unscaledcycleclock.h"
 
-#if ABSL_USE_UNSCALED_CYCLECLOCK
+#if Y_ABSL_USE_UNSCALED_CYCLECLOCK
 
 #if defined(_WIN32)
 #include <intrin.h>
@@ -32,7 +32,7 @@
 #include "y_absl/base/internal/sysinfo.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 
 #if defined(__i386__)
@@ -148,7 +148,7 @@ double UnscaledCycleClock::Frequency() {
 #endif
 
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_USE_UNSCALED_CYCLECLOCK
+#endif  // Y_ABSL_USE_UNSCALED_CYCLECLOCK
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/unscaledcycleclock.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/unscaledcycleclock.h
index 618c5c7e73..fd82752f78 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
@@ -33,8 +33,8 @@
 // The CPU is not required to maintain the ordering of a cycle counter read
 // with respect to surrounding instructions.
 
-#ifndef ABSL_BASE_INTERNAL_UNSCALEDCYCLECLOCK_H_
-#define ABSL_BASE_INTERNAL_UNSCALEDCYCLECLOCK_H_
+#ifndef Y_ABSL_BASE_INTERNAL_UNSCALEDCYCLECLOCK_H_
+#define Y_ABSL_BASE_INTERNAL_UNSCALEDCYCLECLOCK_H_
 
 #include <cstdint>
 
@@ -48,9 +48,9 @@
 #if defined(__i386__) || defined(__x86_64__) || defined(__aarch64__) || \
     defined(__powerpc__) || defined(__ppc__) || defined(__riscv) ||     \
     defined(_M_IX86) || defined(_M_X64)
-#define ABSL_HAVE_UNSCALED_CYCLECLOCK_IMPLEMENTATION 1
+#define Y_ABSL_HAVE_UNSCALED_CYCLECLOCK_IMPLEMENTATION 1
 #else
-#define ABSL_HAVE_UNSCALED_CYCLECLOCK_IMPLEMENTATION 0
+#define Y_ABSL_HAVE_UNSCALED_CYCLECLOCK_IMPLEMENTATION 0
 #endif
 
 // The following platforms often disable access to the hardware
@@ -62,31 +62,31 @@
 #if defined(__native_client__) ||                      \
     (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE) || \
     (defined(__ANDROID__) && defined(__aarch64__))
-#define ABSL_USE_UNSCALED_CYCLECLOCK_DEFAULT 0
+#define Y_ABSL_USE_UNSCALED_CYCLECLOCK_DEFAULT 0
 #else
-#define ABSL_USE_UNSCALED_CYCLECLOCK_DEFAULT 1
+#define Y_ABSL_USE_UNSCALED_CYCLECLOCK_DEFAULT 1
 #endif
 
 // UnscaledCycleClock is an optional internal feature.
-// Use "#if ABSL_USE_UNSCALED_CYCLECLOCK" to test for its presence.
+// Use "#if Y_ABSL_USE_UNSCALED_CYCLECLOCK" to test for its presence.
 // Can be overridden at compile-time via -DABSL_USE_UNSCALED_CYCLECLOCK=0|1
-#if !defined(ABSL_USE_UNSCALED_CYCLECLOCK)
-#define ABSL_USE_UNSCALED_CYCLECLOCK               \
-  (ABSL_HAVE_UNSCALED_CYCLECLOCK_IMPLEMENTATION && \
-   ABSL_USE_UNSCALED_CYCLECLOCK_DEFAULT)
+#if !defined(Y_ABSL_USE_UNSCALED_CYCLECLOCK)
+#define Y_ABSL_USE_UNSCALED_CYCLECLOCK               \
+  (Y_ABSL_HAVE_UNSCALED_CYCLECLOCK_IMPLEMENTATION && \
+   Y_ABSL_USE_UNSCALED_CYCLECLOCK_DEFAULT)
 #endif
 
-#if ABSL_USE_UNSCALED_CYCLECLOCK
+#if Y_ABSL_USE_UNSCALED_CYCLECLOCK
 
 // This macro can be used to test if UnscaledCycleClock::Frequency()
 // is NominalCPUFrequency() on a particular platform.
 #if (defined(__i386__) || defined(__x86_64__) || defined(__riscv) || \
      defined(_M_IX86) || defined(_M_X64))
-#define ABSL_INTERNAL_UNSCALED_CYCLECLOCK_FREQUENCY_IS_CPU_FREQUENCY
+#define Y_ABSL_INTERNAL_UNSCALED_CYCLECLOCK_FREQUENCY_IS_CPU_FREQUENCY
 #endif
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace time_internal {
 class UnscaledCycleClockWrapperForGetCurrentTime;
 }  // namespace time_internal
@@ -116,9 +116,9 @@ class UnscaledCycleClock {
 };
 
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_USE_UNSCALED_CYCLECLOCK
+#endif  // Y_ABSL_USE_UNSCALED_CYCLECLOCK
 
-#endif  // ABSL_BASE_INTERNAL_UNSCALEDCYCLECLOCK_H_
+#endif  // Y_ABSL_BASE_INTERNAL_UNSCALEDCYCLECLOCK_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity.cc
index 2ae8c75aec..3212ba04c9 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity.cc
@@ -17,11 +17,11 @@
 #include <ostream>
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 std::ostream& operator<<(std::ostream& os, y_absl::LogSeverity s) {
   if (s == y_absl::NormalizeLogSeverity(s)) return os << y_absl::LogSeverityName(s);
   return os << "y_absl::LogSeverity(" << static_cast<int>(s) << ")";
 }
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity.h
index 26f20ad8e1..07ee164f45 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 Y_ABSL_BASE_LOG_SEVERITY_H_
+#define Y_ABSL_BASE_LOG_SEVERITY_H_
 
 #include <array>
 #include <ostream>
@@ -22,7 +22,7 @@
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // y_absl::LogSeverity
 //
@@ -115,7 +115,7 @@ constexpr y_absl::LogSeverity NormalizeLogSeverity(int s) {
 // unspecified; do not rely on it.
 std::ostream& operator<<(std::ostream& os, y_absl::LogSeverity s);
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_BASE_LOG_SEVERITY_H_
+#endif  // Y_ABSL_BASE_LOG_SEVERITY_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/macros.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/macros.h
index b09a81877d..1caf95d46e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/macros.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/macros.h
@@ -25,8 +25,8 @@
 // platforms like Windows, Mac, and embedded systems.  Before making
 // any changes here, make sure that you're not breaking any platforms.
 
-#ifndef ABSL_BASE_MACROS_H_
-#define ABSL_BASE_MACROS_H_
+#ifndef Y_ABSL_BASE_MACROS_H_
+#define Y_ABSL_BASE_MACROS_H_
 
 #include <cassert>
 #include <cstddef>
@@ -36,26 +36,26 @@
 #include "y_absl/base/optimization.h"
 #include "y_absl/base/port.h"
 
-// ABSL_ARRAYSIZE()
+// Y_ABSL_ARRAYSIZE()
 //
 // Returns the number of elements in an array as a compile-time constant, which
 // can be used in defining new arrays. If you use this macro on a pointer by
 // mistake, you will get a compile-time error.
-#define ABSL_ARRAYSIZE(array) \
+#define Y_ABSL_ARRAYSIZE(array) \
   (sizeof(::y_absl::macros_internal::ArraySizeHelper(array)))
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace macros_internal {
-// Note: this internal template function declaration is used by ABSL_ARRAYSIZE.
+// Note: this internal template function declaration is used by Y_ABSL_ARRAYSIZE.
 // The function doesn't need a definition, as we only use its type.
 template <typename T, size_t N>
 auto ArraySizeHelper(const T (&array)[N]) -> char (&)[N];
 }  // namespace macros_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-// ABSL_BAD_CALL_IF()
+// Y_ABSL_BAD_CALL_IF()
 //
 // Used on a function overload to trap bad calls: any call that matches the
 // overload will cause a compile-time error. This macro uses a clang-specific
@@ -63,96 +63,96 @@ ABSL_NAMESPACE_END
 // https://clang.llvm.org/docs/AttributeReference.html#enable-if
 //
 // Overloads which use this macro should be bracketed by
-// `#ifdef ABSL_BAD_CALL_IF`.
+// `#ifdef Y_ABSL_BAD_CALL_IF`.
 //
 // Example:
 //
 //   int isdigit(int c);
-//   #ifdef ABSL_BAD_CALL_IF
+//   #ifdef Y_ABSL_BAD_CALL_IF
 //   int isdigit(int c)
-//     ABSL_BAD_CALL_IF(c <= -1 || c > 255,
+//     Y_ABSL_BAD_CALL_IF(c <= -1 || c > 255,
 //                       "'c' must have the value of an unsigned char or EOF");
-//   #endif // ABSL_BAD_CALL_IF
-#if ABSL_HAVE_ATTRIBUTE(enable_if)
-#define ABSL_BAD_CALL_IF(expr, msg) \
+//   #endif // Y_ABSL_BAD_CALL_IF
+#if Y_ABSL_HAVE_ATTRIBUTE(enable_if)
+#define Y_ABSL_BAD_CALL_IF(expr, msg) \
   __attribute__((enable_if(expr, "Bad call trap"), unavailable(msg)))
 #endif
 
-// ABSL_ASSERT()
+// Y_ABSL_ASSERT()
 //
 // In C++11, `assert` can't be used portably within constexpr functions.
-// ABSL_ASSERT functions as a runtime assert but works in C++11 constexpr
+// Y_ABSL_ASSERT functions as a runtime assert but works in C++11 constexpr
 // functions.  Example:
 //
 // constexpr double Divide(double a, double b) {
-//   return ABSL_ASSERT(b != 0), a / b;
+//   return Y_ABSL_ASSERT(b != 0), a / b;
 // }
 //
 // This macro is inspired by
 // https://akrzemi1.wordpress.com/2017/05/18/asserts-in-constexpr-functions/
 #if defined(NDEBUG)
-#define ABSL_ASSERT(expr) \
+#define Y_ABSL_ASSERT(expr) \
   (false ? static_cast<void>(expr) : static_cast<void>(0))
 #else
-#define ABSL_ASSERT(expr)                           \
-  (ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0) \
+#define Y_ABSL_ASSERT(expr)                           \
+  (Y_ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0) \
                              : [] { assert(false && #expr); }())  // NOLINT
 #endif
 
-// `ABSL_INTERNAL_HARDENING_ABORT()` controls how `ABSL_HARDENING_ASSERT()`
+// `Y_ABSL_INTERNAL_HARDENING_ABORT()` controls how `Y_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)) || \
+#if (Y_ABSL_HAVE_BUILTIN(__builtin_trap) &&         \
+     Y_ABSL_HAVE_BUILTIN(__builtin_unreachable)) || \
     (defined(__GNUC__) && !defined(__clang__))
-#define ABSL_INTERNAL_HARDENING_ABORT() \
+#define Y_ABSL_INTERNAL_HARDENING_ABORT() \
   do {                                  \
     __builtin_trap();                   \
     __builtin_unreachable();            \
   } while (false)
 #else
-#define ABSL_INTERNAL_HARDENING_ABORT() abort()
+#define Y_ABSL_INTERNAL_HARDENING_ABORT() abort()
 #endif
 
-// ABSL_HARDENING_ASSERT()
+// Y_ABSL_HARDENING_ASSERT()
 //
-// `ABSL_HARDENING_ASSERT()` is like `ABSL_ASSERT()`, but used to implement
+// `Y_ABSL_HARDENING_ASSERT()` is like `Y_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()`.
+// When `NDEBUG` is not defined, `Y_ABSL_HARDENING_ASSERT()` is identical to
+// `Y_ABSL_ASSERT()`.
 //
-// See `ABSL_OPTION_HARDENED` in `y_absl/base/options.h` for more information on
+// See `Y_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(); }())
+#if Y_ABSL_OPTION_HARDENED == 1 && defined(NDEBUG)
+#define Y_ABSL_HARDENING_ASSERT(expr)                 \
+  (Y_ABSL_PREDICT_TRUE((expr)) ? static_cast<void>(0) \
+                             : [] { Y_ABSL_INTERNAL_HARDENING_ABORT(); }())
 #else
-#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
+#define Y_ABSL_HARDENING_ASSERT(expr) Y_ABSL_ASSERT(expr)
 #endif
 
-#ifdef ABSL_HAVE_EXCEPTIONS
-#define ABSL_INTERNAL_TRY try
-#define ABSL_INTERNAL_CATCH_ANY catch (...)
-#define ABSL_INTERNAL_RETHROW do { throw; } while (false)
-#else  // ABSL_HAVE_EXCEPTIONS
-#define ABSL_INTERNAL_TRY if (true)
-#define ABSL_INTERNAL_CATCH_ANY else if (false)
-#define ABSL_INTERNAL_RETHROW do {} while (false)
-#endif  // ABSL_HAVE_EXCEPTIONS
+#ifdef Y_ABSL_HAVE_EXCEPTIONS
+#define Y_ABSL_INTERNAL_TRY try
+#define Y_ABSL_INTERNAL_CATCH_ANY catch (...)
+#define Y_ABSL_INTERNAL_RETHROW do { throw; } while (false)
+#else  // Y_ABSL_HAVE_EXCEPTIONS
+#define Y_ABSL_INTERNAL_TRY if (true)
+#define Y_ABSL_INTERNAL_CATCH_ANY else if (false)
+#define Y_ABSL_INTERNAL_RETHROW do {} while (false)
+#endif  // Y_ABSL_HAVE_EXCEPTIONS
 
-// `ABSL_INTERNAL_UNREACHABLE` is an unreachable statement.  A program which
+// `Y_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()
+#if defined(__GNUC__) || Y_ABSL_HAVE_BUILTIN(__builtin_unreachable)
+#define Y_ABSL_INTERNAL_UNREACHABLE __builtin_unreachable()
 #elif defined(_MSC_VER)
-#define ABSL_INTERNAL_UNREACHABLE __assume(0)
+#define Y_ABSL_INTERNAL_UNREACHABLE __assume(0)
 #else
-#define ABSL_INTERNAL_UNREACHABLE
+#define Y_ABSL_INTERNAL_UNREACHABLE
 #endif
 
-#endif  // ABSL_BASE_MACROS_H_
+#endif  // Y_ABSL_BASE_MACROS_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/optimization.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/optimization.h
index 501530ae30..72cf6ef8a2 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/optimization.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/optimization.h
@@ -19,14 +19,14 @@
 //
 // This header file defines portable macros for performance optimization.
 
-#ifndef ABSL_BASE_OPTIMIZATION_H_
-#define ABSL_BASE_OPTIMIZATION_H_
+#ifndef Y_ABSL_BASE_OPTIMIZATION_H_
+#define Y_ABSL_BASE_OPTIMIZATION_H_
 
 #include <assert.h>
 
 #include "y_absl/base/config.h"
 
-// ABSL_BLOCK_TAIL_CALL_OPTIMIZATION
+// Y_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
@@ -36,30 +36,30 @@
 //
 //   int f() {
 //     int result = g();
-//     ABSL_BLOCK_TAIL_CALL_OPTIMIZATION();
+//     Y_ABSL_BLOCK_TAIL_CALL_OPTIMIZATION();
 //     return result;
 //   }
 #if defined(__pnacl__)
-#define ABSL_BLOCK_TAIL_CALL_OPTIMIZATION() if (volatile int x = 0) { (void)x; }
+#define Y_ABSL_BLOCK_TAIL_CALL_OPTIMIZATION() if (volatile int x = 0) { (void)x; }
 #elif defined(__clang__)
 // Clang will not tail call given inline volatile assembly.
-#define ABSL_BLOCK_TAIL_CALL_OPTIMIZATION() __asm__ __volatile__("")
+#define Y_ABSL_BLOCK_TAIL_CALL_OPTIMIZATION() __asm__ __volatile__("")
 #elif defined(__GNUC__)
 // GCC will not tail call given inline volatile assembly.
-#define ABSL_BLOCK_TAIL_CALL_OPTIMIZATION() __asm__ __volatile__("")
+#define Y_ABSL_BLOCK_TAIL_CALL_OPTIMIZATION() __asm__ __volatile__("")
 #elif defined(_MSC_VER)
 #include <intrin.h>
 // The __nop() intrinsic blocks the optimisation.
-#define ABSL_BLOCK_TAIL_CALL_OPTIMIZATION() __nop()
+#define Y_ABSL_BLOCK_TAIL_CALL_OPTIMIZATION() __nop()
 #else
-#define ABSL_BLOCK_TAIL_CALL_OPTIMIZATION() if (volatile int x = 0) { (void)x; }
+#define Y_ABSL_BLOCK_TAIL_CALL_OPTIMIZATION() if (volatile int x = 0) { (void)x; }
 #endif
 
-// ABSL_CACHELINE_SIZE
+// Y_ABSL_CACHELINE_SIZE
 //
 // Explicitly defines the size of the L1 cache for purposes of alignment.
 // Setting the cacheline size allows you to specify that certain objects be
-// aligned on a cacheline boundary with `ABSL_CACHELINE_ALIGNED` declarations.
+// aligned on a cacheline boundary with `Y_ABSL_CACHELINE_ALIGNED` declarations.
 // (See below.)
 //
 // NOTE: this macro should be replaced with the following C++17 features, when
@@ -73,35 +73,35 @@
 #if defined(__GNUC__)
 // Cache line alignment
 #if defined(__i386__) || defined(__x86_64__)
-#define ABSL_CACHELINE_SIZE 64
+#define Y_ABSL_CACHELINE_SIZE 64
 #elif defined(__powerpc64__)
-#define ABSL_CACHELINE_SIZE 128
+#define Y_ABSL_CACHELINE_SIZE 128
 #elif defined(__aarch64__)
 // We would need to read special register ctr_el0 to find out L1 dcache size.
 // This value is a good estimate based on a real aarch64 machine.
-#define ABSL_CACHELINE_SIZE 64
+#define Y_ABSL_CACHELINE_SIZE 64
 #elif defined(__arm__)
 // Cache line sizes for ARM: These values are not strictly correct since
 // cache line sizes depend on implementations, not architectures.  There
 // are even implementations with cache line sizes configurable at boot
 // time.
 #if defined(__ARM_ARCH_5T__)
-#define ABSL_CACHELINE_SIZE 32
+#define Y_ABSL_CACHELINE_SIZE 32
 #elif defined(__ARM_ARCH_7A__)
-#define ABSL_CACHELINE_SIZE 64
+#define Y_ABSL_CACHELINE_SIZE 64
 #endif
 #endif
 
-#ifndef ABSL_CACHELINE_SIZE
+#ifndef Y_ABSL_CACHELINE_SIZE
 // A reasonable default guess.  Note that overestimates tend to waste more
 // space, while underestimates tend to waste more time.
-#define ABSL_CACHELINE_SIZE 64
+#define Y_ABSL_CACHELINE_SIZE 64
 #endif
 
-// ABSL_CACHELINE_ALIGNED
+// Y_ABSL_CACHELINE_ALIGNED
 //
 // Indicates that the declared object be cache aligned using
-// `ABSL_CACHELINE_SIZE` (see above). Cacheline aligning objects allows you to
+// `Y_ABSL_CACHELINE_SIZE` (see above). Cacheline aligning objects allows you to
 // load a set of related objects in the L1 cache for performance improvements.
 // Cacheline aligning objects properly allows constructive memory sharing and
 // prevents destructive (or "false") memory sharing.
@@ -114,7 +114,7 @@
 // See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0154r1.html
 // for more information.
 //
-// On some compilers, `ABSL_CACHELINE_ALIGNED` expands to an `__attribute__`
+// On some compilers, `Y_ABSL_CACHELINE_ALIGNED` expands to an `__attribute__`
 // or `__declspec` attribute. For compilers where this is not known to work,
 // the macro expands to nothing.
 //
@@ -129,9 +129,9 @@
 // this attribute, so prefer to put it at the beginning of your declaration.
 // For example,
 //
-//   ABSL_CACHELINE_ALIGNED static Foo* foo = ...
+//   Y_ABSL_CACHELINE_ALIGNED static Foo* foo = ...
 //
-//   class ABSL_CACHELINE_ALIGNED Bar { ...
+//   class Y_ABSL_CACHELINE_ALIGNED Bar { ...
 //
 // Recommendations:
 //
@@ -141,23 +141,23 @@
 //    the generated machine code.
 // 3) Prefer applying this attribute to individual variables. Avoid
 //    applying it to types. This tends to localize the effect.
-#define ABSL_CACHELINE_ALIGNED __attribute__((aligned(ABSL_CACHELINE_SIZE)))
+#define Y_ABSL_CACHELINE_ALIGNED __attribute__((aligned(Y_ABSL_CACHELINE_SIZE)))
 #elif defined(_MSC_VER)
-#define ABSL_CACHELINE_SIZE 64
-#define ABSL_CACHELINE_ALIGNED __declspec(align(ABSL_CACHELINE_SIZE))
+#define Y_ABSL_CACHELINE_SIZE 64
+#define Y_ABSL_CACHELINE_ALIGNED __declspec(align(Y_ABSL_CACHELINE_SIZE))
 #else
-#define ABSL_CACHELINE_SIZE 64
-#define ABSL_CACHELINE_ALIGNED
+#define Y_ABSL_CACHELINE_SIZE 64
+#define Y_ABSL_CACHELINE_ALIGNED
 #endif
 
-// ABSL_PREDICT_TRUE, ABSL_PREDICT_FALSE
+// Y_ABSL_PREDICT_TRUE, Y_ABSL_PREDICT_FALSE
 //
 // Enables the compiler to prioritize compilation using static analysis for
 // likely paths within a boolean branch.
 //
 // Example:
 //
-//   if (ABSL_PREDICT_TRUE(expression)) {
+//   if (Y_ABSL_PREDICT_TRUE(expression)) {
 //     return result;                        // Faster if more likely
 //   } else {
 //     return 0;
@@ -172,16 +172,16 @@
 // branch in a codebase is likely counterproductive; however, annotating
 // specific branches that are both hot and consistently mispredicted is likely
 // to yield performance improvements.
-#if ABSL_HAVE_BUILTIN(__builtin_expect) || \
+#if Y_ABSL_HAVE_BUILTIN(__builtin_expect) || \
     (defined(__GNUC__) && !defined(__clang__))
-#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
-#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
+#define Y_ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
+#define Y_ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
 #else
-#define ABSL_PREDICT_FALSE(x) (x)
-#define ABSL_PREDICT_TRUE(x) (x)
+#define Y_ABSL_PREDICT_FALSE(x) (x)
+#define Y_ABSL_PREDICT_TRUE(x) (x)
 #endif
 
-// ABSL_INTERNAL_ASSUME(cond)
+// Y_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.
@@ -192,30 +192,30 @@
 // Example:
 //
 //   int x = ...;
-//   ABSL_INTERNAL_ASSUME(x >= 0);
+//   Y_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)        \
+#define Y_ABSL_INTERNAL_ASSUME(cond) assert(cond)
+#elif Y_ABSL_HAVE_BUILTIN(__builtin_assume)
+#define Y_ABSL_INTERNAL_ASSUME(cond) __builtin_assume(cond)
+#elif defined(__GNUC__) || Y_ABSL_HAVE_BUILTIN(__builtin_unreachable)
+#define Y_ABSL_INTERNAL_ASSUME(cond)        \
   do {                                    \
     if (!(cond)) __builtin_unreachable(); \
   } while (0)
 #elif defined(_MSC_VER)
-#define ABSL_INTERNAL_ASSUME(cond) __assume(cond)
+#define Y_ABSL_INTERNAL_ASSUME(cond) __assume(cond)
 #else
-#define ABSL_INTERNAL_ASSUME(cond)      \
+#define Y_ABSL_INTERNAL_ASSUME(cond)      \
   do {                                  \
     static_cast<void>(false && (cond)); \
   } while (0)
 #endif
 
-// ABSL_INTERNAL_UNIQUE_SMALL_NAME(cond)
+// Y_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
@@ -226,19 +226,19 @@
 //
 // #define MY_MACRO(txt)
 // namespace {
-//  char VeryVeryLongVarName[] ABSL_INTERNAL_UNIQUE_SMALL_NAME() = txt;
-//  const char* VeryVeryLongFuncName() ABSL_INTERNAL_UNIQUE_SMALL_NAME();
+//  char VeryVeryLongVarName[] Y_ABSL_INTERNAL_UNIQUE_SMALL_NAME() = txt;
+//  const char* VeryVeryLongFuncName() Y_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__))
+#define Y_ABSL_INTERNAL_UNIQUE_SMALL_NAME2(x) #x
+#define Y_ABSL_INTERNAL_UNIQUE_SMALL_NAME1(x) Y_ABSL_INTERNAL_UNIQUE_SMALL_NAME2(x)
+#define Y_ABSL_INTERNAL_UNIQUE_SMALL_NAME() \
+  asm(Y_ABSL_INTERNAL_UNIQUE_SMALL_NAME1(.y_absl.__COUNTER__))
 #else
-#define ABSL_INTERNAL_UNIQUE_SMALL_NAME()
+#define Y_ABSL_INTERNAL_UNIQUE_SMALL_NAME()
 #endif
 
-#endif  // ABSL_BASE_OPTIMIZATION_H_
+#endif  // Y_ABSL_BASE_OPTIMIZATION_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/options.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/options.h
index 906310cde0..05f05f9410 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/options.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/options.h
@@ -64,8 +64,8 @@
 // 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 Y_ABSL_BASE_OPTIONS_H_
+#define Y_ABSL_BASE_OPTIONS_H_
 
 // Include a standard library header to allow configuration based on the
 // standard library in use.
@@ -77,7 +77,7 @@
 // Type Compatibility Options
 // -----------------------------------------------------------------------------
 //
-// ABSL_OPTION_USE_STD_ANY
+// Y_ABSL_OPTION_USE_STD_ANY
 //
 // This option controls whether y_absl::any is implemented as an alias to
 // std::any, or as an independent implementation.
@@ -98,12 +98,12 @@
 // For more info, see https://abseil.io/about/design/dropin-types.
 //
 // User code should not inspect this macro.  To check in the preprocessor if
-// y_absl::any is a typedef of std::any, use the feature macro ABSL_USES_STD_ANY.
+// y_absl::any is a typedef of std::any, use the feature macro Y_ABSL_USES_STD_ANY.
 
-#define ABSL_OPTION_USE_STD_ANY 2
+#define Y_ABSL_OPTION_USE_STD_ANY 2
 
 
-// ABSL_OPTION_USE_STD_OPTIONAL
+// Y_ABSL_OPTION_USE_STD_OPTIONAL
 //
 // This option controls whether y_absl::optional is implemented as an alias to
 // std::optional, or as an independent implementation.
@@ -125,12 +125,12 @@
 
 // User code should not inspect this macro.  To check in the preprocessor if
 // y_absl::optional is a typedef of std::optional, use the feature macro
-// ABSL_USES_STD_OPTIONAL.
+// Y_ABSL_USES_STD_OPTIONAL.
 
-#define ABSL_OPTION_USE_STD_OPTIONAL 2
+#define Y_ABSL_OPTION_USE_STD_OPTIONAL 2
 
 
-// ABSL_OPTION_USE_STD_STRING_VIEW
+// Y_ABSL_OPTION_USE_STD_STRING_VIEW
 //
 // This option controls whether y_absl::string_view is implemented as an alias to
 // std::string_view, or as an independent implementation.
@@ -152,11 +152,11 @@
 //
 // User code should not inspect this macro.  To check in the preprocessor if
 // y_absl::string_view is a typedef of std::string_view, use the feature macro
-// ABSL_USES_STD_STRING_VIEW.
+// Y_ABSL_USES_STD_STRING_VIEW.
 
-#define ABSL_OPTION_USE_STD_STRING_VIEW 2
+#define Y_ABSL_OPTION_USE_STD_STRING_VIEW 2
 
-// ABSL_OPTION_USE_STD_VARIANT
+// Y_ABSL_OPTION_USE_STD_VARIANT
 //
 // This option controls whether y_absl::variant is implemented as an alias to
 // std::variant, or as an independent implementation.
@@ -178,13 +178,13 @@
 //
 // User code should not inspect this macro.  To check in the preprocessor if
 // y_absl::variant is a typedef of std::variant, use the feature macro
-// ABSL_USES_STD_VARIANT.
+// Y_ABSL_USES_STD_VARIANT.
 
-#define ABSL_OPTION_USE_STD_VARIANT 2
+#define Y_ABSL_OPTION_USE_STD_VARIANT 2
 
 
-// ABSL_OPTION_USE_INLINE_NAMESPACE
-// ABSL_OPTION_INLINE_NAMESPACE_NAME
+// Y_ABSL_OPTION_USE_INLINE_NAMESPACE
+// Y_ABSL_OPTION_INLINE_NAMESPACE_NAME
 //
 // These options controls whether all entities in the y_absl namespace are
 // contained within an inner inline namespace.  This does not affect the
@@ -201,14 +201,14 @@
 // A value of 0 means not to use inline namespaces.
 //
 // A value of 1 means to use an inline namespace with the given name inside
-// namespace y_absl.  If this is set, ABSL_OPTION_INLINE_NAMESPACE_NAME must also
+// namespace y_absl.  If this is set, Y_ABSL_OPTION_INLINE_NAMESPACE_NAME must also
 // be changed to a new, unique identifier name.  In particular "head" is not
 // allowed.
 
-#define ABSL_OPTION_USE_INLINE_NAMESPACE 1
-#define ABSL_OPTION_INLINE_NAMESPACE_NAME lts_y_20211102
+#define Y_ABSL_OPTION_USE_INLINE_NAMESPACE 1
+#define Y_ABSL_OPTION_INLINE_NAMESPACE_NAME lts_y_20211102
 
-// ABSL_OPTION_HARDENED
+// Y_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).
@@ -220,7 +220,7 @@
 // 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
+// defining Y_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
@@ -229,10 +229,10 @@
 // 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
+// defined, even in the case when Y_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
+#define Y_ABSL_OPTION_HARDENED 0
 
-#endif  // ABSL_BASE_OPTIONS_H_
+#endif  // Y_ABSL_BASE_OPTIONS_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/policy_checks.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/policy_checks.h
index 06b3243916..77b7dca964 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
@@ -21,8 +21,8 @@
 // reported with `#error`. This enforcement is best effort, so successfully
 // compiling this header does not guarantee a supported configuration.
 
-#ifndef ABSL_BASE_POLICY_CHECKS_H_
-#define ABSL_BASE_POLICY_CHECKS_H_
+#ifndef Y_ABSL_BASE_POLICY_CHECKS_H_
+#define Y_ABSL_BASE_POLICY_CHECKS_H_
 
 // Included for the __GLIBC_PREREQ macro used below.
 #include <limits.h>
@@ -108,4 +108,4 @@
 #error "Abseil assumes that int is at least 4 bytes. "
 #endif
 
-#endif  // ABSL_BASE_POLICY_CHECKS_H_
+#endif  // Y_ABSL_BASE_POLICY_CHECKS_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/port.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/port.h
index 69ec795d46..f627abeb03 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/base/port.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/base/port.h
@@ -15,11 +15,11 @@
 // This files is a forwarding header for other headers containing various
 // portability macros and functions.
 
-#ifndef ABSL_BASE_PORT_H_
-#define ABSL_BASE_PORT_H_
+#ifndef Y_ABSL_BASE_PORT_H_
+#define Y_ABSL_BASE_PORT_H_
 
 #include "y_absl/base/attributes.h"
 #include "y_absl/base/config.h"
 #include "y_absl/base/optimization.h"
 
-#endif  // ABSL_BASE_PORT_H_
+#endif  // Y_ABSL_BASE_PORT_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/base/thread_annotations.h b/contrib/restricted/abseil-cpp-tstring/y_absl/base/thread_annotations.h
index aba5d58dc3..25427b419a 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
@@ -31,21 +31,21 @@
 // you want to refer to is not in scope, you may use a member pointer
 // (e.g. &MyClass::mutex_) to refer to a mutex in some (unknown) object.
 
-#ifndef ABSL_BASE_THREAD_ANNOTATIONS_H_
-#define ABSL_BASE_THREAD_ANNOTATIONS_H_
+#ifndef Y_ABSL_BASE_THREAD_ANNOTATIONS_H_
+#define Y_ABSL_BASE_THREAD_ANNOTATIONS_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
 
-// ABSL_GUARDED_BY()
+// Y_ABSL_GUARDED_BY()
 //
 // Documents if a shared field or global variable needs to be protected by a
-// mutex. ABSL_GUARDED_BY() allows the user to specify a particular mutex that
+// mutex. Y_ABSL_GUARDED_BY() allows the user to specify a particular mutex that
 // should be held when accessing the annotated variable.
 //
-// Although this annotation (and ABSL_PT_GUARDED_BY, below) cannot be applied to
+// Although this annotation (and Y_ABSL_PT_GUARDED_BY, below) cannot be applied to
 // local variables, a local variable and its associated mutex can often be
 // combined into a small class or struct, thereby allowing the annotation.
 //
@@ -53,16 +53,16 @@
 //
 //   class Foo {
 //     Mutex mu_;
-//     int p1_ ABSL_GUARDED_BY(mu_);
+//     int p1_ Y_ABSL_GUARDED_BY(mu_);
 //     ...
 //   };
-#if ABSL_HAVE_ATTRIBUTE(guarded_by)
-#define ABSL_GUARDED_BY(x) __attribute__((guarded_by(x)))
+#if Y_ABSL_HAVE_ATTRIBUTE(guarded_by)
+#define Y_ABSL_GUARDED_BY(x) __attribute__((guarded_by(x)))
 #else
-#define ABSL_GUARDED_BY(x)
+#define Y_ABSL_GUARDED_BY(x)
 #endif
 
-// ABSL_PT_GUARDED_BY()
+// Y_ABSL_PT_GUARDED_BY()
 //
 // Documents if the memory location pointed to by a pointer should be guarded
 // by a mutex when dereferencing the pointer.
@@ -70,7 +70,7 @@
 // Example:
 //   class Foo {
 //     Mutex mu_;
-//     int *p1_ ABSL_PT_GUARDED_BY(mu_);
+//     int *p1_ Y_ABSL_PT_GUARDED_BY(mu_);
 //     ...
 //   };
 //
@@ -81,41 +81,41 @@
 //
 //   // `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)))
+//   int *q_ Y_ABSL_GUARDED_BY(mu1_) Y_ABSL_PT_GUARDED_BY(mu2_);
+#if Y_ABSL_HAVE_ATTRIBUTE(pt_guarded_by)
+#define Y_ABSL_PT_GUARDED_BY(x) __attribute__((pt_guarded_by(x)))
 #else
-#define ABSL_PT_GUARDED_BY(x)
+#define Y_ABSL_PT_GUARDED_BY(x)
 #endif
 
-// ABSL_ACQUIRED_AFTER() / ABSL_ACQUIRED_BEFORE()
+// Y_ABSL_ACQUIRED_AFTER() / Y_ABSL_ACQUIRED_BEFORE()
 //
 // Documents the acquisition order between locks that can be held
 // simultaneously by a thread. For any two locks that need to be annotated
 // to establish an acquisition order, only one of them needs the annotation.
-// (i.e. You don't have to annotate both locks with both ABSL_ACQUIRED_AFTER
-// and ABSL_ACQUIRED_BEFORE.)
+// (i.e. You don't have to annotate both locks with both Y_ABSL_ACQUIRED_AFTER
+// and Y_ABSL_ACQUIRED_BEFORE.)
 //
-// As with ABSL_GUARDED_BY, this is only applicable to mutexes that are shared
+// As with Y_ABSL_GUARDED_BY, this is only applicable to mutexes that are shared
 // fields or global variables.
 //
 // Example:
 //
 //   Mutex m1_;
-//   Mutex m2_ ABSL_ACQUIRED_AFTER(m1_);
-#if ABSL_HAVE_ATTRIBUTE(acquired_after)
-#define ABSL_ACQUIRED_AFTER(...) __attribute__((acquired_after(__VA_ARGS__)))
+//   Mutex m2_ Y_ABSL_ACQUIRED_AFTER(m1_);
+#if Y_ABSL_HAVE_ATTRIBUTE(acquired_after)
+#define Y_ABSL_ACQUIRED_AFTER(...) __attribute__((acquired_after(__VA_ARGS__)))
 #else
-#define ABSL_ACQUIRED_AFTER(...)
+#define Y_ABSL_ACQUIRED_AFTER(...)
 #endif
 
-#if ABSL_HAVE_ATTRIBUTE(acquired_before)
-#define ABSL_ACQUIRED_BEFORE(...) __attribute__((acquired_before(__VA_ARGS__)))
+#if Y_ABSL_HAVE_ATTRIBUTE(acquired_before)
+#define Y_ABSL_ACQUIRED_BEFORE(...) __attribute__((acquired_before(__VA_ARGS__)))
 #else
-#define ABSL_ACQUIRED_BEFORE(...)
+#define Y_ABSL_ACQUIRED_BEFORE(...)
 #endif
 
-// ABSL_EXCLUSIVE_LOCKS_REQUIRED() / ABSL_SHARED_LOCKS_REQUIRED()
+// Y_ABSL_EXCLUSIVE_LOCKS_REQUIRED() / Y_ABSL_SHARED_LOCKS_REQUIRED()
 //
 // Documents a function that expects a mutex to be held prior to entry.
 // The mutex is expected to be held both on entry to, and exit from, the
@@ -127,108 +127,108 @@
 // concurrently.
 //
 // Generally, non-const methods should be annotated with
-// ABSL_EXCLUSIVE_LOCKS_REQUIRED, while const methods should be annotated with
-// ABSL_SHARED_LOCKS_REQUIRED.
+// Y_ABSL_EXCLUSIVE_LOCKS_REQUIRED, while const methods should be annotated with
+// Y_ABSL_SHARED_LOCKS_REQUIRED.
 //
 // Example:
 //
 //   Mutex mu1, mu2;
-//   int a ABSL_GUARDED_BY(mu1);
-//   int b ABSL_GUARDED_BY(mu2);
+//   int a Y_ABSL_GUARDED_BY(mu1);
+//   int b Y_ABSL_GUARDED_BY(mu2);
 //
-//   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(...) \
+//   void foo() Y_ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu1, mu2) { ... }
+//   void bar() const Y_ABSL_SHARED_LOCKS_REQUIRED(mu1, mu2) { ... }
+#if Y_ABSL_HAVE_ATTRIBUTE(exclusive_locks_required)
+#define Y_ABSL_EXCLUSIVE_LOCKS_REQUIRED(...) \
   __attribute__((exclusive_locks_required(__VA_ARGS__)))
 #else
-#define ABSL_EXCLUSIVE_LOCKS_REQUIRED(...)
+#define Y_ABSL_EXCLUSIVE_LOCKS_REQUIRED(...)
 #endif
 
-#if ABSL_HAVE_ATTRIBUTE(shared_locks_required)
-#define ABSL_SHARED_LOCKS_REQUIRED(...) \
+#if Y_ABSL_HAVE_ATTRIBUTE(shared_locks_required)
+#define Y_ABSL_SHARED_LOCKS_REQUIRED(...) \
   __attribute__((shared_locks_required(__VA_ARGS__)))
 #else
-#define ABSL_SHARED_LOCKS_REQUIRED(...)
+#define Y_ABSL_SHARED_LOCKS_REQUIRED(...)
 #endif
 
-// ABSL_LOCKS_EXCLUDED()
+// Y_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__)))
+#if Y_ABSL_HAVE_ATTRIBUTE(locks_excluded)
+#define Y_ABSL_LOCKS_EXCLUDED(...) __attribute__((locks_excluded(__VA_ARGS__)))
 #else
-#define ABSL_LOCKS_EXCLUDED(...)
+#define Y_ABSL_LOCKS_EXCLUDED(...)
 #endif
 
-// ABSL_LOCK_RETURNED()
+// Y_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)))
+// be annotated with Y_ABSL_LOCK_RETURNED.
+#if Y_ABSL_HAVE_ATTRIBUTE(lock_returned)
+#define Y_ABSL_LOCK_RETURNED(x) __attribute__((lock_returned(x)))
 #else
-#define ABSL_LOCK_RETURNED(x)
+#define Y_ABSL_LOCK_RETURNED(x)
 #endif
 
-// ABSL_LOCKABLE
+// Y_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))
+#if Y_ABSL_HAVE_ATTRIBUTE(lockable)
+#define Y_ABSL_LOCKABLE __attribute__((lockable))
 #else
-#define ABSL_LOCKABLE
+#define Y_ABSL_LOCKABLE
 #endif
 
-// ABSL_SCOPED_LOCKABLE
+// Y_ABSL_SCOPED_LOCKABLE
 //
 // Documents if a class does RAII locking (such as the `MutexLock` class).
 // The constructor should use `LOCK_FUNCTION()` to specify the mutex that is
 // 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))
+#if Y_ABSL_HAVE_ATTRIBUTE(scoped_lockable)
+#define Y_ABSL_SCOPED_LOCKABLE __attribute__((scoped_lockable))
 #else
-#define ABSL_SCOPED_LOCKABLE
+#define Y_ABSL_SCOPED_LOCKABLE
 #endif
 
-// ABSL_EXCLUSIVE_LOCK_FUNCTION()
+// Y_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(...) \
+#if Y_ABSL_HAVE_ATTRIBUTE(exclusive_lock_function)
+#define Y_ABSL_EXCLUSIVE_LOCK_FUNCTION(...) \
   __attribute__((exclusive_lock_function(__VA_ARGS__)))
 #else
-#define ABSL_EXCLUSIVE_LOCK_FUNCTION(...)
+#define Y_ABSL_EXCLUSIVE_LOCK_FUNCTION(...)
 #endif
 
-// ABSL_SHARED_LOCK_FUNCTION()
+// Y_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)
-#define ABSL_SHARED_LOCK_FUNCTION(...) \
+#if Y_ABSL_HAVE_ATTRIBUTE(shared_lock_function)
+#define Y_ABSL_SHARED_LOCK_FUNCTION(...) \
   __attribute__((shared_lock_function(__VA_ARGS__)))
 #else
-#define ABSL_SHARED_LOCK_FUNCTION(...)
+#define Y_ABSL_SHARED_LOCK_FUNCTION(...)
 #endif
 
-// ABSL_UNLOCK_FUNCTION()
+// Y_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__)))
+#if Y_ABSL_HAVE_ATTRIBUTE(unlock_function)
+#define Y_ABSL_UNLOCK_FUNCTION(...) __attribute__((unlock_function(__VA_ARGS__)))
 #else
-#define ABSL_UNLOCK_FUNCTION(...)
+#define Y_ABSL_UNLOCK_FUNCTION(...)
 #endif
 
-// ABSL_EXCLUSIVE_TRYLOCK_FUNCTION() / ABSL_SHARED_TRYLOCK_FUNCTION()
+// Y_ABSL_EXCLUSIVE_TRYLOCK_FUNCTION() / Y_ABSL_SHARED_TRYLOCK_FUNCTION()
 //
 // Documents functions that try to acquire a lock, and return success or failure
 // (or a non-boolean value that can be interpreted as a boolean).
@@ -236,100 +236,100 @@
 // 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)
-#define ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(...) \
+#if Y_ABSL_HAVE_ATTRIBUTE(exclusive_trylock_function)
+#define Y_ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(...) \
   __attribute__((exclusive_trylock_function(__VA_ARGS__)))
 #else
-#define ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(...)
+#define Y_ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(...)
 #endif
 
-#if ABSL_HAVE_ATTRIBUTE(shared_trylock_function)
-#define ABSL_SHARED_TRYLOCK_FUNCTION(...) \
+#if Y_ABSL_HAVE_ATTRIBUTE(shared_trylock_function)
+#define Y_ABSL_SHARED_TRYLOCK_FUNCTION(...) \
   __attribute__((shared_trylock_function(__VA_ARGS__)))
 #else
-#define ABSL_SHARED_TRYLOCK_FUNCTION(...)
+#define Y_ABSL_SHARED_TRYLOCK_FUNCTION(...)
 #endif
 
-// ABSL_ASSERT_EXCLUSIVE_LOCK() / ABSL_ASSERT_SHARED_LOCK()
+// Y_ABSL_ASSERT_EXCLUSIVE_LOCK() / Y_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)
-#define ABSL_ASSERT_EXCLUSIVE_LOCK(...) \
+#if Y_ABSL_HAVE_ATTRIBUTE(assert_exclusive_lock)
+#define Y_ABSL_ASSERT_EXCLUSIVE_LOCK(...) \
   __attribute__((assert_exclusive_lock(__VA_ARGS__)))
 #else
-#define ABSL_ASSERT_EXCLUSIVE_LOCK(...)
+#define Y_ABSL_ASSERT_EXCLUSIVE_LOCK(...)
 #endif
 
-#if ABSL_HAVE_ATTRIBUTE(assert_shared_lock)
-#define ABSL_ASSERT_SHARED_LOCK(...) \
+#if Y_ABSL_HAVE_ATTRIBUTE(assert_shared_lock)
+#define Y_ABSL_ASSERT_SHARED_LOCK(...) \
   __attribute__((assert_shared_lock(__VA_ARGS__)))
 #else
-#define ABSL_ASSERT_SHARED_LOCK(...)
+#define Y_ABSL_ASSERT_SHARED_LOCK(...)
 #endif
 
-// ABSL_NO_THREAD_SAFETY_ANALYSIS
+// Y_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)
-#define ABSL_NO_THREAD_SAFETY_ANALYSIS \
+#if Y_ABSL_HAVE_ATTRIBUTE(no_thread_safety_analysis)
+#define Y_ABSL_NO_THREAD_SAFETY_ANALYSIS \
   __attribute__((no_thread_safety_analysis))
 #else
-#define ABSL_NO_THREAD_SAFETY_ANALYSIS
+#define Y_ABSL_NO_THREAD_SAFETY_ANALYSIS
 #endif
 
 //------------------------------------------------------------------------------
 // Tool-Supplied Annotations
 //------------------------------------------------------------------------------
 
-// ABSL_TS_UNCHECKED should be placed around lock expressions that are not valid
+// Y_ABSL_TS_UNCHECKED should be placed around lock expressions that are not valid
 // C++ syntax, but which are present for documentation purposes.  These
 // annotations will be ignored by the analysis.
-#define ABSL_TS_UNCHECKED(x) ""
+#define Y_ABSL_TS_UNCHECKED(x) ""
 
-// ABSL_TS_FIXME is used to mark lock expressions that are not valid C++ syntax.
+// Y_ABSL_TS_FIXME is used to mark lock expressions that are not valid C++ syntax.
 // It is used by automated tools to mark and disable invalid expressions.
-// The annotation should either be fixed, or changed to ABSL_TS_UNCHECKED.
-#define ABSL_TS_FIXME(x) ""
+// The annotation should either be fixed, or changed to Y_ABSL_TS_UNCHECKED.
+#define Y_ABSL_TS_FIXME(x) ""
 
-// Like ABSL_NO_THREAD_SAFETY_ANALYSIS, this turns off checking within the body
+// Like Y_ABSL_NO_THREAD_SAFETY_ANALYSIS, this turns off checking within the body
 // of a particular function.  However, this attribute is used to mark functions
 // that are incorrect and need to be fixed.  It is used by automated tools to
 // avoid breaking the build when the analysis is updated.
 // Code owners are expected to eventually fix the routine.
-#define ABSL_NO_THREAD_SAFETY_ANALYSIS_FIXME ABSL_NO_THREAD_SAFETY_ANALYSIS
+#define Y_ABSL_NO_THREAD_SAFETY_ANALYSIS_FIXME Y_ABSL_NO_THREAD_SAFETY_ANALYSIS
 
-// Similar to ABSL_NO_THREAD_SAFETY_ANALYSIS_FIXME, this macro marks a
-// ABSL_GUARDED_BY annotation that needs to be fixed, because it is producing
-// thread safety warning. It disables the ABSL_GUARDED_BY.
-#define ABSL_GUARDED_BY_FIXME(x)
+// Similar to Y_ABSL_NO_THREAD_SAFETY_ANALYSIS_FIXME, this macro marks a
+// Y_ABSL_GUARDED_BY annotation that needs to be fixed, because it is producing
+// thread safety warning. It disables the Y_ABSL_GUARDED_BY.
+#define Y_ABSL_GUARDED_BY_FIXME(x)
 
 // Disables warnings for a single read operation.  This can be used to avoid
 // warnings when it is known that the read is not actually involved in a race,
 // but the compiler cannot confirm that.
-#define ABSL_TS_UNCHECKED_READ(x) y_absl::base_internal::ts_unchecked_read(x)
+#define Y_ABSL_TS_UNCHECKED_READ(x) y_absl::base_internal::y_ts_unchecked_read(x)
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 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 Y_ABSL_TS_UNCHECKED_READ instead.
 template <typename T>
-inline const T& ts_unchecked_read(const T& v) ABSL_NO_THREAD_SAFETY_ANALYSIS {
+inline const T& y_ts_unchecked_read(const T& v) Y_ABSL_NO_THREAD_SAFETY_ANALYSIS {
   return v;
 }
 
 template <typename T>
-inline T& ts_unchecked_read(T& v) ABSL_NO_THREAD_SAFETY_ANALYSIS {
+inline T& y_ts_unchecked_read(T& v) Y_ABSL_NO_THREAD_SAFETY_ANALYSIS {
   return v;
 }
 
 }  // namespace base_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_BASE_THREAD_ANNOTATIONS_H_
+#endif  // Y_ABSL_BASE_THREAD_ANNOTATIONS_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_map.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_map.h
index 3f46c541b8..229c9fec83 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_map.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_map.h
@@ -44,14 +44,14 @@
 // reason, `insert()` and `erase()` return a valid iterator at the current
 // position.
 
-#ifndef ABSL_CONTAINER_BTREE_MAP_H_
-#define ABSL_CONTAINER_BTREE_MAP_H_
+#ifndef Y_ABSL_CONTAINER_BTREE_MAP_H_
+#define Y_ABSL_CONTAINER_BTREE_MAP_H_
 
 #include "y_absl/container/internal/btree.h"  // IWYU pragma: export
 #include "y_absl/container/internal/btree_container.h"  // IWYU pragma: export
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // y_absl::btree_map<>
 //
@@ -809,7 +809,7 @@ void erase_if(btree_multimap<K, V, C, A> &map, Pred pred) {
   }
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_BTREE_MAP_H_
+#endif  // Y_ABSL_CONTAINER_BTREE_MAP_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_set.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_set.h
index 905fb8e964..1eb60368f5 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_set.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_set.h
@@ -44,14 +44,14 @@
 // reason, `insert()` and `erase()` return a valid iterator at the current
 // position.
 
-#ifndef ABSL_CONTAINER_BTREE_SET_H_
-#define ABSL_CONTAINER_BTREE_SET_H_
+#ifndef Y_ABSL_CONTAINER_BTREE_SET_H_
+#define Y_ABSL_CONTAINER_BTREE_SET_H_
 
 #include "y_absl/container/internal/btree.h"  // IWYU pragma: export
 #include "y_absl/container/internal/btree_container.h"  // IWYU pragma: export
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // y_absl::btree_set<>
 //
@@ -722,7 +722,7 @@ void erase_if(btree_multiset<K, C, A> &set, Pred pred) {
   }
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_BTREE_SET_H_
+#endif  // Y_ABSL_CONTAINER_BTREE_SET_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_test.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_test.h
index 97ed054ce8..bab5a99314 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_test.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/btree_test.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_CONTAINER_BTREE_TEST_H_
-#define ABSL_CONTAINER_BTREE_TEST_H_
+#ifndef Y_ABSL_CONTAINER_BTREE_TEST_H_
+#define Y_ABSL_CONTAINER_BTREE_TEST_H_
 
 #include <algorithm>
 #include <cassert>
@@ -29,7 +29,7 @@
 #include "y_absl/time/time.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
 // Like remove_const but propagates the removal through std::pair.
@@ -160,7 +160,7 @@ std::vector<V> GenerateValuesWithSeed(int n, int maxval, int seed) {
 }
 
 }  // namespace container_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_BTREE_TEST_H_
+#endif  // Y_ABSL_CONTAINER_BTREE_TEST_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/fixed_array.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/fixed_array.h
index 33b6caf00d..8fb4c679dc 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/fixed_array.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/fixed_array.h
@@ -27,8 +27,8 @@
 // accidentally overflowing your stack if large input is passed to
 // your function.
 
-#ifndef ABSL_CONTAINER_FIXED_ARRAY_H_
-#define ABSL_CONTAINER_FIXED_ARRAY_H_
+#ifndef Y_ABSL_CONTAINER_FIXED_ARRAY_H_
+#define Y_ABSL_CONTAINER_FIXED_ARRAY_H_
 
 #include <algorithm>
 #include <cassert>
@@ -51,7 +51,7 @@
 #include "y_absl/memory/memory.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 constexpr static auto kFixedArrayUseDefault = static_cast<size_t>(-1);
 
@@ -213,7 +213,7 @@ class FixedArray {
   // Returns a reference the ith element of the fixed array.
   // REQUIRES: 0 <= i < size()
   reference operator[](size_type i) {
-    ABSL_HARDENING_ASSERT(i < size());
+    Y_ABSL_HARDENING_ASSERT(i < size());
     return data()[i];
   }
 
@@ -221,7 +221,7 @@ class FixedArray {
   // ith element of the fixed array.
   // REQUIRES: 0 <= i < size()
   const_reference operator[](size_type i) const {
-    ABSL_HARDENING_ASSERT(i < size());
+    Y_ABSL_HARDENING_ASSERT(i < size());
     return data()[i];
   }
 
@@ -230,7 +230,7 @@ class FixedArray {
   // Bounds-checked access.  Returns a reference to the ith element of the fixed
   // array, or throws std::out_of_range
   reference at(size_type i) {
-    if (ABSL_PREDICT_FALSE(i >= size())) {
+    if (Y_ABSL_PREDICT_FALSE(i >= size())) {
       base_internal::ThrowStdOutOfRange("FixedArray::at failed bounds check");
     }
     return data()[i];
@@ -239,7 +239,7 @@ class FixedArray {
   // Overload of FixedArray::at() to return a const reference to the ith element
   // of the fixed array.
   const_reference at(size_type i) const {
-    if (ABSL_PREDICT_FALSE(i >= size())) {
+    if (Y_ABSL_PREDICT_FALSE(i >= size())) {
       base_internal::ThrowStdOutOfRange("FixedArray::at failed bounds check");
     }
     return data()[i];
@@ -249,14 +249,14 @@ class FixedArray {
   //
   // Returns a reference to the first element of the fixed array.
   reference front() {
-    ABSL_HARDENING_ASSERT(!empty());
+    Y_ABSL_HARDENING_ASSERT(!empty());
     return data()[0];
   }
 
   // Overload of FixedArray::front() to return a reference to the first element
   // of a fixed array of const values.
   const_reference front() const {
-    ABSL_HARDENING_ASSERT(!empty());
+    Y_ABSL_HARDENING_ASSERT(!empty());
     return data()[0];
   }
 
@@ -264,14 +264,14 @@ class FixedArray {
   //
   // Returns a reference to the last element of the fixed array.
   reference back() {
-    ABSL_HARDENING_ASSERT(!empty());
+    Y_ABSL_HARDENING_ASSERT(!empty());
     return data()[size() - 1];
   }
 
   // Overload of FixedArray::back() to return a reference to the last element
   // of a fixed array of const values.
   const_reference back() const {
-    ABSL_HARDENING_ASSERT(!empty());
+    Y_ABSL_HARDENING_ASSERT(!empty());
     return data()[size() - 1];
   }
 
@@ -418,15 +418,15 @@ class FixedArray {
     void AnnotateConstruct(size_type n);
     void AnnotateDestruct(size_type n);
 
-#ifdef ABSL_HAVE_ADDRESS_SANITIZER
+#ifdef Y_ABSL_HAVE_ADDRESS_SANITIZER
     void* RedzoneBegin() { return &redzone_begin_; }
     void* RedzoneEnd() { return &redzone_end_ + 1; }
-#endif  // ABSL_HAVE_ADDRESS_SANITIZER
+#endif  // Y_ABSL_HAVE_ADDRESS_SANITIZER
 
    private:
-    ABSL_ADDRESS_SANITIZER_REDZONE(redzone_begin_);
+    Y_ABSL_ADDRESS_SANITIZER_REDZONE(redzone_begin_);
     alignas(StorageElement) char buff_[sizeof(StorageElement[inline_elements])];
-    ABSL_ADDRESS_SANITIZER_REDZONE(redzone_end_);
+    Y_ABSL_ADDRESS_SANITIZER_REDZONE(redzone_end_);
   };
 
   class EmptyInlinedStorage {
@@ -499,29 +499,29 @@ constexpr typename FixedArray<T, N, A>::size_type
 template <typename T, size_t N, typename A>
 void FixedArray<T, N, A>::NonEmptyInlinedStorage::AnnotateConstruct(
     typename FixedArray<T, N, A>::size_type n) {
-#ifdef ABSL_HAVE_ADDRESS_SANITIZER
+#ifdef Y_ABSL_HAVE_ADDRESS_SANITIZER
   if (!n) return;
-  ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(data(), RedzoneEnd(), RedzoneEnd(),
+  Y_ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(data(), RedzoneEnd(), RedzoneEnd(),
                                      data() + n);
-  ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(RedzoneBegin(), data(), data(),
+  Y_ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(RedzoneBegin(), data(), data(),
                                      RedzoneBegin());
-#endif  // ABSL_HAVE_ADDRESS_SANITIZER
+#endif  // Y_ABSL_HAVE_ADDRESS_SANITIZER
   static_cast<void>(n);  // Mark used when not in asan mode
 }
 
 template <typename T, size_t N, typename A>
 void FixedArray<T, N, A>::NonEmptyInlinedStorage::AnnotateDestruct(
     typename FixedArray<T, N, A>::size_type n) {
-#ifdef ABSL_HAVE_ADDRESS_SANITIZER
+#ifdef Y_ABSL_HAVE_ADDRESS_SANITIZER
   if (!n) return;
-  ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(data(), RedzoneEnd(), data() + n,
+  Y_ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(data(), RedzoneEnd(), data() + n,
                                      RedzoneEnd());
-  ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(RedzoneBegin(), data(), RedzoneBegin(),
+  Y_ABSL_ANNOTATE_CONTIGUOUS_CONTAINER(RedzoneBegin(), data(), RedzoneBegin(),
                                      data());
-#endif  // ABSL_HAVE_ADDRESS_SANITIZER
+#endif  // Y_ABSL_HAVE_ADDRESS_SANITIZER
   static_cast<void>(n);  // Mark used when not in asan mode
 }
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_FIXED_ARRAY_H_
+#endif  // Y_ABSL_CONTAINER_FIXED_ARRAY_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/flat_hash_map.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/flat_hash_map.h
index eb3f09f06d..71f49b0bbe 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/flat_hash_map.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/flat_hash_map.h
@@ -27,8 +27,8 @@
 // In most cases, your default choice for a hash map should be a map of type
 // `flat_hash_map`.
 
-#ifndef ABSL_CONTAINER_FLAT_HASH_MAP_H_
-#define ABSL_CONTAINER_FLAT_HASH_MAP_H_
+#ifndef Y_ABSL_CONTAINER_FLAT_HASH_MAP_H_
+#define Y_ABSL_CONTAINER_FLAT_HASH_MAP_H_
 
 #include <cstddef>
 #include <new>
@@ -42,7 +42,7 @@
 #include "y_absl/memory/memory.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 template <class K, class V>
 struct FlatHashMapPolicy;
@@ -600,7 +600,7 @@ struct IsUnorderedContainer<
 
 }  // namespace container_algorithm_internal
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_FLAT_HASH_MAP_H_
+#endif  // Y_ABSL_CONTAINER_FLAT_HASH_MAP_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/flat_hash_set.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/flat_hash_set.h
index 23fe02a950..e83e956f99 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/flat_hash_set.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/flat_hash_set.h
@@ -26,8 +26,8 @@
 //
 // In most cases, your default choice for a hash set should be a set of type
 // `flat_hash_set`.
-#ifndef ABSL_CONTAINER_FLAT_HASH_SET_H_
-#define ABSL_CONTAINER_FLAT_HASH_SET_H_
+#ifndef Y_ABSL_CONTAINER_FLAT_HASH_SET_H_
+#define Y_ABSL_CONTAINER_FLAT_HASH_SET_H_
 
 #include <type_traits>
 #include <utility>
@@ -40,7 +40,7 @@
 #include "y_absl/memory/memory.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 template <typename T>
 struct FlatHashSetPolicy;
@@ -498,7 +498,7 @@ struct IsUnorderedContainer<y_absl::flat_hash_set<Key, Hash, KeyEqual, Allocator
 
 }  // namespace container_algorithm_internal
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_FLAT_HASH_SET_H_
+#endif  // Y_ABSL_CONTAINER_FLAT_HASH_SET_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/inlined_vector.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/inlined_vector.h
index 34af121cf7..b91b1fb11d 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/inlined_vector.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/inlined_vector.h
@@ -32,8 +32,8 @@
 // the default allocator (defined as `std::allocator<T>`). Optionally, a custom
 // allocator type may be specified as `A` in `y_absl::InlinedVector<T, N, A>`.
 
-#ifndef ABSL_CONTAINER_INLINED_VECTOR_H_
-#define ABSL_CONTAINER_INLINED_VECTOR_H_
+#ifndef Y_ABSL_CONTAINER_INLINED_VECTOR_H_
+#define Y_ABSL_CONTAINER_INLINED_VECTOR_H_
 
 #include <algorithm>
 #include <cassert>
@@ -55,7 +55,7 @@
 #include "y_absl/memory/memory.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 // -----------------------------------------------------------------------------
 // InlinedVector
 // -----------------------------------------------------------------------------
@@ -319,14 +319,14 @@ class InlinedVector {
   //
   // Returns a `reference` to the `i`th element of the inlined vector.
   reference operator[](size_type i) {
-    ABSL_HARDENING_ASSERT(i < size());
+    Y_ABSL_HARDENING_ASSERT(i < size());
     return data()[i];
   }
 
   // Overload of `InlinedVector::operator[](...)` that returns a
   // `const_reference` to the `i`th element of the inlined vector.
   const_reference operator[](size_type i) const {
-    ABSL_HARDENING_ASSERT(i < size());
+    Y_ABSL_HARDENING_ASSERT(i < size());
     return data()[i];
   }
 
@@ -337,7 +337,7 @@ class InlinedVector {
   // NOTE: if `i` is not within the required range of `InlinedVector::at(...)`,
   // in both debug and non-debug builds, `std::out_of_range` will be thrown.
   reference at(size_type i) {
-    if (ABSL_PREDICT_FALSE(i >= size())) {
+    if (Y_ABSL_PREDICT_FALSE(i >= size())) {
       base_internal::ThrowStdOutOfRange(
           "`InlinedVector::at(size_type)` failed bounds check");
     }
@@ -350,7 +350,7 @@ class InlinedVector {
   // NOTE: if `i` is not within the required range of `InlinedVector::at(...)`,
   // in both debug and non-debug builds, `std::out_of_range` will be thrown.
   const_reference at(size_type i) const {
-    if (ABSL_PREDICT_FALSE(i >= size())) {
+    if (Y_ABSL_PREDICT_FALSE(i >= size())) {
       base_internal::ThrowStdOutOfRange(
           "`InlinedVector::at(size_type) const` failed bounds check");
     }
@@ -361,14 +361,14 @@ class InlinedVector {
   //
   // Returns a `reference` to the first element of the inlined vector.
   reference front() {
-    ABSL_HARDENING_ASSERT(!empty());
+    Y_ABSL_HARDENING_ASSERT(!empty());
     return data()[0];
   }
 
   // Overload of `InlinedVector::front()` that returns a `const_reference` to
   // the first element of the inlined vector.
   const_reference front() const {
-    ABSL_HARDENING_ASSERT(!empty());
+    Y_ABSL_HARDENING_ASSERT(!empty());
     return data()[0];
   }
 
@@ -376,14 +376,14 @@ class InlinedVector {
   //
   // Returns a `reference` to the last element of the inlined vector.
   reference back() {
-    ABSL_HARDENING_ASSERT(!empty());
+    Y_ABSL_HARDENING_ASSERT(!empty());
     return data()[size() - 1];
   }
 
   // Overload of `InlinedVector::back()` that returns a `const_reference` to the
   // last element of the inlined vector.
   const_reference back() const {
-    ABSL_HARDENING_ASSERT(!empty());
+    Y_ABSL_HARDENING_ASSERT(!empty());
     return data()[size() - 1];
   }
 
@@ -470,7 +470,7 @@ class InlinedVector {
   // Overload of `InlinedVector::operator=(...)` that replaces the elements of
   // the inlined vector with copies of the elements of `other`.
   InlinedVector& operator=(const InlinedVector& other) {
-    if (ABSL_PREDICT_TRUE(this != std::addressof(other))) {
+    if (Y_ABSL_PREDICT_TRUE(this != std::addressof(other))) {
       const_pointer other_data = other.data();
       assign(other_data, other_data + other.size());
     }
@@ -484,7 +484,7 @@ class InlinedVector {
   // NOTE: as a result of calling this overload, `other` is left in a valid but
   // unspecified state.
   InlinedVector& operator=(InlinedVector&& other) {
-    if (ABSL_PREDICT_TRUE(this != std::addressof(other))) {
+    if (Y_ABSL_PREDICT_TRUE(this != std::addressof(other))) {
       if (IsMemcpyOk<A>::value || other.storage_.GetIsAllocated()) {
         inlined_vector_internal::DestroyElements<A>(storage_.GetAllocator(),
                                                     data(), size());
@@ -549,7 +549,7 @@ class InlinedVector {
   // NOTE: If `n` is smaller than `size()`, extra elements are destroyed. If `n`
   // is larger than `size()`, new elements are value-initialized.
   void resize(size_type n) {
-    ABSL_HARDENING_ASSERT(n <= max_size());
+    Y_ABSL_HARDENING_ASSERT(n <= max_size());
     storage_.Resize(DefaultValueAdapter<A>(), n);
   }
 
@@ -559,7 +559,7 @@ class InlinedVector {
   // NOTE: if `n` is smaller than `size()`, extra elements are destroyed. If `n`
   // is larger than `size()`, new elements are copied-constructed from `v`.
   void resize(size_type n, const_reference v) {
-    ABSL_HARDENING_ASSERT(n <= max_size());
+    Y_ABSL_HARDENING_ASSERT(n <= max_size());
     storage_.Resize(CopyValueAdapter<A>(std::addressof(v)), n);
   }
 
@@ -581,10 +581,10 @@ class InlinedVector {
   // of `v` starting at `pos`, returning an `iterator` pointing to the first of
   // the newly inserted elements.
   iterator insert(const_iterator pos, size_type n, const_reference v) {
-    ABSL_HARDENING_ASSERT(pos >= begin());
-    ABSL_HARDENING_ASSERT(pos <= end());
+    Y_ABSL_HARDENING_ASSERT(pos >= begin());
+    Y_ABSL_HARDENING_ASSERT(pos <= end());
 
-    if (ABSL_PREDICT_TRUE(n != 0)) {
+    if (Y_ABSL_PREDICT_TRUE(n != 0)) {
       value_type dealias = v;
       return storage_.Insert(pos, CopyValueAdapter<A>(std::addressof(dealias)),
                              n);
@@ -609,10 +609,10 @@ class InlinedVector {
             EnableIfAtLeastForwardIterator<ForwardIterator> = 0>
   iterator insert(const_iterator pos, ForwardIterator first,
                   ForwardIterator last) {
-    ABSL_HARDENING_ASSERT(pos >= begin());
-    ABSL_HARDENING_ASSERT(pos <= end());
+    Y_ABSL_HARDENING_ASSERT(pos >= begin());
+    Y_ABSL_HARDENING_ASSERT(pos <= end());
 
-    if (ABSL_PREDICT_TRUE(first != last)) {
+    if (Y_ABSL_PREDICT_TRUE(first != last)) {
       return storage_.Insert(pos,
                              IteratorValueAdapter<A, ForwardIterator>(first),
                              std::distance(first, last));
@@ -629,8 +629,8 @@ class InlinedVector {
   template <typename InputIterator,
             DisableIfAtLeastForwardIterator<InputIterator> = 0>
   iterator insert(const_iterator pos, InputIterator first, InputIterator last) {
-    ABSL_HARDENING_ASSERT(pos >= begin());
-    ABSL_HARDENING_ASSERT(pos <= end());
+    Y_ABSL_HARDENING_ASSERT(pos >= begin());
+    Y_ABSL_HARDENING_ASSERT(pos <= end());
 
     size_type index = std::distance(cbegin(), pos);
     for (size_type i = index; first != last; ++i, static_cast<void>(++first)) {
@@ -646,8 +646,8 @@ class InlinedVector {
   // `pos`, returning an `iterator` pointing to the newly emplaced element.
   template <typename... Args>
   iterator emplace(const_iterator pos, Args&&... args) {
-    ABSL_HARDENING_ASSERT(pos >= begin());
-    ABSL_HARDENING_ASSERT(pos <= end());
+    Y_ABSL_HARDENING_ASSERT(pos >= begin());
+    Y_ABSL_HARDENING_ASSERT(pos <= end());
 
     value_type dealias(std::forward<Args>(args)...);
     return storage_.Insert(pos,
@@ -680,7 +680,7 @@ class InlinedVector {
   //
   // Destroys the element at `back()`, reducing the size by `1`.
   void pop_back() noexcept {
-    ABSL_HARDENING_ASSERT(!empty());
+    Y_ABSL_HARDENING_ASSERT(!empty());
 
     AllocatorTraits<A>::destroy(storage_.GetAllocator(), data() + (size() - 1));
     storage_.SubtractSize(1);
@@ -693,8 +693,8 @@ class InlinedVector {
   //
   // NOTE: may return `end()`, which is not dereferencable.
   iterator erase(const_iterator pos) {
-    ABSL_HARDENING_ASSERT(pos >= begin());
-    ABSL_HARDENING_ASSERT(pos < end());
+    Y_ABSL_HARDENING_ASSERT(pos >= begin());
+    Y_ABSL_HARDENING_ASSERT(pos < end());
 
     return storage_.Erase(pos, pos + 1);
   }
@@ -705,11 +705,11 @@ class InlinedVector {
   //
   // NOTE: may return `end()`, which is not dereferencable.
   iterator erase(const_iterator from, const_iterator to) {
-    ABSL_HARDENING_ASSERT(from >= begin());
-    ABSL_HARDENING_ASSERT(from <= to);
-    ABSL_HARDENING_ASSERT(to <= end());
+    Y_ABSL_HARDENING_ASSERT(from >= begin());
+    Y_ABSL_HARDENING_ASSERT(from <= to);
+    Y_ABSL_HARDENING_ASSERT(to <= end());
 
-    if (ABSL_PREDICT_TRUE(from != to)) {
+    if (Y_ABSL_PREDICT_TRUE(from != to)) {
       return storage_.Erase(from, to);
     } else {
       return const_cast<iterator>(from);
@@ -751,7 +751,7 @@ class InlinedVector {
   //
   // Swaps the contents of the inlined vector with `other`.
   void swap(InlinedVector& other) {
-    if (ABSL_PREDICT_TRUE(this != std::addressof(other))) {
+    if (Y_ABSL_PREDICT_TRUE(this != std::addressof(other))) {
       storage_.Swap(std::addressof(other.storage_));
     }
   }
@@ -849,7 +849,7 @@ H AbslHashValue(H h, const y_absl::InlinedVector<T, N, A>& a) {
   return H::combine(H::combine_contiguous(std::move(h), a.data(), size), size);
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_INLINED_VECTOR_H_
+#endif  // Y_ABSL_CONTAINER_INLINED_VECTOR_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/btree.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/btree.h
index a249260811..01bd8d729f 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/btree.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/btree.h
@@ -42,8 +42,8 @@
 // pointing to the item just after the one that was erased (or end() if none
 // exists).
 
-#ifndef ABSL_CONTAINER_INTERNAL_BTREE_H_
-#define ABSL_CONTAINER_INTERNAL_BTREE_H_
+#ifndef Y_ABSL_CONTAINER_INTERNAL_BTREE_H_
+#define Y_ABSL_CONTAINER_INTERNAL_BTREE_H_
 
 #include <algorithm>
 #include <cassert>
@@ -71,7 +71,7 @@
 #include "y_absl/utility/utility.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
 // A helper class that indicates if the Compare parameter is a key-compare-to
@@ -1028,9 +1028,9 @@ struct btree_iterator {
 
   // Accessors for the key/value the iterator is pointing at.
   reference operator*() const {
-    ABSL_HARDENING_ASSERT(node != nullptr);
-    ABSL_HARDENING_ASSERT(node->start() <= position);
-    ABSL_HARDENING_ASSERT(node->finish() > position);
+    Y_ABSL_HARDENING_ASSERT(node != nullptr);
+    Y_ABSL_HARDENING_ASSERT(node->start() <= position);
+    Y_ABSL_HARDENING_ASSERT(node->finish() > position);
     return node->value(position);
   }
   pointer operator->() const { return &operator*(); }
@@ -2635,7 +2635,7 @@ int btree<P>::internal_verify(const node_type *node, const key_type *lo,
 }
 
 }  // namespace container_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_INTERNAL_BTREE_H_
+#endif  // Y_ABSL_CONTAINER_INTERNAL_BTREE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/btree_container.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/btree_container.h
index d23feff31b..8a4a4e3244 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/btree_container.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/btree_container.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_CONTAINER_INTERNAL_BTREE_CONTAINER_H_
-#define ABSL_CONTAINER_INTERNAL_BTREE_CONTAINER_H_
+#ifndef Y_ABSL_CONTAINER_INTERNAL_BTREE_CONTAINER_H_
+#define Y_ABSL_CONTAINER_INTERNAL_BTREE_CONTAINER_H_
 
 #include <algorithm>
 #include <initializer_list>
@@ -28,7 +28,7 @@
 #include "y_absl/meta/type_traits.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
 // A common base class for btree_set, btree_map, btree_multiset, and
@@ -177,7 +177,7 @@ class btree_container {
   }
 
   // Utility routines.
-  ABSL_ATTRIBUTE_REINITIALIZES void clear() { tree_.clear(); }
+  Y_ABSL_ATTRIBUTE_REINITIALIZES void clear() { tree_.clear(); }
   void swap(btree_container &other) { tree_.swap(other.tree_); }
   void verify() const { tree_.verify(); }
 
@@ -677,7 +677,7 @@ class btree_multimap_container : public btree_multiset_container<Tree> {
 };
 
 }  // namespace container_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_INTERNAL_BTREE_CONTAINER_H_
+#endif  // Y_ABSL_CONTAINER_INTERNAL_BTREE_CONTAINER_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/common.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/common.h
index ec84f975e5..6c7369e67b 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/common.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/common.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_CONTAINER_INTERNAL_CONTAINER_H_
-#define ABSL_CONTAINER_INTERNAL_CONTAINER_H_
+#ifndef Y_ABSL_CONTAINER_INTERNAL_CONTAINER_H_
+#define Y_ABSL_CONTAINER_INTERNAL_CONTAINER_H_
 
 #include <cassert>
 #include <type_traits>
@@ -22,7 +22,7 @@
 #include "y_absl/types/optional.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
 template <class, class = void>
@@ -200,7 +200,7 @@ struct InsertReturnType {
 };
 
 }  // namespace container_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_INTERNAL_CONTAINER_H_
+#endif  // Y_ABSL_CONTAINER_INTERNAL_CONTAINER_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/compressed_tuple.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/compressed_tuple.h
index 735b738a9b..b1bd5d4efa 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/compressed_tuple.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/compressed_tuple.h
@@ -29,8 +29,8 @@
 //
 // https://en.cppreference.com/w/cpp/language/ebo
 
-#ifndef ABSL_CONTAINER_INTERNAL_COMPRESSED_TUPLE_H_
-#define ABSL_CONTAINER_INTERNAL_COMPRESSED_TUPLE_H_
+#ifndef Y_ABSL_CONTAINER_INTERNAL_COMPRESSED_TUPLE_H_
+#define Y_ABSL_CONTAINER_INTERNAL_COMPRESSED_TUPLE_H_
 
 #include <initializer_list>
 #include <tuple>
@@ -42,13 +42,13 @@
 #if defined(_MSC_VER) && !defined(__NVCC__)
 // We need to mark these classes with this declspec to ensure that
 // CompressedTuple happens.
-#define ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC __declspec(empty_bases)
+#define Y_ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC __declspec(empty_bases)
 #else
-#define ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC
+#define Y_ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC
 #endif
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
 template <typename... Ts>
@@ -113,7 +113,7 @@ struct Storage {
 };
 
 template <typename T, size_t I>
-struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC Storage<T, I, true> : T {
+struct Y_ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC Storage<T, I, true> : T {
   constexpr Storage() = default;
 
   template <typename V>
@@ -127,10 +127,10 @@ struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC Storage<T, I, true> : T {
 };
 
 template <typename D, typename I, bool ShouldAnyUseBase>
-struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl;
+struct Y_ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl;
 
 template <typename... Ts, size_t... I, bool ShouldAnyUseBase>
-struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl<
+struct Y_ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl<
     CompressedTuple<Ts...>, y_absl::index_sequence<I...>, ShouldAnyUseBase>
     // We use the dummy identity function through std::integral_constant to
     // convince MSVC of accepting and expanding I in that context. Without it
@@ -146,7 +146,7 @@ struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl<
 };
 
 template <typename... Ts, size_t... I>
-struct ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl<
+struct Y_ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTupleImpl<
     CompressedTuple<Ts...>, y_absl::index_sequence<I...>, false>
     // We use the dummy identity function as above...
     : Storage<Ts, std::integral_constant<size_t, I>::value, false>... {
@@ -218,7 +218,7 @@ struct TupleItemsMoveConstructible
 //
 // https://en.cppreference.com/w/cpp/language/ebo
 template <typename... Ts>
-class ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple
+class Y_ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple
     : private internal_compressed_tuple::CompressedTupleImpl<
           CompressedTuple<Ts...>, y_absl::index_sequence_for<Ts...>,
           internal_compressed_tuple::ShouldAnyUseBase<Ts...>()> {
@@ -279,12 +279,12 @@ class ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple
 // Explicit specialization for a zero-element tuple
 // (needed to avoid ambiguous overloads for the default constructor).
 template <>
-class ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple<> {};
+class Y_ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC CompressedTuple<> {};
 
 }  // namespace container_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#undef ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC
+#undef Y_ABSL_INTERNAL_COMPRESSED_TUPLE_DECLSPEC
 
-#endif  // ABSL_CONTAINER_INTERNAL_COMPRESSED_TUPLE_H_
+#endif  // Y_ABSL_CONTAINER_INTERNAL_COMPRESSED_TUPLE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/container_memory.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/container_memory.h
index 348bc8c0d0..90d35184ab 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/container_memory.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/container_memory.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_CONTAINER_INTERNAL_CONTAINER_MEMORY_H_
-#define ABSL_CONTAINER_INTERNAL_CONTAINER_MEMORY_H_
+#ifndef Y_ABSL_CONTAINER_INTERNAL_CONTAINER_MEMORY_H_
+#define Y_ABSL_CONTAINER_INTERNAL_CONTAINER_MEMORY_H_
 
 #include <cassert>
 #include <cstddef>
@@ -28,16 +28,16 @@
 #include "y_absl/meta/type_traits.h"
 #include "y_absl/utility/utility.h"
 
-#ifdef ABSL_HAVE_ADDRESS_SANITIZER
+#ifdef Y_ABSL_HAVE_ADDRESS_SANITIZER
 #include <sanitizer/asan_interface.h>
 #endif
 
-#ifdef ABSL_HAVE_MEMORY_SANITIZER
+#ifdef Y_ABSL_HAVE_MEMORY_SANITIZER
 #include <sanitizer/msan_interface.h>
 #endif
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
 template <size_t Alignment>
@@ -217,10 +217,10 @@ DecomposeValue(F&& f, Arg&& arg) {
 
 // Helper functions for asan and msan.
 inline void SanitizerPoisonMemoryRegion(const void* m, size_t s) {
-#ifdef ABSL_HAVE_ADDRESS_SANITIZER
+#ifdef Y_ABSL_HAVE_ADDRESS_SANITIZER
   ASAN_POISON_MEMORY_REGION(m, s);
 #endif
-#ifdef ABSL_HAVE_MEMORY_SANITIZER
+#ifdef Y_ABSL_HAVE_MEMORY_SANITIZER
   __msan_poison(m, s);
 #endif
   (void)m;
@@ -228,10 +228,10 @@ inline void SanitizerPoisonMemoryRegion(const void* m, size_t s) {
 }
 
 inline void SanitizerUnpoisonMemoryRegion(const void* m, size_t s) {
-#ifdef ABSL_HAVE_ADDRESS_SANITIZER
+#ifdef Y_ABSL_HAVE_ADDRESS_SANITIZER
   ASAN_UNPOISON_MEMORY_REGION(m, s);
 #endif
-#ifdef ABSL_HAVE_MEMORY_SANITIZER
+#ifdef Y_ABSL_HAVE_MEMORY_SANITIZER
   __msan_unpoison(m, s);
 #endif
   (void)m;
@@ -454,7 +454,7 @@ struct map_slot_policy {
 };
 
 }  // namespace container_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_INTERNAL_CONTAINER_MEMORY_H_
+#endif  // Y_ABSL_CONTAINER_INTERNAL_CONTAINER_MEMORY_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/counting_allocator.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/counting_allocator.h
index c8975dbd90..fda23e14fb 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/counting_allocator.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/counting_allocator.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_CONTAINER_INTERNAL_COUNTING_ALLOCATOR_H_
-#define ABSL_CONTAINER_INTERNAL_COUNTING_ALLOCATOR_H_
+#ifndef Y_ABSL_CONTAINER_INTERNAL_COUNTING_ALLOCATOR_H_
+#define Y_ABSL_CONTAINER_INTERNAL_COUNTING_ALLOCATOR_H_
 
 #include <cstdint>
 #include <memory>
@@ -21,7 +21,7 @@
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
 // This is a stateful allocator, but the state lives outside of the
@@ -108,7 +108,7 @@ class CountingAllocator {
 };
 
 }  // namespace container_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_INTERNAL_COUNTING_ALLOCATOR_H_
+#endif  // Y_ABSL_CONTAINER_INTERNAL_COUNTING_ALLOCATOR_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_function_defaults.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_function_defaults.h
index 68a18058d1..3de475353c 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_function_defaults.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_function_defaults.h
@@ -42,8 +42,8 @@
 // the hash function is hash<TString> but as a pointer when the hash
 // function is hash<void*>.
 //
-#ifndef ABSL_CONTAINER_INTERNAL_HASH_FUNCTION_DEFAULTS_H_
-#define ABSL_CONTAINER_INTERNAL_HASH_FUNCTION_DEFAULTS_H_
+#ifndef Y_ABSL_CONTAINER_INTERNAL_HASH_FUNCTION_DEFAULTS_H_
+#define Y_ABSL_CONTAINER_INTERNAL_HASH_FUNCTION_DEFAULTS_H_
 
 #include <stdint.h>
 #include <cstddef>
@@ -57,7 +57,7 @@
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
 // The hash of an object of type T is computed by using y_absl::Hash.
@@ -157,7 +157,7 @@ template <class T>
 using hash_default_eq = typename container_internal::HashEq<T>::Eq;
 
 }  // namespace container_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_INTERNAL_HASH_FUNCTION_DEFAULTS_H_
+#endif  // Y_ABSL_CONTAINER_INTERNAL_HASH_FUNCTION_DEFAULTS_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_generator_testing.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_generator_testing.h
index 79b215465e..d62f2da501 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_generator_testing.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_generator_testing.h
@@ -15,8 +15,8 @@
 // Generates random values for testing. Specialized only for the few types we
 // care about.
 
-#ifndef ABSL_CONTAINER_INTERNAL_HASH_GENERATOR_TESTING_H_
-#define ABSL_CONTAINER_INTERNAL_HASH_GENERATOR_TESTING_H_
+#ifndef Y_ABSL_CONTAINER_INTERNAL_HASH_GENERATOR_TESTING_H_
+#define Y_ABSL_CONTAINER_INTERNAL_HASH_GENERATOR_TESTING_H_
 
 #include <stdint.h>
 
@@ -35,7 +35,7 @@
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 namespace hash_internal {
 namespace generator_internal {
@@ -176,7 +176,7 @@ struct UniqueGenerator {
 
 }  // namespace hash_internal
 }  // namespace container_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_INTERNAL_HASH_GENERATOR_TESTING_H_
+#endif  // Y_ABSL_CONTAINER_INTERNAL_HASH_GENERATOR_TESTING_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_policy_testing.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_policy_testing.h
index baa367eee6..2ebffcdc88 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_policy_testing.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_policy_testing.h
@@ -15,8 +15,8 @@
 // Utilities to help tests verify that hash tables properly handle stateful
 // allocators and hash functions.
 
-#ifndef ABSL_CONTAINER_INTERNAL_HASH_POLICY_TESTING_H_
-#define ABSL_CONTAINER_INTERNAL_HASH_POLICY_TESTING_H_
+#ifndef Y_ABSL_CONTAINER_INTERNAL_HASH_POLICY_TESTING_H_
+#define Y_ABSL_CONTAINER_INTERNAL_HASH_POLICY_TESTING_H_
 
 #include <cstdlib>
 #include <limits>
@@ -30,7 +30,7 @@
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 namespace hash_testing_internal {
 
@@ -163,10 +163,10 @@ auto keys(const Set& s)
 }
 
 }  // namespace container_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-// ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS is false for glibcxx versions
+// Y_ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS is false for glibcxx versions
 // where the unordered containers are missing certain constructors that
 // take allocator arguments. This test is defined ad-hoc for the platforms
 // we care about (notably Crosstool 17) because libstdcxx's useless
@@ -176,9 +176,9 @@ ABSL_NAMESPACE_END
 // meet the allocator-aware container requirements;"
 #if (defined(__GLIBCXX__) && __GLIBCXX__ <= 20140425 ) || \
 ( __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 9 ))
-#define ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS 0
+#define Y_ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS 0
 #else
-#define ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS 1
+#define Y_ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS 1
 #endif
 
-#endif  // ABSL_CONTAINER_INTERNAL_HASH_POLICY_TESTING_H_
+#endif  // Y_ABSL_CONTAINER_INTERNAL_HASH_POLICY_TESTING_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_policy_traits.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_policy_traits.h
index 33f704fc4b..1ac62b0a3e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_policy_traits.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hash_policy_traits.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_CONTAINER_INTERNAL_HASH_POLICY_TRAITS_H_
-#define ABSL_CONTAINER_INTERNAL_HASH_POLICY_TRAITS_H_
+#ifndef Y_ABSL_CONTAINER_INTERNAL_HASH_POLICY_TRAITS_H_
+#define Y_ABSL_CONTAINER_INTERNAL_HASH_POLICY_TRAITS_H_
 
 #include <cstddef>
 #include <memory>
@@ -24,7 +24,7 @@
 #include "y_absl/meta/type_traits.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
 // Defines how slots are initialized/destroyed/moved.
@@ -202,7 +202,7 @@ struct hash_policy_traits {
 };
 
 }  // namespace container_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_INTERNAL_HASH_POLICY_TRAITS_H_
+#endif  // Y_ABSL_CONTAINER_INTERNAL_HASH_POLICY_TRAITS_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtable_debug.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtable_debug.h
index 2be9db2297..d3bfd70ac9 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtable_debug.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtable_debug.h
@@ -27,8 +27,8 @@
 // This library supports std::unordered_{set,map}, dense_hash_{set,map} and
 // y_absl::{flat,node,string}_hash_{set,map}.
 
-#ifndef ABSL_CONTAINER_INTERNAL_HASHTABLE_DEBUG_H_
-#define ABSL_CONTAINER_INTERNAL_HASHTABLE_DEBUG_H_
+#ifndef Y_ABSL_CONTAINER_INTERNAL_HASHTABLE_DEBUG_H_
+#define Y_ABSL_CONTAINER_INTERNAL_HASHTABLE_DEBUG_H_
 
 #include <cstddef>
 #include <algorithm>
@@ -38,7 +38,7 @@
 #include "y_absl/container/internal/hashtable_debug_hooks.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
 // Returns the number of probes required to lookup `key`.  Returns 0 for a
@@ -104,7 +104,7 @@ size_t LowerBoundAllocatedByteSize(size_t num_elements) {
 }
 
 }  // namespace container_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_INTERNAL_HASHTABLE_DEBUG_H_
+#endif  // Y_ABSL_CONTAINER_INTERNAL_HASHTABLE_DEBUG_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtable_debug_hooks.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtable_debug_hooks.h
index ec8c0fd29d..64609ad2db 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtable_debug_hooks.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtable_debug_hooks.h
@@ -14,8 +14,8 @@
 //
 // Provides the internal API for hashtable_debug.h.
 
-#ifndef ABSL_CONTAINER_INTERNAL_HASHTABLE_DEBUG_HOOKS_H_
-#define ABSL_CONTAINER_INTERNAL_HASHTABLE_DEBUG_HOOKS_H_
+#ifndef Y_ABSL_CONTAINER_INTERNAL_HASHTABLE_DEBUG_HOOKS_H_
+#define Y_ABSL_CONTAINER_INTERNAL_HASHTABLE_DEBUG_HOOKS_H_
 
 #include <cstddef>
 
@@ -26,7 +26,7 @@
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 namespace hashtable_debug_internal {
 
@@ -79,7 +79,7 @@ struct HashtableDebugAccess {
 
 }  // namespace hashtable_debug_internal
 }  // namespace container_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_INTERNAL_HASHTABLE_DEBUG_HOOKS_H_
+#endif  // Y_ABSL_CONTAINER_INTERNAL_HASHTABLE_DEBUG_HOOKS_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler.cc
index 6017ac9bb0..51235fd9be 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler.cc
@@ -29,26 +29,26 @@
 #include "y_absl/synchronization/mutex.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 constexpr int HashtablezInfo::kMaxStackDepth;
 
 namespace {
-ABSL_CONST_INIT std::atomic<bool> g_hashtablez_enabled{
+Y_ABSL_CONST_INIT std::atomic<bool> g_hashtablez_enabled{
     false
 };
-ABSL_CONST_INIT std::atomic<int32_t> g_hashtablez_sample_parameter{1 << 10};
+Y_ABSL_CONST_INIT std::atomic<int32_t> g_hashtablez_sample_parameter{1 << 10};
 
-#if defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
-ABSL_PER_THREAD_TLS_KEYWORD y_absl::profiling_internal::ExponentialBiased
+#if defined(Y_ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
+Y_ABSL_PER_THREAD_TLS_KEYWORD y_absl::profiling_internal::ExponentialBiased
     g_exponential_biased_generator;
 #endif
 
 }  // namespace
 
-#if defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
-ABSL_PER_THREAD_TLS_KEYWORD int64_t global_next_sample = 0;
-#endif  // defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
+#if defined(Y_ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
+Y_ABSL_PER_THREAD_TLS_KEYWORD int64_t global_next_sample = 0;
+#endif  // defined(Y_ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
 
 HashtablezSampler& GlobalHashtablezSampler() {
   static auto* sampler = new HashtablezSampler();
@@ -87,13 +87,13 @@ static bool ShouldForceSampling() {
     kForce,
     kUninitialized
   };
-  ABSL_CONST_INIT static std::atomic<ForceState> global_state{
+  Y_ABSL_CONST_INIT static std::atomic<ForceState> global_state{
       kUninitialized};
   ForceState state = global_state.load(std::memory_order_relaxed);
-  if (ABSL_PREDICT_TRUE(state == kDontForce)) return false;
+  if (Y_ABSL_PREDICT_TRUE(state == kDontForce)) return false;
 
   if (state == kUninitialized) {
-    state = ABSL_INTERNAL_C_SYMBOL(AbslContainerInternalSampleEverything)()
+    state = Y_ABSL_INTERNAL_C_SYMBOL(AbslContainerInternalSampleEverything)()
                 ? kForce
                 : kDontForce;
     global_state.store(state, std::memory_order_relaxed);
@@ -102,14 +102,14 @@ static bool ShouldForceSampling() {
 }
 
 HashtablezInfo* SampleSlow(int64_t* next_sample, size_t inline_element_size) {
-  if (ABSL_PREDICT_FALSE(ShouldForceSampling())) {
+  if (Y_ABSL_PREDICT_FALSE(ShouldForceSampling())) {
     *next_sample = 1;
     HashtablezInfo* result = GlobalHashtablezSampler().Register();
     result->inline_element_size = inline_element_size;
     return result;
   }
 
-#if !defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
+#if !defined(Y_ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
   *next_sample = std::numeric_limits<int64_t>::max();
   return nullptr;
 #else
@@ -117,7 +117,7 @@ HashtablezInfo* SampleSlow(int64_t* next_sample, size_t inline_element_size) {
   *next_sample = g_exponential_biased_generator.GetStride(
       g_hashtablez_sample_parameter.load(std::memory_order_relaxed));
   // Small values of interval are equivalent to just sampling next time.
-  ABSL_ASSERT(*next_sample >= 1);
+  Y_ABSL_ASSERT(*next_sample >= 1);
 
   // g_hashtablez_enabled can be dynamically flipped, we need to set a threshold
   // low enough that we will start sampling in a reasonable time, so we just use
@@ -127,7 +127,7 @@ HashtablezInfo* SampleSlow(int64_t* next_sample, size_t inline_element_size) {
   // We will only be negative on our first count, so we should just retry in
   // that case.
   if (first) {
-    if (ABSL_PREDICT_TRUE(--*next_sample > 0)) return nullptr;
+    if (Y_ABSL_PREDICT_TRUE(--*next_sample > 0)) return nullptr;
     return SampleSlow(next_sample, inline_element_size);
   }
 
@@ -146,7 +146,7 @@ void RecordInsertSlow(HashtablezInfo* info, size_t hash,
   // SwissTables probe in groups of 16, so scale this to count items probes and
   // not offset from desired.
   size_t probe_length = distance_from_desired;
-#if ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2
+#if Y_ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2
   probe_length /= 16;
 #else
   probe_length /= 8;
@@ -171,7 +171,7 @@ void SetHashtablezSampleParameter(int32_t rate) {
   if (rate > 0) {
     g_hashtablez_sample_parameter.store(rate, std::memory_order_release);
   } else {
-    ABSL_RAW_LOG(ERROR, "Invalid hashtablez sample rate: %lld",
+    Y_ABSL_RAW_LOG(ERROR, "Invalid hashtablez sample rate: %lld",
                  static_cast<long long>(rate));  // NOLINT(runtime/int)
   }
 }
@@ -180,11 +180,11 @@ void SetHashtablezMaxSamples(int32_t max) {
   if (max > 0) {
     GlobalHashtablezSampler().SetMaxSamples(max);
   } else {
-    ABSL_RAW_LOG(ERROR, "Invalid hashtablez max samples: %lld",
+    Y_ABSL_RAW_LOG(ERROR, "Invalid hashtablez max samples: %lld",
                  static_cast<long long>(max));  // NOLINT(runtime/int)
   }
 }
 
 }  // namespace container_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler.h
index 8521ee754a..3f600deea0 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler.h
@@ -36,8 +36,8 @@
 //
 // This utility is internal-only. Use at your own risk.
 
-#ifndef ABSL_CONTAINER_INTERNAL_HASHTABLEZ_SAMPLER_H_
-#define ABSL_CONTAINER_INTERNAL_HASHTABLEZ_SAMPLER_H_
+#ifndef Y_ABSL_CONTAINER_INTERNAL_HASHTABLEZ_SAMPLER_H_
+#define Y_ABSL_CONTAINER_INTERNAL_HASHTABLEZ_SAMPLER_H_
 
 #include <atomic>
 #include <functional>
@@ -52,7 +52,7 @@
 #include "y_absl/utility/utility.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
 // Stores information about a sampled hashtable.  All mutations to this *must*
@@ -67,7 +67,7 @@ struct HashtablezInfo : public profiling_internal::Sample<HashtablezInfo> {
 
   // Puts the object into a clean state, fills in the logically `const` members,
   // blocking for any readers that are currently sampling the object.
-  void PrepareForSampling() ABSL_EXCLUSIVE_LOCKS_REQUIRED(init_mu);
+  void PrepareForSampling() Y_ABSL_EXCLUSIVE_LOCKS_REQUIRED(init_mu);
 
   // These fields are mutated by the various Record* APIs and need to be
   // thread-safe.
@@ -95,7 +95,7 @@ struct HashtablezInfo : public profiling_internal::Sample<HashtablezInfo> {
 };
 
 inline void RecordRehashSlow(HashtablezInfo* info, size_t total_probe_length) {
-#if ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2
+#if Y_ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2
   total_probe_length /= 16;
 #else
   total_probe_length /= 8;
@@ -147,17 +147,17 @@ inline void RecordEraseSlow(HashtablezInfo* info) {
 HashtablezInfo* SampleSlow(int64_t* next_sample, size_t inline_element_size);
 void UnsampleSlow(HashtablezInfo* info);
 
-#if defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
-#error ABSL_INTERNAL_HASHTABLEZ_SAMPLE cannot be directly set
-#endif  // defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
+#if defined(Y_ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
+#error Y_ABSL_INTERNAL_HASHTABLEZ_SAMPLE cannot be directly set
+#endif  // defined(Y_ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
 
-#if defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
+#if defined(Y_ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
 class HashtablezInfoHandle {
  public:
   explicit HashtablezInfoHandle() : info_(nullptr) {}
   explicit HashtablezInfoHandle(HashtablezInfo* info) : info_(info) {}
   ~HashtablezInfoHandle() {
-    if (ABSL_PREDICT_TRUE(info_ == nullptr)) return;
+    if (Y_ABSL_PREDICT_TRUE(info_ == nullptr)) return;
     UnsampleSlow(info_);
   }
 
@@ -167,7 +167,7 @@ class HashtablezInfoHandle {
   HashtablezInfoHandle(HashtablezInfoHandle&& o) noexcept
       : info_(y_absl::exchange(o.info_, nullptr)) {}
   HashtablezInfoHandle& operator=(HashtablezInfoHandle&& o) noexcept {
-    if (ABSL_PREDICT_FALSE(info_ != nullptr)) {
+    if (Y_ABSL_PREDICT_FALSE(info_ != nullptr)) {
       UnsampleSlow(info_);
     }
     info_ = y_absl::exchange(o.info_, nullptr);
@@ -175,32 +175,32 @@ class HashtablezInfoHandle {
   }
 
   inline void RecordStorageChanged(size_t size, size_t capacity) {
-    if (ABSL_PREDICT_TRUE(info_ == nullptr)) return;
+    if (Y_ABSL_PREDICT_TRUE(info_ == nullptr)) return;
     RecordStorageChangedSlow(info_, size, capacity);
   }
 
   inline void RecordRehash(size_t total_probe_length) {
-    if (ABSL_PREDICT_TRUE(info_ == nullptr)) return;
+    if (Y_ABSL_PREDICT_TRUE(info_ == nullptr)) return;
     RecordRehashSlow(info_, total_probe_length);
   }
 
   inline void RecordReservation(size_t target_capacity) {
-    if (ABSL_PREDICT_TRUE(info_ == nullptr)) return;
+    if (Y_ABSL_PREDICT_TRUE(info_ == nullptr)) return;
     RecordReservationSlow(info_, target_capacity);
   }
 
   inline void RecordClearedReservation() {
-    if (ABSL_PREDICT_TRUE(info_ == nullptr)) return;
+    if (Y_ABSL_PREDICT_TRUE(info_ == nullptr)) return;
     RecordClearedReservationSlow(info_);
   }
 
   inline void RecordInsert(size_t hash, size_t distance_from_desired) {
-    if (ABSL_PREDICT_TRUE(info_ == nullptr)) return;
+    if (Y_ABSL_PREDICT_TRUE(info_ == nullptr)) return;
     RecordInsertSlow(info_, hash, distance_from_desired);
   }
 
   inline void RecordErase() {
-    if (ABSL_PREDICT_TRUE(info_ == nullptr)) return;
+    if (Y_ABSL_PREDICT_TRUE(info_ == nullptr)) return;
     RecordEraseSlow(info_);
   }
 
@@ -231,25 +231,25 @@ class HashtablezInfoHandle {
   friend inline void swap(HashtablezInfoHandle& /*lhs*/,
                           HashtablezInfoHandle& /*rhs*/) {}
 };
-#endif  // defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
+#endif  // defined(Y_ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
 
-#if defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
-extern ABSL_PER_THREAD_TLS_KEYWORD int64_t global_next_sample;
-#endif  // defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
+#if defined(Y_ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
+extern Y_ABSL_PER_THREAD_TLS_KEYWORD int64_t global_next_sample;
+#endif  // defined(Y_ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
 
 // Returns an RAII sampling handle that manages registration and unregistation
 // with the global sampler.
 inline HashtablezInfoHandle Sample(
-    size_t inline_element_size ABSL_ATTRIBUTE_UNUSED) {
-#if defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
-  if (ABSL_PREDICT_TRUE(--global_next_sample > 0)) {
+    size_t inline_element_size Y_ABSL_ATTRIBUTE_UNUSED) {
+#if defined(Y_ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
+  if (Y_ABSL_PREDICT_TRUE(--global_next_sample > 0)) {
     return HashtablezInfoHandle(nullptr);
   }
   return HashtablezInfoHandle(
       SampleSlow(&global_next_sample, inline_element_size));
 #else
   return HashtablezInfoHandle(nullptr);
-#endif  // !ABSL_PER_THREAD_TLS
+#endif  // !Y_ABSL_PER_THREAD_TLS
 }
 
 using HashtablezSampler =
@@ -272,10 +272,10 @@ void SetHashtablezMaxSamples(int32_t max);
 // initialization of static storage duration objects.
 // The definition of this constant is weak, which allows us to inject a
 // different value for it at link time.
-extern "C" bool ABSL_INTERNAL_C_SYMBOL(AbslContainerInternalSampleEverything)();
+extern "C" bool Y_ABSL_INTERNAL_C_SYMBOL(AbslContainerInternalSampleEverything)();
 
 }  // namespace container_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_INTERNAL_HASHTABLEZ_SAMPLER_H_
+#endif  // Y_ABSL_CONTAINER_INTERNAL_HASHTABLEZ_SAMPLER_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler_force_weak_definition.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler_force_weak_definition.cc
index 79a3122981..7174c1cf6a 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler_force_weak_definition.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/hashtablez_sampler_force_weak_definition.cc
@@ -17,15 +17,15 @@
 #include "y_absl/base/attributes.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
 // See hashtablez_sampler.h for details.
-extern "C" ABSL_ATTRIBUTE_WEAK bool ABSL_INTERNAL_C_SYMBOL(
+extern "C" Y_ABSL_ATTRIBUTE_WEAK bool Y_ABSL_INTERNAL_C_SYMBOL(
     AbslContainerInternalSampleEverything)() {
   return false;
 }
 
 }  // namespace container_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/have_sse.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/have_sse.h
index e75e1a16d3..d89f632a45 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/have_sse.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/have_sse.h
@@ -13,38 +13,38 @@
 // limitations under the License.
 //
 // Shared config probing for SSE instructions used in Swiss tables.
-#ifndef ABSL_CONTAINER_INTERNAL_HAVE_SSE_H_
-#define ABSL_CONTAINER_INTERNAL_HAVE_SSE_H_
+#ifndef Y_ABSL_CONTAINER_INTERNAL_HAVE_SSE_H_
+#define Y_ABSL_CONTAINER_INTERNAL_HAVE_SSE_H_
 
-#ifndef ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2
+#ifndef Y_ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2
 #if defined(__SSE2__) ||  \
     (defined(_MSC_VER) && \
      (defined(_M_X64) || (defined(_M_IX86) && _M_IX86_FP >= 2)))
-#define ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2 1
+#define Y_ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2 1
 #else
-#define ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2 0
+#define Y_ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2 0
 #endif
 #endif
 
-#ifndef ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3
+#ifndef Y_ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3
 #ifdef __SSSE3__
-#define ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3 1
+#define Y_ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3 1
 #else
-#define ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3 0
+#define Y_ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3 0
 #endif
 #endif
 
-#if ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3 && \
-    !ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2
+#if Y_ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3 && \
+    !Y_ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2
 #error "Bad configuration!"
 #endif
 
-#if ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2
+#if Y_ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2
 #include <emmintrin.h>
 #endif
 
-#if ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3
+#if Y_ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3
 #include <tmmintrin.h>
 #endif
 
-#endif  // ABSL_CONTAINER_INTERNAL_HAVE_SSE_H_
+#endif  // Y_ABSL_CONTAINER_INTERNAL_HAVE_SSE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/inlined_vector.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/inlined_vector.h
index e6488e843e..9c8b3858af 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/inlined_vector.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/inlined_vector.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_CONTAINER_INTERNAL_INLINED_VECTOR_INTERNAL_H_
-#define ABSL_CONTAINER_INTERNAL_INLINED_VECTOR_INTERNAL_H_
+#ifndef Y_ABSL_CONTAINER_INTERNAL_INLINED_VECTOR_INTERNAL_H_
+#define Y_ABSL_CONTAINER_INTERNAL_INLINED_VECTOR_INTERNAL_H_
 
 #include <algorithm>
 #include <cstddef>
@@ -33,7 +33,7 @@
 #include "y_absl/types/span.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace inlined_vector_internal {
 
 // GCC does not deal very well with the below code
@@ -113,7 +113,7 @@ struct Allocation {
 
 template <typename A,
           bool IsOverAligned =
-              (alignof(ValueType<A>) > ABSL_INTERNAL_DEFAULT_NEW_ALIGNMENT)>
+              (alignof(ValueType<A>) > Y_ABSL_INTERNAL_DEFAULT_NEW_ALIGNMENT)>
 struct MallocAdapter {
   static Allocation<A> Allocate(A& allocator, SizeType<A> requested_capacity) {
     return {AllocatorTraits<A>::allocate(allocator, requested_capacity),
@@ -131,10 +131,10 @@ void ConstructElements(NoTypeDeduction<A>& allocator,
                        Pointer<A> construct_first, ValueAdapter& values,
                        SizeType<A> construct_size) {
   for (SizeType<A> i = 0; i < construct_size; ++i) {
-    ABSL_INTERNAL_TRY { values.ConstructNext(allocator, construct_first + i); }
-    ABSL_INTERNAL_CATCH_ANY {
+    Y_ABSL_INTERNAL_TRY { values.ConstructNext(allocator, construct_first + i); }
+    Y_ABSL_INTERNAL_CATCH_ANY {
       DestroyElements<A>(allocator, construct_first, i);
-      ABSL_INTERNAL_RETHROW;
+      Y_ABSL_INTERNAL_RETHROW;
     }
   }
 }
@@ -229,7 +229,7 @@ class AllocationTransaction {
     return result.data;
   }
 
-  ABSL_MUST_USE_RESULT Allocation<A> Release() && {
+  Y_ABSL_MUST_USE_RESULT Allocation<A> Release() && {
     Allocation<A> result = {GetData(), GetCapacity()};
     Reset();
     return result;
@@ -364,7 +364,7 @@ class Storage {
   // Storage Member Mutators
   // ---------------------------------------------------------------------------
 
-  ABSL_ATTRIBUTE_NOINLINE void InitFrom(const Storage& other);
+  Y_ABSL_ATTRIBUTE_NOINLINE void InitFrom(const Storage& other);
 
   template <typename ValueAdapter>
   void Initialize(ValueAdapter values, SizeType<A> new_size);
@@ -441,7 +441,7 @@ class Storage {
   }
 
  private:
-  ABSL_ATTRIBUTE_NOINLINE void DestroyContents();
+  Y_ABSL_ATTRIBUTE_NOINLINE void DestroyContents();
 
   using Metadata = container_internal::CompressedTuple<A, SizeType<A>>;
 
@@ -460,7 +460,7 @@ class Storage {
   };
 
   template <typename... Args>
-  ABSL_ATTRIBUTE_NOINLINE Reference<A> EmplaceBackSlow(Args&&... args);
+  Y_ABSL_ATTRIBUTE_NOINLINE Reference<A> EmplaceBackSlow(Args&&... args);
 
   Metadata metadata_;
   Data data_;
@@ -717,7 +717,7 @@ template <typename... Args>
 auto Storage<T, N, A>::EmplaceBack(Args&&... args) -> Reference<A> {
   StorageView<A> storage_view = MakeStorageView();
   const SizeType<A> n = storage_view.size;
-  if (ABSL_PREDICT_TRUE(n != storage_view.capacity)) {
+  if (Y_ABSL_PREDICT_TRUE(n != storage_view.capacity)) {
     // Fast path; new element fits.
     Pointer<A> last_ptr = storage_view.data + n;
     AllocatorTraits<A>::construct(GetAllocator(), last_ptr,
@@ -744,13 +744,13 @@ auto Storage<T, N, A>::EmplaceBackSlow(Args&&... args) -> Reference<A> {
   AllocatorTraits<A>::construct(GetAllocator(), last_ptr,
                                 std::forward<Args>(args)...);
   // Move elements from old backing store to new backing store.
-  ABSL_INTERNAL_TRY {
+  Y_ABSL_INTERNAL_TRY {
     ConstructElements<A>(GetAllocator(), allocation_tx.GetData(), move_values,
                          storage_view.size);
   }
-  ABSL_INTERNAL_CATCH_ANY {
+  Y_ABSL_INTERNAL_CATCH_ANY {
     AllocatorTraits<A>::destroy(GetAllocator(), last_ptr);
-    ABSL_INTERNAL_RETHROW;
+    Y_ABSL_INTERNAL_RETHROW;
   }
   // Destroy elements in old backing store.
   DestroyElements<A>(GetAllocator(), storage_view.data, storage_view.size);
@@ -790,7 +790,7 @@ template <typename T, size_t N, typename A>
 auto Storage<T, N, A>::Reserve(SizeType<A> requested_capacity) -> void {
   StorageView<A> storage_view = MakeStorageView();
 
-  if (ABSL_PREDICT_FALSE(requested_capacity <= storage_view.capacity)) return;
+  if (Y_ABSL_PREDICT_FALSE(requested_capacity <= storage_view.capacity)) return;
 
   AllocationTransaction<A> allocation_tx(GetAllocator());
 
@@ -819,7 +819,7 @@ auto Storage<T, N, A>::ShrinkToFit() -> void {
   StorageView<A> storage_view{GetAllocatedData(), GetSize(),
                               GetAllocatedCapacity()};
 
-  if (ABSL_PREDICT_FALSE(storage_view.size == storage_view.capacity)) return;
+  if (Y_ABSL_PREDICT_FALSE(storage_view.size == storage_view.capacity)) return;
 
   AllocationTransaction<A> allocation_tx(GetAllocator());
 
@@ -838,13 +838,13 @@ auto Storage<T, N, A>::ShrinkToFit() -> void {
     construct_data = GetInlinedData();
   }
 
-  ABSL_INTERNAL_TRY {
+  Y_ABSL_INTERNAL_TRY {
     ConstructElements<A>(GetAllocator(), construct_data, move_values,
                          storage_view.size);
   }
-  ABSL_INTERNAL_CATCH_ANY {
+  Y_ABSL_INTERNAL_CATCH_ANY {
     SetAllocation({storage_view.data, storage_view.capacity});
-    ABSL_INTERNAL_RETHROW;
+    Y_ABSL_INTERNAL_RETHROW;
   }
 
   DestroyElements<A>(GetAllocator(), storage_view.data, storage_view.size);
@@ -898,15 +898,15 @@ auto Storage<T, N, A>::Swap(Storage* other_storage_ptr) -> void {
     IteratorValueAdapter<A, MoveIterator<A>> move_values(
         MoveIterator<A>(inlined_ptr->GetInlinedData()));
 
-    ABSL_INTERNAL_TRY {
+    Y_ABSL_INTERNAL_TRY {
       ConstructElements<A>(inlined_ptr->GetAllocator(),
                            allocated_ptr->GetInlinedData(), move_values,
                            inlined_ptr->GetSize());
     }
-    ABSL_INTERNAL_CATCH_ANY {
+    Y_ABSL_INTERNAL_CATCH_ANY {
       allocated_ptr->SetAllocation(
           Allocation<A>{allocated_storage_view.data, allocated_storage_view.capacity});
-      ABSL_INTERNAL_RETHROW;
+      Y_ABSL_INTERNAL_RETHROW;
     }
 
     DestroyElements<A>(inlined_ptr->GetAllocator(),
@@ -926,7 +926,7 @@ auto Storage<T, N, A>::Swap(Storage* other_storage_ptr) -> void {
 #endif
 
 }  // namespace inlined_vector_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_INTERNAL_INLINED_VECTOR_INTERNAL_H_
+#endif  // Y_ABSL_CONTAINER_INTERNAL_INLINED_VECTOR_INTERNAL_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/layout.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/layout.h
index 4c3f668943..b7faf1b329 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/layout.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/layout.h
@@ -157,8 +157,8 @@
 // creates a `Layout` object, which exposes the same functionality by inheriting
 // from `LayoutImpl<>`.
 
-#ifndef ABSL_CONTAINER_INTERNAL_LAYOUT_H_
-#define ABSL_CONTAINER_INTERNAL_LAYOUT_H_
+#ifndef Y_ABSL_CONTAINER_INTERNAL_LAYOUT_H_
+#define Y_ABSL_CONTAINER_INTERNAL_LAYOUT_H_
 
 #include <assert.h>
 #include <stddef.h>
@@ -177,20 +177,20 @@
 #include "y_absl/types/span.h"
 #include "y_absl/utility/utility.h"
 
-#ifdef ABSL_HAVE_ADDRESS_SANITIZER
+#ifdef Y_ABSL_HAVE_ADDRESS_SANITIZER
 #include <sanitizer/asan_interface.h>
 #endif
 
 #if defined(__GXX_RTTI)
-#define ABSL_INTERNAL_HAS_CXA_DEMANGLE
+#define Y_ABSL_INTERNAL_HAS_CXA_DEMANGLE
 #endif
 
-#ifdef ABSL_INTERNAL_HAS_CXA_DEMANGLE
+#ifdef Y_ABSL_INTERNAL_HAS_CXA_DEMANGLE
 #include <cxxabi.h>
 #endif
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
 // A type wrapper that instructs `Layout` to use the specific alignment for the
@@ -296,7 +296,7 @@ TString TypeName() {
   TString out;
   int status = 0;
   char* demangled = nullptr;
-#ifdef ABSL_INTERNAL_HAS_CXA_DEMANGLE
+#ifdef Y_ABSL_INTERNAL_HAS_CXA_DEMANGLE
   demangled = abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, &status);
 #endif
   if (status == 0 && demangled != nullptr) {  // Demangling succeeded.
@@ -616,7 +616,7 @@ class LayoutImpl<std::tuple<Elements...>, y_absl::index_sequence<SizeSeq...>,
   void PoisonPadding(const Char* p) const {
     static_assert(N < NumOffsets, "Index out of bounds");
     (void)p;
-#ifdef ABSL_HAVE_ADDRESS_SANITIZER
+#ifdef Y_ABSL_HAVE_ADDRESS_SANITIZER
     PoisonPadding<Char, N - 1>(p);
     // The `if` is an optimization. It doesn't affect the observable behaviour.
     if (ElementAlignment<N - 1>::value % ElementAlignment<N>::value) {
@@ -737,7 +737,7 @@ class Layout : public internal_layout::LayoutType<sizeof...(Ts), Ts...> {
 };
 
 }  // namespace container_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_INTERNAL_LAYOUT_H_
+#endif  // Y_ABSL_CONTAINER_INTERNAL_LAYOUT_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/node_hash_policy.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/node_hash_policy.h
index 24d0eaf5ee..65c98410c1 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/node_hash_policy.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/node_hash_policy.h
@@ -30,8 +30,8 @@
 // It may also optionally define `value()` and `apply()`. For documentation on
 // these, see hash_policy_traits.h.
 
-#ifndef ABSL_CONTAINER_INTERNAL_NODE_HASH_POLICY_H_
-#define ABSL_CONTAINER_INTERNAL_NODE_HASH_POLICY_H_
+#ifndef Y_ABSL_CONTAINER_INTERNAL_NODE_HASH_POLICY_H_
+#define Y_ABSL_CONTAINER_INTERNAL_NODE_HASH_POLICY_H_
 
 #include <cassert>
 #include <cstddef>
@@ -42,7 +42,7 @@
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
 template <class Reference, class Policy>
@@ -86,7 +86,7 @@ struct node_hash_policy {
 };
 
 }  // namespace container_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_INTERNAL_NODE_HASH_POLICY_H_
+#endif  // Y_ABSL_CONTAINER_INTERNAL_NODE_HASH_POLICY_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_map.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_map.h
index 8a0591f581..524178ff6f 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_map.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_map.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_CONTAINER_INTERNAL_RAW_HASH_MAP_H_
-#define ABSL_CONTAINER_INTERNAL_RAW_HASH_MAP_H_
+#ifndef Y_ABSL_CONTAINER_INTERNAL_RAW_HASH_MAP_H_
+#define Y_ABSL_CONTAINER_INTERNAL_RAW_HASH_MAP_H_
 
 #include <tuple>
 #include <type_traits>
@@ -24,7 +24,7 @@
 #include "y_absl/container/internal/raw_hash_set.h"  // IWYU pragma: export
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
 template <class Policy, class Hash, class Eq, class Alloc>
@@ -192,7 +192,7 @@ class raw_hash_map : public raw_hash_set<Policy, Hash, Eq, Alloc> {
 };
 
 }  // namespace container_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_INTERNAL_RAW_HASH_MAP_H_
+#endif  // Y_ABSL_CONTAINER_INTERNAL_RAW_HASH_MAP_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set.cc
index bf2a15a678..a3291e681e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set.cc
@@ -20,10 +20,10 @@
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
-alignas(16) ABSL_CONST_INIT ABSL_DLL const ctrl_t kEmptyGroup[16] = {
+alignas(16) Y_ABSL_CONST_INIT Y_ABSL_DLL const ctrl_t kEmptyGroup[16] = {
     ctrl_t::kSentinel, ctrl_t::kEmpty, ctrl_t::kEmpty, ctrl_t::kEmpty,
     ctrl_t::kEmpty,    ctrl_t::kEmpty, ctrl_t::kEmpty, ctrl_t::kEmpty,
     ctrl_t::kEmpty,    ctrl_t::kEmpty, ctrl_t::kEmpty, ctrl_t::kEmpty,
@@ -33,13 +33,13 @@ constexpr size_t Group::kWidth;
 
 // Returns "random" seed.
 inline size_t RandomSeed() {
-#ifdef ABSL_HAVE_THREAD_LOCAL
+#ifdef Y_ABSL_HAVE_THREAD_LOCAL
   static thread_local size_t counter = 0;
   size_t value = ++counter;
-#else   // ABSL_HAVE_THREAD_LOCAL
+#else   // Y_ABSL_HAVE_THREAD_LOCAL
   static std::atomic<size_t> counter(0);
   size_t value = counter.fetch_add(1, std::memory_order_relaxed);
-#endif  // ABSL_HAVE_THREAD_LOCAL
+#endif  // Y_ABSL_HAVE_THREAD_LOCAL
   return value ^ static_cast<size_t>(reinterpret_cast<uintptr_t>(&counter));
 }
 
@@ -63,5 +63,5 @@ void ConvertDeletedToEmptyAndFullToDeleted(ctrl_t* ctrl, size_t capacity) {
 template FindInfo find_first_non_full(const ctrl_t*, size_t, size_t);
 
 }  // namespace container_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set.h
index 8f45559b31..d264d85eef 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/raw_hash_set.h
@@ -99,8 +99,8 @@
 // are `kEmpty`, and these ensure that we always see at least one empty slot and
 // can stop an unsuccessful search.
 
-#ifndef ABSL_CONTAINER_INTERNAL_RAW_HASH_SET_H_
-#define ABSL_CONTAINER_INTERNAL_RAW_HASH_SET_H_
+#ifndef Y_ABSL_CONTAINER_INTERNAL_RAW_HASH_SET_H_
+#define Y_ABSL_CONTAINER_INTERNAL_RAW_HASH_SET_H_
 
 #include <algorithm>
 #include <cmath>
@@ -129,7 +129,7 @@
 #include "y_absl/utility/utility.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
 template <typename AllocType>
@@ -200,7 +200,7 @@ constexpr bool IsNoThrowSwappable(std::false_type /* is_swappable */) {
 
 template <typename T>
 uint32_t TrailingZeros(T x) {
-  ABSL_INTERNAL_ASSUME(x != 0);
+  Y_ABSL_INTERNAL_ASSUME(x != 0);
   return countr_zero(x);
 }
 
@@ -301,7 +301,7 @@ static_assert(ctrl_t::kDeleted == static_cast<ctrl_t>(-2),
 
 // A single block of empty control bytes for tables without any slots allocated.
 // This enables removing a branch in the hot path of find().
-ABSL_DLL extern const ctrl_t kEmptyGroup[16];
+Y_ABSL_DLL extern const ctrl_t kEmptyGroup[16];
 inline ctrl_t* EmptyGroup() {
   return const_cast<ctrl_t*>(kEmptyGroup);
 }
@@ -331,7 +331,7 @@ inline bool IsFull(ctrl_t c) { return c >= static_cast<ctrl_t>(0); }
 inline bool IsDeleted(ctrl_t c) { return c == ctrl_t::kDeleted; }
 inline bool IsEmptyOrDeleted(ctrl_t c) { return c < ctrl_t::kSentinel; }
 
-#if ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2
+#if Y_ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2
 
 // https://github.com/abseil/abseil-cpp/issues/209
 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=87853
@@ -365,7 +365,7 @@ struct GroupSse2Impl {
 
   // Returns a bitmask representing the positions of empty slots.
   BitMask<uint32_t, kWidth> MatchEmpty() const {
-#if ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3
+#if Y_ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3
     // This only works because ctrl_t::kEmpty is -128.
     return BitMask<uint32_t, kWidth>(
         _mm_movemask_epi8(_mm_sign_epi8(ctrl, ctrl)));
@@ -391,7 +391,7 @@ struct GroupSse2Impl {
   void ConvertSpecialToEmptyAndFullToDeleted(ctrl_t* dst) const {
     auto msbs = _mm_set1_epi8(static_cast<char>(-128));
     auto x126 = _mm_set1_epi8(126);
-#if ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3
+#if Y_ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSSE3
     auto res = _mm_or_si128(_mm_shuffle_epi8(x126, ctrl), msbs);
 #else
     auto zero = _mm_setzero_si128();
@@ -403,7 +403,7 @@ struct GroupSse2Impl {
 
   __m128i ctrl;
 };
-#endif  // ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2
+#endif  // Y_ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2
 
 struct GroupPortableImpl {
   static constexpr size_t kWidth = 8;
@@ -457,7 +457,7 @@ struct GroupPortableImpl {
   uint64_t ctrl;
 };
 
-#if ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2
+#if Y_ABSL_INTERNAL_RAW_HASH_SET_HAVE_SSE2
 using Group = GroupSse2Impl;
 #else
 using Group = GroupPortableImpl;
@@ -534,13 +534,13 @@ size_t SelectBucketCountForIterRange(InputIter first, InputIter last,
 }
 
 inline void AssertIsFull(ctrl_t* ctrl) {
-  ABSL_HARDENING_ASSERT((ctrl != nullptr && IsFull(*ctrl)) &&
+  Y_ABSL_HARDENING_ASSERT((ctrl != nullptr && IsFull(*ctrl)) &&
                         "Invalid operation on iterator. The element might have "
                         "been erased, or the table might have rehashed.");
 }
 
 inline void AssertIsValid(ctrl_t* ctrl) {
-  ABSL_HARDENING_ASSERT((ctrl == nullptr || IsFull(*ctrl)) &&
+  Y_ABSL_HARDENING_ASSERT((ctrl == nullptr || IsFull(*ctrl)) &&
                         "Invalid operation on iterator. The element might have "
                         "been erased, or the table might have rehashed.");
 }
@@ -804,7 +804,7 @@ class raw_hash_set {
     iterator(ctrl_t* ctrl, slot_type* slot) : ctrl_(ctrl), slot_(slot) {
       // This assumption helps the compiler know that any non-end iterator is
       // not equal to any end iterator.
-      ABSL_INTERNAL_ASSUME(ctrl != nullptr);
+      Y_ABSL_INTERNAL_ASSUME(ctrl != nullptr);
     }
 
     void skip_empty_or_deleted() {
@@ -813,7 +813,7 @@ class raw_hash_set {
         ctrl_ += shift;
         slot_ += shift;
       }
-      if (ABSL_PREDICT_FALSE(*ctrl_ == ctrl_t::kSentinel)) ctrl_ = nullptr;
+      if (Y_ABSL_PREDICT_FALSE(*ctrl_ == ctrl_t::kSentinel)) ctrl_ = nullptr;
     }
 
     ctrl_t* ctrl_ = nullptr;
@@ -1070,7 +1070,7 @@ class raw_hash_set {
   size_t capacity() const { return capacity_; }
   size_t max_size() const { return (std::numeric_limits<size_t>::max)(); }
 
-  ABSL_ATTRIBUTE_REINITIALIZES void clear() {
+  Y_ABSL_ATTRIBUTE_REINITIALIZES void clear() {
     // Iterating over this container is O(bucket_count()). When bucket_count()
     // is much greater than size(), iteration becomes prohibitively expensive.
     // For clear() it is more important to reuse the allocated array when the
@@ -1466,12 +1466,12 @@ class raw_hash_set {
     while (true) {
       Group g{ctrl_ + seq.offset()};
       for (int i : g.Match(H2(hash))) {
-        if (ABSL_PREDICT_TRUE(PolicyTraits::apply(
+        if (Y_ABSL_PREDICT_TRUE(PolicyTraits::apply(
                 EqualElement<K>{key, eq_ref()},
                 PolicyTraits::element(slots_ + seq.offset(i)))))
           return iterator_at(seq.offset(i));
       }
-      if (ABSL_PREDICT_TRUE(g.MatchEmpty())) return end();
+      if (Y_ABSL_PREDICT_TRUE(g.MatchEmpty())) return end();
       seq.next();
       assert(seq.index() <= capacity_ && "full table!");
     }
@@ -1707,7 +1707,7 @@ class raw_hash_set {
     infoz().RecordRehash(total_probe_length);
   }
 
-  void drop_deletes_without_resize() ABSL_ATTRIBUTE_NOINLINE {
+  void drop_deletes_without_resize() Y_ABSL_ATTRIBUTE_NOINLINE {
     assert(IsValidCapacity(capacity_));
     assert(!is_small(capacity_));
     // Algorithm:
@@ -1747,7 +1747,7 @@ class raw_hash_set {
       };
 
       // Element doesn't move.
-      if (ABSL_PREDICT_TRUE(probe_index(new_i) == probe_index(i))) {
+      if (Y_ABSL_PREDICT_TRUE(probe_index(new_i) == probe_index(i))) {
         SetCtrl(i, H2(hash), capacity_, ctrl_, slots_, sizeof(slot_type));
         continue;
       }
@@ -1833,11 +1833,11 @@ class raw_hash_set {
     while (true) {
       Group g{ctrl_ + seq.offset()};
       for (int i : g.Match(H2(hash))) {
-        if (ABSL_PREDICT_TRUE(PolicyTraits::element(slots_ + seq.offset(i)) ==
+        if (Y_ABSL_PREDICT_TRUE(PolicyTraits::element(slots_ + seq.offset(i)) ==
                               elem))
           return true;
       }
-      if (ABSL_PREDICT_TRUE(g.MatchEmpty())) return false;
+      if (Y_ABSL_PREDICT_TRUE(g.MatchEmpty())) return false;
       seq.next();
       assert(seq.index() <= capacity_ && "full table!");
     }
@@ -1865,21 +1865,21 @@ class raw_hash_set {
     while (true) {
       Group g{ctrl_ + seq.offset()};
       for (int i : g.Match(H2(hash))) {
-        if (ABSL_PREDICT_TRUE(PolicyTraits::apply(
+        if (Y_ABSL_PREDICT_TRUE(PolicyTraits::apply(
                 EqualElement<K>{key, eq_ref()},
                 PolicyTraits::element(slots_ + seq.offset(i)))))
           return {seq.offset(i), false};
       }
-      if (ABSL_PREDICT_TRUE(g.MatchEmpty())) break;
+      if (Y_ABSL_PREDICT_TRUE(g.MatchEmpty())) break;
       seq.next();
       assert(seq.index() <= capacity_ && "full table!");
     }
     return {prepare_insert(hash), true};
   }
 
-  size_t prepare_insert(size_t hash) ABSL_ATTRIBUTE_NOINLINE {
+  size_t prepare_insert(size_t hash) Y_ABSL_ATTRIBUTE_NOINLINE {
     auto target = find_first_non_full(ctrl_, hash, capacity_);
-    if (ABSL_PREDICT_FALSE(growth_left() == 0 &&
+    if (Y_ABSL_PREDICT_FALSE(growth_left() == 0 &&
                            !IsDeleted(ctrl_[target.offset]))) {
       rehash_and_grow_if_necessary();
       target = find_first_non_full(ctrl_, hash, capacity_);
@@ -2028,7 +2028,7 @@ struct HashtableDebugAccess<Set, y_absl::void_t<typename Set::raw_hash_set>> {
 
 }  // namespace hashtable_debug_internal
 }  // namespace container_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_INTERNAL_RAW_HASH_SET_H_
+#endif  // Y_ABSL_CONTAINER_INTERNAL_RAW_HASH_SET_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/test_instance_tracker.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/test_instance_tracker.h
index 49dcaf5d21..b05387391d 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/test_instance_tracker.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/test_instance_tracker.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_CONTAINER_INTERNAL_TEST_INSTANCE_TRACKER_H_
-#define ABSL_CONTAINER_INTERNAL_TEST_INSTANCE_TRACKER_H_
+#ifndef Y_ABSL_CONTAINER_INTERNAL_TEST_INSTANCE_TRACKER_H_
+#define Y_ABSL_CONTAINER_INTERNAL_TEST_INSTANCE_TRACKER_H_
 
 #include <cstdlib>
 #include <ostream>
@@ -21,7 +21,7 @@
 #include "y_absl/types/compare.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace test_internal {
 
 // A type that counts number of occurrences of the type, the live occurrences of
@@ -268,7 +268,7 @@ class MovableOnlyInstance : public BaseCountedInstance {
 };
 
 }  // namespace test_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_INTERNAL_TEST_INSTANCE_TRACKER_H_
+#endif  // Y_ABSL_CONTAINER_INTERNAL_TEST_INSTANCE_TRACKER_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/tracked.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/tracked.h
index 8765ee5ea6..b978ddd722 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/tracked.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/tracked.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_CONTAINER_INTERNAL_TRACKED_H_
-#define ABSL_CONTAINER_INTERNAL_TRACKED_H_
+#ifndef Y_ABSL_CONTAINER_INTERNAL_TRACKED_H_
+#define Y_ABSL_CONTAINER_INTERNAL_TRACKED_H_
 
 #include <stddef.h>
 
@@ -23,7 +23,7 @@
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
 // A class that tracks its copies and moves so that it can be queried in tests.
@@ -77,7 +77,7 @@ class Tracked {
 };
 
 }  // namespace container_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_INTERNAL_TRACKED_H_
+#endif  // Y_ABSL_CONTAINER_INTERNAL_TRACKED_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_constructor_test.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_constructor_test.h
index f55d6293ae..b91b2c5dba 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_constructor_test.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_constructor_test.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_CONSTRUCTOR_TEST_H_
-#define ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_CONSTRUCTOR_TEST_H_
+#ifndef Y_ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_CONSTRUCTOR_TEST_H_
+#define Y_ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_CONSTRUCTOR_TEST_H_
 
 #include <algorithm>
 #include <unordered_map>
@@ -25,7 +25,7 @@
 #include "y_absl/container/internal/hash_policy_testing.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
 template <class UnordMap>
@@ -141,7 +141,7 @@ TYPED_TEST_P(ConstructorTest, BucketCountHashAlloc) {
   BucketCountHashAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
 }
 
-#if ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS
+#if Y_ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS
 using has_alloc_std_constructors = std::true_type;
 #else
 using has_alloc_std_constructors = std::false_type;
@@ -488,7 +488,7 @@ REGISTER_TYPED_TEST_CASE_P(
     AssignmentFromInitializerListOverwritesExisting, AssignmentOnSelf);
 
 }  // namespace container_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_CONSTRUCTOR_TEST_H_
+#endif  // Y_ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_CONSTRUCTOR_TEST_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_lookup_test.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_lookup_test.h
index 251f49aea2..5d42807f89 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_lookup_test.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_lookup_test.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_LOOKUP_TEST_H_
-#define ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_LOOKUP_TEST_H_
+#ifndef Y_ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_LOOKUP_TEST_H_
+#define Y_ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_LOOKUP_TEST_H_
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
@@ -21,7 +21,7 @@
 #include "y_absl/container/internal/hash_policy_testing.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
 template <class UnordMap>
@@ -111,7 +111,7 @@ REGISTER_TYPED_TEST_CASE_P(LookupTest, At, OperatorBracket, Count, Find,
                            EqualRange);
 
 }  // namespace container_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_LOOKUP_TEST_H_
+#endif  // Y_ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_LOOKUP_TEST_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_members_test.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_members_test.h
index 1c9dc8c6be..ef2d2b65f6 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_members_test.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_members_test.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_MEMBERS_TEST_H_
-#define ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_MEMBERS_TEST_H_
+#ifndef Y_ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_MEMBERS_TEST_H_
+#define Y_ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_MEMBERS_TEST_H_
 
 #include <type_traits>
 #include "gmock/gmock.h"
@@ -21,7 +21,7 @@
 #include "y_absl/meta/type_traits.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
 template <class UnordMap>
@@ -81,7 +81,7 @@ TYPED_TEST_P(MembersTest, BeginEnd) {
 REGISTER_TYPED_TEST_SUITE_P(MembersTest, Typedefs, SimpleFunctions, BeginEnd);
 
 }  // namespace container_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_MEMBERS_TEST_H_
+#endif  // Y_ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_MEMBERS_TEST_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_modifiers_test.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_modifiers_test.h
index 725cfdc345..f29b02ee55 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_modifiers_test.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_map_modifiers_test.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_MODIFIERS_TEST_H_
-#define ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_MODIFIERS_TEST_H_
+#ifndef Y_ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_MODIFIERS_TEST_H_
+#define Y_ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_MODIFIERS_TEST_H_
 
 #include <memory>
 
@@ -23,7 +23,7 @@
 #include "y_absl/container/internal/hash_policy_testing.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
 template <class UnordMap>
@@ -345,7 +345,7 @@ TYPED_TEST_P(UniquePtrModifiersTest, TryEmplace) {
 REGISTER_TYPED_TEST_SUITE_P(UniquePtrModifiersTest, TryEmplace);
 
 }  // namespace container_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_MODIFIERS_TEST_H_
+#endif  // Y_ABSL_CONTAINER_INTERNAL_UNORDERED_MAP_MODIFIERS_TEST_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_constructor_test.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_constructor_test.h
index 1404f44916..374512e714 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_constructor_test.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_constructor_test.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_CONTAINER_INTERNAL_UNORDERED_SET_CONSTRUCTOR_TEST_H_
-#define ABSL_CONTAINER_INTERNAL_UNORDERED_SET_CONSTRUCTOR_TEST_H_
+#ifndef Y_ABSL_CONTAINER_INTERNAL_UNORDERED_SET_CONSTRUCTOR_TEST_H_
+#define Y_ABSL_CONTAINER_INTERNAL_UNORDERED_SET_CONSTRUCTOR_TEST_H_
 
 #include <algorithm>
 #include <unordered_set>
@@ -26,7 +26,7 @@
 #include "y_absl/meta/type_traits.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
 template <class UnordMap>
@@ -150,7 +150,7 @@ TYPED_TEST_P(ConstructorTest, BucketCountHashAlloc) {
   BucketCountHashAllocTest<TypeParam>(expect_cxx14_apis<TypeParam>());
 }
 
-#if ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS
+#if Y_ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS
 using has_alloc_std_constructors = std::true_type;
 #else
 using has_alloc_std_constructors = std::false_type;
@@ -490,7 +490,7 @@ REGISTER_TYPED_TEST_CASE_P(
     AssignmentFromInitializerListOverwritesExisting, AssignmentOnSelf);
 
 }  // namespace container_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_SET_CONSTRUCTOR_TEST_H_
+#endif  // Y_ABSL_CONTAINER_INTERNAL_UNORDERED_SET_CONSTRUCTOR_TEST_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_lookup_test.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_lookup_test.h
index 05579173d1..94393b1d89 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_lookup_test.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_lookup_test.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_CONTAINER_INTERNAL_UNORDERED_SET_LOOKUP_TEST_H_
-#define ABSL_CONTAINER_INTERNAL_UNORDERED_SET_LOOKUP_TEST_H_
+#ifndef Y_ABSL_CONTAINER_INTERNAL_UNORDERED_SET_LOOKUP_TEST_H_
+#define Y_ABSL_CONTAINER_INTERNAL_UNORDERED_SET_LOOKUP_TEST_H_
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
@@ -21,7 +21,7 @@
 #include "y_absl/container/internal/hash_policy_testing.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
 template <class UnordSet>
@@ -85,7 +85,7 @@ TYPED_TEST_P(LookupTest, EqualRange) {
 REGISTER_TYPED_TEST_CASE_P(LookupTest, Count, Find, EqualRange);
 
 }  // namespace container_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_SET_LOOKUP_TEST_H_
+#endif  // Y_ABSL_CONTAINER_INTERNAL_UNORDERED_SET_LOOKUP_TEST_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_members_test.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_members_test.h
index ad1c88d8b2..8e9d6b6959 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_members_test.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_members_test.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_CONTAINER_INTERNAL_UNORDERED_SET_MEMBERS_TEST_H_
-#define ABSL_CONTAINER_INTERNAL_UNORDERED_SET_MEMBERS_TEST_H_
+#ifndef Y_ABSL_CONTAINER_INTERNAL_UNORDERED_SET_MEMBERS_TEST_H_
+#define Y_ABSL_CONTAINER_INTERNAL_UNORDERED_SET_MEMBERS_TEST_H_
 
 #include <type_traits>
 #include "gmock/gmock.h"
@@ -21,7 +21,7 @@
 #include "y_absl/meta/type_traits.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
 template <class UnordSet>
@@ -80,7 +80,7 @@ TYPED_TEST_P(MembersTest, BeginEnd) {
 REGISTER_TYPED_TEST_SUITE_P(MembersTest, Typedefs, SimpleFunctions, BeginEnd);
 
 }  // namespace container_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_SET_MEMBERS_TEST_H_
+#endif  // Y_ABSL_CONTAINER_INTERNAL_UNORDERED_SET_MEMBERS_TEST_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_modifiers_test.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_modifiers_test.h
index 2f96a0197b..192549005e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_modifiers_test.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/internal/unordered_set_modifiers_test.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_CONTAINER_INTERNAL_UNORDERED_SET_MODIFIERS_TEST_H_
-#define ABSL_CONTAINER_INTERNAL_UNORDERED_SET_MODIFIERS_TEST_H_
+#ifndef Y_ABSL_CONTAINER_INTERNAL_UNORDERED_SET_MODIFIERS_TEST_H_
+#define Y_ABSL_CONTAINER_INTERNAL_UNORDERED_SET_MODIFIERS_TEST_H_
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
@@ -21,7 +21,7 @@
 #include "y_absl/container/internal/hash_policy_testing.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
 template <class UnordSet>
@@ -215,7 +215,7 @@ REGISTER_TYPED_TEST_CASE_P(ModifiersTest, Clear, Insert, InsertHint,
                            Erase, EraseRange, EraseKey, Swap);
 
 }  // namespace container_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_INTERNAL_UNORDERED_SET_MODIFIERS_TEST_H_
+#endif  // Y_ABSL_CONTAINER_INTERNAL_UNORDERED_SET_MODIFIERS_TEST_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/node_hash_map.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/node_hash_map.h
index 07e26def79..4da000b176 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/node_hash_map.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/node_hash_map.h
@@ -33,8 +33,8 @@
 // `node_hash_map` and perhaps converting to a more efficient `flat_hash_map`
 // upon further review.
 
-#ifndef ABSL_CONTAINER_NODE_HASH_MAP_H_
-#define ABSL_CONTAINER_NODE_HASH_MAP_H_
+#ifndef Y_ABSL_CONTAINER_NODE_HASH_MAP_H_
+#define Y_ABSL_CONTAINER_NODE_HASH_MAP_H_
 
 #include <tuple>
 #include <type_traits>
@@ -48,7 +48,7 @@
 #include "y_absl/memory/memory.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 template <class Key, class Value>
 class NodeHashMapPolicy;
@@ -591,7 +591,7 @@ struct IsUnorderedContainer<
 
 }  // namespace container_algorithm_internal
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_NODE_HASH_MAP_H_
+#endif  // Y_ABSL_CONTAINER_NODE_HASH_MAP_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/container/node_hash_set.h b/contrib/restricted/abseil-cpp-tstring/y_absl/container/node_hash_set.h
index aa98bb29b8..7f25f34850 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/container/node_hash_set.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/container/node_hash_set.h
@@ -32,8 +32,8 @@
 // `node_hash_set` and perhaps converting to a more efficient `flat_hash_set`
 // upon further review.
 
-#ifndef ABSL_CONTAINER_NODE_HASH_SET_H_
-#define ABSL_CONTAINER_NODE_HASH_SET_H_
+#ifndef Y_ABSL_CONTAINER_NODE_HASH_SET_H_
+#define Y_ABSL_CONTAINER_NODE_HASH_SET_H_
 
 #include <type_traits>
 
@@ -44,7 +44,7 @@
 #include "y_absl/memory/memory.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 template <typename T>
 struct NodeHashSetPolicy;
@@ -487,7 +487,7 @@ struct IsUnorderedContainer<y_absl::node_hash_set<Key, Hash, KeyEqual, Allocator
     : std::true_type {};
 
 }  // namespace container_algorithm_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_CONTAINER_NODE_HASH_SET_H_
+#endif  // Y_ABSL_CONTAINER_NODE_HASH_SET_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler.cc
index fa6e30f935..a79d902623 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler.cc
@@ -29,7 +29,7 @@
 #include <TargetConditionals.h>
 #endif
 
-#ifdef ABSL_HAVE_MMAP
+#ifdef Y_ABSL_HAVE_MMAP
 #include <sys/mman.h>
 #endif
 
@@ -49,18 +49,18 @@
 #include "y_absl/debugging/stacktrace.h"
 
 #ifndef _WIN32
-#define ABSL_HAVE_SIGACTION
+#define Y_ABSL_HAVE_SIGACTION
 // Apple WatchOS and TVOS don't allow sigaltstack
 #if !(defined(TARGET_OS_WATCH) && TARGET_OS_WATCH) && \
     !(defined(TARGET_OS_TV) && TARGET_OS_TV)
-#define ABSL_HAVE_SIGALTSTACK
+#define Y_ABSL_HAVE_SIGALTSTACK
 #endif
 #endif
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
-ABSL_CONST_INIT static FailureSignalHandlerOptions fsh_options;
+Y_ABSL_CONST_INIT static FailureSignalHandlerOptions fsh_options;
 
 // Resets the signal handler for signo to the default action for that
 // signal, then raises the signal.
@@ -72,7 +72,7 @@ static void RaiseToDefaultHandler(int signo) {
 struct FailureSignalData {
   const int signo;
   const char* const as_string;
-#ifdef ABSL_HAVE_SIGACTION
+#ifdef Y_ABSL_HAVE_SIGACTION
   struct sigaction previous_action;
   // StructSigaction is used to silence -Wmissing-field-initializers.
   using StructSigaction = struct sigaction;
@@ -83,7 +83,7 @@ struct FailureSignalData {
 #endif
 };
 
-ABSL_CONST_INIT static FailureSignalData failure_signal_data[] = {
+Y_ABSL_CONST_INIT static FailureSignalData failure_signal_data[] = {
     {SIGSEGV, "SIGSEGV", FSD_PREVIOUS_INIT},
     {SIGILL, "SIGILL", FSD_PREVIOUS_INIT},
     {SIGFPE, "SIGFPE", FSD_PREVIOUS_INIT},
@@ -101,7 +101,7 @@ static void RaiseToPreviousHandler(int signo) {
   // Search for the previous handler.
   for (const auto& it : failure_signal_data) {
     if (it.signo == signo) {
-#ifdef ABSL_HAVE_SIGACTION
+#ifdef Y_ABSL_HAVE_SIGACTION
       sigaction(signo, &it.previous_action, nullptr);
 #else
       signal(signo, it.previous_handler);
@@ -128,7 +128,7 @@ const char* FailureSignalToString(int signo) {
 
 }  // namespace debugging_internal
 
-#ifdef ABSL_HAVE_SIGALTSTACK
+#ifdef Y_ABSL_HAVE_SIGALTSTACK
 
 static bool SetupAlternateStackOnce() {
 #if defined(__wasm__) || defined (__asjms__)
@@ -138,8 +138,8 @@ static bool SetupAlternateStackOnce() {
 #endif
   size_t stack_size =
       (std::max<size_t>(SIGSTKSZ, 65536) + page_mask) & ~page_mask;
-#if defined(ABSL_HAVE_ADDRESS_SANITIZER) || \
-    defined(ABSL_HAVE_MEMORY_SANITIZER) || defined(ABSL_HAVE_THREAD_SANITIZER)
+#if defined(Y_ABSL_HAVE_ADDRESS_SANITIZER) || \
+    defined(Y_ABSL_HAVE_MEMORY_SANITIZER) || defined(Y_ABSL_HAVE_THREAD_SANITIZER)
   // Account for sanitizer instrumentation requiring additional stack space.
   stack_size *= 5;
 #endif
@@ -148,7 +148,7 @@ static bool SetupAlternateStackOnce() {
   memset(&sigstk, 0, sizeof(sigstk));
   sigstk.ss_size = stack_size;
 
-#ifdef ABSL_HAVE_MMAP
+#ifdef Y_ABSL_HAVE_MMAP
 #ifndef MAP_STACK
 #define MAP_STACK 0
 #endif
@@ -158,31 +158,31 @@ static bool SetupAlternateStackOnce() {
   sigstk.ss_sp = mmap(nullptr, sigstk.ss_size, PROT_READ | PROT_WRITE,
                       MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, -1, 0);
   if (sigstk.ss_sp == MAP_FAILED) {
-    ABSL_RAW_LOG(FATAL, "mmap() for alternate signal stack failed");
+    Y_ABSL_RAW_LOG(FATAL, "mmap() for alternate signal stack failed");
   }
 #else
   sigstk.ss_sp = malloc(sigstk.ss_size);
   if (sigstk.ss_sp == nullptr) {
-    ABSL_RAW_LOG(FATAL, "malloc() for alternate signal stack failed");
+    Y_ABSL_RAW_LOG(FATAL, "malloc() for alternate signal stack failed");
   }
 #endif
 
   if (sigaltstack(&sigstk, nullptr) != 0) {
-    ABSL_RAW_LOG(FATAL, "sigaltstack() failed with errno=%d", errno);
+    Y_ABSL_RAW_LOG(FATAL, "sigaltstack() failed with errno=%d", errno);
   }
   return true;
 }
 
 #endif
 
-#ifdef ABSL_HAVE_SIGACTION
+#ifdef Y_ABSL_HAVE_SIGACTION
 
 // Sets up an alternate stack for signal handlers once.
 // Returns the appropriate flag for sig_action.sa_flags
 // if the system supports using an alternate stack.
 static int MaybeSetupAlternateStack() {
-#ifdef ABSL_HAVE_SIGALTSTACK
-  ABSL_ATTRIBUTE_UNUSED static const bool kOnce = SetupAlternateStackOnce();
+#ifdef Y_ABSL_HAVE_SIGALTSTACK
+  Y_ABSL_ATTRIBUTE_UNUSED static const bool kOnce = SetupAlternateStackOnce();
   return SA_ONSTACK;
 #else
   return 0;
@@ -202,7 +202,7 @@ static void InstallOneFailureHandler(FailureSignalData* data,
     act.sa_flags |= MaybeSetupAlternateStack();
   }
   act.sa_sigaction = handler;
-  ABSL_RAW_CHECK(sigaction(data->signo, &act, &data->previous_action) == 0,
+  Y_ABSL_RAW_CHECK(sigaction(data->signo, &act, &data->previous_action) == 0,
                  "sigaction() failed");
 }
 
@@ -211,7 +211,7 @@ static void InstallOneFailureHandler(FailureSignalData* data,
 static void InstallOneFailureHandler(FailureSignalData* data,
                                      void (*handler)(int)) {
   data->previous_handler = signal(data->signo, handler);
-  ABSL_RAW_CHECK(data->previous_handler != SIG_ERR, "signal() failed");
+  Y_ABSL_RAW_CHECK(data->previous_handler != SIG_ERR, "signal() failed");
 }
 
 #endif
@@ -259,7 +259,7 @@ static void WriterFnWrapper(const char* data, void* arg) {
 // Convenient wrapper around DumpPCAndFrameSizesAndStackTrace() for signal
 // handlers. "noinline" so that GetStackFrames() skips the top-most stack
 // frame for this function.
-ABSL_ATTRIBUTE_NOINLINE static void WriteStackTrace(
+Y_ABSL_ATTRIBUTE_NOINLINE static void WriteStackTrace(
     void* ucontext, bool symbolize_stacktrace,
     void (*writerfn)(const char*, void*), void* writerfn_arg) {
   constexpr int kNumStackFrames = 32;
@@ -300,7 +300,7 @@ static void PortableSleepForSeconds(int seconds) {
 #endif
 }
 
-#ifdef ABSL_HAVE_ALARM
+#ifdef Y_ABSL_HAVE_ALARM
 // AbslFailureSignalHandler() installs this as a signal handler for
 // SIGALRM, then sets an alarm to be delivered to the program after a
 // set amount of time. If AbslFailureSignalHandler() hangs for more than
@@ -314,9 +314,9 @@ static void ImmediateAbortSignalHandler(int) {
 // y_absl::base_internal::GetTID() returns pid_t on most platforms, but
 // returns y_absl::base_internal::pid_t on Windows.
 using GetTidType = decltype(y_absl::base_internal::GetTID());
-ABSL_CONST_INIT static std::atomic<GetTidType> failed_tid(0);
+Y_ABSL_CONST_INIT static std::atomic<GetTidType> failed_tid(0);
 
-#ifndef ABSL_HAVE_SIGACTION
+#ifndef Y_ABSL_HAVE_SIGACTION
 static void AbslFailureSignalHandler(int signo) {
   void* ucontext = nullptr;
 #else
@@ -328,7 +328,7 @@ static void AbslFailureSignalHandler(int signo, siginfo_t*, void* ucontext) {
   if (!failed_tid.compare_exchange_strong(
           previous_failed_tid, static_cast<intptr_t>(this_tid),
           std::memory_order_acq_rel, std::memory_order_relaxed)) {
-    ABSL_RAW_LOG(
+    Y_ABSL_RAW_LOG(
         ERROR,
         "Signal %d raised at PC=%p while already in AbslFailureSignalHandler()",
         signo, y_absl::debugging_internal::GetProgramCounter(ucontext));
@@ -347,11 +347,11 @@ static void AbslFailureSignalHandler(int signo, siginfo_t*, void* ucontext) {
   // signal was received by doing this as early as possible, i.e. after
   // verifying that this is not a recursive signal handler invocation.
   int my_cpu = -1;
-#ifdef ABSL_HAVE_SCHED_GETCPU
+#ifdef Y_ABSL_HAVE_SCHED_GETCPU
   my_cpu = sched_getcpu();
 #endif
 
-#ifdef ABSL_HAVE_ALARM
+#ifdef Y_ABSL_HAVE_ALARM
   // Set an alarm to abort the program in case this code hangs or deadlocks.
   if (fsh_options.alarm_on_failure_secs > 0) {
     alarm(0);  // Cancel any existing alarms.
@@ -384,5 +384,5 @@ void InstallFailureSignalHandler(const FailureSignalHandlerOptions& options) {
   }
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler.h
index 879df3c434..b426264276 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/failure_signal_handler.h
@@ -41,13 +41,13 @@
 // handler installed (which would be triggered if Abseil's failure signal
 // handler sets `call_previous_handler` to `true`).
 
-#ifndef ABSL_DEBUGGING_FAILURE_SIGNAL_HANDLER_H_
-#define ABSL_DEBUGGING_FAILURE_SIGNAL_HANDLER_H_
+#ifndef Y_ABSL_DEBUGGING_FAILURE_SIGNAL_HANDLER_H_
+#define Y_ABSL_DEBUGGING_FAILURE_SIGNAL_HANDLER_H_
 
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // FailureSignalHandlerOptions
 //
@@ -115,7 +115,7 @@ namespace debugging_internal {
 const char* FailureSignalToString(int signo);
 }  // namespace debugging_internal
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_DEBUGGING_FAILURE_SIGNAL_HANDLER_H_
+#endif  // Y_ABSL_DEBUGGING_FAILURE_SIGNAL_HANDLER_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/address_is_readable.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/address_is_readable.cc
index df217335ea..669d81f878 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/address_is_readable.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/address_is_readable.cc
@@ -20,14 +20,14 @@
 #if !defined(__linux__) || defined(__ANDROID__)
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace debugging_internal {
 
 // On platforms other than Linux, just return true.
 bool AddressIsReadable(const void* /* addr */) { return true; }
 
 }  // namespace debugging_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 #else
@@ -44,13 +44,13 @@ ABSL_NAMESPACE_END
 #include "y_absl/base/internal/raw_logging.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace debugging_internal {
 
 // Pack a pid and two file descriptors into a 64-bit word,
 // using 16, 24, and 24 bits for each respectively.
 static uint64_t Pack(uint64_t pid, uint64_t read_fd, uint64_t write_fd) {
-  ABSL_RAW_CHECK((read_fd >> 24) == 0 && (write_fd >> 24) == 0,
+  Y_ABSL_RAW_CHECK((read_fd >> 24) == 0 && (write_fd >> 24) == 0,
                  "fd out of range");
   return (pid << 48) | ((read_fd & 0xffffff) << 24) | (write_fd & 0xffffff);
 }
@@ -93,7 +93,7 @@ bool AddressIsReadable(const void *addr) {
       int p[2];
       // new pipe
       if (pipe(p) != 0) {
-        ABSL_RAW_LOG(FATAL, "Failed to create pipe, errno=%d", errno);
+        Y_ABSL_RAW_LOG(FATAL, "Failed to create pipe, errno=%d", errno);
       }
       fcntl(p[0], F_SETFD, FD_CLOEXEC);
       fcntl(p[1], F_SETFD, FD_CLOEXEC);
@@ -133,7 +133,7 @@ bool AddressIsReadable(const void *addr) {
 }
 
 }  // namespace debugging_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 #endif
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/address_is_readable.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/address_is_readable.h
index 279dcc640b..bbda33123f 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/address_is_readable.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/address_is_readable.h
@@ -12,13 +12,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_DEBUGGING_INTERNAL_ADDRESS_IS_READABLE_H_
-#define ABSL_DEBUGGING_INTERNAL_ADDRESS_IS_READABLE_H_
+#ifndef Y_ABSL_DEBUGGING_INTERNAL_ADDRESS_IS_READABLE_H_
+#define Y_ABSL_DEBUGGING_INTERNAL_ADDRESS_IS_READABLE_H_
 
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace debugging_internal {
 
 // Return whether the byte at *addr is readable, without faulting.
@@ -26,7 +26,7 @@ namespace debugging_internal {
 bool AddressIsReadable(const void *addr);
 
 }  // namespace debugging_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_DEBUGGING_INTERNAL_ADDRESS_IS_READABLE_H_
+#endif  // Y_ABSL_DEBUGGING_INTERNAL_ADDRESS_IS_READABLE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/demangle.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/demangle.cc
index 0a4daa2f5c..e9319575cb 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/demangle.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/demangle.cc
@@ -24,7 +24,7 @@
 #include <limits>
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace debugging_internal {
 
 typedef struct {
@@ -1955,5 +1955,5 @@ bool Demangle(const char *mangled, char *out, int out_size) {
 }
 
 }  // namespace debugging_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/demangle.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/demangle.h
index a9b42edb45..28d4dfb0e9 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/demangle.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/demangle.h
@@ -50,13 +50,13 @@
 // C++ ABI in the future.
 //
 
-#ifndef ABSL_DEBUGGING_INTERNAL_DEMANGLE_H_
-#define ABSL_DEBUGGING_INTERNAL_DEMANGLE_H_
+#ifndef Y_ABSL_DEBUGGING_INTERNAL_DEMANGLE_H_
+#define Y_ABSL_DEBUGGING_INTERNAL_DEMANGLE_H_
 
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace debugging_internal {
 
 // Demangle `mangled`.  On success, return true and write the
@@ -65,7 +65,7 @@ namespace debugging_internal {
 bool Demangle(const char *mangled, char *out, int out_size);
 
 }  // namespace debugging_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_DEBUGGING_INTERNAL_DEMANGLE_H_
+#endif  // Y_ABSL_DEBUGGING_INTERNAL_DEMANGLE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.cc
index ba4bbc3855..1df9cca1b6 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.cc
@@ -17,7 +17,7 @@
 
 #include "y_absl/debugging/internal/elf_mem_image.h"
 
-#ifdef ABSL_HAVE_ELF_MEM_IMAGE  // defined in elf_mem_image.h
+#ifdef Y_ABSL_HAVE_ELF_MEM_IMAGE  // defined in elf_mem_image.h
 
 #include <string.h>
 #include <cassert>
@@ -39,7 +39,7 @@
 #define VERSYM_VERSION 0x7fff
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace debugging_internal {
 
 namespace {
@@ -55,11 +55,11 @@ int ElfType(const ElfW(Sym) *symbol) { return ELF64_ST_TYPE(symbol->st_info); }
 #else
 const int kElfClass = -1;
 int ElfBind(const ElfW(Sym) *) {
-  ABSL_RAW_LOG(FATAL, "Unexpected word size");
+  Y_ABSL_RAW_LOG(FATAL, "Unexpected word size");
   return 0;
 }
 int ElfType(const ElfW(Sym) *) {
-  ABSL_RAW_LOG(FATAL, "Unexpected word size");
+  Y_ABSL_RAW_LOG(FATAL, "Unexpected word size");
   return 0;
 }
 #endif
@@ -82,7 +82,7 @@ const T *GetTableElement(const ElfW(Ehdr) * ehdr, ElfW(Off) table_offset,
 const int ElfMemImage::kInvalidBaseSentinel = 0;
 
 ElfMemImage::ElfMemImage(const void *base) {
-  ABSL_RAW_CHECK(base != kInvalidBase, "bad pointer");
+  Y_ABSL_RAW_CHECK(base != kInvalidBase, "bad pointer");
   Init(base);
 }
 
@@ -95,17 +95,17 @@ int ElfMemImage::GetNumSymbols() const {
 }
 
 const ElfW(Sym) *ElfMemImage::GetDynsym(int index) const {
-  ABSL_RAW_CHECK(index < GetNumSymbols(), "index out of range");
+  Y_ABSL_RAW_CHECK(index < GetNumSymbols(), "index out of range");
   return dynsym_ + index;
 }
 
 const ElfW(Versym) *ElfMemImage::GetVersym(int index) const {
-  ABSL_RAW_CHECK(index < GetNumSymbols(), "index out of range");
+  Y_ABSL_RAW_CHECK(index < GetNumSymbols(), "index out of range");
   return versym_ + index;
 }
 
 const ElfW(Phdr) *ElfMemImage::GetPhdr(int index) const {
-  ABSL_RAW_CHECK(index < ehdr_->e_phnum, "index out of range");
+  Y_ABSL_RAW_CHECK(index < ehdr_->e_phnum, "index out of range");
   return GetTableElement<ElfW(Phdr)>(ehdr_,
                                      ehdr_->e_phoff,
                                      ehdr_->e_phentsize,
@@ -113,7 +113,7 @@ const ElfW(Phdr) *ElfMemImage::GetPhdr(int index) const {
 }
 
 const char *ElfMemImage::GetDynstr(ElfW(Word) offset) const {
-  ABSL_RAW_CHECK(offset < strsize_, "offset out of range");
+  Y_ABSL_RAW_CHECK(offset < strsize_, "offset out of range");
   return dynstr_ + offset;
 }
 
@@ -122,12 +122,12 @@ const void *ElfMemImage::GetSymAddr(const ElfW(Sym) *sym) const {
     // Symbol corresponds to "special" (e.g. SHN_ABS) section.
     return reinterpret_cast<const void *>(sym->st_value);
   }
-  ABSL_RAW_CHECK(link_base_ < sym->st_value, "symbol out of range");
+  Y_ABSL_RAW_CHECK(link_base_ < sym->st_value, "symbol out of range");
   return GetTableElement<char>(ehdr_, 0, 1, sym->st_value - link_base_);
 }
 
 const ElfW(Verdef) *ElfMemImage::GetVerdef(int index) const {
-  ABSL_RAW_CHECK(0 <= index && static_cast<size_t>(index) <= verdefnum_,
+  Y_ABSL_RAW_CHECK(0 <= index && static_cast<size_t>(index) <= verdefnum_,
                  "index out of range");
   const ElfW(Verdef) *version_definition = verdef_;
   while (version_definition->vd_ndx < index && version_definition->vd_next) {
@@ -146,7 +146,7 @@ const ElfW(Verdaux) *ElfMemImage::GetVerdefAux(
 }
 
 const char *ElfMemImage::GetVerstr(ElfW(Word) offset) const {
-  ABSL_RAW_CHECK(offset < strsize_, "offset out of range");
+  Y_ABSL_RAW_CHECK(offset < strsize_, "offset out of range");
   return dynstr_ + offset;
 }
 
@@ -176,14 +176,14 @@ void ElfMemImage::Init(const void *base) {
   }
   switch (base_as_char[EI_DATA]) {
     case ELFDATA2LSB: {
-#ifndef ABSL_IS_LITTLE_ENDIAN
+#ifndef Y_ABSL_IS_LITTLE_ENDIAN
       assert(false);
       return;
 #endif
       break;
     }
     case ELFDATA2MSB: {
-#ifndef ABSL_IS_BIG_ENDIAN
+#ifndef Y_ABSL_IS_BIG_ENDIAN
       assert(false);
       return;
 #endif
@@ -338,7 +338,7 @@ ElfMemImage::SymbolIterator ElfMemImage::end() const {
 
 void ElfMemImage::SymbolIterator::Update(int increment) {
   const ElfMemImage *image = reinterpret_cast<const ElfMemImage *>(image_);
-  ABSL_RAW_CHECK(image->IsPresent() || increment == 0, "");
+  Y_ABSL_RAW_CHECK(image->IsPresent() || increment == 0, "");
   if (!image->IsPresent()) {
     return;
   }
@@ -349,7 +349,7 @@ void ElfMemImage::SymbolIterator::Update(int increment) {
   }
   const ElfW(Sym)    *symbol = image->GetDynsym(index_);
   const ElfW(Versym) *version_symbol = image->GetVersym(index_);
-  ABSL_RAW_CHECK(symbol && version_symbol, "");
+  Y_ABSL_RAW_CHECK(symbol && version_symbol, "");
   const char *const symbol_name = image->GetDynstr(symbol->st_name);
   const ElfW(Versym) version_index = version_symbol[0] & VERSYM_VERSION;
   const ElfW(Verdef) *version_definition = nullptr;
@@ -364,7 +364,7 @@ void ElfMemImage::SymbolIterator::Update(int increment) {
   if (version_definition) {
     // I am expecting 1 or 2 auxiliary entries: 1 for the version itself,
     // optional 2nd if the version has a parent.
-    ABSL_RAW_CHECK(
+    Y_ABSL_RAW_CHECK(
         version_definition->vd_cnt == 1 || version_definition->vd_cnt == 2,
         "wrong number of entries");
     const ElfW(Verdaux) *version_aux = image->GetVerdefAux(version_definition);
@@ -377,7 +377,7 @@ void ElfMemImage::SymbolIterator::Update(int increment) {
 }
 
 }  // namespace debugging_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_HAVE_ELF_MEM_IMAGE
+#endif  // Y_ABSL_HAVE_ELF_MEM_IMAGE
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.h
index 13a6b2e664..c19c0e9f8e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/elf_mem_image.h
@@ -16,8 +16,8 @@
 
 // Allow dynamic symbol lookup for in-memory Elf images.
 
-#ifndef ABSL_DEBUGGING_INTERNAL_ELF_MEM_IMAGE_H_
-#define ABSL_DEBUGGING_INTERNAL_ELF_MEM_IMAGE_H_
+#ifndef Y_ABSL_DEBUGGING_INTERNAL_ELF_MEM_IMAGE_H_
+#define Y_ABSL_DEBUGGING_INTERNAL_ELF_MEM_IMAGE_H_
 
 // Including this will define the __GLIBC__ macro if glibc is being
 // used.
@@ -27,16 +27,16 @@
 
 // Maybe one day we can rewrite this file not to require the elf
 // symbol extensions in glibc, but for right now we need them.
-#ifdef ABSL_HAVE_ELF_MEM_IMAGE
-#error ABSL_HAVE_ELF_MEM_IMAGE cannot be directly set
+#ifdef Y_ABSL_HAVE_ELF_MEM_IMAGE
+#error Y_ABSL_HAVE_ELF_MEM_IMAGE cannot be directly set
 #endif
 
 #if defined(__ELF__) && !defined(__native_client__) && !defined(__asmjs__) && \
     !defined(__wasm__)
-#define ABSL_HAVE_ELF_MEM_IMAGE 1
+#define Y_ABSL_HAVE_ELF_MEM_IMAGE 1
 #endif
 
-#ifdef ABSL_HAVE_ELF_MEM_IMAGE
+#ifdef Y_ABSL_HAVE_ELF_MEM_IMAGE
 
 #include <link.h>  // for ElfW
 
@@ -45,7 +45,7 @@
 #endif
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace debugging_internal {
 
 // An in-memory ELF image (may not exist on disk).
@@ -130,9 +130,9 @@ class ElfMemImage {
 };
 
 }  // namespace debugging_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_HAVE_ELF_MEM_IMAGE
+#endif  // Y_ABSL_HAVE_ELF_MEM_IMAGE
 
-#endif  // ABSL_DEBUGGING_INTERNAL_ELF_MEM_IMAGE_H_
+#endif  // Y_ABSL_DEBUGGING_INTERNAL_ELF_MEM_IMAGE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/examine_stack.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/examine_stack.cc
index c59d92b6a3..edc926cafd 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/examine_stack.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/examine_stack.cc
@@ -34,7 +34,7 @@
 #include "y_absl/debugging/symbolize.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace debugging_internal {
 
 // Returns the program counter from signal context, nullptr if
@@ -53,7 +53,7 @@ void* GetProgramCounter(void* vuc) {
 #elif defined(__hppa__)
     return reinterpret_cast<void*>(context->uc_mcontext.sc_iaoq[0]);
 #elif defined(__i386__)
-    if (14 < ABSL_ARRAYSIZE(context->uc_mcontext.gregs))
+    if (14 < Y_ABSL_ARRAYSIZE(context->uc_mcontext.gregs))
       return reinterpret_cast<void*>(context->uc_mcontext.gregs[14]);
 #elif defined(__ia64__)
     return reinterpret_cast<void*>(context->uc_mcontext.sc_ip);
@@ -78,7 +78,7 @@ void* GetProgramCounter(void* vuc) {
 #elif defined(__sparc__) && defined(__arch64__)
     return reinterpret_cast<void*>(context->uc_mcontext.mc_gregs[19]);
 #elif defined(__x86_64__)
-    if (16 < ABSL_ARRAYSIZE(context->uc_mcontext.gregs))
+    if (16 < Y_ABSL_ARRAYSIZE(context->uc_mcontext.gregs))
       return reinterpret_cast<void*>(context->uc_mcontext.gregs[16]);
 #elif defined(__e2k__)
     return reinterpret_cast<void*>(context->uc_mcontext.cr0_hi);
@@ -199,5 +199,5 @@ void DumpPCAndFrameSizesAndStackTrace(
 }
 
 }  // namespace debugging_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/examine_stack.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/examine_stack.h
index 32892a1150..4ac2c8358a 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/examine_stack.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/examine_stack.h
@@ -14,13 +14,13 @@
 // limitations under the License.
 //
 
-#ifndef ABSL_DEBUGGING_INTERNAL_EXAMINE_STACK_H_
-#define ABSL_DEBUGGING_INTERNAL_EXAMINE_STACK_H_
+#ifndef Y_ABSL_DEBUGGING_INTERNAL_EXAMINE_STACK_H_
+#define Y_ABSL_DEBUGGING_INTERNAL_EXAMINE_STACK_H_
 
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace debugging_internal {
 
 // Returns the program counter from signal context, or nullptr if
@@ -36,7 +36,7 @@ void DumpPCAndFrameSizesAndStackTrace(
     void (*writerfn)(const char*, void*), void* writerfn_arg);
 
 }  // namespace debugging_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_DEBUGGING_INTERNAL_EXAMINE_STACK_H_
+#endif  // Y_ABSL_DEBUGGING_INTERNAL_EXAMINE_STACK_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stack_consumption.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stack_consumption.h
index 80137ad0eb..f527eeb155 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stack_consumption.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stack_consumption.h
@@ -15,22 +15,22 @@
 
 // Helper function for measuring stack consumption of signal handlers.
 
-#ifndef ABSL_DEBUGGING_INTERNAL_STACK_CONSUMPTION_H_
-#define ABSL_DEBUGGING_INTERNAL_STACK_CONSUMPTION_H_
+#ifndef Y_ABSL_DEBUGGING_INTERNAL_STACK_CONSUMPTION_H_
+#define Y_ABSL_DEBUGGING_INTERNAL_STACK_CONSUMPTION_H_
 
 #include "y_absl/base/config.h"
 
 // The code in this module is not portable.
 // Use this feature test macro to detect its availability.
-#ifdef ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION
-#error ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION cannot be set directly
+#ifdef Y_ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION
+#error Y_ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION cannot be set directly
 #elif !defined(__APPLE__) && !defined(_WIN32) &&                     \
     (defined(__i386__) || defined(__x86_64__) || defined(__ppc__) || \
      defined(__aarch64__) || defined(__riscv))
-#define ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION 1
+#define Y_ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION 1
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace debugging_internal {
 
 // Returns the stack consumption in bytes for the code exercised by
@@ -42,9 +42,9 @@ namespace debugging_internal {
 int GetSignalHandlerStackConsumption(void (*signal_handler)(int));
 
 }  // namespace debugging_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION
+#endif  // Y_ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION
 
-#endif  // ABSL_DEBUGGING_INTERNAL_STACK_CONSUMPTION_H_
+#endif  // Y_ABSL_DEBUGGING_INTERNAL_STACK_CONSUMPTION_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_aarch64-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_aarch64-inl.inc
index 700f607488..e225b4dd18 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_aarch64-inl.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_aarch64-inl.inc
@@ -1,5 +1,5 @@
-#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_AARCH64_INL_H_
-#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_AARCH64_INL_H_
+#ifndef Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_AARCH64_INL_H_
+#define Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_AARCH64_INL_H_
 
 // Generate stack tracer for aarch64
 
@@ -25,7 +25,7 @@ static const uintptr_t kUnknownFrameSize = 0;
 // Returns the address of the VDSO __kernel_rt_sigreturn function, if present.
 static const unsigned char* GetKernelRtSigreturnAddress() {
   constexpr uintptr_t kImpossibleAddress = 1;
-  ABSL_CONST_INIT static std::atomic<uintptr_t> memoized{kImpossibleAddress};
+  Y_ABSL_CONST_INIT static std::atomic<uintptr_t> memoized{kImpossibleAddress};
   uintptr_t address = memoized.load(std::memory_order_relaxed);
   if (address != kImpossibleAddress) {
     return reinterpret_cast<const unsigned char*>(address);
@@ -33,7 +33,7 @@ static const unsigned char* GetKernelRtSigreturnAddress() {
 
   address = reinterpret_cast<uintptr_t>(nullptr);
 
-#ifdef ABSL_HAVE_VDSO_SUPPORT
+#ifdef Y_ABSL_HAVE_VDSO_SUPPORT
   y_absl::debugging_internal::VDSOSupport vdso;
   if (vdso.IsPresent()) {
     y_absl::debugging_internal::VDSOSupport::SymbolInfo symbol_info;
@@ -77,8 +77,8 @@ static inline uintptr_t ComputeStackFrameSize(const T* low,
 // checks (the strictness of which is controlled by the boolean parameter
 // "STRICT_UNWINDING") to reduce the chance that a bad pointer is returned.
 template<bool STRICT_UNWINDING, bool WITH_CONTEXT>
-ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
-ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
+Y_ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
+Y_ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
 static void **NextStackFrame(void **old_frame_pointer, const void *uc) {
   void **new_frame_pointer = reinterpret_cast<void**>(*old_frame_pointer);
   bool check_frame_size = true;
@@ -128,8 +128,8 @@ static void **NextStackFrame(void **old_frame_pointer, const void *uc) {
 }
 
 template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
-ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
-ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
+Y_ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
+Y_ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
 static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
                       const void *ucp, int *min_dropped_frames) {
 #ifdef __GNUC__
@@ -187,13 +187,13 @@ static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
 }
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace debugging_internal {
 bool StackTraceWorksForTest() {
   return true;
 }
 }  // namespace debugging_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_DEBUGGING_INTERNAL_STACKTRACE_AARCH64_INL_H_
+#endif  // Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_AARCH64_INL_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_arm-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_arm-inl.inc
index b73307120e..d735d1f933 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_arm-inl.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_arm-inl.inc
@@ -14,8 +14,8 @@
 //
 // This is inspired by Craig Silverstein's PowerPC stacktrace code.
 
-#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_ARM_INL_H_
-#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_ARM_INL_H_
+#ifndef Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_ARM_INL_H_
+#define Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_ARM_INL_H_
 
 #include <cstdint>
 
@@ -122,13 +122,13 @@ static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
 }
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace debugging_internal {
 bool StackTraceWorksForTest() {
   return false;
 }
 }  // namespace debugging_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_DEBUGGING_INTERNAL_STACKTRACE_ARM_INL_H_
+#endif  // Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_ARM_INL_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_config.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_config.h
index 7ba212ab03..d93c3f1dd9 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_config.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_config.h
@@ -13,32 +13,32 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
 
- * Defines ABSL_STACKTRACE_INL_HEADER to the *-inl.h containing
+ * Defines Y_ABSL_STACKTRACE_INL_HEADER to the *-inl.h containing
  * actual unwinder implementation.
  * This header is "private" to stacktrace.cc.
  * DO NOT include it into any other files.
 */
-#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_CONFIG_H_
-#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_CONFIG_H_
+#ifndef Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_CONFIG_H_
+#define Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_CONFIG_H_
 
 #include "y_absl/base/config.h"
 
-#if defined(ABSL_STACKTRACE_INL_HEADER)
-#error ABSL_STACKTRACE_INL_HEADER cannot be directly set
+#if defined(Y_ABSL_STACKTRACE_INL_HEADER)
+#error Y_ABSL_STACKTRACE_INL_HEADER cannot be directly set
 
 #elif defined(_WIN32)
-#define ABSL_STACKTRACE_INL_HEADER \
+#define Y_ABSL_STACKTRACE_INL_HEADER \
     "y_absl/debugging/internal/stacktrace_win32-inl.inc"
 
 #elif defined(__APPLE__)
-#ifdef ABSL_HAVE_THREAD_LOCAL
+#ifdef Y_ABSL_HAVE_THREAD_LOCAL
 // Thread local support required for UnwindImpl.
-#define ABSL_STACKTRACE_INL_HEADER \
+#define Y_ABSL_STACKTRACE_INL_HEADER \
   "y_absl/debugging/internal/stacktrace_generic-inl.inc"
-#endif  // defined(ABSL_HAVE_THREAD_LOCAL)
+#endif  // defined(Y_ABSL_HAVE_THREAD_LOCAL)
 
 #elif defined(__EMSCRIPTEN__)
-#define ABSL_STACKTRACE_INL_HEADER \
+#define Y_ABSL_STACKTRACE_INL_HEADER \
   "y_absl/debugging/internal/stacktrace_emscripten-inl.inc"
 
 #elif defined(__linux__) && !defined(__ANDROID__)
@@ -47,31 +47,31 @@
     (defined(__i386__) || defined(__x86_64__) || defined(__aarch64__))
 // Note: The libunwind-based implementation is not available to open-source
 // users.
-#define ABSL_STACKTRACE_INL_HEADER \
+#define Y_ABSL_STACKTRACE_INL_HEADER \
   "y_absl/debugging/internal/stacktrace_libunwind-inl.inc"
 #define STACKTRACE_USES_LIBUNWIND 1
 #elif defined(NO_FRAME_POINTER) && defined(__has_include)
 #if __has_include(<execinfo.h>)
 // Note: When using glibc this may require -funwind-tables to function properly.
-#define ABSL_STACKTRACE_INL_HEADER \
+#define Y_ABSL_STACKTRACE_INL_HEADER \
   "y_absl/debugging/internal/stacktrace_generic-inl.inc"
 #endif  // __has_include(<execinfo.h>)
 #elif defined(__i386__) || defined(__x86_64__)
-#define ABSL_STACKTRACE_INL_HEADER \
+#define Y_ABSL_STACKTRACE_INL_HEADER \
   "y_absl/debugging/internal/stacktrace_x86-inl.inc"
 #elif defined(__ppc__) || defined(__PPC__)
-#define ABSL_STACKTRACE_INL_HEADER \
+#define Y_ABSL_STACKTRACE_INL_HEADER \
   "y_absl/debugging/internal/stacktrace_powerpc-inl.inc"
 #elif defined(__aarch64__)
-#define ABSL_STACKTRACE_INL_HEADER \
+#define Y_ABSL_STACKTRACE_INL_HEADER \
   "y_absl/debugging/internal/stacktrace_aarch64-inl.inc"
 #elif defined(__riscv)
-#define ABSL_STACKTRACE_INL_HEADER \
+#define Y_ABSL_STACKTRACE_INL_HEADER \
   "y_absl/debugging/internal/stacktrace_riscv-inl.inc"
 #elif defined(__has_include)
 #if __has_include(<execinfo.h>)
 // Note: When using glibc this may require -funwind-tables to function properly.
-#define ABSL_STACKTRACE_INL_HEADER \
+#define Y_ABSL_STACKTRACE_INL_HEADER \
   "y_absl/debugging/internal/stacktrace_generic-inl.inc"
 #endif  // __has_include(<execinfo.h>)
 #endif  // defined(__has_include)
@@ -79,9 +79,9 @@
 #endif  // defined(__linux__) && !defined(__ANDROID__)
 
 // Fallback to the empty implementation.
-#if !defined(ABSL_STACKTRACE_INL_HEADER)
-#define ABSL_STACKTRACE_INL_HEADER \
+#if !defined(Y_ABSL_STACKTRACE_INL_HEADER)
+#define Y_ABSL_STACKTRACE_INL_HEADER \
   "y_absl/debugging/internal/stacktrace_unimplemented-inl.inc"
 #endif
 
-#endif  // ABSL_DEBUGGING_INTERNAL_STACKTRACE_CONFIG_H_
+#endif  // Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_CONFIG_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_emscripten-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_emscripten-inl.inc
index cdb5557134..ea86e5b0e1 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_emscripten-inl.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_emscripten-inl.inc
@@ -17,8 +17,8 @@
 // Note:  The glibc implementation may cause a call to malloc.
 // This can cause a deadlock in HeapProfiler.
 
-#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_EMSCRIPTEN_INL_H_
-#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_EMSCRIPTEN_INL_H_
+#ifndef Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_EMSCRIPTEN_INL_H_
+#define Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_EMSCRIPTEN_INL_H_
 
 #error #include <emscripten.h>
 
@@ -49,7 +49,7 @@ static __thread int recursive = 0;
 static std::atomic<bool> disable_stacktraces(true);  // Disabled until healthy.
 // Waiting until static initializers run seems to be late enough.
 // This file is included into stacktrace.cc so this will only run once.
-ABSL_ATTRIBUTE_UNUSED static int stacktraces_enabler = []() {
+Y_ABSL_ATTRIBUTE_UNUSED static int stacktraces_enabler = []() {
   // Check if we can even create stacktraces. If not, bail early and leave
   // disable_stacktraces set as-is.
   // clang-format off
@@ -100,11 +100,11 @@ static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count,
 }
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace debugging_internal {
 bool StackTraceWorksForTest() { return true; }
 }  // namespace debugging_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_DEBUGGING_INTERNAL_STACKTRACE_EMSCRIPTEN_INL_H_
+#endif  // Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_EMSCRIPTEN_INL_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_generic-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_generic-inl.inc
index fa623aa954..fd0408fc24 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_generic-inl.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_generic-inl.inc
@@ -17,8 +17,8 @@
 // Note:  The glibc implementation may cause a call to malloc.
 // This can cause a deadlock in HeapProfiler.
 
-#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_GENERIC_INL_H_
-#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_GENERIC_INL_H_
+#ifndef Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_GENERIC_INL_H_
+#define Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_GENERIC_INL_H_
 
 #include <execinfo.h>
 #include <atomic>
@@ -45,7 +45,7 @@ static __thread int recursive = 0;
 static std::atomic<bool> disable_stacktraces(true);  // Disabled until healthy.
 // Waiting until static initializers run seems to be late enough.
 // This file is included into stacktrace.cc so this will only run once.
-ABSL_ATTRIBUTE_UNUSED static int stacktraces_enabler = []() {
+Y_ABSL_ATTRIBUTE_UNUSED static int stacktraces_enabler = []() {
   void* unused_stack[1];
   // Force the first backtrace to happen early to get the one-time shared lib
   // loading (allocation) out of the way. After the first call it is much safer
@@ -96,13 +96,13 @@ static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
 }
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace debugging_internal {
 bool StackTraceWorksForTest() {
   return true;
 }
 }  // namespace debugging_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_DEBUGGING_INTERNAL_STACKTRACE_GENERIC_INL_H_
+#endif  // Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_GENERIC_INL_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_powerpc-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_powerpc-inl.inc
index 1e41c4ebf2..635c3dd2a6 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_powerpc-inl.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_powerpc-inl.inc
@@ -18,8 +18,8 @@
 //    https://www.linux-foundation.org/spec/ELF/ppc64/PPC-elf64abi-1.9.html#STACK
 // Linux has similar code: http://patchwork.ozlabs.org/linuxppc/patch?id=8882
 
-#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_POWERPC_INL_H_
-#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_POWERPC_INL_H_
+#ifndef Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_POWERPC_INL_H_
+#define Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_POWERPC_INL_H_
 
 #if defined(__linux__)
 #include <asm/ptrace.h>   // for PT_NIP.
@@ -66,8 +66,8 @@ static inline void *StacktracePowerPCGetLR(void **sp) {
 // checks (the strictness of which is controlled by the boolean parameter
 // "STRICT_UNWINDING") to reduce the chance that a bad pointer is returned.
 template<bool STRICT_UNWINDING, bool IS_WITH_CONTEXT>
-ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
-ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
+Y_ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
+Y_ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
 static void **NextStackFrame(void **old_sp, const void *uc) {
   void **new_sp = (void **) *old_sp;
   enum { kStackAlignment = 16 };
@@ -157,13 +157,13 @@ static void **NextStackFrame(void **old_sp, const void *uc) {
 }
 
 // This ensures that y_absl::GetStackTrace sets up the Link Register properly.
-ABSL_ATTRIBUTE_NOINLINE static void AbslStacktracePowerPCDummyFunction() {
-  ABSL_BLOCK_TAIL_CALL_OPTIMIZATION();
+Y_ABSL_ATTRIBUTE_NOINLINE static void AbslStacktracePowerPCDummyFunction() {
+  Y_ABSL_BLOCK_TAIL_CALL_OPTIMIZATION();
 }
 
 template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
-ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
-ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
+Y_ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
+Y_ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
 static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
                       const void *ucp, int *min_dropped_frames) {
   void **sp;
@@ -241,13 +241,13 @@ static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
 }
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace debugging_internal {
 bool StackTraceWorksForTest() {
   return true;
 }
 }  // namespace debugging_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_DEBUGGING_INTERNAL_STACKTRACE_POWERPC_INL_H_
+#endif  // Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_POWERPC_INL_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_riscv-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_riscv-inl.inc
index 8571c8cbfd..4072ecc116 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_riscv-inl.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_riscv-inl.inc
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_RISCV_INL_H_
-#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_RISCV_INL_H_
+#ifndef Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_RISCV_INL_H_
+#define Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_RISCV_INL_H_
 
 // Generate stack trace for riscv
 
@@ -42,7 +42,7 @@ static const uintptr_t kUnknownFrameSize = 0;
 // Returns the address of the VDSO __kernel_rt_sigreturn function, if present.
 static const unsigned char *GetKernelRtSigreturnAddress() {
   constexpr uintptr_t kImpossibleAddress = 0;
-  ABSL_CONST_INIT static std::atomic<uintptr_t> memoized(kImpossibleAddress);
+  Y_ABSL_CONST_INIT static std::atomic<uintptr_t> memoized(kImpossibleAddress);
   uintptr_t address = memoized.load(std::memory_order_relaxed);
   if (address != kImpossibleAddress) {
     return reinterpret_cast<const unsigned char *>(address);
@@ -50,7 +50,7 @@ static const unsigned char *GetKernelRtSigreturnAddress() {
 
   address = reinterpret_cast<uintptr_t>(nullptr);
 
-#if ABSL_HAVE_VDSO_SUPPORT
+#if Y_ABSL_HAVE_VDSO_SUPPORT
   y_absl::debugging_internal::VDSOSupport vdso;
   if (vdso.IsPresent()) {
     y_absl::debugging_internal::VDSOSupport::SymbolInfo symbol_info;
@@ -94,8 +94,8 @@ static inline uintptr_t ComputeStackFrameSize(const T *low, const T *high) {
 // strictness of which is controlled by the boolean parameter
 // "STRICT_UNWINDING") to reduce the chance that a bad pointer is returned.
 template <bool STRICT_UNWINDING, bool WITH_CONTEXT>
-ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
-ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
+Y_ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
+Y_ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
 static void ** NextStackFrame(void **old_frame_pointer, const void *uc) {
   //               .
   //               .
@@ -167,8 +167,8 @@ static void ** NextStackFrame(void **old_frame_pointer, const void *uc) {
 }
 
 template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
-ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
-ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
+Y_ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
+Y_ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
 static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count,
                       const void *ucp, int *min_dropped_frames) {
 #if defined(__GNUC__)
@@ -224,11 +224,11 @@ static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count,
 }
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace debugging_internal {
 bool StackTraceWorksForTest() { return true; }
 }  // namespace debugging_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 #endif
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_unimplemented-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_unimplemented-inl.inc
index 54dccaeae9..b1edc021bd 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_unimplemented-inl.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_unimplemented-inl.inc
@@ -1,5 +1,5 @@
-#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_UNIMPLEMENTED_INL_H_
-#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_UNIMPLEMENTED_INL_H_
+#ifndef Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_UNIMPLEMENTED_INL_H_
+#define Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_UNIMPLEMENTED_INL_H_
 
 template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
 static int UnwindImpl(void** /* result */, int* /* sizes */,
@@ -12,13 +12,13 @@ static int UnwindImpl(void** /* result */, int* /* sizes */,
 }
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace debugging_internal {
 bool StackTraceWorksForTest() {
   return false;
 }
 }  // namespace debugging_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_DEBUGGING_INTERNAL_STACKTRACE_UNIMPLEMENTED_INL_H_
+#endif  // Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_UNIMPLEMENTED_INL_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_win32-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_win32-inl.inc
index 69bd7e3f2f..654990f206 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_win32-inl.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_win32-inl.inc
@@ -34,8 +34,8 @@
 // This code is inspired by a patch from David Vitek:
 //   https://code.google.com/p/google-perftools/issues/detail?id=83
 
-#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_WIN32_INL_H_
-#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_WIN32_INL_H_
+#ifndef Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_WIN32_INL_H_
+#define Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_WIN32_INL_H_
 
 #include <windows.h>    // for GetProcAddress and GetModuleHandle
 #include <cassert>
@@ -81,13 +81,13 @@ static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
 }
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace debugging_internal {
 bool StackTraceWorksForTest() {
   return false;
 }
 }  // namespace debugging_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_DEBUGGING_INTERNAL_STACKTRACE_WIN32_INL_H_
+#endif  // Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_WIN32_INL_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_x86-inl.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_x86-inl.inc
index 8936f8ca70..6e598bc359 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_x86-inl.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/stacktrace_x86-inl.inc
@@ -14,8 +14,8 @@
 //
 // Produce stack trace
 
-#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_X86_INL_INC_
-#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_X86_INL_INC_
+#ifndef Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_X86_INL_INC_
+#define Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_X86_INL_INC_
 
 #if defined(__linux__) && (defined(__i386__) || defined(__x86_64__))
 #include <ucontext.h>  // for ucontext_t
@@ -157,8 +157,8 @@ static uintptr_t GetFP(const void *vuc) {
 // checks (the strictness of which is controlled by the boolean parameter
 // "STRICT_UNWINDING") to reduce the chance that a bad pointer is returned.
 template <bool STRICT_UNWINDING, bool WITH_CONTEXT>
-ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
-ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
+Y_ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
+Y_ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
 static void **NextStackFrame(void **old_fp, const void *uc,
                              size_t stack_low, size_t stack_high) {
   void **new_fp = (void **)*old_fp;
@@ -174,7 +174,7 @@ static void **NextStackFrame(void **old_fp, const void *uc,
     static const unsigned char *kernel_rt_sigreturn_address = nullptr;
     static const unsigned char *kernel_vsyscall_address = nullptr;
     if (num_push_instructions == -1) {
-#ifdef ABSL_HAVE_VDSO_SUPPORT
+#ifdef Y_ABSL_HAVE_VDSO_SUPPORT
       y_absl::debugging_internal::VDSOSupport vdso;
       if (vdso.IsPresent()) {
         y_absl::debugging_internal::VDSOSupport::SymbolInfo
@@ -203,9 +203,9 @@ static void **NextStackFrame(void **old_fp, const void *uc,
       } else {
         num_push_instructions = 0;
       }
-#else  // ABSL_HAVE_VDSO_SUPPORT
+#else  // Y_ABSL_HAVE_VDSO_SUPPORT
       num_push_instructions = 0;
-#endif  // ABSL_HAVE_VDSO_SUPPORT
+#endif  // Y_ABSL_HAVE_VDSO_SUPPORT
     }
     if (num_push_instructions != 0 && kernel_rt_sigreturn_address != nullptr &&
         old_fp[1] == kernel_rt_sigreturn_address) {
@@ -302,9 +302,9 @@ static void **NextStackFrame(void **old_fp, const void *uc,
 }
 
 template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
-ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
-ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
-ABSL_ATTRIBUTE_NOINLINE
+Y_ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
+Y_ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
+Y_ABSL_ATTRIBUTE_NOINLINE
 static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count,
                       const void *ucp, int *min_dropped_frames) {
   int n = 0;
@@ -352,13 +352,13 @@ static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count,
 }
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace debugging_internal {
 bool StackTraceWorksForTest() {
   return true;
 }
 }  // namespace debugging_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_DEBUGGING_INTERNAL_STACKTRACE_X86_INL_INC_
+#endif  // Y_ABSL_DEBUGGING_INTERNAL_STACKTRACE_X86_INL_INC_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/symbolize.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/symbolize.h
index e6e2b0724a..c404b3cf91 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/symbolize.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/symbolize.h
@@ -15,8 +15,8 @@
 // This file contains internal parts of the Abseil symbolizer.
 // Do not depend on the anything in this file, it may change at anytime.
 
-#ifndef ABSL_DEBUGGING_INTERNAL_SYMBOLIZE_H_
-#define ABSL_DEBUGGING_INTERNAL_SYMBOLIZE_H_
+#ifndef Y_ABSL_DEBUGGING_INTERNAL_SYMBOLIZE_H_
+#define Y_ABSL_DEBUGGING_INTERNAL_SYMBOLIZE_H_
 
 #ifdef __cplusplus
 
@@ -26,11 +26,11 @@
 #include "y_absl/base/config.h"
 #include "y_absl/strings/string_view.h"
 
-#ifdef ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE
-#error ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE cannot be directly set
+#ifdef Y_ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE
+#error Y_ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE cannot be directly set
 #elif defined(__ELF__) && defined(__GLIBC__) && !defined(__native_client__) \
       && !defined(__asmjs__) && !defined(__wasm__)
-#define ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE 1
+#define Y_ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE 1
 
 #include <elf.h>
 #include <link.h>  // For ElfW() macro.
@@ -38,7 +38,7 @@
 #include <util/generic/string.h>
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace debugging_internal {
 
 // Iterates over all sections, invoking callback on each with the section name
@@ -57,25 +57,25 @@ bool GetSectionHeaderByName(int fd, const char *name, size_t name_len,
                             ElfW(Shdr) *out);
 
 }  // namespace debugging_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE
+#endif  // Y_ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE
 
-#ifdef ABSL_INTERNAL_HAVE_DARWIN_SYMBOLIZE
-#error ABSL_INTERNAL_HAVE_DARWIN_SYMBOLIZE cannot be directly set
+#ifdef Y_ABSL_INTERNAL_HAVE_DARWIN_SYMBOLIZE
+#error Y_ABSL_INTERNAL_HAVE_DARWIN_SYMBOLIZE cannot be directly set
 #elif defined(__APPLE__)
-#define ABSL_INTERNAL_HAVE_DARWIN_SYMBOLIZE 1
+#define Y_ABSL_INTERNAL_HAVE_DARWIN_SYMBOLIZE 1
 #endif
 
-#ifdef ABSL_INTERNAL_HAVE_EMSCRIPTEN_SYMBOLIZE
-#error ABSL_INTERNAL_HAVE_EMSCRIPTEN_SYMBOLIZE cannot be directly set
+#ifdef Y_ABSL_INTERNAL_HAVE_EMSCRIPTEN_SYMBOLIZE
+#error Y_ABSL_INTERNAL_HAVE_EMSCRIPTEN_SYMBOLIZE cannot be directly set
 #elif defined(__EMSCRIPTEN__)
-#define ABSL_INTERNAL_HAVE_EMSCRIPTEN_SYMBOLIZE 1
+#define Y_ABSL_INTERNAL_HAVE_EMSCRIPTEN_SYMBOLIZE 1
 #endif
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace debugging_internal {
 
 struct SymbolDecoratorArgs {
@@ -135,7 +135,7 @@ bool GetFileMappingHint(const void** start, const void** end, uint64_t* offset,
                         const char** filename);
 
 }  // namespace debugging_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 #endif  // __cplusplus
@@ -150,4 +150,4 @@ extern "C"
     YAbslInternalGetFileMappingHint(const void** start, const void** end,
                                    uint64_t* offset, const char** filename);
 
-#endif  // ABSL_DEBUGGING_INTERNAL_SYMBOLIZE_H_
+#endif  // Y_ABSL_DEBUGGING_INTERNAL_SYMBOLIZE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/vdso_support.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/vdso_support.cc
index 7905eba32f..ff28d04d57 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/vdso_support.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/vdso_support.cc
@@ -18,7 +18,7 @@
 
 #include "y_absl/debugging/internal/vdso_support.h"
 
-#ifdef ABSL_HAVE_VDSO_SUPPORT     // defined in vdso_support.h
+#ifdef Y_ABSL_HAVE_VDSO_SUPPORT     // defined in vdso_support.h
 
 #if !defined(__has_include)
 #define __has_include(header) 0
@@ -35,10 +35,10 @@
 
 #if defined(__GLIBC__) && \
     (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 16))
-#define ABSL_HAVE_GETAUXVAL
+#define Y_ABSL_HAVE_GETAUXVAL
 #endif
 
-#ifdef ABSL_HAVE_GETAUXVAL
+#ifdef Y_ABSL_HAVE_GETAUXVAL
 #include <sys/auxv.h>
 #endif
 
@@ -56,10 +56,10 @@ using Elf32_auxv_t = Elf32_Auxinfo;
 #endif
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace debugging_internal {
 
-ABSL_CONST_INIT
+Y_ABSL_CONST_INIT
 std::atomic<const void *> VDSOSupport::vdso_base_(
     debugging_internal::ElfMemImage::kInvalidBase);
 
@@ -83,7 +83,7 @@ VDSOSupport::VDSOSupport()
 // the operation should be idempotent.
 const void *VDSOSupport::Init() {
   const auto kInvalidBase = debugging_internal::ElfMemImage::kInvalidBase;
-#ifdef ABSL_HAVE_GETAUXVAL
+#ifdef Y_ABSL_HAVE_GETAUXVAL
   if (vdso_base_.load(std::memory_order_relaxed) == kInvalidBase) {
     errno = 0;
     const void *const sysinfo_ehdr =
@@ -92,7 +92,7 @@ const void *VDSOSupport::Init() {
       vdso_base_.store(sysinfo_ehdr, std::memory_order_relaxed);
     }
   }
-#endif  // ABSL_HAVE_GETAUXVAL
+#endif  // Y_ABSL_HAVE_GETAUXVAL
   if (vdso_base_.load(std::memory_order_relaxed) == kInvalidBase) {
     int fd = open("/proc/self/auxv", O_RDONLY);
     if (fd == -1) {
@@ -130,7 +130,7 @@ const void *VDSOSupport::Init() {
 }
 
 const void *VDSOSupport::SetBase(const void *base) {
-  ABSL_RAW_CHECK(base != debugging_internal::ElfMemImage::kInvalidBase,
+  Y_ABSL_RAW_CHECK(base != debugging_internal::ElfMemImage::kInvalidBase,
                  "internal error");
   const void *old_base = vdso_base_.load(std::memory_order_relaxed);
   vdso_base_.store(base, std::memory_order_relaxed);
@@ -170,14 +170,14 @@ long VDSOSupport::InitAndGetCPU(unsigned *cpu,  // NOLINT(runtime/int)
                                 void *x, void *y) {
   Init();
   GetCpuFn fn = getcpu_fn_.load(std::memory_order_relaxed);
-  ABSL_RAW_CHECK(fn != &InitAndGetCPU, "Init() did not set getcpu_fn_");
+  Y_ABSL_RAW_CHECK(fn != &InitAndGetCPU, "Init() did not set getcpu_fn_");
   return (*fn)(cpu, x, y);
 }
 
 // This function must be very fast, and may be called from very
 // low level (e.g. tcmalloc). Hence I avoid things like
 // GoogleOnceInit() and ::operator new.
-ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY
+Y_ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY
 int GetCPU() {
   unsigned cpu;
   int ret_code = (*VDSOSupport::getcpu_fn_)(&cpu, nullptr, nullptr);
@@ -185,7 +185,7 @@ int GetCPU() {
 }
 
 }  // namespace debugging_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_HAVE_VDSO_SUPPORT
+#endif  // Y_ABSL_HAVE_VDSO_SUPPORT
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/vdso_support.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/vdso_support.h
index c0064b9fe1..40a22780d5 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/vdso_support.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/internal/vdso_support.h
@@ -36,24 +36,24 @@
 //     fn = reinterpret_cast<FN>(info.address);
 //  }
 
-#ifndef ABSL_DEBUGGING_INTERNAL_VDSO_SUPPORT_H_
-#define ABSL_DEBUGGING_INTERNAL_VDSO_SUPPORT_H_
+#ifndef Y_ABSL_DEBUGGING_INTERNAL_VDSO_SUPPORT_H_
+#define Y_ABSL_DEBUGGING_INTERNAL_VDSO_SUPPORT_H_
 
 #include <atomic>
 
 #include "y_absl/base/attributes.h"
 #include "y_absl/debugging/internal/elf_mem_image.h"
 
-#ifdef ABSL_HAVE_ELF_MEM_IMAGE
+#ifdef Y_ABSL_HAVE_ELF_MEM_IMAGE
 
-#ifdef ABSL_HAVE_VDSO_SUPPORT
-#error ABSL_HAVE_VDSO_SUPPORT cannot be directly set
+#ifdef Y_ABSL_HAVE_VDSO_SUPPORT
+#error Y_ABSL_HAVE_VDSO_SUPPORT cannot be directly set
 #else
-#define ABSL_HAVE_VDSO_SUPPORT 1
+#define Y_ABSL_HAVE_VDSO_SUPPORT 1
 #endif
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace debugging_internal {
 
 // NOTE: this class may be used from within tcmalloc, and can not
@@ -134,7 +134,7 @@ class VDSOSupport {
 
   // This function pointer may point to InitAndGetCPU,
   // GetCPUViaSyscall, or __vdso_getcpu at different stages of initialization.
-  ABSL_CONST_INIT static std::atomic<GetCpuFn> getcpu_fn_;
+  Y_ABSL_CONST_INIT static std::atomic<GetCpuFn> getcpu_fn_;
 
   friend int GetCPU(void);  // Needs access to getcpu_fn_.
 
@@ -150,9 +150,9 @@ class VDSOSupport {
 int GetCPU();
 
 }  // namespace debugging_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_HAVE_ELF_MEM_IMAGE
+#endif  // Y_ABSL_HAVE_ELF_MEM_IMAGE
 
-#endif  // ABSL_DEBUGGING_INTERNAL_VDSO_SUPPORT_H_
+#endif  // Y_ABSL_DEBUGGING_INTERNAL_VDSO_SUPPORT_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check.cc
index ae5cf79fe2..0ac471b986 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check.cc
@@ -22,7 +22,7 @@
 #ifndef LEAK_SANITIZER
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 bool HaveLeakSanitizer() { return false; }
 bool LeakCheckerIsActive() { return false; }
 void DoIgnoreLeak(const void*) { }
@@ -30,22 +30,22 @@ void RegisterLivePointers(const void*, size_t) { }
 void UnRegisterLivePointers(const void*, size_t) { }
 LeakCheckDisabler::LeakCheckDisabler() { }
 LeakCheckDisabler::~LeakCheckDisabler() { }
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 #else
 
 #include <sanitizer/lsan_interface.h>
 
-#if ABSL_HAVE_ATTRIBUTE_WEAK
-extern "C" ABSL_ATTRIBUTE_WEAK int __lsan_is_turned_off();
+#if Y_ABSL_HAVE_ATTRIBUTE_WEAK
+extern "C" Y_ABSL_ATTRIBUTE_WEAK int __lsan_is_turned_off();
 #endif
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 bool HaveLeakSanitizer() { return true; }
 
-#if ABSL_HAVE_ATTRIBUTE_WEAK
+#if Y_ABSL_HAVE_ATTRIBUTE_WEAK
 bool LeakCheckerIsActive() {
   return !(&__lsan_is_turned_off && __lsan_is_turned_off());
 }
@@ -63,7 +63,7 @@ void UnRegisterLivePointers(const void* ptr, size_t size) {
 }
 LeakCheckDisabler::LeakCheckDisabler() { __lsan_disable(); }
 LeakCheckDisabler::~LeakCheckDisabler() { __lsan_enable(); }
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 #endif  // LEAK_SANITIZER
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check.h
index d69f08f248..154fe4805d 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/leak_check.h
@@ -27,15 +27,15 @@
 // See https://github.com/google/sanitizers/wiki/AddressSanitizerLeakSanitizer
 //
 // -----------------------------------------------------------------------------
-#ifndef ABSL_DEBUGGING_LEAK_CHECK_H_
-#define ABSL_DEBUGGING_LEAK_CHECK_H_
+#ifndef Y_ABSL_DEBUGGING_LEAK_CHECK_H_
+#define Y_ABSL_DEBUGGING_LEAK_CHECK_H_
 
 #include <cstddef>
 
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // HaveLeakSanitizer()
 //
@@ -127,7 +127,7 @@ void RegisterLivePointers(const void* ptr, size_t size);
 // `RegisterLivePointers()`, enabling leak checking of those pointers.
 void UnRegisterLivePointers(const void* ptr, size_t size);
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_DEBUGGING_LEAK_CHECK_H_
+#endif  // Y_ABSL_DEBUGGING_LEAK_CHECK_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace.cc
index 9263d6a2a8..7b3e34fc81 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace.cc
@@ -42,8 +42,8 @@
 #include "y_absl/base/port.h"
 #include "y_absl/debugging/internal/stacktrace_config.h"
 
-#if defined(ABSL_STACKTRACE_INL_HEADER)
-#include ABSL_STACKTRACE_INL_HEADER
+#if defined(Y_ABSL_STACKTRACE_INL_HEADER)
+#include Y_ABSL_STACKTRACE_INL_HEADER
 #else
 # error Cannot calculate stack trace: will need to write for your environment
 
@@ -59,14 +59,14 @@
 #endif
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace {
 
 typedef int (*Unwinder)(void**, int*, int, int, const void*, int*);
 std::atomic<Unwinder> custom;
 
 template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
-ABSL_ATTRIBUTE_ALWAYS_INLINE inline int Unwind(void** result, int* sizes,
+Y_ABSL_ATTRIBUTE_ALWAYS_INLINE inline int Unwind(void** result, int* sizes,
                                                int max_depth, int skip_count,
                                                const void* uc,
                                                int* min_dropped_frames) {
@@ -78,19 +78,19 @@ ABSL_ATTRIBUTE_ALWAYS_INLINE inline int Unwind(void** result, int* sizes,
   int size = (*f)(result, sizes, max_depth, skip_count + 1, uc,
                   min_dropped_frames);
   // To disable tail call to (*f)(...)
-  ABSL_BLOCK_TAIL_CALL_OPTIMIZATION();
+  Y_ABSL_BLOCK_TAIL_CALL_OPTIMIZATION();
   return size;
 }
 
 }  // anonymous namespace
 
-ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int GetStackFrames(
+Y_ABSL_ATTRIBUTE_NOINLINE Y_ABSL_ATTRIBUTE_NO_TAIL_CALL int GetStackFrames(
     void** result, int* sizes, int max_depth, int skip_count) {
   return Unwind<true, false>(result, sizes, max_depth, skip_count, nullptr,
                              nullptr);
 }
 
-ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int
+Y_ABSL_ATTRIBUTE_NOINLINE Y_ABSL_ATTRIBUTE_NO_TAIL_CALL int
 GetStackFramesWithContext(void** result, int* sizes, int max_depth,
                           int skip_count, const void* uc,
                           int* min_dropped_frames) {
@@ -98,13 +98,13 @@ GetStackFramesWithContext(void** result, int* sizes, int max_depth,
                             min_dropped_frames);
 }
 
-ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int GetStackTrace(
+Y_ABSL_ATTRIBUTE_NOINLINE Y_ABSL_ATTRIBUTE_NO_TAIL_CALL int GetStackTrace(
     void** result, int max_depth, int skip_count) {
   return Unwind<false, false>(result, nullptr, max_depth, skip_count, nullptr,
                               nullptr);
 }
 
-ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int
+Y_ABSL_ATTRIBUTE_NOINLINE Y_ABSL_ATTRIBUTE_NO_TAIL_CALL int
 GetStackTraceWithContext(void** result, int max_depth, int skip_count,
                          const void* uc, int* min_dropped_frames) {
   return Unwind<false, true>(result, nullptr, max_depth, skip_count, uc,
@@ -138,5 +138,5 @@ int DefaultStackUnwinder(void** pcs, int* sizes, int depth, int skip,
   return n;
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace.h
index cbd48b986b..3e83d4cc02 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/stacktrace.h
@@ -28,13 +28,13 @@
 // frames consisting of function addresses rather than human-readable function
 // names. (See symbolize.h for information on symbolizing these values.)
 
-#ifndef ABSL_DEBUGGING_STACKTRACE_H_
-#define ABSL_DEBUGGING_STACKTRACE_H_
+#ifndef Y_ABSL_DEBUGGING_STACKTRACE_H_
+#define Y_ABSL_DEBUGGING_STACKTRACE_H_
 
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // GetStackFrames()
 //
@@ -225,7 +225,7 @@ namespace debugging_internal {
 // working.
 extern bool StackTraceWorksForTest();
 }  // namespace debugging_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_DEBUGGING_STACKTRACE_H_
+#endif  // Y_ABSL_DEBUGGING_STACKTRACE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize.cc
index 88c92a19ea..43363339cd 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize.cc
@@ -19,13 +19,13 @@
 #if !(WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)) || \
     WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
 // UWP doesn't have access to win32 APIs.
-#define ABSL_INTERNAL_HAVE_SYMBOLIZE_WIN32
+#define Y_ABSL_INTERNAL_HAVE_SYMBOLIZE_WIN32
 #endif
 #endif
 
-#if defined(ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE)
+#if defined(Y_ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE)
 #include "y_absl/debugging/symbolize_elf.inc"
-#elif defined(ABSL_INTERNAL_HAVE_SYMBOLIZE_WIN32)
+#elif defined(Y_ABSL_INTERNAL_HAVE_SYMBOLIZE_WIN32)
 // The Windows Symbolizer only works if PDB files containing the debug info
 // are available to the program at runtime.
 #include "y_absl/debugging/symbolize_win32.inc"
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize.h b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize.h
index 2a99f65c83..01131a005a 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize.h
@@ -49,13 +49,13 @@
 //     return 0;
 //  }
 //
-#ifndef ABSL_DEBUGGING_SYMBOLIZE_H_
-#define ABSL_DEBUGGING_SYMBOLIZE_H_
+#ifndef Y_ABSL_DEBUGGING_SYMBOLIZE_H_
+#define Y_ABSL_DEBUGGING_SYMBOLIZE_H_
 
 #include "y_absl/debugging/internal/symbolize.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // InitializeSymbolizer()
 //
@@ -93,7 +93,7 @@ void InitializeSymbolizer(const char* argv0);
 //  }
 bool Symbolize(const void *pc, char *out, int out_size);
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_DEBUGGING_SYMBOLIZE_H_
+#endif  // Y_ABSL_DEBUGGING_SYMBOLIZE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_darwin.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_darwin.inc
index c5960a7938..f36444f9b7 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_darwin.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_darwin.inc
@@ -25,7 +25,7 @@
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 void InitializeSymbolizer(const char*) {}
 
@@ -97,5 +97,5 @@ bool Symbolize(const void* pc, char* out, int out_size) {
   return true;
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_elf.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_elf.inc
index 18297405e3..343be4f91b 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_elf.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_elf.inc
@@ -82,13 +82,13 @@
 #endif
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // Value of argv[0]. Used by MaybeInitializeObjFile().
 static char *argv0_value = nullptr;
 
 void InitializeSymbolizer(const char *argv0) {
-#ifdef ABSL_HAVE_VDSO_SUPPORT
+#ifdef Y_ABSL_HAVE_VDSO_SUPPORT
   // We need to make sure VDSOSupport::Init() is called before any setuid or
   // chroot calls, so InitializeSymbolizer() should be called very early in the
   // life of a program.
@@ -161,14 +161,14 @@ struct FileMappingHint {
 // Moreover, we are using only TryLock(), if the decorator list
 // is being modified (is busy), we skip all decorators, and possibly
 // loose some info. Sorry, that's the best we could do.
-ABSL_CONST_INIT y_absl::base_internal::SpinLock g_decorators_mu(
+Y_ABSL_CONST_INIT y_absl::base_internal::SpinLock g_decorators_mu(
     y_absl::kConstInit, y_absl::base_internal::SCHEDULE_KERNEL_ONLY);
 
 const int kMaxFileMappingHints = 8;
 int g_num_file_mapping_hints;
 FileMappingHint g_file_mapping_hints[kMaxFileMappingHints];
 // Protects g_file_mapping_hints.
-ABSL_CONST_INIT y_absl::base_internal::SpinLock g_file_mapping_mu(
+Y_ABSL_CONST_INIT y_absl::base_internal::SpinLock g_file_mapping_mu(
     y_absl::kConstInit, y_absl::base_internal::SCHEDULE_KERNEL_ONLY);
 
 // Async-signal-safe function to zero a buffer.
@@ -303,12 +303,12 @@ class Symbolizer {
     int len = strlen(s);
     char *dst = static_cast<char *>(
         base_internal::LowLevelAlloc::AllocWithArena(len + 1, SigSafeArena()));
-    ABSL_RAW_CHECK(dst != nullptr, "out of memory");
+    Y_ABSL_RAW_CHECK(dst != nullptr, "out of memory");
     memcpy(dst, s, len + 1);
     return dst;
   }
   ObjFile *FindObjFile(const void *const start,
-                       size_t size) ABSL_ATTRIBUTE_NOINLINE;
+                       size_t size) Y_ABSL_ATTRIBUTE_NOINLINE;
   static bool RegisterObjFile(const char *filename,
                               const void *const start_addr,
                               const void *const end_addr, uint64_t offset,
@@ -388,7 +388,7 @@ static void FreeSymbolizer(Symbolizer *s) {
 
 Symbolizer::Symbolizer() : ok_(true), addr_map_read_(false) {
   for (SymbolCacheLine &symbol_cache_line : symbol_cache_) {
-    for (size_t j = 0; j < ABSL_ARRAYSIZE(symbol_cache_line.name); ++j) {
+    for (size_t j = 0; j < Y_ABSL_ARRAYSIZE(symbol_cache_line.name); ++j) {
       symbol_cache_line.pc[j] = nullptr;
       symbol_cache_line.name[j] = nullptr;
       symbol_cache_line.age[j] = 0;
@@ -422,7 +422,7 @@ static ssize_t ReadPersistent(int fd, void *buf, size_t count) {
     ssize_t len;
     NO_INTR(len = read(fd, buf0 + num_bytes, count - num_bytes));
     if (len < 0) {  // There was an error other than EINTR.
-      ABSL_RAW_LOG(WARNING, "read failed: errno=%d", errno);
+      Y_ABSL_RAW_LOG(WARNING, "read failed: errno=%d", errno);
       return -1;
     }
     if (len == 0) {  // Reached EOF.
@@ -441,7 +441,7 @@ static ssize_t ReadFromOffset(const int fd, void *buf, const size_t count,
                               const off_t offset) {
   off_t off = lseek(fd, offset, SEEK_SET);
   if (off == (off_t)-1) {
-    ABSL_RAW_LOG(WARNING, "lseek(%d, %ju, SEEK_SET) failed: errno=%d", fd,
+    Y_ABSL_RAW_LOG(WARNING, "lseek(%d, %ju, SEEK_SET) failed: errno=%d", fd,
                  static_cast<uintmax_t>(offset), errno);
     return -1;
   }
@@ -475,7 +475,7 @@ static int FileGetElfType(const int fd) {
 // and return true.  Otherwise, return false.
 // To keep stack consumption low, we would like this function to not get
 // inlined.
-static ABSL_ATTRIBUTE_NOINLINE bool GetSectionHeaderByType(
+static Y_ABSL_ATTRIBUTE_NOINLINE bool GetSectionHeaderByType(
     const int fd, ElfW(Half) sh_num, const off_t sh_offset, ElfW(Word) type,
     ElfW(Shdr) * out, char *tmp_buf, int tmp_buf_size) {
   ElfW(Shdr) *buf = reinterpret_cast<ElfW(Shdr) *>(tmp_buf);
@@ -489,7 +489,7 @@ static ABSL_ATTRIBUTE_NOINLINE bool GetSectionHeaderByType(
     const off_t offset = sh_offset + i * sizeof(buf[0]);
     const ssize_t len = ReadFromOffset(fd, buf, num_bytes_to_read, offset);
     if (len % sizeof(buf[0]) != 0) {
-      ABSL_RAW_LOG(
+      Y_ABSL_RAW_LOG(
           WARNING,
           "Reading %zd bytes from offset %ju returned %zd which is not a "
           "multiple of %zu.",
@@ -560,7 +560,7 @@ bool GetSectionHeaderByName(int fd, const char *name, size_t name_len,
                             ElfW(Shdr) * out) {
   char header_name[kMaxSectionNameLen];
   if (sizeof(header_name) < name_len) {
-    ABSL_RAW_LOG(WARNING,
+    Y_ABSL_RAW_LOG(WARNING,
                  "Section name '%s' is too long (%zu); "
                  "section will not be found (even if present).",
                  name, name_len);
@@ -659,7 +659,7 @@ static const char *ComputeOffset(const char *base, ptrdiff_t offset) {
 // If the symbol is not found, SYMBOL_NOT_FOUND is returned;
 // To keep stack consumption low, we would like this function to not get
 // inlined.
-static ABSL_ATTRIBUTE_NOINLINE FindSymbolResult FindSymbol(
+static Y_ABSL_ATTRIBUTE_NOINLINE FindSymbolResult FindSymbol(
     const void *const pc, const int fd, char *out, int out_size,
     ptrdiff_t relocation, const ElfW(Shdr) * strtab, const ElfW(Shdr) * symtab,
     const ElfW(Shdr) * opd, char *tmp_buf, int tmp_buf_size) {
@@ -747,12 +747,12 @@ static ABSL_ATTRIBUTE_NOINLINE FindSymbolResult FindSymbol(
     const ssize_t n_read = ReadFromOffset(fd, out, out_size, off);
     if (n_read <= 0) {
       // This should never happen.
-      ABSL_RAW_LOG(WARNING,
+      Y_ABSL_RAW_LOG(WARNING,
                    "Unable to read from fd %d at offset %zu: n_read = %zd", fd,
                    off, n_read);
       return SYMBOL_NOT_FOUND;
     }
-    ABSL_RAW_CHECK(n_read <= out_size, "ReadFromOffset read too much data.");
+    Y_ABSL_RAW_CHECK(n_read <= out_size, "ReadFromOffset read too much data.");
 
     // strtab->sh_offset points into .strtab-like section that contains
     // NUL-terminated strings: '\0foo\0barbaz\0...".
@@ -962,7 +962,7 @@ static bool ShouldUseMapping(const char *const flags) {
 // Read /proc/self/maps and run "callback" for each mmapped file found.  If
 // "callback" returns false, stop scanning and return true. Else continue
 // scanning /proc/self/maps. Return true if no parse error is found.
-static ABSL_ATTRIBUTE_NOINLINE bool ReadAddrMap(
+static Y_ABSL_ATTRIBUTE_NOINLINE bool ReadAddrMap(
     bool (*callback)(const char *filename, const void *const start_addr,
                      const void *const end_addr, uint64_t offset, void *arg),
     void *arg, void *tmp_buf, int tmp_buf_size) {
@@ -976,7 +976,7 @@ static ABSL_ATTRIBUTE_NOINLINE bool ReadAddrMap(
   NO_INTR(maps_fd = open(maps_path, O_RDONLY));
   FileDescriptor wrapped_maps_fd(maps_fd);
   if (wrapped_maps_fd.get() < 0) {
-    ABSL_RAW_LOG(WARNING, "%s: errno=%d", maps_path, errno);
+    Y_ABSL_RAW_LOG(WARNING, "%s: errno=%d", maps_path, errno);
     return false;
   }
 
@@ -1003,7 +1003,7 @@ static ABSL_ATTRIBUTE_NOINLINE bool ReadAddrMap(
     // Read start address.
     cursor = GetHex(cursor, eol, &start_address);
     if (cursor == eol || *cursor != '-') {
-      ABSL_RAW_LOG(WARNING, "Corrupt /proc/self/maps line: %s", line);
+      Y_ABSL_RAW_LOG(WARNING, "Corrupt /proc/self/maps line: %s", line);
       return false;
     }
     ++cursor;  // Skip '-'.
@@ -1012,7 +1012,7 @@ static ABSL_ATTRIBUTE_NOINLINE bool ReadAddrMap(
     const void *end_address;
     cursor = GetHex(cursor, eol, &end_address);
     if (cursor == eol || *cursor != ' ') {
-      ABSL_RAW_LOG(WARNING, "Corrupt /proc/self/maps line: %s", line);
+      Y_ABSL_RAW_LOG(WARNING, "Corrupt /proc/self/maps line: %s", line);
       return false;
     }
     ++cursor;  // Skip ' '.
@@ -1024,7 +1024,7 @@ static ABSL_ATTRIBUTE_NOINLINE bool ReadAddrMap(
     }
     // We expect at least four letters for flags (ex. "r-xp").
     if (cursor == eol || cursor < flags_start + 4) {
-      ABSL_RAW_LOG(WARNING, "Corrupt /proc/self/maps: %s", line);
+      Y_ABSL_RAW_LOG(WARNING, "Corrupt /proc/self/maps: %s", line);
       return false;
     }
 
@@ -1129,7 +1129,7 @@ bool Symbolizer::RegisterObjFile(const char *filename,
   if (addr_map_size != 0) {
     ObjFile *old = impl->addr_map_.At(addr_map_size - 1);
     if (old->end_addr > end_addr) {
-      ABSL_RAW_LOG(ERROR,
+      Y_ABSL_RAW_LOG(ERROR,
                    "Unsorted addr map entry: 0x%" PRIxPTR ": %s <-> 0x%" PRIxPTR
                    ": %s",
                    reinterpret_cast<uintptr_t>(end_addr), filename,
@@ -1139,7 +1139,7 @@ bool Symbolizer::RegisterObjFile(const char *filename,
       // The same entry appears twice. This sometimes happens for [vdso].
       if (old->start_addr != start_addr ||
           strcmp(old->filename, filename) != 0) {
-        ABSL_RAW_LOG(ERROR,
+        Y_ABSL_RAW_LOG(ERROR,
                      "Duplicate addr 0x%" PRIxPTR ": %s <-> 0x%" PRIxPTR ": %s",
                      reinterpret_cast<uintptr_t>(end_addr), filename,
                      reinterpret_cast<uintptr_t>(old->end_addr), old->filename);
@@ -1161,7 +1161,7 @@ bool Symbolizer::RegisterObjFile(const char *filename,
 // where the input symbol is demangled in-place.
 // To keep stack consumption low, we would like this function to not
 // get inlined.
-static ABSL_ATTRIBUTE_NOINLINE void DemangleInplace(char *out, int out_size,
+static Y_ABSL_ATTRIBUTE_NOINLINE void DemangleInplace(char *out, int out_size,
                                                     char *tmp_buf,
                                                     int tmp_buf_size) {
   if (Demangle(out, tmp_buf, tmp_buf_size)) {
@@ -1193,7 +1193,7 @@ const char *Symbolizer::FindSymbolInCache(const void *const pc) {
   if (pc == nullptr) return nullptr;
 
   SymbolCacheLine *line = GetCacheLine(pc);
-  for (size_t i = 0; i < ABSL_ARRAYSIZE(line->pc); ++i) {
+  for (size_t i = 0; i < Y_ABSL_ARRAYSIZE(line->pc); ++i) {
     if (line->pc[i] == pc) {
       AgeSymbols(line);
       line->age[i] = 0;
@@ -1210,7 +1210,7 @@ const char *Symbolizer::InsertSymbolInCache(const void *const pc,
   SymbolCacheLine *line = GetCacheLine(pc);
   uint32_t max_age = 0;
   int oldest_index = -1;
-  for (size_t i = 0; i < ABSL_ARRAYSIZE(line->pc); ++i) {
+  for (size_t i = 0; i < Y_ABSL_ARRAYSIZE(line->pc); ++i) {
     if (line->pc[i] == nullptr) {
       AgeSymbols(line);
       line->pc[i] = pc;
@@ -1225,7 +1225,7 @@ const char *Symbolizer::InsertSymbolInCache(const void *const pc,
   }
 
   AgeSymbols(line);
-  ABSL_RAW_CHECK(oldest_index >= 0, "Corrupt cache");
+  Y_ABSL_RAW_CHECK(oldest_index >= 0, "Corrupt cache");
   base_internal::LowLevelAlloc::Free(line->name[oldest_index]);
   line->pc[oldest_index] = pc;
   line->name[oldest_index] = CopyString(name);
@@ -1277,19 +1277,19 @@ static bool MaybeInitializeObjFile(ObjFile *obj) {
     }
 
     if (obj->fd < 0) {
-      ABSL_RAW_LOG(WARNING, "%s: open failed: errno=%d", obj->filename, errno);
+      Y_ABSL_RAW_LOG(WARNING, "%s: open failed: errno=%d", obj->filename, errno);
       return false;
     }
     obj->elf_type = FileGetElfType(obj->fd);
     if (obj->elf_type < 0) {
-      ABSL_RAW_LOG(WARNING, "%s: wrong elf type: %d", obj->filename,
+      Y_ABSL_RAW_LOG(WARNING, "%s: wrong elf type: %d", obj->filename,
                    obj->elf_type);
       return false;
     }
 
     if (!ReadFromOffsetExact(obj->fd, &obj->elf_header, sizeof(obj->elf_header),
                              0)) {
-      ABSL_RAW_LOG(WARNING, "%s: failed to read elf header", obj->filename);
+      Y_ABSL_RAW_LOG(WARNING, "%s: failed to read elf header", obj->filename);
       return false;
     }
     const int phnum = obj->elf_header.e_phnum;
@@ -1299,7 +1299,7 @@ static bool MaybeInitializeObjFile(ObjFile *obj) {
     for (int j = 0; j < phnum; j++) {
       ElfW(Phdr) phdr;
       if (!ReadFromOffsetExact(obj->fd, &phdr, sizeof(phdr), phoff)) {
-        ABSL_RAW_LOG(WARNING, "%s: failed to read program header %d",
+        Y_ABSL_RAW_LOG(WARNING, "%s: failed to read program header %d",
                      obj->filename, j);
         return false;
       }
@@ -1312,14 +1312,14 @@ static bool MaybeInitializeObjFile(ObjFile *obj) {
       if (num_executable_load_segments < obj->phdr.size()) {
         memcpy(&obj->phdr[num_executable_load_segments++], &phdr, sizeof(phdr));
       } else {
-        ABSL_RAW_LOG(WARNING, "%s: too many executable LOAD segments",
+        Y_ABSL_RAW_LOG(WARNING, "%s: too many executable LOAD segments",
                      obj->filename);
         break;
       }
     }
     if (num_executable_load_segments == 0) {
       // This object has no "r-x" LOAD segments. That's unexpected.
-      ABSL_RAW_LOG(WARNING, "%s: no executable LOAD segments", obj->filename);
+      Y_ABSL_RAW_LOG(WARNING, "%s: no executable LOAD segments", obj->filename);
       return false;
     }
   }
@@ -1361,7 +1361,7 @@ const char *Symbolizer::GetSymbol(const void *const pc) {
           if (p.p_type != PT_LOAD) {
             // We only expect PT_LOADs. This must be PT_NULL that we didn't
             // write over (i.e. we exhausted all interesting PT_LOADs).
-            ABSL_RAW_CHECK(p.p_type == PT_NULL, "unexpected p_type");
+            Y_ABSL_RAW_CHECK(p.p_type == PT_NULL, "unexpected p_type");
             break;
           }
           if (pc < reinterpret_cast<void *>(start_addr + p.p_memsz)) {
@@ -1371,7 +1371,7 @@ const char *Symbolizer::GetSymbol(const void *const pc) {
         }
         if (phdr == nullptr) {
           // That's unexpected. Hope for the best.
-          ABSL_RAW_LOG(
+          Y_ABSL_RAW_LOG(
               WARNING,
               "%s: unable to find LOAD segment for pc: %p, start_addr: %zx",
               obj->filename, pc, start_addr);
@@ -1393,14 +1393,14 @@ const char *Symbolizer::GetSymbol(const void *const pc) {
       }
     }
   } else {
-#if ABSL_HAVE_VDSO_SUPPORT
+#if Y_ABSL_HAVE_VDSO_SUPPORT
     VDSOSupport vdso;
     if (vdso.IsPresent()) {
       VDSOSupport::SymbolInfo symbol_info;
       if (vdso.LookupSymbolByAddress(pc, &symbol_info)) {
         // All VDSO symbols are known to be short.
         size_t len = strlen(symbol_info.name);
-        ABSL_RAW_CHECK(len + 1 < sizeof(symbol_buf_),
+        Y_ABSL_RAW_CHECK(len + 1 < sizeof(symbol_buf_),
                        "VDSO symbol unexpectedly long");
         memcpy(symbol_buf_, symbol_info.name, len + 1);
       }
@@ -1493,7 +1493,7 @@ bool RegisterFileMappingHint(const void *start, const void *end, uint64_t offset
     int len = strlen(filename);
     char *dst = static_cast<char *>(
         base_internal::LowLevelAlloc::AllocWithArena(len + 1, SigSafeArena()));
-    ABSL_RAW_CHECK(dst != nullptr, "out of memory");
+    Y_ABSL_RAW_CHECK(dst != nullptr, "out of memory");
     memcpy(dst, filename, len + 1);
 
     auto &hint = g_file_mapping_hints[g_num_file_mapping_hints++];
@@ -1540,7 +1540,7 @@ bool GetFileMappingHint(const void **start, const void **end, uint64_t *offset,
 
 bool Symbolize(const void *pc, char *out, int out_size) {
   // Symbolization is very slow under tsan.
-  ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN();
+  Y_ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN();
   SAFE_ASSERT(out_size >= 0);
   debugging_internal::Symbolizer *s = debugging_internal::AllocateSymbolizer();
   const char *name = s->GetSymbol(pc);
@@ -1559,11 +1559,11 @@ bool Symbolize(const void *pc, char *out, int out_size) {
     }
   }
   debugging_internal::FreeSymbolizer(s);
-  ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_END();
+  Y_ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_END();
   return ok;
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 extern "C" bool YAbslInternalGetFileMappingHint(const void **start,
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_emscripten.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_emscripten.inc
index 6ddb5b4a7f..5aa97cca46 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_emscripten.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_emscripten.inc
@@ -34,11 +34,11 @@ EM_JS(bool, HaveOffsetConverter, (),
 // clang-format on
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 void InitializeSymbolizer(const char*) {
   if (!HaveOffsetConverter()) {
-    ABSL_RAW_LOG(INFO,
+    Y_ABSL_RAW_LOG(INFO,
                  "Symbolization unavailable. Rebuild with -sWASM=1 "
                  "and -sUSE_OFFSET_CONVERTER=1.");
   }
@@ -68,5 +68,5 @@ bool Symbolize(const void* pc, char* out, int out_size) {
   return true;
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_unimplemented.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_unimplemented.inc
index 4e55ed122f..ec50f589c6 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_unimplemented.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_unimplemented.inc
@@ -17,7 +17,7 @@
 #include "y_absl/base/internal/raw_logging.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 namespace debugging_internal {
 
@@ -36,5 +36,5 @@ bool GetFileMappingHint(const void **, const void **, uint64_t *, const char **)
 void InitializeSymbolizer(const char*) {}
 bool Symbolize(const void *, char *, int) { return false; }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_win32.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_win32.inc
index 81e0473f88..ac6748092c 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_win32.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/debugging/symbolize_win32.inc
@@ -31,7 +31,7 @@
 #include "y_absl/base/internal/raw_logging.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 static HANDLE process = NULL;
 
@@ -47,10 +47,10 @@ void InitializeSymbolizer(const char*) {
   SymSetOptions(SYMOPT_DEFERRED_LOADS | SYMOPT_UNDNAME);
   if (!SymInitialize(process, nullptr, true)) {
     // GetLastError() returns a Win32 DWORD, but we assign to
-    // unsigned long long to simplify the ABSL_RAW_LOG case below.  The uniform
+    // unsigned long long to simplify the Y_ABSL_RAW_LOG case below.  The uniform
     // initialization guarantees this is not a narrowing conversion.
     const unsigned long long error{GetLastError()};  // NOLINT(runtime/int)
-    ABSL_RAW_LOG(FATAL, "SymInitialize() failed: %llu", error);
+    Y_ABSL_RAW_LOG(FATAL, "SymInitialize() failed: %llu", error);
   }
 }
 
@@ -77,5 +77,5 @@ bool Symbolize(const void* pc, char* out, int out_size) {
   return true;
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/functional/bind_front.h b/contrib/restricted/abseil-cpp-tstring/y_absl/functional/bind_front.h
index 457b1fa734..bf3b367b93 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/functional/bind_front.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/functional/bind_front.h
@@ -27,14 +27,14 @@
 // partial function application. (See
 // https://en.wikipedia.org/wiki/Partial_application).
 
-#ifndef ABSL_FUNCTIONAL_BIND_FRONT_H_
-#define ABSL_FUNCTIONAL_BIND_FRONT_H_
+#ifndef Y_ABSL_FUNCTIONAL_BIND_FRONT_H_
+#define Y_ABSL_FUNCTIONAL_BIND_FRONT_H_
 
 #include "y_absl/functional/internal/front_binder.h"
 #include "y_absl/utility/utility.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // bind_front()
 //
@@ -178,7 +178,7 @@ constexpr functional_internal::bind_front_t<F, BoundArgs...> bind_front(
       y_absl::forward<BoundArgs>(args)...);
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_FUNCTIONAL_BIND_FRONT_H_
+#endif  // Y_ABSL_FUNCTIONAL_BIND_FRONT_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/functional/function_ref.h b/contrib/restricted/abseil-cpp-tstring/y_absl/functional/function_ref.h
index 6ae4c63c9e..09fec40c7f 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/functional/function_ref.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/functional/function_ref.h
@@ -43,8 +43,8 @@
 // the visitor pattern are a good example of when this class should be used.
 //
 // This class is trivial to copy and should be passed by value.
-#ifndef ABSL_FUNCTIONAL_FUNCTION_REF_H_
-#define ABSL_FUNCTIONAL_FUNCTION_REF_H_
+#ifndef Y_ABSL_FUNCTIONAL_FUNCTION_REF_H_
+#define Y_ABSL_FUNCTIONAL_FUNCTION_REF_H_
 
 #include <cassert>
 #include <functional>
@@ -55,7 +55,7 @@
 #include "y_absl/meta/type_traits.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // FunctionRef
 //
@@ -100,7 +100,7 @@ class FunctionRef<R(Args...)> {
   // Constructs a FunctionRef from any invokable type.
   template <typename F, typename = EnableIfCompatible<const F&>>
   // NOLINTNEXTLINE(runtime/explicit)
-  FunctionRef(const F& f ABSL_ATTRIBUTE_LIFETIME_BOUND)
+  FunctionRef(const F& f Y_ABSL_ATTRIBUTE_LIFETIME_BOUND)
       : invoker_(&y_absl::functional_internal::InvokeObject<F, R, Args...>) {
     y_absl::functional_internal::AssertNonNull(f);
     ptr_.obj = &f;
@@ -136,7 +136,7 @@ class FunctionRef<R(Args...)> {
   y_absl::functional_internal::Invoker<R, Args...> invoker_;
 };
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_FUNCTIONAL_FUNCTION_REF_H_
+#endif  // Y_ABSL_FUNCTIONAL_FUNCTION_REF_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/functional/internal/front_binder.h b/contrib/restricted/abseil-cpp-tstring/y_absl/functional/internal/front_binder.h
index b2fff44274..e20e1d2666 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/functional/internal/front_binder.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/functional/internal/front_binder.h
@@ -14,8 +14,8 @@
 
 // Implementation details for `y_absl::bind_front()`.
 
-#ifndef ABSL_FUNCTIONAL_INTERNAL_FRONT_BINDER_H_
-#define ABSL_FUNCTIONAL_INTERNAL_FRONT_BINDER_H_
+#ifndef Y_ABSL_FUNCTIONAL_INTERNAL_FRONT_BINDER_H_
+#define Y_ABSL_FUNCTIONAL_INTERNAL_FRONT_BINDER_H_
 
 #include <cstddef>
 #include <type_traits>
@@ -27,7 +27,7 @@
 #include "y_absl/utility/utility.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace functional_internal {
 
 // Invoke the method, expanding the tuple of bound arguments.
@@ -89,7 +89,7 @@ template <class F, class... BoundArgs>
 using bind_front_t = FrontBinder<decay_t<F>, y_absl::decay_t<BoundArgs>...>;
 
 }  // namespace functional_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_FUNCTIONAL_INTERNAL_FRONT_BINDER_H_
+#endif  // Y_ABSL_FUNCTIONAL_INTERNAL_FRONT_BINDER_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/functional/internal/function_ref.h b/contrib/restricted/abseil-cpp-tstring/y_absl/functional/internal/function_ref.h
index 1ba81ee96a..a6be684ffa 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/functional/internal/function_ref.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/functional/internal/function_ref.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_FUNCTIONAL_INTERNAL_FUNCTION_REF_H_
-#define ABSL_FUNCTIONAL_INTERNAL_FUNCTION_REF_H_
+#ifndef Y_ABSL_FUNCTIONAL_INTERNAL_FUNCTION_REF_H_
+#define Y_ABSL_FUNCTIONAL_INTERNAL_FUNCTION_REF_H_
 
 #include <cassert>
 #include <functional>
@@ -23,7 +23,7 @@
 #include "y_absl/meta/type_traits.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace functional_internal {
 
 // Like a void* that can handle function pointers as well. The standard does not
@@ -100,7 +100,7 @@ template <bool C>
 using EnableIf = typename ::std::enable_if<C, int>::type;
 
 }  // namespace functional_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_FUNCTIONAL_INTERNAL_FUNCTION_REF_H_
+#endif  // Y_ABSL_FUNCTIONAL_INTERNAL_FUNCTION_REF_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/hash.h b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/hash.h
index 1e93ee96d9..f876d11dbd 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/hash.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/hash.h
@@ -70,15 +70,15 @@
 //
 // For more information, see Adding Type Support to `y_absl::Hash` below.
 //
-#ifndef ABSL_HASH_HASH_H_
-#define ABSL_HASH_HASH_H_
+#ifndef Y_ABSL_HASH_HASH_H_
+#define Y_ABSL_HASH_HASH_H_
 
 #include <tuple>
 
 #include "y_absl/hash/internal/hash.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // -----------------------------------------------------------------------------
 // `y_absl::Hash`
@@ -341,7 +341,7 @@ class HashState : public hash_internal::HashStateBase<HashState> {
   void (*combine_contiguous_)(void*, const unsigned char*, size_t);
 };
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_HASH_HASH_H_
+#endif  // Y_ABSL_HASH_HASH_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/hash_testing.h b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/hash_testing.h
index 2f22d37039..25cc4e488d 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/hash_testing.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/hash_testing.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_HASH_HASH_TESTING_H_
-#define ABSL_HASH_HASH_TESTING_H_
+#ifndef Y_ABSL_HASH_HASH_TESTING_H_
+#define Y_ABSL_HASH_HASH_TESTING_H_
 
 #include <initializer_list>
 #include <tuple>
@@ -28,7 +28,7 @@
 #include "y_absl/types/variant.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // Run the y_absl::Hash algorithm over all the elements passed in and verify that
 // their hash expansion is congruent with their `==` operator.
@@ -141,19 +141,19 @@ ABSL_NAMESPACE_BEGIN
 // }
 //
 template <int&... ExplicitBarrier, typename Container>
-ABSL_MUST_USE_RESULT testing::AssertionResult
+Y_ABSL_MUST_USE_RESULT testing::AssertionResult
 VerifyTypeImplementsAbslHashCorrectly(const Container& values);
 
 template <int&... ExplicitBarrier, typename Container, typename Eq>
-ABSL_MUST_USE_RESULT testing::AssertionResult
+Y_ABSL_MUST_USE_RESULT testing::AssertionResult
 VerifyTypeImplementsAbslHashCorrectly(const Container& values, Eq equals);
 
 template <int&..., typename T>
-ABSL_MUST_USE_RESULT testing::AssertionResult
+Y_ABSL_MUST_USE_RESULT testing::AssertionResult
 VerifyTypeImplementsAbslHashCorrectly(std::initializer_list<T> values);
 
 template <int&..., typename T, typename Eq>
-ABSL_MUST_USE_RESULT testing::AssertionResult
+Y_ABSL_MUST_USE_RESULT testing::AssertionResult
 VerifyTypeImplementsAbslHashCorrectly(std::initializer_list<T> values,
                                       Eq equals);
 
@@ -184,7 +184,7 @@ struct ExpandVisitor {
 };
 
 template <typename Container, typename Eq>
-ABSL_MUST_USE_RESULT testing::AssertionResult
+Y_ABSL_MUST_USE_RESULT testing::AssertionResult
 VerifyTypeImplementsAbslHashCorrectly(const Container& values, Eq equals) {
   using V = typename Container::value_type;
 
@@ -341,7 +341,7 @@ struct DefaultEquals {
 }  // namespace hash_internal
 
 template <int&..., typename Container>
-ABSL_MUST_USE_RESULT testing::AssertionResult
+Y_ABSL_MUST_USE_RESULT testing::AssertionResult
 VerifyTypeImplementsAbslHashCorrectly(const Container& values) {
   return hash_internal::VerifyTypeImplementsAbslHashCorrectly(
       hash_internal::ContainerAsVector<Container>::Do(values),
@@ -349,14 +349,14 @@ VerifyTypeImplementsAbslHashCorrectly(const Container& values) {
 }
 
 template <int&..., typename Container, typename Eq>
-ABSL_MUST_USE_RESULT testing::AssertionResult
+Y_ABSL_MUST_USE_RESULT testing::AssertionResult
 VerifyTypeImplementsAbslHashCorrectly(const Container& values, Eq equals) {
   return hash_internal::VerifyTypeImplementsAbslHashCorrectly(
       hash_internal::ContainerAsVector<Container>::Do(values), equals);
 }
 
 template <int&..., typename T>
-ABSL_MUST_USE_RESULT testing::AssertionResult
+Y_ABSL_MUST_USE_RESULT testing::AssertionResult
 VerifyTypeImplementsAbslHashCorrectly(std::initializer_list<T> values) {
   return hash_internal::VerifyTypeImplementsAbslHashCorrectly(
       hash_internal::ContainerAsVector<std::initializer_list<T>>::Do(values),
@@ -364,7 +364,7 @@ VerifyTypeImplementsAbslHashCorrectly(std::initializer_list<T> values) {
 }
 
 template <int&..., typename T, typename Eq>
-ABSL_MUST_USE_RESULT testing::AssertionResult
+Y_ABSL_MUST_USE_RESULT testing::AssertionResult
 VerifyTypeImplementsAbslHashCorrectly(std::initializer_list<T> values,
                                       Eq equals) {
   return hash_internal::VerifyTypeImplementsAbslHashCorrectly(
@@ -372,7 +372,7 @@ VerifyTypeImplementsAbslHashCorrectly(std::initializer_list<T> values,
       equals);
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_HASH_HASH_TESTING_H_
+#endif  // Y_ABSL_HASH_HASH_TESTING_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/city.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/city.cc
index 5f1b655e7e..9b6021ab85 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/city.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/city.cc
@@ -30,10 +30,10 @@
 #include "y_absl/base/optimization.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace hash_internal {
 
-#ifdef ABSL_IS_BIG_ENDIAN
+#ifdef Y_ABSL_IS_BIG_ENDIAN
 #define uint32_in_expected_order(x) (y_absl::gbswap_32(x))
 #define uint64_in_expected_order(x) (y_absl::gbswap_64(x))
 #else
@@ -42,11 +42,11 @@ namespace hash_internal {
 #endif
 
 static uint64_t Fetch64(const char *p) {
-  return uint64_in_expected_order(ABSL_INTERNAL_UNALIGNED_LOAD64(p));
+  return uint64_in_expected_order(Y_ABSL_INTERNAL_UNALIGNED_LOAD64(p));
 }
 
 static uint32_t Fetch32(const char *p) {
-  return uint32_in_expected_order(ABSL_INTERNAL_UNALIGNED_LOAD32(p));
+  return uint32_in_expected_order(Y_ABSL_INTERNAL_UNALIGNED_LOAD32(p));
 }
 
 // Some primes between 2^63 and 2^64 for various uses.
@@ -345,5 +345,5 @@ uint64_t CityHash64WithSeeds(const char *s, size_t len, uint64_t seed0,
 }
 
 }  // namespace hash_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/city.h b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/city.h
index d2b32f0068..2a4470e3ef 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/city.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/city.h
@@ -42,8 +42,8 @@
 // of a+b is easily derived from the hashes of a and b.  This property
 // doesn't hold for any hash functions in this file.
 
-#ifndef ABSL_HASH_INTERNAL_CITY_H_
-#define ABSL_HASH_INTERNAL_CITY_H_
+#ifndef Y_ABSL_HASH_INTERNAL_CITY_H_
+#define Y_ABSL_HASH_INTERNAL_CITY_H_
 
 #include <stdint.h>
 #include <stdlib.h>  // for size_t.
@@ -53,7 +53,7 @@
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace hash_internal {
 
 // Hash function for a byte array.
@@ -72,7 +72,7 @@ uint64_t CityHash64WithSeeds(const char *s, size_t len, uint64_t seed0,
 uint32_t CityHash32(const char *s, size_t len);
 
 }  // namespace hash_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_HASH_INTERNAL_CITY_H_
+#endif  // Y_ABSL_HASH_INTERNAL_CITY_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/hash.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/hash.cc
index fe075de43a..356cb7631c 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/hash.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/hash.cc
@@ -15,7 +15,7 @@
 #include "y_absl/hash/internal/hash.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace hash_internal {
 
 uint64_t MixingHashState::CombineLargeContiguousImpl32(
@@ -44,7 +44,7 @@ uint64_t MixingHashState::CombineLargeContiguousImpl64(
                                std::integral_constant<int, 8>{});
 }
 
-ABSL_CONST_INIT const void* const MixingHashState::kSeed = &kSeed;
+Y_ABSL_CONST_INIT const void* const MixingHashState::kSeed = &kSeed;
 
 // The salt array used by LowLevelHash. This array is NOT the mechanism used to
 // make y_absl::Hash non-deterministic between program invocations.  See `Seed()`
@@ -65,5 +65,5 @@ uint64_t MixingHashState::LowLevelHashImpl(const unsigned char* data,
 }
 
 }  // namespace hash_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/hash.h b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/hash.h
index fcbe43accd..a14b74ed74 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/hash.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/hash.h
@@ -16,8 +16,8 @@
 // File: hash.h
 // -----------------------------------------------------------------------------
 //
-#ifndef ABSL_HASH_INTERNAL_HASH_H_
-#define ABSL_HASH_INTERNAL_HASH_H_
+#ifndef Y_ABSL_HASH_INTERNAL_HASH_H_
+#define Y_ABSL_HASH_INTERNAL_HASH_H_
 
 #include <algorithm>
 #include <array>
@@ -53,7 +53,7 @@
 #include "y_absl/utility/utility.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace hash_internal {
 
 // Internal detail: Large buffers are hashed in smaller chunks.  This function
@@ -502,7 +502,7 @@ AbslHashValue(H hash_state, const std::vector<T, Allocator>& vector) {
                     vector.size());
 }
 
-#if defined(ABSL_IS_BIG_ENDIAN) && \
+#if defined(Y_ABSL_IS_BIG_ENDIAN) && \
     (defined(__GLIBCXX__) || defined(__GLIBCPP__))
 // AbslHashValue for hashing std::vector<bool>
 //
@@ -620,7 +620,7 @@ AbslHashValue(H hash_state, const y_absl::variant<T...>& v) {
 // It does not expose the raw bytes, and a fallback to std::hash<> is most
 // likely faster.
 
-#if defined(ABSL_IS_BIG_ENDIAN) && \
+#if defined(Y_ABSL_IS_BIG_ENDIAN) && \
     (defined(__GLIBCXX__) || defined(__GLIBCPP__))
 // AbslHashValue for hashing std::bitset
 //
@@ -662,11 +662,11 @@ hash_range_or_bytes(H hash_state, const T* data, size_t size) {
   return hash_state;
 }
 
-#if defined(ABSL_INTERNAL_LEGACY_HASH_NAMESPACE) && \
-    ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
-#define ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_ 1
+#if defined(Y_ABSL_INTERNAL_LEGACY_HASH_NAMESPACE) && \
+    Y_ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
+#define Y_ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_ 1
 #else
-#define ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_ 0
+#define Y_ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_ 0
 #endif
 
 // HashSelect
@@ -705,18 +705,18 @@ struct HashSelect {
   };
 
   struct LegacyHashProbe {
-#if ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_
+#if Y_ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_
     template <typename H, typename T>
     static auto Invoke(H state, const T& value) -> y_absl::enable_if_t<
         std::is_convertible<
-            decltype(ABSL_INTERNAL_LEGACY_HASH_NAMESPACE::hash<T>()(value)),
+            decltype(Y_ABSL_INTERNAL_LEGACY_HASH_NAMESPACE::hash<T>()(value)),
             size_t>::value,
         H> {
       return hash_internal::hash_bytes(
           std::move(state),
-          ABSL_INTERNAL_LEGACY_HASH_NAMESPACE::hash<T>{}(value));
+          Y_ABSL_INTERNAL_LEGACY_HASH_NAMESPACE::hash<T>{}(value));
     }
-#endif  // ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_
+#endif  // Y_ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_
   };
 
   struct StdHashProbe {
@@ -757,14 +757,14 @@ struct is_hashable
     : std::integral_constant<bool, HashSelect::template Apply<T>::value> {};
 
 // MixingHashState
-class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
+class Y_ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
   // y_absl::uint128 is not an alias or a thin wrapper around the intrinsic.
   // We use the intrinsic when available to improve performance.
-#ifdef ABSL_HAVE_INTRINSIC_INT128
+#ifdef Y_ABSL_HAVE_INTRINSIC_INT128
   using uint128 = __uint128_t;
-#else   // ABSL_HAVE_INTRINSIC_INT128
+#else   // Y_ABSL_HAVE_INTRINSIC_INT128
   using uint128 = y_absl::uint128;
-#endif  // ABSL_HAVE_INTRINSIC_INT128
+#endif  // Y_ABSL_HAVE_INTRINSIC_INT128
 
   static constexpr uint64_t kMul =
       sizeof(size_t) == 4 ? uint64_t{0xcc9e2d51}
@@ -853,7 +853,7 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
                                                  size_t len) {
     uint64_t low_mem = y_absl::base_internal::UnalignedLoad64(p);
     uint64_t high_mem = y_absl::base_internal::UnalignedLoad64(p + len - 8);
-#ifdef ABSL_IS_LITTLE_ENDIAN
+#ifdef Y_ABSL_IS_LITTLE_ENDIAN
     uint64_t most_significant = high_mem;
     uint64_t least_significant = low_mem;
 #else
@@ -867,7 +867,7 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
   static uint64_t Read4To8(const unsigned char* p, size_t len) {
     uint32_t low_mem = y_absl::base_internal::UnalignedLoad32(p);
     uint32_t high_mem = y_absl::base_internal::UnalignedLoad32(p + len - 4);
-#ifdef ABSL_IS_LITTLE_ENDIAN
+#ifdef Y_ABSL_IS_LITTLE_ENDIAN
     uint32_t most_significant = high_mem;
     uint32_t least_significant = low_mem;
 #else
@@ -883,7 +883,7 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
     unsigned char mem0 = p[0];
     unsigned char mem1 = p[len / 2];
     unsigned char mem2 = p[len - 1];
-#ifdef ABSL_IS_LITTLE_ENDIAN
+#ifdef Y_ABSL_IS_LITTLE_ENDIAN
     unsigned char significant2 = mem2;
     unsigned char significant1 = mem1;
     unsigned char significant0 = mem0;
@@ -897,7 +897,7 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
                                  (significant2 << ((len - 1) * 8)));
   }
 
-  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Mix(uint64_t state, uint64_t v) {
+  Y_ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Mix(uint64_t state, uint64_t v) {
 #if defined(__aarch64__)
     // On AArch64, calculating a 128-bit product is inefficient, because it
     // requires a sequence of two instructions to calculate the upper and lower
@@ -920,9 +920,9 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
   // values for both the seed and salt parameters.
   static uint64_t LowLevelHashImpl(const unsigned char* data, size_t len);
 
-  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Hash64(const unsigned char* data,
+  Y_ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Hash64(const unsigned char* data,
                                                       size_t len) {
-#ifdef ABSL_HAVE_INTRINSIC_INT128
+#ifdef Y_ABSL_HAVE_INTRINSIC_INT128
     return LowLevelHashImpl(data, len);
 #else
     return hash_internal::CityHash64(reinterpret_cast<const char*>(data), len);
@@ -945,7 +945,7 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
   //
   // On other platforms this is still going to be non-deterministic but most
   // probably per-build and not per-process.
-  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Seed() {
+  Y_ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Seed() {
 #if (!defined(__clang__) || __clang_major__ > 11) && \
     !defined(__apple_build_version__)
     return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(&kSeed));
@@ -968,7 +968,7 @@ inline uint64_t MixingHashState::CombineContiguousImpl(
   // multiplicative hash.
   uint64_t v;
   if (len > 8) {
-    if (ABSL_PREDICT_FALSE(len > PiecewiseChunkSize())) {
+    if (Y_ABSL_PREDICT_FALSE(len > PiecewiseChunkSize())) {
       return CombineLargeContiguousImpl32(state, first, len);
     }
     v = hash_internal::CityHash32(reinterpret_cast<const char*>(first), len);
@@ -991,7 +991,7 @@ inline uint64_t MixingHashState::CombineContiguousImpl(
   // for small ones we just use a multiplicative hash.
   uint64_t v;
   if (len > 16) {
-    if (ABSL_PREDICT_FALSE(len > PiecewiseChunkSize())) {
+    if (Y_ABSL_PREDICT_FALSE(len > PiecewiseChunkSize())) {
       return CombineLargeContiguousImpl64(state, first, len);
     }
     v = Hash64(first, len);
@@ -1090,7 +1090,7 @@ H PiecewiseCombiner::finalize(H state) {
 }
 
 }  // namespace hash_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_HASH_INTERNAL_HASH_H_
+#endif  // Y_ABSL_HASH_INTERNAL_HASH_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/low_level_hash.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/low_level_hash.cc
index 08b6dd85d4..e4d982e2ad 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/low_level_hash.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/low_level_hash.cc
@@ -19,7 +19,7 @@
 #include "y_absl/numeric/int128.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace hash_internal {
 
 static uint64_t Mix(uint64_t v0, uint64_t v1) {
@@ -119,5 +119,5 @@ uint64_t LowLevelHash(const void* data, size_t len, uint64_t seed,
 }
 
 }  // namespace hash_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/low_level_hash.h b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/low_level_hash.h
index 4a71ab9418..f371e59433 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/low_level_hash.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/low_level_hash.h
@@ -22,8 +22,8 @@
 // It is closely based on a version of wyhash, but does not maintain or
 // guarantee future compatibility with it.
 
-#ifndef ABSL_HASH_INTERNAL_LOW_LEVEL_HASH_H_
-#define ABSL_HASH_INTERNAL_LOW_LEVEL_HASH_H_
+#ifndef Y_ABSL_HASH_INTERNAL_LOW_LEVEL_HASH_H_
+#define Y_ABSL_HASH_INTERNAL_LOW_LEVEL_HASH_H_
 
 #include <stdint.h>
 #include <stdlib.h>
@@ -31,7 +31,7 @@
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace hash_internal {
 
 // Hash function for a byte array. A 64-bit seed and a set of five 64-bit
@@ -44,7 +44,7 @@ uint64_t LowLevelHash(const void* data, size_t len, uint64_t seed,
                       const uint64_t salt[5]);
 
 }  // namespace hash_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_HASH_INTERNAL_LOW_LEVEL_HASH_H_
+#endif  // Y_ABSL_HASH_INTERNAL_LOW_LEVEL_HASH_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/spy_hash_state.h b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/spy_hash_state.h
index 520cbf904f..f06948e43a 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/spy_hash_state.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/spy_hash_state.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_HASH_INTERNAL_SPY_HASH_STATE_H_
-#define ABSL_HASH_INTERNAL_SPY_HASH_STATE_H_
+#ifndef Y_ABSL_HASH_INTERNAL_SPY_HASH_STATE_H_
+#define Y_ABSL_HASH_INTERNAL_SPY_HASH_STATE_H_
 
 #include <ostream>
 #include <util/generic/string.h>
@@ -25,7 +25,7 @@
 #include "y_absl/strings/str_join.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace hash_internal {
 
 // SpyHashState is an implementation of the HashState API that simply
@@ -225,7 +225,7 @@ void AbslHashValue(SpyHashStateImpl<T>, const U&);
 using SpyHashState = SpyHashStateImpl<void>;
 
 }  // namespace hash_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_HASH_INTERNAL_SPY_HASH_STATE_H_
+#endif  // Y_ABSL_HASH_INTERNAL_SPY_HASH_STATE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/memory/memory.h b/contrib/restricted/abseil-cpp-tstring/y_absl/memory/memory.h
index 134a614b33..4addc6fb91 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/memory/memory.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/memory/memory.h
@@ -20,8 +20,8 @@
 // conversion of smart pointers. This file is an extension to the C++
 // standard <memory> library header file.
 
-#ifndef ABSL_MEMORY_MEMORY_H_
-#define ABSL_MEMORY_MEMORY_H_
+#ifndef Y_ABSL_MEMORY_MEMORY_H_
+#define Y_ABSL_MEMORY_MEMORY_H_
 
 #include <cstddef>
 #include <limits>
@@ -34,7 +34,7 @@
 #include "y_absl/meta/type_traits.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // -----------------------------------------------------------------------------
 // Function Template: WrapUnique()
@@ -622,7 +622,7 @@ using GetIsNothrow = typename Alloc::is_nothrow;
 
 }  // namespace memory_internal
 
-// ABSL_ALLOCATOR_NOTHROW is a build time configuration macro for user to
+// Y_ABSL_ALLOCATOR_NOTHROW is a build time configuration macro for user to
 // specify whether the default allocation function can throw or never throws.
 // If the allocation function never throws, user should define it to a non-zero
 // value (e.g. via `-DABSL_ALLOCATOR_NOTHROW`).
@@ -632,7 +632,7 @@ using GetIsNothrow = typename Alloc::is_nothrow;
 // allocator_is_nothrow<Alloc> is a traits class that derives from
 // Alloc::is_nothrow if present, otherwise std::false_type. It's specialized
 // for Alloc = std::allocator<T> for any type T according to the state of
-// ABSL_ALLOCATOR_NOTHROW.
+// Y_ABSL_ALLOCATOR_NOTHROW.
 //
 // default_allocator_is_nothrow is a class that derives from std::true_type
 // when the default allocator (global operator new) never throws, and
@@ -646,7 +646,7 @@ struct allocator_is_nothrow
     : memory_internal::ExtractOrT<memory_internal::GetIsNothrow, Alloc,
                                   std::false_type> {};
 
-#if defined(ABSL_ALLOCATOR_NOTHROW) && ABSL_ALLOCATOR_NOTHROW
+#if defined(Y_ABSL_ALLOCATOR_NOTHROW) && Y_ABSL_ALLOCATOR_NOTHROW
 template <typename T>
 struct allocator_is_nothrow<std::allocator<T>> : std::true_type {};
 struct default_allocator_is_nothrow : std::true_type {};
@@ -659,16 +659,16 @@ template <typename Allocator, typename Iterator, typename... Args>
 void ConstructRange(Allocator& alloc, Iterator first, Iterator last,
                     const Args&... args) {
   for (Iterator cur = first; cur != last; ++cur) {
-    ABSL_INTERNAL_TRY {
+    Y_ABSL_INTERNAL_TRY {
       std::allocator_traits<Allocator>::construct(alloc, std::addressof(*cur),
                                                   args...);
     }
-    ABSL_INTERNAL_CATCH_ANY {
+    Y_ABSL_INTERNAL_CATCH_ANY {
       while (cur != first) {
         --cur;
         std::allocator_traits<Allocator>::destroy(alloc, std::addressof(*cur));
       }
-      ABSL_INTERNAL_RETHROW;
+      Y_ABSL_INTERNAL_RETHROW;
     }
   }
 }
@@ -678,21 +678,21 @@ void CopyRange(Allocator& alloc, Iterator destination, InputIterator first,
                InputIterator last) {
   for (Iterator cur = destination; first != last;
        static_cast<void>(++cur), static_cast<void>(++first)) {
-    ABSL_INTERNAL_TRY {
+    Y_ABSL_INTERNAL_TRY {
       std::allocator_traits<Allocator>::construct(alloc, std::addressof(*cur),
                                                   *first);
     }
-    ABSL_INTERNAL_CATCH_ANY {
+    Y_ABSL_INTERNAL_CATCH_ANY {
       while (cur != destination) {
         --cur;
         std::allocator_traits<Allocator>::destroy(alloc, std::addressof(*cur));
       }
-      ABSL_INTERNAL_RETHROW;
+      Y_ABSL_INTERNAL_RETHROW;
     }
   }
 }
 }  // namespace memory_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_MEMORY_MEMORY_H_
+#endif  // Y_ABSL_MEMORY_MEMORY_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/meta/type_traits.h b/contrib/restricted/abseil-cpp-tstring/y_absl/meta/type_traits.h
index eb9649060b..3ef4411009 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/meta/type_traits.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/meta/type_traits.h
@@ -32,8 +32,8 @@
 // features is brittle and not guaranteed. Neither the standard library nor
 // Abseil provides any guarantee that APIs are stable in the face of template
 // metaprogramming. Use with caution.
-#ifndef ABSL_META_TYPE_TRAITS_H_
-#define ABSL_META_TYPE_TRAITS_H_
+#ifndef Y_ABSL_META_TYPE_TRAITS_H_
+#define Y_ABSL_META_TYPE_TRAITS_H_
 
 #include <cstddef>
 #include <functional>
@@ -44,19 +44,19 @@
 // MSVC constructibility traits do not detect destructor properties and so our
 // implementations should not use them as a source-of-truth.
 #if defined(_MSC_VER) && !defined(__clang__) && !defined(__GNUC__)
-#define ABSL_META_INTERNAL_STD_CONSTRUCTION_TRAITS_DONT_CHECK_DESTRUCTION 1
+#define Y_ABSL_META_INTERNAL_STD_CONSTRUCTION_TRAITS_DONT_CHECK_DESTRUCTION 1
 #endif
 
 // Defines the default alignment. `__STDCPP_DEFAULT_NEW_ALIGNMENT__` is a C++17
 // feature.
 #if defined(__STDCPP_DEFAULT_NEW_ALIGNMENT__)
-#define ABSL_INTERNAL_DEFAULT_NEW_ALIGNMENT __STDCPP_DEFAULT_NEW_ALIGNMENT__
+#define Y_ABSL_INTERNAL_DEFAULT_NEW_ALIGNMENT __STDCPP_DEFAULT_NEW_ALIGNMENT__
 #else  // defined(__STDCPP_DEFAULT_NEW_ALIGNMENT__)
-#define ABSL_INTERNAL_DEFAULT_NEW_ALIGNMENT alignof(std::max_align_t)
+#define Y_ABSL_INTERNAL_DEFAULT_NEW_ALIGNMENT alignof(std::max_align_t)
 #endif  // defined(__STDCPP_DEFAULT_NEW_ALIGNMENT__)
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // Defined and documented later on in this file.
 template <typename T>
@@ -300,7 +300,7 @@ template <typename T>
 struct is_trivially_destructible
     : std::integral_constant<bool, __has_trivial_destructor(T) &&
                                    std::is_destructible<T>::value> {
-#ifdef ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE
+#ifdef Y_ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE
  private:
   static constexpr bool compliant = std::is_trivially_destructible<T>::value ==
                                     is_trivially_destructible::value;
@@ -310,7 +310,7 @@ struct is_trivially_destructible
   static_assert(compliant || !std::is_trivially_destructible<T>::value,
                 "Not compliant with std::is_trivially_destructible; "
                 "Standard: true, Implementation: false");
-#endif  // ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE
+#endif  // Y_ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE
 };
 
 // is_trivially_default_constructible()
@@ -350,9 +350,9 @@ struct is_trivially_default_constructible
     : std::integral_constant<bool, __has_trivial_constructor(T) &&
                                    std::is_default_constructible<T>::value &&
                                    is_trivially_destructible<T>::value> {
-#if defined(ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE) && \
+#if defined(Y_ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE) && \
     !defined(                                            \
-        ABSL_META_INTERNAL_STD_CONSTRUCTION_TRAITS_DONT_CHECK_DESTRUCTION)
+        Y_ABSL_META_INTERNAL_STD_CONSTRUCTION_TRAITS_DONT_CHECK_DESTRUCTION)
  private:
   static constexpr bool compliant =
       std::is_trivially_default_constructible<T>::value ==
@@ -363,7 +363,7 @@ struct is_trivially_default_constructible
   static_assert(compliant || !std::is_trivially_default_constructible<T>::value,
                 "Not compliant with std::is_trivially_default_constructible; "
                 "Standard: true, Implementation: false");
-#endif  // ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE
+#endif  // Y_ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE
 };
 
 // is_trivially_move_constructible()
@@ -385,9 +385,9 @@ struct is_trivially_move_constructible
           std::is_object<T>::value && !std::is_array<T>::value,
           type_traits_internal::IsTriviallyMoveConstructibleObject<T>,
           std::is_reference<T>>::type::type {
-#if defined(ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE) && \
+#if defined(Y_ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE) && \
     !defined(                                            \
-        ABSL_META_INTERNAL_STD_CONSTRUCTION_TRAITS_DONT_CHECK_DESTRUCTION)
+        Y_ABSL_META_INTERNAL_STD_CONSTRUCTION_TRAITS_DONT_CHECK_DESTRUCTION)
  private:
   static constexpr bool compliant =
       std::is_trivially_move_constructible<T>::value ==
@@ -398,7 +398,7 @@ struct is_trivially_move_constructible
   static_assert(compliant || !std::is_trivially_move_constructible<T>::value,
                 "Not compliant with std::is_trivially_move_constructible; "
                 "Standard: true, Implementation: false");
-#endif  // ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE
+#endif  // Y_ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE
 };
 
 // is_trivially_copy_constructible()
@@ -420,9 +420,9 @@ struct is_trivially_copy_constructible
           std::is_object<T>::value && !std::is_array<T>::value,
           type_traits_internal::IsTriviallyCopyConstructibleObject<T>,
           std::is_lvalue_reference<T>>::type::type {
-#if defined(ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE) && \
+#if defined(Y_ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE) && \
     !defined(                                            \
-        ABSL_META_INTERNAL_STD_CONSTRUCTION_TRAITS_DONT_CHECK_DESTRUCTION)
+        Y_ABSL_META_INTERNAL_STD_CONSTRUCTION_TRAITS_DONT_CHECK_DESTRUCTION)
  private:
   static constexpr bool compliant =
       std::is_trivially_copy_constructible<T>::value ==
@@ -433,7 +433,7 @@ struct is_trivially_copy_constructible
   static_assert(compliant || !std::is_trivially_copy_constructible<T>::value,
                 "Not compliant with std::is_trivially_copy_constructible; "
                 "Standard: true, Implementation: false");
-#endif  // ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE
+#endif  // Y_ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE
 };
 
 // is_trivially_move_assignable()
@@ -459,7 +459,7 @@ struct is_trivially_move_assignable
           std::is_move_assignable<type_traits_internal::SingleMemberUnion<T>>,
           type_traits_internal::IsTriviallyMoveAssignableReference<T>>::type::
           type {
-#ifdef ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE
+#ifdef Y_ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE
  private:
   static constexpr bool compliant =
       std::is_trivially_move_assignable<T>::value ==
@@ -470,7 +470,7 @@ struct is_trivially_move_assignable
   static_assert(compliant || !std::is_trivially_move_assignable<T>::value,
                 "Not compliant with std::is_trivially_move_assignable; "
                 "Standard: true, Implementation: false");
-#endif  // ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE
+#endif  // Y_ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE
 };
 
 // is_trivially_copy_assignable()
@@ -493,7 +493,7 @@ struct is_trivially_copy_assignable
     : std::integral_constant<
           bool, __has_trivial_assign(typename std::remove_reference<T>::type) &&
                     y_absl::is_copy_assignable<T>::value> {
-#ifdef ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE
+#ifdef Y_ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE
  private:
   static constexpr bool compliant =
       std::is_trivially_copy_assignable<T>::value ==
@@ -504,7 +504,7 @@ struct is_trivially_copy_assignable
   static_assert(compliant || !std::is_trivially_copy_assignable<T>::value,
                 "Not compliant with std::is_trivially_copy_assignable; "
                 "Standard: true, Implementation: false");
-#endif  // ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE
+#endif  // Y_ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE
 };
 
 #if defined(__cpp_lib_remove_cvref) && __cpp_lib_remove_cvref >= 201711L
@@ -664,15 +664,15 @@ namespace type_traits_internal {
 //
 #if defined(_MSC_VER) || (defined(_LIBCPP_VERSION) && \
                           _LIBCPP_VERSION < 4000 && _LIBCPP_STD_VER > 11)
-#define ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_ 0
+#define Y_ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_ 0
 #else
-#define ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_ 1
+#define Y_ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_ 1
 #endif
 
-#if !ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
+#if !Y_ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
 template <typename Key, typename = size_t>
 struct IsHashable : std::true_type {};
-#else   // ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
+#else   // Y_ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
 template <typename Key, typename = void>
 struct IsHashable : std::false_type {};
 
@@ -682,7 +682,7 @@ struct IsHashable<
     y_absl::enable_if_t<std::is_convertible<
         decltype(std::declval<std::hash<Key>&>()(std::declval<Key const&>())),
         std::size_t>::value>> : std::true_type {};
-#endif  // !ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
+#endif  // !Y_ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
 
 struct AssertHashEnabledHelper {
  private:
@@ -791,7 +791,7 @@ using swap_internal::Swap;
 using swap_internal::StdSwapIsUnconstrained;
 
 }  // namespace type_traits_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_META_TYPE_TRAITS_H_
+#endif  // Y_ABSL_META_TYPE_TRAITS_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/bits.h b/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/bits.h
index 92cb0c3a91..a4dcd71f7a 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/bits.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/bits.h
@@ -31,8 +31,8 @@
 // When using a standard library that implements these functions, we use the
 // standard library's implementation.
 
-#ifndef ABSL_NUMERIC_BITS_H_
-#define ABSL_NUMERIC_BITS_H_
+#ifndef Y_ABSL_NUMERIC_BITS_H_
+#define Y_ABSL_NUMERIC_BITS_H_
 
 #include <cstdint>
 #include <limits>
@@ -48,19 +48,19 @@
 #include "y_absl/numeric/internal/bits.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 #if !(defined(__cpp_lib_bitops) && __cpp_lib_bitops >= 201907L)
 // rotating
 template <class T>
-ABSL_MUST_USE_RESULT constexpr
+Y_ABSL_MUST_USE_RESULT constexpr
     typename std::enable_if<std::is_unsigned<T>::value, T>::type
     rotl(T x, int s) noexcept {
   return numeric_internal::RotateLeft(x, s);
 }
 
 template <class T>
-ABSL_MUST_USE_RESULT constexpr
+Y_ABSL_MUST_USE_RESULT constexpr
     typename std::enable_if<std::is_unsigned<T>::value, T>::type
     rotr(T x, int s) noexcept {
   return numeric_internal::RotateRight(x, s);
@@ -72,14 +72,14 @@ ABSL_MUST_USE_RESULT constexpr
 // not be marked as constexpr due to constraints of the compiler/available
 // intrinsics.
 template <class T>
-ABSL_INTERNAL_CONSTEXPR_CLZ inline
+Y_ABSL_INTERNAL_CONSTEXPR_CLZ inline
     typename std::enable_if<std::is_unsigned<T>::value, int>::type
     countl_zero(T x) noexcept {
   return numeric_internal::CountLeadingZeroes(x);
 }
 
 template <class T>
-ABSL_INTERNAL_CONSTEXPR_CLZ inline
+Y_ABSL_INTERNAL_CONSTEXPR_CLZ inline
     typename std::enable_if<std::is_unsigned<T>::value, int>::type
     countl_one(T x) noexcept {
   // Avoid integer promotion to a wider type
@@ -87,14 +87,14 @@ ABSL_INTERNAL_CONSTEXPR_CLZ inline
 }
 
 template <class T>
-ABSL_INTERNAL_CONSTEXPR_CTZ inline
+Y_ABSL_INTERNAL_CONSTEXPR_CTZ inline
     typename std::enable_if<std::is_unsigned<T>::value, int>::type
     countr_zero(T x) noexcept {
   return numeric_internal::CountTrailingZeroes(x);
 }
 
 template <class T>
-ABSL_INTERNAL_CONSTEXPR_CTZ inline
+Y_ABSL_INTERNAL_CONSTEXPR_CTZ inline
     typename std::enable_if<std::is_unsigned<T>::value, int>::type
     countr_one(T x) noexcept {
   // Avoid integer promotion to a wider type
@@ -102,7 +102,7 @@ ABSL_INTERNAL_CONSTEXPR_CTZ inline
 }
 
 template <class T>
-ABSL_INTERNAL_CONSTEXPR_POPCOUNT inline
+Y_ABSL_INTERNAL_CONSTEXPR_POPCOUNT inline
     typename std::enable_if<std::is_unsigned<T>::value, int>::type
     popcount(T x) noexcept {
   return numeric_internal::Popcount(x);
@@ -130,7 +130,7 @@ has_single_bit(T x) noexcept {
 // Returns: If x == 0, 0; otherwise one plus the base-2 logarithm of x, with any
 // fractional part discarded.
 template <class T>
-ABSL_INTERNAL_CONSTEXPR_CLZ inline
+Y_ABSL_INTERNAL_CONSTEXPR_CLZ inline
     typename std::enable_if<std::is_unsigned<T>::value, T>::type
     bit_width(T x) noexcept {
   return std::numeric_limits<T>::digits - countl_zero(x);
@@ -139,7 +139,7 @@ ABSL_INTERNAL_CONSTEXPR_CLZ inline
 // Returns: If x == 0, 0; otherwise the maximal value y such that
 // has_single_bit(y) is true and y <= x.
 template <class T>
-ABSL_INTERNAL_CONSTEXPR_CLZ inline
+Y_ABSL_INTERNAL_CONSTEXPR_CLZ inline
     typename std::enable_if<std::is_unsigned<T>::value, T>::type
     bit_floor(T x) noexcept {
   return x == 0 ? 0 : T{1} << (bit_width(x) - 1);
@@ -149,7 +149,7 @@ ABSL_INTERNAL_CONSTEXPR_CLZ inline
 //
 // Preconditions: N is representable as a value of type T.
 template <class T>
-ABSL_INTERNAL_CONSTEXPR_CLZ inline
+Y_ABSL_INTERNAL_CONSTEXPR_CLZ inline
     typename std::enable_if<std::is_unsigned<T>::value, T>::type
     bit_ceil(T x) {
   // If T is narrower than unsigned, T{1} << bit_width will be promoted.  We
@@ -171,7 +171,7 @@ using std::has_single_bit;
 
 #endif
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_NUMERIC_BITS_H_
+#endif  // Y_ABSL_NUMERIC_BITS_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128.cc
index 6172372d75..90b7181c7b 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128.cc
@@ -27,9 +27,9 @@
 #include "y_absl/numeric/bits.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
-ABSL_DLL const uint128 kuint128max = MakeUint128(
+Y_ABSL_DLL const uint128 kuint128max = MakeUint128(
     std::numeric_limits<uint64_t>::max(), std::numeric_limits<uint64_t>::max());
 
 namespace {
@@ -40,13 +40,13 @@ namespace {
 // For example:
 //   Given: 5 (decimal) == 101 (binary)
 //   Returns: 2
-inline ABSL_ATTRIBUTE_ALWAYS_INLINE int Fls128(uint128 n) {
+inline Y_ABSL_ATTRIBUTE_ALWAYS_INLINE int Fls128(uint128 n) {
   if (uint64_t hi = Uint128High64(n)) {
-    ABSL_INTERNAL_ASSUME(hi != 0);
+    Y_ABSL_INTERNAL_ASSUME(hi != 0);
     return 127 - countl_zero(hi);
   }
   const uint64_t low = Uint128Low64(n);
-  ABSL_INTERNAL_ASSUME(low != 0);
+  Y_ABSL_INTERNAL_ASSUME(low != 0);
   return 63 - countl_zero(low);
 }
 
@@ -138,7 +138,7 @@ uint128::uint128(float v) : uint128(MakeUint128FromFloat(v)) {}
 uint128::uint128(double v) : uint128(MakeUint128FromFloat(v)) {}
 uint128::uint128(long double v) : uint128(MakeUint128FromFloat(v)) {}
 
-#if !defined(ABSL_HAVE_INTRINSIC_INT128)
+#if !defined(Y_ABSL_HAVE_INTRINSIC_INT128)
 uint128 operator/(uint128 lhs, uint128 rhs) {
   uint128 quotient = 0;
   uint128 remainder = 0;
@@ -152,7 +152,7 @@ uint128 operator%(uint128 lhs, uint128 rhs) {
   DivModImpl(lhs, rhs, &quotient, &remainder);
   return remainder;
 }
-#endif  // !defined(ABSL_HAVE_INTRINSIC_INT128)
+#endif  // !defined(Y_ABSL_HAVE_INTRINSIC_INT128)
 
 namespace {
 
@@ -233,7 +233,7 @@ uint128 UnsignedAbsoluteValue(int128 v) {
 
 }  // namespace
 
-#if !defined(ABSL_HAVE_INTRINSIC_INT128)
+#if !defined(Y_ABSL_HAVE_INTRINSIC_INT128)
 namespace {
 
 template <typename T>
@@ -282,7 +282,7 @@ int128 operator%(int128 lhs, int128 rhs) {
   return MakeInt128(int128_internal::BitCastToSigned(Uint128High64(remainder)),
                     Uint128Low64(remainder));
 }
-#endif  // ABSL_HAVE_INTRINSIC_INT128
+#endif  // Y_ABSL_HAVE_INTRINSIC_INT128
 
 std::ostream& operator<<(std::ostream& os, int128 v) {
   std::ios_base::fmtflags flags = os.flags();
@@ -329,7 +329,7 @@ std::ostream& operator<<(std::ostream& os, int128 v) {
   return os << rep;
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 namespace std {
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128.h b/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128.h
index b54d614ce9..ef5ff99c78 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128.h
@@ -23,8 +23,8 @@
 // are defined in this file, while many inline `int128` methods are defined in
 // the `int128_*_intrinsic.inc` files.
 
-#ifndef ABSL_NUMERIC_INT128_H_
-#define ABSL_NUMERIC_INT128_H_
+#ifndef Y_ABSL_NUMERIC_INT128_H_
+#define Y_ABSL_NUMERIC_INT128_H_
 
 #include <cassert>
 #include <cmath>
@@ -43,17 +43,17 @@
 // a typedef for unsigned short.  Otherwise wchar_t is mapped to the __wchar_t
 // builtin type.  We need to make sure not to define operator wchar_t()
 // alongside operator unsigned short() in these instances.
-#define ABSL_INTERNAL_WCHAR_T __wchar_t
+#define Y_ABSL_INTERNAL_WCHAR_T __wchar_t
 #if defined(_M_X64)
 #include <intrin.h>
 #pragma intrinsic(_umul128)
 #endif  // defined(_M_X64)
 #else   // defined(_MSC_VER)
-#define ABSL_INTERNAL_WCHAR_T wchar_t
+#define Y_ABSL_INTERNAL_WCHAR_T wchar_t
 #endif  // defined(_MSC_VER)
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 class int128;
 
@@ -77,7 +77,7 @@ class int128;
 //
 // Additionally, if your compiler supports `__int128`, `uint128` is
 // interoperable with that type. (Abseil checks for this compatibility through
-// the `ABSL_HAVE_INTRINSIC_INT128` macro.)
+// the `Y_ABSL_HAVE_INTRINSIC_INT128` macro.)
 //
 // However, a `uint128` differs from intrinsic integral types in the following
 // ways:
@@ -102,9 +102,9 @@ class int128;
 //     uint64_t i = static_cast<uint64_t>(v);  // OK
 //
 class
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
+#if defined(Y_ABSL_HAVE_INTRINSIC_INT128)
     alignas(unsigned __int128)
-#endif  // ABSL_HAVE_INTRINSIC_INT128
+#endif  // Y_ABSL_HAVE_INTRINSIC_INT128
         uint128 {
  public:
   uint128() = default;
@@ -116,10 +116,10 @@ class
   constexpr uint128(unsigned long v);       // NOLINT(runtime/int)
   constexpr uint128(long long v);           // NOLINT(runtime/int)
   constexpr uint128(unsigned long long v);  // NOLINT(runtime/int)
-#ifdef ABSL_HAVE_INTRINSIC_INT128
+#ifdef Y_ABSL_HAVE_INTRINSIC_INT128
   constexpr uint128(__int128 v);           // NOLINT(runtime/explicit)
   constexpr uint128(unsigned __int128 v);  // NOLINT(runtime/explicit)
-#endif  // ABSL_HAVE_INTRINSIC_INT128
+#endif  // Y_ABSL_HAVE_INTRINSIC_INT128
   constexpr uint128(int128 v);  // NOLINT(runtime/explicit)
   explicit uint128(float v);
   explicit uint128(double v);
@@ -132,10 +132,10 @@ class
   uint128& operator=(unsigned long v);       // NOLINT(runtime/int)
   uint128& operator=(long long v);           // NOLINT(runtime/int)
   uint128& operator=(unsigned long long v);  // NOLINT(runtime/int)
-#ifdef ABSL_HAVE_INTRINSIC_INT128
+#ifdef Y_ABSL_HAVE_INTRINSIC_INT128
   uint128& operator=(__int128 v);
   uint128& operator=(unsigned __int128 v);
-#endif  // ABSL_HAVE_INTRINSIC_INT128
+#endif  // Y_ABSL_HAVE_INTRINSIC_INT128
   uint128& operator=(int128 v);
 
   // Conversion operators to other arithmetic types
@@ -145,7 +145,7 @@ class
   constexpr explicit operator unsigned char() const;
   constexpr explicit operator char16_t() const;
   constexpr explicit operator char32_t() const;
-  constexpr explicit operator ABSL_INTERNAL_WCHAR_T() const;
+  constexpr explicit operator Y_ABSL_INTERNAL_WCHAR_T() const;
   constexpr explicit operator short() const;  // NOLINT(runtime/int)
   // NOLINTNEXTLINE(runtime/int)
   constexpr explicit operator unsigned short() const;
@@ -158,10 +158,10 @@ class
   constexpr explicit operator long long() const;
   // NOLINTNEXTLINE(runtime/int)
   constexpr explicit operator unsigned long long() const;
-#ifdef ABSL_HAVE_INTRINSIC_INT128
+#ifdef Y_ABSL_HAVE_INTRINSIC_INT128
   constexpr explicit operator __int128() const;
   constexpr explicit operator unsigned __int128() const;
-#endif  // ABSL_HAVE_INTRINSIC_INT128
+#endif  // Y_ABSL_HAVE_INTRINSIC_INT128
   explicit operator float() const;
   explicit operator double() const;
   explicit operator long double() const;
@@ -224,10 +224,10 @@ class
   // uint128 are fixed to not depend on alignof(uint128) == 8. Also add
   // alignas(16) to class definition to keep alignment consistent across
   // platforms.
-#if defined(ABSL_IS_LITTLE_ENDIAN)
+#if defined(Y_ABSL_IS_LITTLE_ENDIAN)
   uint64_t lo_;
   uint64_t hi_;
-#elif defined(ABSL_IS_BIG_ENDIAN)
+#elif defined(Y_ABSL_IS_BIG_ENDIAN)
   uint64_t hi_;
   uint64_t lo_;
 #else  // byte order
@@ -238,7 +238,7 @@ class
 // Prefer to use the constexpr `Uint128Max()`.
 //
 // TODO(y_absl-team) deprecate kuint128max once migration tool is released.
-ABSL_DLL extern const uint128 kuint128max;
+Y_ABSL_DLL extern const uint128 kuint128max;
 
 // allow uint128 to be logged
 std::ostream& operator<<(std::ostream& os, uint128 v);
@@ -250,7 +250,7 @@ constexpr uint128 Uint128Max() {
                  (std::numeric_limits<uint64_t>::max)());
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 // Specialized numeric_limits for uint128.
@@ -279,11 +279,11 @@ class numeric_limits<y_absl::uint128> {
   static constexpr int min_exponent10 = 0;
   static constexpr int max_exponent = 0;
   static constexpr int max_exponent10 = 0;
-#ifdef ABSL_HAVE_INTRINSIC_INT128
+#ifdef Y_ABSL_HAVE_INTRINSIC_INT128
   static constexpr bool traps = numeric_limits<unsigned __int128>::traps;
-#else   // ABSL_HAVE_INTRINSIC_INT128
+#else   // Y_ABSL_HAVE_INTRINSIC_INT128
   static constexpr bool traps = numeric_limits<uint64_t>::traps;
-#endif  // ABSL_HAVE_INTRINSIC_INT128
+#endif  // Y_ABSL_HAVE_INTRINSIC_INT128
   static constexpr bool tinyness_before = false;
 
   static constexpr y_absl::uint128 (min)() { return 0; }
@@ -299,7 +299,7 @@ class numeric_limits<y_absl::uint128> {
 }  // namespace std
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // int128
 //
@@ -321,7 +321,7 @@ ABSL_NAMESPACE_BEGIN
 
 // Additionally, if your compiler supports `__int128`, `int128` is
 // interoperable with that type. (Abseil checks for this compatibility through
-// the `ABSL_HAVE_INTRINSIC_INT128` macro.)
+// the `Y_ABSL_HAVE_INTRINSIC_INT128` macro.)
 //
 // The design goal for `int128` is that it will be compatible with a future
 // `int128_t`, if that type becomes a part of the standard.
@@ -346,10 +346,10 @@ class int128 {
   constexpr int128(unsigned long v);       // NOLINT(runtime/int)
   constexpr int128(long long v);           // NOLINT(runtime/int)
   constexpr int128(unsigned long long v);  // NOLINT(runtime/int)
-#ifdef ABSL_HAVE_INTRINSIC_INT128
+#ifdef Y_ABSL_HAVE_INTRINSIC_INT128
   constexpr int128(__int128 v);  // NOLINT(runtime/explicit)
   constexpr explicit int128(unsigned __int128 v);
-#endif  // ABSL_HAVE_INTRINSIC_INT128
+#endif  // Y_ABSL_HAVE_INTRINSIC_INT128
   constexpr explicit int128(uint128 v);
   explicit int128(float v);
   explicit int128(double v);
@@ -362,9 +362,9 @@ class int128 {
   int128& operator=(unsigned long v);       // NOLINT(runtime/int)
   int128& operator=(long long v);           // NOLINT(runtime/int)
   int128& operator=(unsigned long long v);  // NOLINT(runtime/int)
-#ifdef ABSL_HAVE_INTRINSIC_INT128
+#ifdef Y_ABSL_HAVE_INTRINSIC_INT128
   int128& operator=(__int128 v);
-#endif  // ABSL_HAVE_INTRINSIC_INT128
+#endif  // Y_ABSL_HAVE_INTRINSIC_INT128
 
   // Conversion operators to other arithmetic types
   constexpr explicit operator bool() const;
@@ -373,7 +373,7 @@ class int128 {
   constexpr explicit operator unsigned char() const;
   constexpr explicit operator char16_t() const;
   constexpr explicit operator char32_t() const;
-  constexpr explicit operator ABSL_INTERNAL_WCHAR_T() const;
+  constexpr explicit operator Y_ABSL_INTERNAL_WCHAR_T() const;
   constexpr explicit operator short() const;  // NOLINT(runtime/int)
   // NOLINTNEXTLINE(runtime/int)
   constexpr explicit operator unsigned short() const;
@@ -386,10 +386,10 @@ class int128 {
   constexpr explicit operator long long() const;
   // NOLINTNEXTLINE(runtime/int)
   constexpr explicit operator unsigned long long() const;
-#ifdef ABSL_HAVE_INTRINSIC_INT128
+#ifdef Y_ABSL_HAVE_INTRINSIC_INT128
   constexpr explicit operator __int128() const;
   constexpr explicit operator unsigned __int128() const;
-#endif  // ABSL_HAVE_INTRINSIC_INT128
+#endif  // Y_ABSL_HAVE_INTRINSIC_INT128
   explicit operator float() const;
   explicit operator double() const;
   explicit operator long double() const;
@@ -457,19 +457,19 @@ class int128 {
  private:
   constexpr int128(int64_t high, uint64_t low);
 
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
+#if defined(Y_ABSL_HAVE_INTRINSIC_INT128)
   __int128 v_;
-#else  // ABSL_HAVE_INTRINSIC_INT128
-#if defined(ABSL_IS_LITTLE_ENDIAN)
+#else  // Y_ABSL_HAVE_INTRINSIC_INT128
+#if defined(Y_ABSL_IS_LITTLE_ENDIAN)
   uint64_t lo_;
   int64_t hi_;
-#elif defined(ABSL_IS_BIG_ENDIAN)
+#elif defined(Y_ABSL_IS_BIG_ENDIAN)
   int64_t hi_;
   uint64_t lo_;
 #else  // byte order
 #error "Unsupported byte order: must be little-endian or big-endian."
 #endif  // byte order
-#endif  // ABSL_HAVE_INTRINSIC_INT128
+#endif  // Y_ABSL_HAVE_INTRINSIC_INT128
 };
 
 std::ostream& operator<<(std::ostream& os, int128 v);
@@ -485,7 +485,7 @@ constexpr int128 Int128Min() {
   return int128((std::numeric_limits<int64_t>::min)(), 0);
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 // Specialized numeric_limits for int128.
@@ -514,11 +514,11 @@ class numeric_limits<y_absl::int128> {
   static constexpr int min_exponent10 = 0;
   static constexpr int max_exponent = 0;
   static constexpr int max_exponent10 = 0;
-#ifdef ABSL_HAVE_INTRINSIC_INT128
+#ifdef Y_ABSL_HAVE_INTRINSIC_INT128
   static constexpr bool traps = numeric_limits<__int128>::traps;
-#else   // ABSL_HAVE_INTRINSIC_INT128
+#else   // Y_ABSL_HAVE_INTRINSIC_INT128
   static constexpr bool traps = numeric_limits<uint64_t>::traps;
-#endif  // ABSL_HAVE_INTRINSIC_INT128
+#endif  // Y_ABSL_HAVE_INTRINSIC_INT128
   static constexpr bool tinyness_before = false;
 
   static constexpr y_absl::int128 (min)() { return y_absl::Int128Min(); }
@@ -537,7 +537,7 @@ class numeric_limits<y_absl::int128> {
 //                      Implementation details follow
 // --------------------------------------------------------------------------
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 constexpr uint128 MakeUint128(uint64_t high, uint64_t low) {
   return uint128(high, low);
@@ -570,7 +570,7 @@ inline uint128& uint128::operator=(unsigned long long v) {
   return *this = uint128(v);
 }
 
-#ifdef ABSL_HAVE_INTRINSIC_INT128
+#ifdef Y_ABSL_HAVE_INTRINSIC_INT128
 inline uint128& uint128::operator=(__int128 v) {
   return *this = uint128(v);
 }
@@ -578,7 +578,7 @@ inline uint128& uint128::operator=(__int128 v) {
 inline uint128& uint128::operator=(unsigned __int128 v) {
   return *this = uint128(v);
 }
-#endif  // ABSL_HAVE_INTRINSIC_INT128
+#endif  // Y_ABSL_HAVE_INTRINSIC_INT128
 
 inline uint128& uint128::operator=(int128 v) {
   return *this = uint128(v);
@@ -635,7 +635,7 @@ constexpr uint64_t Uint128High64(uint128 v) { return v.hi_; }
 
 // Constructors from integer types.
 
-#if defined(ABSL_IS_LITTLE_ENDIAN)
+#if defined(Y_ABSL_IS_LITTLE_ENDIAN)
 
 constexpr uint128::uint128(uint64_t high, uint64_t low)
     : lo_{low}, hi_{high} {}
@@ -656,19 +656,19 @@ constexpr uint128::uint128(unsigned long v) : lo_{v}, hi_{0} {}
 // NOLINTNEXTLINE(runtime/int)
 constexpr uint128::uint128(unsigned long long v) : lo_{v}, hi_{0} {}
 
-#ifdef ABSL_HAVE_INTRINSIC_INT128
+#ifdef Y_ABSL_HAVE_INTRINSIC_INT128
 constexpr uint128::uint128(__int128 v)
     : lo_{static_cast<uint64_t>(v & ~uint64_t{0})},
       hi_{static_cast<uint64_t>(static_cast<unsigned __int128>(v) >> 64)} {}
 constexpr uint128::uint128(unsigned __int128 v)
     : lo_{static_cast<uint64_t>(v & ~uint64_t{0})},
       hi_{static_cast<uint64_t>(v >> 64)} {}
-#endif  // ABSL_HAVE_INTRINSIC_INT128
+#endif  // Y_ABSL_HAVE_INTRINSIC_INT128
 
 constexpr uint128::uint128(int128 v)
     : lo_{Int128Low64(v)}, hi_{static_cast<uint64_t>(Int128High64(v))} {}
 
-#elif defined(ABSL_IS_BIG_ENDIAN)
+#elif defined(Y_ABSL_IS_BIG_ENDIAN)
 
 constexpr uint128::uint128(uint64_t high, uint64_t low)
     : hi_{high}, lo_{low} {}
@@ -689,14 +689,14 @@ constexpr uint128::uint128(unsigned long v) : hi_{0}, lo_{v} {}
 // NOLINTNEXTLINE(runtime/int)
 constexpr uint128::uint128(unsigned long long v) : hi_{0}, lo_{v} {}
 
-#ifdef ABSL_HAVE_INTRINSIC_INT128
+#ifdef Y_ABSL_HAVE_INTRINSIC_INT128
 constexpr uint128::uint128(__int128 v)
     : hi_{static_cast<uint64_t>(static_cast<unsigned __int128>(v) >> 64)},
       lo_{static_cast<uint64_t>(v & ~uint64_t{0})} {}
 constexpr uint128::uint128(unsigned __int128 v)
     : hi_{static_cast<uint64_t>(v >> 64)},
       lo_{static_cast<uint64_t>(v & ~uint64_t{0})} {}
-#endif  // ABSL_HAVE_INTRINSIC_INT128
+#endif  // Y_ABSL_HAVE_INTRINSIC_INT128
 
 constexpr uint128::uint128(int128 v)
     : hi_{static_cast<uint64_t>(Int128High64(v))}, lo_{Int128Low64(v)} {}
@@ -727,8 +727,8 @@ constexpr uint128::operator char32_t() const {
   return static_cast<char32_t>(lo_);
 }
 
-constexpr uint128::operator ABSL_INTERNAL_WCHAR_T() const {
-  return static_cast<ABSL_INTERNAL_WCHAR_T>(lo_);
+constexpr uint128::operator Y_ABSL_INTERNAL_WCHAR_T() const {
+  return static_cast<Y_ABSL_INTERNAL_WCHAR_T>(lo_);
 }
 
 // NOLINTNEXTLINE(runtime/int)
@@ -759,7 +759,7 @@ constexpr uint128::operator unsigned long long() const {  // NOLINT(runtime/int)
   return static_cast<unsigned long long>(lo_);            // NOLINT(runtime/int)
 }
 
-#ifdef ABSL_HAVE_INTRINSIC_INT128
+#ifdef Y_ABSL_HAVE_INTRINSIC_INT128
 constexpr uint128::operator __int128() const {
   return (static_cast<__int128>(hi_) << 64) + lo_;
 }
@@ -767,7 +767,7 @@ constexpr uint128::operator __int128() const {
 constexpr uint128::operator unsigned __int128() const {
   return (static_cast<unsigned __int128>(hi_) << 64) + lo_;
 }
-#endif  // ABSL_HAVE_INTRINSIC_INT128
+#endif  // Y_ABSL_HAVE_INTRINSIC_INT128
 
 // Conversion operators to floating point types.
 
@@ -787,7 +787,7 @@ inline uint128::operator long double() const {
 // Comparison operators.
 
 constexpr bool operator==(uint128 lhs, uint128 rhs) {
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
+#if defined(Y_ABSL_HAVE_INTRINSIC_INT128)
   return static_cast<unsigned __int128>(lhs) ==
          static_cast<unsigned __int128>(rhs);
 #else
@@ -799,7 +799,7 @@ constexpr bool operator==(uint128 lhs, uint128 rhs) {
 constexpr bool operator!=(uint128 lhs, uint128 rhs) { return !(lhs == rhs); }
 
 constexpr bool operator<(uint128 lhs, uint128 rhs) {
-#ifdef ABSL_HAVE_INTRINSIC_INT128
+#ifdef Y_ABSL_HAVE_INTRINSIC_INT128
   return static_cast<unsigned __int128>(lhs) <
          static_cast<unsigned __int128>(rhs);
 #else
@@ -826,7 +826,7 @@ constexpr inline int128 operator+(int128 val) {
 }
 
 constexpr uint128 operator-(uint128 val) {
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
+#if defined(Y_ABSL_HAVE_INTRINSIC_INT128)
   return -static_cast<unsigned __int128>(val);
 #else
   return MakeUint128(
@@ -836,7 +836,7 @@ constexpr uint128 operator-(uint128 val) {
 }
 
 constexpr inline bool operator!(uint128 val) {
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
+#if defined(Y_ABSL_HAVE_INTRINSIC_INT128)
   return !static_cast<unsigned __int128>(val);
 #else
   return !Uint128High64(val) && !Uint128Low64(val);
@@ -846,7 +846,7 @@ constexpr inline bool operator!(uint128 val) {
 // Logical operators.
 
 constexpr inline uint128 operator~(uint128 val) {
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
+#if defined(Y_ABSL_HAVE_INTRINSIC_INT128)
   return ~static_cast<unsigned __int128>(val);
 #else
   return MakeUint128(~Uint128High64(val), ~Uint128Low64(val));
@@ -854,7 +854,7 @@ constexpr inline uint128 operator~(uint128 val) {
 }
 
 constexpr inline uint128 operator|(uint128 lhs, uint128 rhs) {
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
+#if defined(Y_ABSL_HAVE_INTRINSIC_INT128)
   return static_cast<unsigned __int128>(lhs) |
          static_cast<unsigned __int128>(rhs);
 #else
@@ -864,7 +864,7 @@ constexpr inline uint128 operator|(uint128 lhs, uint128 rhs) {
 }
 
 constexpr inline uint128 operator&(uint128 lhs, uint128 rhs) {
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
+#if defined(Y_ABSL_HAVE_INTRINSIC_INT128)
   return static_cast<unsigned __int128>(lhs) &
          static_cast<unsigned __int128>(rhs);
 #else
@@ -874,7 +874,7 @@ constexpr inline uint128 operator&(uint128 lhs, uint128 rhs) {
 }
 
 constexpr inline uint128 operator^(uint128 lhs, uint128 rhs) {
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
+#if defined(Y_ABSL_HAVE_INTRINSIC_INT128)
   return static_cast<unsigned __int128>(lhs) ^
          static_cast<unsigned __int128>(rhs);
 #else
@@ -901,7 +901,7 @@ inline uint128& uint128::operator^=(uint128 other) {
 // Arithmetic operators.
 
 constexpr uint128 operator<<(uint128 lhs, int amount) {
-#ifdef ABSL_HAVE_INTRINSIC_INT128
+#ifdef Y_ABSL_HAVE_INTRINSIC_INT128
   return static_cast<unsigned __int128>(lhs) << amount;
 #else
   // uint64_t shifts of >= 64 are undefined, so we will need some
@@ -915,7 +915,7 @@ constexpr uint128 operator<<(uint128 lhs, int amount) {
 }
 
 constexpr uint128 operator>>(uint128 lhs, int amount) {
-#ifdef ABSL_HAVE_INTRINSIC_INT128
+#ifdef Y_ABSL_HAVE_INTRINSIC_INT128
   return static_cast<unsigned __int128>(lhs) >> amount;
 #else
   // uint64_t shifts of >= 64 are undefined, so we will need some
@@ -928,7 +928,7 @@ constexpr uint128 operator>>(uint128 lhs, int amount) {
 #endif
 }
 
-#if !defined(ABSL_HAVE_INTRINSIC_INT128)
+#if !defined(Y_ABSL_HAVE_INTRINSIC_INT128)
 namespace int128_internal {
 constexpr uint128 AddResult(uint128 result, uint128 lhs) {
   // check for carry
@@ -940,7 +940,7 @@ constexpr uint128 AddResult(uint128 result, uint128 lhs) {
 #endif
 
 constexpr uint128 operator+(uint128 lhs, uint128 rhs) {
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
+#if defined(Y_ABSL_HAVE_INTRINSIC_INT128)
   return static_cast<unsigned __int128>(lhs) +
          static_cast<unsigned __int128>(rhs);
 #else
@@ -951,7 +951,7 @@ constexpr uint128 operator+(uint128 lhs, uint128 rhs) {
 #endif
 }
 
-#if !defined(ABSL_HAVE_INTRINSIC_INT128)
+#if !defined(Y_ABSL_HAVE_INTRINSIC_INT128)
 namespace int128_internal {
 constexpr uint128 SubstructResult(uint128 result, uint128 lhs, uint128 rhs) {
   // check for carry
@@ -963,7 +963,7 @@ constexpr uint128 SubstructResult(uint128 result, uint128 lhs, uint128 rhs) {
 #endif
 
 constexpr uint128 operator-(uint128 lhs, uint128 rhs) {
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
+#if defined(Y_ABSL_HAVE_INTRINSIC_INT128)
   return static_cast<unsigned __int128>(lhs) -
          static_cast<unsigned __int128>(rhs);
 #else
@@ -975,7 +975,7 @@ constexpr uint128 operator-(uint128 lhs, uint128 rhs) {
 }
 
 inline uint128 operator*(uint128 lhs, uint128 rhs) {
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
+#if defined(Y_ABSL_HAVE_INTRINSIC_INT128)
   // TODO(strel) Remove once alignment issues are resolved and unsigned __int128
   // can be used for uint128 storage.
   return static_cast<unsigned __int128>(lhs) *
@@ -986,7 +986,7 @@ inline uint128 operator*(uint128 lhs, uint128 rhs) {
   return MakeUint128(Uint128Low64(lhs) * Uint128High64(rhs) +
                          Uint128High64(lhs) * Uint128Low64(rhs) + carry,
                      low);
-#else   // ABSL_HAVE_INTRINSIC128
+#else   // Y_ABSL_HAVE_INTRINSIC128
   uint64_t a32 = Uint128Low64(lhs) >> 32;
   uint64_t a00 = Uint128Low64(lhs) & 0xffffffff;
   uint64_t b32 = Uint128Low64(rhs) >> 32;
@@ -998,10 +998,10 @@ inline uint128 operator*(uint128 lhs, uint128 rhs) {
   result += uint128(a32 * b00) << 32;
   result += uint128(a00 * b32) << 32;
   return result;
-#endif  // ABSL_HAVE_INTRINSIC128
+#endif  // Y_ABSL_HAVE_INTRINSIC128
 }
 
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
+#if defined(Y_ABSL_HAVE_INTRINSIC_INT128)
 inline uint128 operator/(uint128 lhs, uint128 rhs) {
   return static_cast<unsigned __int128>(lhs) /
          static_cast<unsigned __int128>(rhs);
@@ -1151,15 +1151,15 @@ constexpr int64_t BitCastToSigned(uint64_t v) {
 
 }  // namespace int128_internal
 
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
+#if defined(Y_ABSL_HAVE_INTRINSIC_INT128)
 #include "y_absl/numeric/int128_have_intrinsic.inc"  // IWYU pragma: export
-#else  // ABSL_HAVE_INTRINSIC_INT128
+#else  // Y_ABSL_HAVE_INTRINSIC_INT128
 #include "y_absl/numeric/int128_no_intrinsic.inc"  // IWYU pragma: export
-#endif  // ABSL_HAVE_INTRINSIC_INT128
+#endif  // Y_ABSL_HAVE_INTRINSIC_INT128
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#undef ABSL_INTERNAL_WCHAR_T
+#undef Y_ABSL_INTERNAL_WCHAR_T
 
-#endif  // ABSL_NUMERIC_INT128_H_
+#endif  // Y_ABSL_NUMERIC_INT128_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128_have_intrinsic.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128_have_intrinsic.inc
index 3945fa2983..55f2026785 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128_have_intrinsic.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128_have_intrinsic.inc
@@ -14,8 +14,8 @@
 // limitations under the License.
 
 // This file contains :int128 implementation details that depend on internal
-// representation when ABSL_HAVE_INTRINSIC_INT128 is defined. This file is
-// included by int128.h and relies on ABSL_INTERNAL_WCHAR_T being defined.
+// representation when Y_ABSL_HAVE_INTRINSIC_INT128 is defined. This file is
+// included by int128.h and relies on Y_ABSL_INTERNAL_WCHAR_T being defined.
 
 namespace int128_internal {
 
@@ -107,8 +107,8 @@ constexpr int128::operator char32_t() const {
   return static_cast<char32_t>(v_);
 }
 
-constexpr int128::operator ABSL_INTERNAL_WCHAR_T() const {
-  return static_cast<ABSL_INTERNAL_WCHAR_T>(v_);
+constexpr int128::operator Y_ABSL_INTERNAL_WCHAR_T() const {
+  return static_cast<Y_ABSL_INTERNAL_WCHAR_T>(v_);
 }
 
 constexpr int128::operator short() const {  // NOLINT(runtime/int)
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128_no_intrinsic.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128_no_intrinsic.inc
index 8834804cec..8354bd5615 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128_no_intrinsic.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/int128_no_intrinsic.inc
@@ -14,14 +14,14 @@
 // limitations under the License.
 
 // This file contains :int128 implementation details that depend on internal
-// representation when ABSL_HAVE_INTRINSIC_INT128 is *not* defined. This file
-// is included by int128.h and relies on ABSL_INTERNAL_WCHAR_T being defined.
+// representation when Y_ABSL_HAVE_INTRINSIC_INT128 is *not* defined. This file
+// is included by int128.h and relies on Y_ABSL_INTERNAL_WCHAR_T being defined.
 
 constexpr uint64_t Int128Low64(int128 v) { return v.lo_; }
 
 constexpr int64_t Int128High64(int128 v) { return v.hi_; }
 
-#if defined(ABSL_IS_LITTLE_ENDIAN)
+#if defined(Y_ABSL_IS_LITTLE_ENDIAN)
 
 constexpr int128::int128(int64_t high, uint64_t low) :
     lo_(low), hi_(high) {}
@@ -42,7 +42,7 @@ constexpr int128::int128(unsigned long long v) : lo_{v}, hi_{0} {}
 constexpr int128::int128(uint128 v)
     : lo_{Uint128Low64(v)}, hi_{static_cast<int64_t>(Uint128High64(v))} {}
 
-#elif defined(ABSL_IS_BIG_ENDIAN)
+#elif defined(Y_ABSL_IS_BIG_ENDIAN)
 
 constexpr int128::int128(int64_t high, uint64_t low) :
     hi_{high}, lo_{low} {}
@@ -91,9 +91,9 @@ constexpr int128::operator char32_t() const {
   return static_cast<char32_t>(lo_);
 }
 
-constexpr int128::operator ABSL_INTERNAL_WCHAR_T() const {
+constexpr int128::operator Y_ABSL_INTERNAL_WCHAR_T() const {
   // NOLINTNEXTLINE(runtime/int)
-  return static_cast<ABSL_INTERNAL_WCHAR_T>(static_cast<long long>(*this));
+  return static_cast<Y_ABSL_INTERNAL_WCHAR_T>(static_cast<long long>(*this));
 }
 
 constexpr int128::operator short() const {  // NOLINT(runtime/int)
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/internal/bits.h b/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/internal/bits.h
index 2a517399b0..a19e3c6bbc 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/internal/bits.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/internal/bits.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_NUMERIC_INTERNAL_BITS_H_
-#define ABSL_NUMERIC_INTERNAL_BITS_H_
+#ifndef Y_ABSL_NUMERIC_INTERNAL_BITS_H_
+#define Y_ABSL_NUMERIC_INTERNAL_BITS_H_
 
 #include <cstdint>
 #include <limits>
@@ -30,40 +30,40 @@
 
 #if defined(__GNUC__) && !defined(__clang__)
 // GCC
-#define ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(x) 1
+#define Y_ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(x) 1
 #else
-#define ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(x) ABSL_HAVE_BUILTIN(x)
+#define Y_ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(x) Y_ABSL_HAVE_BUILTIN(x)
 #endif
 
-#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_popcountl) && \
-    ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_popcountll)
-#define ABSL_INTERNAL_CONSTEXPR_POPCOUNT constexpr
-#define ABSL_INTERNAL_HAS_CONSTEXPR_POPCOUNT 1
+#if Y_ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_popcountl) && \
+    Y_ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_popcountll)
+#define Y_ABSL_INTERNAL_CONSTEXPR_POPCOUNT constexpr
+#define Y_ABSL_INTERNAL_HAS_CONSTEXPR_POPCOUNT 1
 #else
-#define ABSL_INTERNAL_CONSTEXPR_POPCOUNT
-#define ABSL_INTERNAL_HAS_CONSTEXPR_POPCOUNT 0
+#define Y_ABSL_INTERNAL_CONSTEXPR_POPCOUNT
+#define Y_ABSL_INTERNAL_HAS_CONSTEXPR_POPCOUNT 0
 #endif
 
-#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_clz) && \
-    ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_clzll)
-#define ABSL_INTERNAL_CONSTEXPR_CLZ constexpr
-#define ABSL_INTERNAL_HAS_CONSTEXPR_CLZ 1
+#if Y_ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_clz) && \
+    Y_ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_clzll)
+#define Y_ABSL_INTERNAL_CONSTEXPR_CLZ constexpr
+#define Y_ABSL_INTERNAL_HAS_CONSTEXPR_CLZ 1
 #else
-#define ABSL_INTERNAL_CONSTEXPR_CLZ
-#define ABSL_INTERNAL_HAS_CONSTEXPR_CLZ 0
+#define Y_ABSL_INTERNAL_CONSTEXPR_CLZ
+#define Y_ABSL_INTERNAL_HAS_CONSTEXPR_CLZ 0
 #endif
 
-#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctz) && \
-    ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctzll)
-#define ABSL_INTERNAL_CONSTEXPR_CTZ constexpr
-#define ABSL_INTERNAL_HAS_CONSTEXPR_CTZ 1
+#if Y_ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctz) && \
+    Y_ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctzll)
+#define Y_ABSL_INTERNAL_CONSTEXPR_CTZ constexpr
+#define Y_ABSL_INTERNAL_HAS_CONSTEXPR_CTZ 1
 #else
-#define ABSL_INTERNAL_CONSTEXPR_CTZ
-#define ABSL_INTERNAL_HAS_CONSTEXPR_CTZ 0
+#define Y_ABSL_INTERNAL_CONSTEXPR_CTZ
+#define Y_ABSL_INTERNAL_HAS_CONSTEXPR_CTZ 0
 #endif
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace numeric_internal {
 
 constexpr bool IsPowerOf2(unsigned int x) noexcept {
@@ -71,7 +71,7 @@ constexpr bool IsPowerOf2(unsigned int x) noexcept {
 }
 
 template <class T>
-ABSL_MUST_USE_RESULT ABSL_ATTRIBUTE_ALWAYS_INLINE constexpr T RotateRight(
+Y_ABSL_MUST_USE_RESULT Y_ABSL_ATTRIBUTE_ALWAYS_INLINE constexpr T RotateRight(
     T x, int s) noexcept {
   static_assert(std::is_unsigned<T>::value, "T must be unsigned");
   static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
@@ -82,7 +82,7 @@ ABSL_MUST_USE_RESULT ABSL_ATTRIBUTE_ALWAYS_INLINE constexpr T RotateRight(
 }
 
 template <class T>
-ABSL_MUST_USE_RESULT ABSL_ATTRIBUTE_ALWAYS_INLINE constexpr T RotateLeft(
+Y_ABSL_MUST_USE_RESULT Y_ABSL_ATTRIBUTE_ALWAYS_INLINE constexpr T RotateLeft(
     T x, int s) noexcept {
   static_assert(std::is_unsigned<T>::value, "T must be unsigned");
   static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
@@ -92,9 +92,9 @@ ABSL_MUST_USE_RESULT ABSL_ATTRIBUTE_ALWAYS_INLINE constexpr T RotateLeft(
          static_cast<T>(x >> ((-s) & (std::numeric_limits<T>::digits - 1)));
 }
 
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_POPCOUNT inline int
+Y_ABSL_ATTRIBUTE_ALWAYS_INLINE Y_ABSL_INTERNAL_CONSTEXPR_POPCOUNT inline int
 Popcount32(uint32_t x) noexcept {
-#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_popcount)
+#if Y_ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_popcount)
   static_assert(sizeof(unsigned int) == sizeof(x),
                 "__builtin_popcount does not take 32-bit arg");
   return __builtin_popcount(x);
@@ -105,9 +105,9 @@ Popcount32(uint32_t x) noexcept {
 #endif
 }
 
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_POPCOUNT inline int
+Y_ABSL_ATTRIBUTE_ALWAYS_INLINE Y_ABSL_INTERNAL_CONSTEXPR_POPCOUNT inline int
 Popcount64(uint64_t x) noexcept {
-#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_popcountll)
+#if Y_ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_popcountll)
   static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
                 "__builtin_popcount does not take 64-bit arg");
   return __builtin_popcountll(x);
@@ -120,7 +120,7 @@ Popcount64(uint64_t x) noexcept {
 }
 
 template <class T>
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_POPCOUNT inline int
+Y_ABSL_ATTRIBUTE_ALWAYS_INLINE Y_ABSL_INTERNAL_CONSTEXPR_POPCOUNT inline int
 Popcount(T x) noexcept {
   static_assert(std::is_unsigned<T>::value, "T must be unsigned");
   static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
@@ -129,9 +129,9 @@ Popcount(T x) noexcept {
   return sizeof(x) <= sizeof(uint32_t) ? Popcount32(x) : Popcount64(x);
 }
 
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline int
+Y_ABSL_ATTRIBUTE_ALWAYS_INLINE Y_ABSL_INTERNAL_CONSTEXPR_CLZ inline int
 CountLeadingZeroes32(uint32_t x) {
-#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_clz)
+#if Y_ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_clz)
   // Use __builtin_clz, which uses the following instructions:
   //  x86: bsr, lzcnt
   //  ARM64: clz
@@ -165,9 +165,9 @@ CountLeadingZeroes32(uint32_t x) {
 #endif
 }
 
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline int
+Y_ABSL_ATTRIBUTE_ALWAYS_INLINE Y_ABSL_INTERNAL_CONSTEXPR_CLZ inline int
 CountLeadingZeroes16(uint16_t x) {
-#if ABSL_HAVE_BUILTIN(__builtin_clzs)
+#if Y_ABSL_HAVE_BUILTIN(__builtin_clzs)
   static_assert(sizeof(unsigned short) == sizeof(x),  // NOLINT(runtime/int)
                 "__builtin_clzs does not take 16-bit arg");
   return x == 0 ? 16 : __builtin_clzs(x);
@@ -176,9 +176,9 @@ CountLeadingZeroes16(uint16_t x) {
 #endif
 }
 
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline int
+Y_ABSL_ATTRIBUTE_ALWAYS_INLINE Y_ABSL_INTERNAL_CONSTEXPR_CLZ inline int
 CountLeadingZeroes64(uint64_t x) {
-#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_clzll)
+#if Y_ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_clzll)
   // Use __builtin_clzll, which uses the following instructions:
   //  x86: bsr, lzcnt
   //  ARM64: clz
@@ -230,7 +230,7 @@ CountLeadingZeroes64(uint64_t x) {
 }
 
 template <typename T>
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline int
+Y_ABSL_ATTRIBUTE_ALWAYS_INLINE Y_ABSL_INTERNAL_CONSTEXPR_CLZ inline int
 CountLeadingZeroes(T x) {
   static_assert(std::is_unsigned<T>::value, "T must be unsigned");
   static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
@@ -247,9 +247,9 @@ CountLeadingZeroes(T x) {
                     : CountLeadingZeroes64(x));
 }
 
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CTZ inline int
+Y_ABSL_ATTRIBUTE_ALWAYS_INLINE Y_ABSL_INTERNAL_CONSTEXPR_CTZ inline int
 CountTrailingZeroesNonzero32(uint32_t x) {
-#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctz)
+#if Y_ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctz)
   static_assert(sizeof(unsigned int) == sizeof(x),
                 "__builtin_ctz does not take 32-bit arg");
   return __builtin_ctz(x);
@@ -269,9 +269,9 @@ CountTrailingZeroesNonzero32(uint32_t x) {
 #endif
 }
 
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CTZ inline int
+Y_ABSL_ATTRIBUTE_ALWAYS_INLINE Y_ABSL_INTERNAL_CONSTEXPR_CTZ inline int
 CountTrailingZeroesNonzero64(uint64_t x) {
-#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctzll)
+#if Y_ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctzll)
   static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
                 "__builtin_ctzll does not take 64-bit arg");
   return __builtin_ctzll(x);
@@ -301,9 +301,9 @@ CountTrailingZeroesNonzero64(uint64_t x) {
 #endif
 }
 
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CTZ inline int
+Y_ABSL_ATTRIBUTE_ALWAYS_INLINE Y_ABSL_INTERNAL_CONSTEXPR_CTZ inline int
 CountTrailingZeroesNonzero16(uint16_t x) {
-#if ABSL_HAVE_BUILTIN(__builtin_ctzs)
+#if Y_ABSL_HAVE_BUILTIN(__builtin_ctzs)
   static_assert(sizeof(unsigned short) == sizeof(x),  // NOLINT(runtime/int)
                 "__builtin_ctzs does not take 16-bit arg");
   return __builtin_ctzs(x);
@@ -313,7 +313,7 @@ CountTrailingZeroesNonzero16(uint16_t x) {
 }
 
 template <class T>
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CTZ inline int
+Y_ABSL_ATTRIBUTE_ALWAYS_INLINE Y_ABSL_INTERNAL_CONSTEXPR_CTZ inline int
 CountTrailingZeroes(T x) noexcept {
   static_assert(std::is_unsigned<T>::value, "T must be unsigned");
   static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
@@ -332,14 +332,14 @@ CountTrailingZeroes(T x) noexcept {
 // want to force it to wraparound so that bit_ceil of an invalid value are not
 // core constant expressions.
 template <class T>
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline
+Y_ABSL_ATTRIBUTE_ALWAYS_INLINE Y_ABSL_INTERNAL_CONSTEXPR_CLZ inline
     typename std::enable_if<std::is_unsigned<T>::value, T>::type
     BitCeilPromotionHelper(T x, T promotion) {
   return (T{1} << (x + promotion)) >> promotion;
 }
 
 template <class T>
-ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline
+Y_ABSL_ATTRIBUTE_ALWAYS_INLINE Y_ABSL_INTERNAL_CONSTEXPR_CLZ inline
     typename std::enable_if<std::is_unsigned<T>::value, T>::type
     BitCeilNonPowerOf2(T x) {
   // If T is narrower than unsigned, it undergoes promotion to unsigned when we
@@ -352,7 +352,7 @@ ABSL_ATTRIBUTE_ALWAYS_INLINE ABSL_INTERNAL_CONSTEXPR_CLZ inline
 }
 
 }  // namespace numeric_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_NUMERIC_INTERNAL_BITS_H_
+#endif  // Y_ABSL_NUMERIC_INTERNAL_BITS_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/internal/representation.h b/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/internal/representation.h
index 0761cf39bc..05422c4b75 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/internal/representation.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/numeric/internal/representation.h
@@ -12,15 +12,15 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_NUMERIC_INTERNAL_REPRESENTATION_H_
-#define ABSL_NUMERIC_INTERNAL_REPRESENTATION_H_
+#ifndef Y_ABSL_NUMERIC_INTERNAL_REPRESENTATION_H_
+#define Y_ABSL_NUMERIC_INTERNAL_REPRESENTATION_H_
 
 #include <limits>
 
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace numeric_internal {
 
 // Returns true iff long double is represented as a pair of doubles added
@@ -49,7 +49,7 @@ inline constexpr bool IsDoubleDouble() {
 }
 
 }  // namespace numeric_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_NUMERIC_INTERNAL_REPRESENTATION_H_
+#endif  // Y_ABSL_NUMERIC_INTERNAL_REPRESENTATION_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/exponential_biased.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/exponential_biased.cc
index 02f5dfd9da..2ad78bdcdb 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/exponential_biased.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/exponential_biased.cc
@@ -25,7 +25,7 @@
 #include "y_absl/base/optimization.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace profiling_internal {
 
 // The algorithm generates a random number between 0 and 1 and applies the
@@ -39,7 +39,7 @@ namespace profiling_internal {
 // log_2(q) * (-log_e(2) * 1/m) = x
 // In the code, q is actually in the range 1 to 2**26, hence the -26 below
 int64_t ExponentialBiased::GetSkipCount(int64_t mean) {
-  if (ABSL_PREDICT_FALSE(!initialized_)) {
+  if (Y_ABSL_PREDICT_FALSE(!initialized_)) {
     Initialize();
   }
 
@@ -78,7 +78,7 @@ void ExponentialBiased::Initialize() {
   // bunch to mush the bits around. We use a global_rand to handle the case
   // where the same thread (by memory address) gets created and destroyed
   // repeatedly.
-  ABSL_CONST_INIT static std::atomic<uint32_t> global_rand(0);
+  Y_ABSL_CONST_INIT static std::atomic<uint32_t> global_rand(0);
   uint64_t r = reinterpret_cast<uint64_t>(this) +
                global_rand.fetch_add(1, std::memory_order_relaxed);
   for (int i = 0; i < 20; ++i) {
@@ -89,5 +89,5 @@ void ExponentialBiased::Initialize() {
 }
 
 }  // namespace profiling_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/exponential_biased.h b/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/exponential_biased.h
index ee7954a535..5f7e964adb 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/exponential_biased.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/exponential_biased.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_PROFILING_INTERNAL_EXPONENTIAL_BIASED_H_
-#define ABSL_PROFILING_INTERNAL_EXPONENTIAL_BIASED_H_
+#ifndef Y_ABSL_PROFILING_INTERNAL_EXPONENTIAL_BIASED_H_
+#define Y_ABSL_PROFILING_INTERNAL_EXPONENTIAL_BIASED_H_
 
 #include <stdint.h>
 
@@ -21,7 +21,7 @@
 #include "y_absl/base/macros.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace profiling_internal {
 
 // ExponentialBiased provides a small and fast random number generator for a
@@ -124,7 +124,7 @@ inline uint64_t ExponentialBiased::NextRandom(uint64_t rnd) {
 }
 
 }  // namespace profiling_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_PROFILING_INTERNAL_EXPONENTIAL_BIASED_H_
+#endif  // Y_ABSL_PROFILING_INTERNAL_EXPONENTIAL_BIASED_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/periodic_sampler.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/periodic_sampler.cc
index 39fb3660f0..03892bfa3e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/periodic_sampler.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/periodic_sampler.cc
@@ -19,7 +19,7 @@
 #include "y_absl/profiling/internal/exponential_biased.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace profiling_internal {
 
 int64_t PeriodicSamplerBase::GetExponentialBiased(int period) noexcept {
@@ -30,13 +30,13 @@ bool PeriodicSamplerBase::SubtleConfirmSample() noexcept {
   int current_period = period();
 
   // Deal with period case 0 (always off) and 1 (always on)
-  if (ABSL_PREDICT_FALSE(current_period < 2)) {
+  if (Y_ABSL_PREDICT_FALSE(current_period < 2)) {
     stride_ = 0;
     return current_period == 1;
   }
 
   // Check if this is the first call to Sample()
-  if (ABSL_PREDICT_FALSE(stride_ == 1)) {
+  if (Y_ABSL_PREDICT_FALSE(stride_ == 1)) {
     stride_ = static_cast<uint64_t>(-GetExponentialBiased(current_period));
     if (static_cast<int64_t>(stride_) < -1) {
       ++stride_;
@@ -49,5 +49,5 @@ bool PeriodicSamplerBase::SubtleConfirmSample() noexcept {
 }
 
 }  // namespace profiling_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/periodic_sampler.h b/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/periodic_sampler.h
index 37796a9e00..6faa2d7566 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/periodic_sampler.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/periodic_sampler.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_PROFILING_INTERNAL_PERIODIC_SAMPLER_H_
-#define ABSL_PROFILING_INTERNAL_PERIODIC_SAMPLER_H_
+#ifndef Y_ABSL_PROFILING_INTERNAL_PERIODIC_SAMPLER_H_
+#define Y_ABSL_PROFILING_INTERNAL_PERIODIC_SAMPLER_H_
 
 #include <stdint.h>
 
@@ -23,7 +23,7 @@
 #include "y_absl/profiling/internal/exponential_biased.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace profiling_internal {
 
 // PeriodicSamplerBase provides the basic period sampler implementation.
@@ -77,7 +77,7 @@ class PeriodicSamplerBase {
   //   }
   //
   //   inline void Frobber() {
-  //     if (ABSL_PREDICT_FALSE(sampler.SubtleMaybeSample())) {
+  //     if (Y_ABSL_PREDICT_FALSE(sampler.SubtleMaybeSample())) {
   //       FrobberSampled();
   //     } else {
   //       FrobberImpl();
@@ -121,7 +121,7 @@ class PeriodicSamplerBase {
   //
   // Option 1:
   //   int64_t stride_;
-  //   if (ABSL_PREDICT_TRUE(++stride_ < 0)) { ... }
+  //   if (Y_ABSL_PREDICT_TRUE(++stride_ < 0)) { ... }
   //
   //   GCC   x64 (OK) : https://gcc.godbolt.org/z/R5MzzA
   //   GCC   ppc (OK) : https://gcc.godbolt.org/z/z7NZAt
@@ -131,7 +131,7 @@ class PeriodicSamplerBase {
   //
   // Option 2:
   //   int64_t stride_ = 0;
-  //   if (ABSL_PREDICT_TRUE(--stride_ >= 0)) { ... }
+  //   if (Y_ABSL_PREDICT_TRUE(--stride_ >= 0)) { ... }
   //
   //   GCC   x64 (OK) : https://gcc.godbolt.org/z/jSQxYK
   //   GCC   ppc (OK) : https://gcc.godbolt.org/z/VJdYaA
@@ -141,7 +141,7 @@ class PeriodicSamplerBase {
   //
   // Option 3:
   //   uint64_t stride_;
-  //   if (ABSL_PREDICT_TRUE(static_cast<int64_t>(++stride_) < 0)) { ... }
+  //   if (Y_ABSL_PREDICT_TRUE(static_cast<int64_t>(++stride_) < 0)) { ... }
   //
   //   GCC   x64 (OK) : https://gcc.godbolt.org/z/bFbfPy
   //   GCC   ppc (OK) : https://gcc.godbolt.org/z/S9KkUE
@@ -154,14 +154,14 @@ class PeriodicSamplerBase {
 
 inline bool PeriodicSamplerBase::SubtleMaybeSample() noexcept {
   // See comments on `stride_` for the unsigned increment / signed compare.
-  if (ABSL_PREDICT_TRUE(static_cast<int64_t>(++stride_) < 0)) {
+  if (Y_ABSL_PREDICT_TRUE(static_cast<int64_t>(++stride_) < 0)) {
     return false;
   }
   return true;
 }
 
 inline bool PeriodicSamplerBase::Sample() noexcept {
-  return ABSL_PREDICT_FALSE(SubtleMaybeSample()) ? SubtleConfirmSample()
+  return Y_ABSL_PREDICT_FALSE(SubtleMaybeSample()) ? SubtleConfirmSample()
                                                  : false;
 }
 
@@ -205,7 +205,7 @@ template <typename Tag, int default_period>
 std::atomic<int> PeriodicSampler<Tag, default_period>::period_(default_period);
 
 }  // namespace profiling_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_PROFILING_INTERNAL_PERIODIC_SAMPLER_H_
+#endif  // Y_ABSL_PROFILING_INTERNAL_PERIODIC_SAMPLER_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/sample_recorder.h b/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/sample_recorder.h
index 449d17a76d..9330aae739 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/sample_recorder.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/sample_recorder.h
@@ -21,8 +21,8 @@
 //
 // This utility is internal-only. Use at your own risk.
 
-#ifndef ABSL_PROFILING_INTERNAL_SAMPLE_RECORDER_H_
-#define ABSL_PROFILING_INTERNAL_SAMPLE_RECORDER_H_
+#ifndef Y_ABSL_PROFILING_INTERNAL_SAMPLE_RECORDER_H_
+#define Y_ABSL_PROFILING_INTERNAL_SAMPLE_RECORDER_H_
 
 #include <atomic>
 #include <cstddef>
@@ -34,7 +34,7 @@
 #include "y_absl/time/time.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace profiling_internal {
 
 // Sample<T> that has members required for linking samples in the linked list of
@@ -45,7 +45,7 @@ struct Sample {
   // prevents races with sampling and resurrecting an object.
   y_absl::Mutex init_mu;
   T* next = nullptr;
-  T* dead ABSL_GUARDED_BY(init_mu) = nullptr;
+  T* dead Y_ABSL_GUARDED_BY(init_mu) = nullptr;
 };
 
 // Holds samples and their associated stack traces with a soft limit of
@@ -224,7 +224,7 @@ void SampleRecorder<T>::SetMaxSamples(int32_t max) {
 }
 
 }  // namespace profiling_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_PROFILING_INTERNAL_SAMPLE_RECORDER_H_
+#endif  // Y_ABSL_PROFILING_INTERNAL_SAMPLE_RECORDER_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/status/internal/status_internal.h b/contrib/restricted/abseil-cpp-tstring/y_absl/status/internal/status_internal.h
index 6754d7d518..3195a6eb4f 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/status/internal/status_internal.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/status/internal/status_internal.h
@@ -11,8 +11,8 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-#ifndef ABSL_STATUS_INTERNAL_STATUS_INTERNAL_H_
-#define ABSL_STATUS_INTERNAL_STATUS_INTERNAL_H_
+#ifndef Y_ABSL_STATUS_INTERNAL_STATUS_INTERNAL_H_
+#define Y_ABSL_STATUS_INTERNAL_STATUS_INTERNAL_H_
 
 #include <util/generic/string.h>
 
@@ -22,16 +22,16 @@
 #ifndef SWIG
 // Disabled for SWIG as it doesn't parse attributes correctly.
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 // Returned Status objects may not be ignored. Codesearch doesn't handle ifdefs
 // as part of a class definitions (b/6995610), so we use a forward declaration.
-class ABSL_MUST_USE_RESULT Status;
-ABSL_NAMESPACE_END
+class Y_ABSL_MUST_USE_RESULT Status;
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 #endif  // !SWIG
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 enum class StatusCode : int;
 
@@ -63,7 +63,7 @@ struct StatusRep {
 y_absl::StatusCode MapToLocalCode(int value);
 }  // namespace status_internal
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STATUS_INTERNAL_STATUS_INTERNAL_H_
+#endif  // Y_ABSL_STATUS_INTERNAL_STATUS_INTERNAL_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/status/internal/statusor_internal.h b/contrib/restricted/abseil-cpp-tstring/y_absl/status/internal/statusor_internal.h
index c4d78e28d2..46469adc33 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/status/internal/statusor_internal.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/status/internal/statusor_internal.h
@@ -11,8 +11,8 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-#ifndef ABSL_STATUS_INTERNAL_STATUSOR_INTERNAL_H_
-#define ABSL_STATUS_INTERNAL_STATUSOR_INTERNAL_H_
+#ifndef Y_ABSL_STATUS_INTERNAL_STATUSOR_INTERNAL_H_
+#define Y_ABSL_STATUS_INTERNAL_STATUSOR_INTERNAL_H_
 
 #include <type_traits>
 #include <utility>
@@ -23,10 +23,10 @@
 #include "y_absl/utility/utility.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 template <typename T>
-class ABSL_MUST_USE_RESULT StatusOr;
+class Y_ABSL_MUST_USE_RESULT StatusOr;
 
 namespace internal_statusor {
 
@@ -136,14 +136,14 @@ class Helper {
  public:
   // Move type-agnostic error handling to the .cc.
   static void HandleInvalidStatusCtorArg(Status*);
-  ABSL_ATTRIBUTE_NORETURN static void Crash(const y_absl::Status& status);
+  Y_ABSL_ATTRIBUTE_NORETURN static void Crash(const y_absl::Status& status);
 };
 
 // Construct an instance of T in `p` through placement new, passing Args... to
 // the constructor.
 // This abstraction is here mostly for the gcc performance fix.
 template <typename T, typename... Args>
-ABSL_ATTRIBUTE_NONNULL(1) void PlacementNew(void* p, Args&&... args) {
+Y_ABSL_ATTRIBUTE_NONNULL(1) void PlacementNew(void* p, Args&&... args) {
   new (p) T(std::forward<Args>(args)...);
 }
 
@@ -286,11 +286,11 @@ class StatusOrData {
   }
 
   void EnsureOk() const {
-    if (ABSL_PREDICT_FALSE(!ok())) Helper::Crash(status_);
+    if (Y_ABSL_PREDICT_FALSE(!ok())) Helper::Crash(status_);
   }
 
   void EnsureNotOk() {
-    if (ABSL_PREDICT_FALSE(ok())) Helper::HandleInvalidStatusCtorArg(&status_);
+    if (Y_ABSL_PREDICT_FALSE(ok())) Helper::HandleInvalidStatusCtorArg(&status_);
   }
 
   // Construct the value (ie. data_) through placement new with the passed
@@ -387,10 +387,10 @@ struct MoveAssignBase<T, false> {
   MoveAssignBase& operator=(MoveAssignBase&&) = delete;
 };
 
-ABSL_ATTRIBUTE_NORETURN void ThrowBadStatusOrAccess(y_absl::Status status);
+Y_ABSL_ATTRIBUTE_NORETURN void ThrowBadStatusOrAccess(y_absl::Status status);
 
 }  // namespace internal_statusor
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STATUS_INTERNAL_STATUSOR_INTERNAL_H_
+#endif  // Y_ABSL_STATUS_INTERNAL_STATUSOR_INTERNAL_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/status/status.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/status/status.cc
index 3b7fe28e08..2bfa4be70a 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/status/status.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/status/status.cc
@@ -25,7 +25,7 @@
 #include "y_absl/strings/str_split.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 TString StatusCodeToString(StatusCode code) {
   switch (code) {
@@ -227,7 +227,7 @@ y_absl::StatusCode Status::code() const {
 }
 
 void Status::PrepareToModify() {
-  ABSL_RAW_CHECK(!ok(), "PrepareToModify shouldn't be called on OK status.");
+  Y_ABSL_RAW_CHECK(!ok(), "PrepareToModify shouldn't be called on OK status.");
   if (IsInlined(rep_)) {
     rep_ = PointerToRep(new status_internal::StatusRep(
         static_cast<y_absl::StatusCode>(raw_code()), y_absl::string_view(),
@@ -440,5 +440,5 @@ bool IsUnknown(const Status& status) {
   return status.code() == y_absl::StatusCode::kUnknown;
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/status/status.h b/contrib/restricted/abseil-cpp-tstring/y_absl/status/status.h
index fa461e9f76..b2acacc709 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/status/status.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/status/status.h
@@ -48,8 +48,8 @@
 // error codes (of type `y_absl::StatusCode`) enumerated in this header file.
 // These canonical codes are understood across the codebase and will be
 // accepted across all API and RPC boundaries.
-#ifndef ABSL_STATUS_STATUS_H_
-#define ABSL_STATUS_STATUS_H_
+#ifndef Y_ABSL_STATUS_STATUS_H_
+#define Y_ABSL_STATUS_STATUS_H_
 
 #include <iostream>
 #include <util/generic/string.h>
@@ -62,7 +62,7 @@
 #include "y_absl/types/optional.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // y_absl::StatusCode
 //
@@ -420,7 +420,7 @@ inline StatusToStringMode& operator^=(StatusToStringMode& lhs,
 //
 // Returned Status objects may not be ignored. status_internal.h has a forward
 // declaration of the form
-// class ABSL_MUST_USE_RESULT Status;
+// class Y_ABSL_MUST_USE_RESULT Status;
 class Status final {
  public:
   // Constructors
@@ -471,7 +471,7 @@ class Status final {
   //
   // Returns `true` if `this->ok()`. Prefer checking for an OK status using this
   // member function.
-  ABSL_MUST_USE_RESULT bool ok() const;
+  Y_ABSL_MUST_USE_RESULT bool ok() const;
 
   // Status::code()
   //
@@ -687,22 +687,22 @@ std::ostream& operator<<(std::ostream& os, const Status& x);
 //
 // These convenience functions return `true` if a given status matches the
 // `y_absl::StatusCode` error code of its associated function.
-ABSL_MUST_USE_RESULT bool IsAborted(const Status& status);
-ABSL_MUST_USE_RESULT bool IsAlreadyExists(const Status& status);
-ABSL_MUST_USE_RESULT bool IsCancelled(const Status& status);
-ABSL_MUST_USE_RESULT bool IsDataLoss(const Status& status);
-ABSL_MUST_USE_RESULT bool IsDeadlineExceeded(const Status& status);
-ABSL_MUST_USE_RESULT bool IsFailedPrecondition(const Status& status);
-ABSL_MUST_USE_RESULT bool IsInternal(const Status& status);
-ABSL_MUST_USE_RESULT bool IsInvalidArgument(const Status& status);
-ABSL_MUST_USE_RESULT bool IsNotFound(const Status& status);
-ABSL_MUST_USE_RESULT bool IsOutOfRange(const Status& status);
-ABSL_MUST_USE_RESULT bool IsPermissionDenied(const Status& status);
-ABSL_MUST_USE_RESULT bool IsResourceExhausted(const Status& status);
-ABSL_MUST_USE_RESULT bool IsUnauthenticated(const Status& status);
-ABSL_MUST_USE_RESULT bool IsUnavailable(const Status& status);
-ABSL_MUST_USE_RESULT bool IsUnimplemented(const Status& status);
-ABSL_MUST_USE_RESULT bool IsUnknown(const Status& status);
+Y_ABSL_MUST_USE_RESULT bool IsAborted(const Status& status);
+Y_ABSL_MUST_USE_RESULT bool IsAlreadyExists(const Status& status);
+Y_ABSL_MUST_USE_RESULT bool IsCancelled(const Status& status);
+Y_ABSL_MUST_USE_RESULT bool IsDataLoss(const Status& status);
+Y_ABSL_MUST_USE_RESULT bool IsDeadlineExceeded(const Status& status);
+Y_ABSL_MUST_USE_RESULT bool IsFailedPrecondition(const Status& status);
+Y_ABSL_MUST_USE_RESULT bool IsInternal(const Status& status);
+Y_ABSL_MUST_USE_RESULT bool IsInvalidArgument(const Status& status);
+Y_ABSL_MUST_USE_RESULT bool IsNotFound(const Status& status);
+Y_ABSL_MUST_USE_RESULT bool IsOutOfRange(const Status& status);
+Y_ABSL_MUST_USE_RESULT bool IsPermissionDenied(const Status& status);
+Y_ABSL_MUST_USE_RESULT bool IsResourceExhausted(const Status& status);
+Y_ABSL_MUST_USE_RESULT bool IsUnauthenticated(const Status& status);
+Y_ABSL_MUST_USE_RESULT bool IsUnavailable(const Status& status);
+Y_ABSL_MUST_USE_RESULT bool IsUnimplemented(const Status& status);
+Y_ABSL_MUST_USE_RESULT bool IsUnknown(const Status& status);
 
 // AbortedError()
 // AlreadyExistsError()
@@ -876,7 +876,7 @@ inline Status OkStatus() { return Status(); }
 // message-less kCancelled errors are common in the infrastructure.
 inline Status CancelledError() { return Status(y_absl::StatusCode::kCancelled); }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STATUS_STATUS_H_
+#endif  // Y_ABSL_STATUS_STATUS_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/status/status_payload_printer.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/status/status_payload_printer.cc
index 6990ff6e8d..ae3803ed48 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/status/status_payload_printer.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/status/status_payload_printer.cc
@@ -19,10 +19,10 @@
 #include "y_absl/base/internal/atomic_hook.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace status_internal {
 
-ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES
+Y_ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES
 static y_absl::base_internal::AtomicHook<StatusPayloadPrinter> storage;
 
 void SetStatusPayloadPrinter(StatusPayloadPrinter printer) {
@@ -34,5 +34,5 @@ StatusPayloadPrinter GetStatusPayloadPrinter() {
 }
 
 }  // namespace status_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/status/status_payload_printer.h b/contrib/restricted/abseil-cpp-tstring/y_absl/status/status_payload_printer.h
index 6968e0f40b..3ecb62fc21 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/status/status_payload_printer.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/status/status_payload_printer.h
@@ -11,8 +11,8 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-#ifndef ABSL_STATUS_STATUS_PAYLOAD_PRINTER_H_
-#define ABSL_STATUS_STATUS_PAYLOAD_PRINTER_H_
+#ifndef Y_ABSL_STATUS_STATUS_PAYLOAD_PRINTER_H_
+#define Y_ABSL_STATUS_STATUS_PAYLOAD_PRINTER_H_
 
 #include <util/generic/string.h>
 
@@ -21,7 +21,7 @@
 #include "y_absl/types/optional.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace status_internal {
 
 // By default, `Status::ToString` and `operator<<(Status)` print a payload by
@@ -45,7 +45,7 @@ void SetStatusPayloadPrinter(StatusPayloadPrinter);
 StatusPayloadPrinter GetStatusPayloadPrinter();
 
 }  // namespace status_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STATUS_STATUS_PAYLOAD_PRINTER_H_
+#endif  // Y_ABSL_STATUS_STATUS_PAYLOAD_PRINTER_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor.cc
index 03e6d1cec4..f9dce7c12d 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor.cc
@@ -22,7 +22,7 @@
 #include "y_absl/strings/str_cat.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 BadStatusOrAccess::BadStatusOrAccess(y_absl::Status status)
     : status_(std::move(status)) {}
@@ -71,26 +71,26 @@ void Helper::HandleInvalidStatusCtorArg(y_absl::Status* status) {
   const char* kMessage =
       "An OK status is not a valid constructor argument to StatusOr<T>";
 #ifdef NDEBUG
-  ABSL_INTERNAL_LOG(ERROR, kMessage);
+  Y_ABSL_INTERNAL_LOG(ERROR, kMessage);
 #else
-  ABSL_INTERNAL_LOG(FATAL, kMessage);
+  Y_ABSL_INTERNAL_LOG(FATAL, kMessage);
 #endif
   // In optimized builds, we will fall back to InternalError.
   *status = y_absl::InternalError(kMessage);
 }
 
 void Helper::Crash(const y_absl::Status& status) {
-  ABSL_INTERNAL_LOG(
+  Y_ABSL_INTERNAL_LOG(
       FATAL,
       y_absl::StrCat("Attempting to fetch value instead of handling error ",
                    status.ToString()));
 }
 
 void ThrowBadStatusOrAccess(y_absl::Status status) {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef Y_ABSL_HAVE_EXCEPTIONS
   throw y_absl::BadStatusOrAccess(std::move(status));
 #else
-  ABSL_INTERNAL_LOG(
+  Y_ABSL_INTERNAL_LOG(
       FATAL,
       y_absl::StrCat("Attempting to fetch value instead of handling error ",
                    status.ToString()));
@@ -99,5 +99,5 @@ void ThrowBadStatusOrAccess(y_absl::Status status) {
 }
 
 }  // namespace internal_statusor
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor.h b/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor.h
index 23e1b8a6e4..6fd14e9819 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/status/statusor.h
@@ -33,8 +33,8 @@
 //   } else {
 //     LOG(ERROR) << result.status();
 //   }
-#ifndef ABSL_STATUS_STATUSOR_H_
-#define ABSL_STATUS_STATUSOR_H_
+#ifndef Y_ABSL_STATUS_STATUSOR_H_
+#define Y_ABSL_STATUS_STATUSOR_H_
 
 #include <exception>
 #include <initializer_list>
@@ -52,7 +52,7 @@
 #include "y_absl/utility/utility.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // BadStatusOrAccess
 //
@@ -106,7 +106,7 @@ class BadStatusOrAccess : public std::exception {
 
 // Returned StatusOr objects may not be ignored.
 template <typename T>
-class ABSL_MUST_USE_RESULT StatusOr;
+class Y_ABSL_MUST_USE_RESULT StatusOr;
 
 // y_absl::StatusOr<T>
 //
@@ -482,7 +482,7 @@ class StatusOr : private internal_statusor::StatusOrData<T>,
   // else {
   //    // Handle error
   // }
-  ABSL_MUST_USE_RESULT bool ok() const { return this->status_.ok(); }
+  Y_ABSL_MUST_USE_RESULT bool ok() const { return this->status_.ok(); }
 
   // StatusOr<T>::status()
   //
@@ -518,10 +518,10 @@ class StatusOr : private internal_statusor::StatusOrData<T>,
   //
   // The `std::move` on statusor instead of on the whole expression enables
   // warnings about possible uses of the statusor object after the move.
-  const T& value() const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
-  T& value() & ABSL_ATTRIBUTE_LIFETIME_BOUND;
-  const T&& value() const&& ABSL_ATTRIBUTE_LIFETIME_BOUND;
-  T&& value() && ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  const T& value() const& Y_ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  T& value() & Y_ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  const T&& value() const&& Y_ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  T&& value() && Y_ABSL_ATTRIBUTE_LIFETIME_BOUND;
 
   // StatusOr<T>:: operator*()
   //
@@ -533,10 +533,10 @@ class StatusOr : private internal_statusor::StatusOrData<T>,
   // `y_absl::StatusOr<T>`. Alternatively, see the `value()` member function for a
   // similar API that guarantees crashing or throwing an exception if there is
   // no current value.
-  const T& operator*() const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
-  T& operator*() & ABSL_ATTRIBUTE_LIFETIME_BOUND;
-  const T&& operator*() const&& ABSL_ATTRIBUTE_LIFETIME_BOUND;
-  T&& operator*() && ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  const T& operator*() const& Y_ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  T& operator*() & Y_ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  const T&& operator*() const&& Y_ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  T&& operator*() && Y_ABSL_ATTRIBUTE_LIFETIME_BOUND;
 
   // StatusOr<T>::operator->()
   //
@@ -545,8 +545,8 @@ class StatusOr : private internal_statusor::StatusOrData<T>,
   // REQUIRES: `this->ok() == true`, otherwise the behavior is undefined.
   //
   // Use `this->ok()` to verify that there is a current value.
-  const T* operator->() const ABSL_ATTRIBUTE_LIFETIME_BOUND;
-  T* operator->() ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  const T* operator->() const Y_ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  T* operator->() Y_ABSL_ATTRIBUTE_LIFETIME_BOUND;
 
   // StatusOr<T>::value_or()
   //
@@ -764,7 +764,7 @@ void StatusOr<T>::IgnoreError() const {
   // no-op
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STATUS_STATUSOR_H_
+#endif  // Y_ABSL_STATUS_STATUSOR_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/ascii.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/ascii.cc
index 959d6c27ff..a628cb0f94 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/ascii.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/ascii.cc
@@ -15,7 +15,7 @@
 #include "y_absl/strings/ascii.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace ascii_internal {
 
 // # Table generated by this Python code (bit 0x02 is currently unused):
@@ -57,7 +57,7 @@ namespace ascii_internal {
 // of these bits is tightly coupled to this implementation, the individual bits
 // are not named. Note that bitfields for all characters above ASCII 127 are
 // zero-initialized.
-ABSL_DLL const unsigned char kPropertyBits[256] = {
+Y_ABSL_DLL const unsigned char kPropertyBits[256] = {
     0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  // 0x00
     0x40, 0x68, 0x48, 0x48, 0x48, 0x48, 0x40, 0x40,
     0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  // 0x10
@@ -79,7 +79,7 @@ ABSL_DLL const unsigned char kPropertyBits[256] = {
 // Array of characters for the ascii_tolower() function. For values 'A'
 // through 'Z', return the lower-case character; otherwise, return the
 // identity of the passed character.
-ABSL_DLL const char kToLower[256] = {
+Y_ABSL_DLL const char kToLower[256] = {
   '\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07',
   '\x08', '\x09', '\x0a', '\x0b', '\x0c', '\x0d', '\x0e', '\x0f',
   '\x10', '\x11', '\x12', '\x13', '\x14', '\x15', '\x16', '\x17',
@@ -117,7 +117,7 @@ ABSL_DLL const char kToLower[256] = {
 // Array of characters for the ascii_toupper() function. For values 'a'
 // through 'z', return the upper-case character; otherwise, return the
 // identity of the passed character.
-ABSL_DLL const char kToUpper[256] = {
+Y_ABSL_DLL const char kToUpper[256] = {
   '\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07',
   '\x08', '\x09', '\x0a', '\x0b', '\x0c', '\x0d', '\x0e', '\x0f',
   '\x10', '\x11', '\x12', '\x13', '\x14', '\x15', '\x16', '\x17',
@@ -196,5 +196,5 @@ void RemoveExtraAsciiWhitespace(TString* str) {
   str->erase(output_it - &(*str)[0]);
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/ascii.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/ascii.h
index bc04710d8c..2050f8f1a9 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/ascii.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/ascii.h
@@ -49,8 +49,8 @@
 //   numerical values greater than 127) then the functions return the same value
 //   as the input character.
 
-#ifndef ABSL_STRINGS_ASCII_H_
-#define ABSL_STRINGS_ASCII_H_
+#ifndef Y_ABSL_STRINGS_ASCII_H_
+#define Y_ABSL_STRINGS_ASCII_H_
 
 #include <algorithm>
 #include <util/generic/string.h>
@@ -60,17 +60,17 @@
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace ascii_internal {
 
 // Declaration for an array of bitfields holding character information.
-ABSL_DLL extern const unsigned char kPropertyBits[256];
+Y_ABSL_DLL extern const unsigned char kPropertyBits[256];
 
 // Declaration for the array of characters to upper-case characters.
-ABSL_DLL extern const char kToUpper[256];
+Y_ABSL_DLL extern const char kToUpper[256];
 
 // Declaration for the array of characters to lower-case characters.
-ABSL_DLL extern const char kToLower[256];
+Y_ABSL_DLL extern const char kToLower[256];
 
 }  // namespace ascii_internal
 
@@ -168,7 +168,7 @@ inline char ascii_tolower(unsigned char c) {
 void AsciiStrToLower(TString* s);
 
 // Creates a lowercase string from a given y_absl::string_view.
-ABSL_MUST_USE_RESULT inline TString AsciiStrToLower(y_absl::string_view s) {
+Y_ABSL_MUST_USE_RESULT inline TString AsciiStrToLower(y_absl::string_view s) {
   TString result(s);
   y_absl::AsciiStrToLower(&result);
   return result;
@@ -186,7 +186,7 @@ inline char ascii_toupper(unsigned char c) {
 void AsciiStrToUpper(TString* s);
 
 // Creates an uppercase string from a given y_absl::string_view.
-ABSL_MUST_USE_RESULT inline TString AsciiStrToUpper(y_absl::string_view s) {
+Y_ABSL_MUST_USE_RESULT inline TString AsciiStrToUpper(y_absl::string_view s) {
   TString result(s);
   y_absl::AsciiStrToUpper(&result);
   return result;
@@ -194,7 +194,7 @@ ABSL_MUST_USE_RESULT inline TString AsciiStrToUpper(y_absl::string_view s) {
 
 // Returns y_absl::string_view with whitespace stripped from the beginning of the
 // given string_view.
-ABSL_MUST_USE_RESULT inline y_absl::string_view StripLeadingAsciiWhitespace(
+Y_ABSL_MUST_USE_RESULT inline y_absl::string_view StripLeadingAsciiWhitespace(
     y_absl::string_view str) {
   auto it = std::find_if_not(str.begin(), str.end(), y_absl::ascii_isspace);
   return str.substr(it - str.begin());
@@ -208,7 +208,7 @@ inline void StripLeadingAsciiWhitespace(TString* str) {
 
 // Returns y_absl::string_view with whitespace stripped from the end of the given
 // string_view.
-ABSL_MUST_USE_RESULT inline y_absl::string_view StripTrailingAsciiWhitespace(
+Y_ABSL_MUST_USE_RESULT inline y_absl::string_view StripTrailingAsciiWhitespace(
     y_absl::string_view str) {
   auto it = std::find_if_not(str.rbegin(), str.rend(), y_absl::ascii_isspace);
   return str.substr(0, str.rend() - it);
@@ -222,7 +222,7 @@ inline void StripTrailingAsciiWhitespace(TString* str) {
 
 // Returns y_absl::string_view with whitespace stripped from both ends of the
 // given string_view.
-ABSL_MUST_USE_RESULT inline y_absl::string_view StripAsciiWhitespace(
+Y_ABSL_MUST_USE_RESULT inline y_absl::string_view StripAsciiWhitespace(
     y_absl::string_view str) {
   return StripTrailingAsciiWhitespace(StripLeadingAsciiWhitespace(str));
 }
@@ -236,7 +236,7 @@ inline void StripAsciiWhitespace(TString* str) {
 // Removes leading, trailing, and consecutive internal whitespace.
 void RemoveExtraAsciiWhitespace(TString*);
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_ASCII_H_
+#endif  // Y_ABSL_STRINGS_ASCII_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/charconv.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/charconv.cc
index 9515ca24dd..01ac7c6260 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/charconv.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/charconv.cc
@@ -25,16 +25,16 @@
 #include "y_absl/strings/internal/charconv_bigint.h"
 #include "y_absl/strings/internal/charconv_parse.h"
 
-// The macro ABSL_BIT_PACK_FLOATS is defined on x86-64, where IEEE floating
+// The macro Y_ABSL_BIT_PACK_FLOATS is defined on x86-64, where IEEE floating
 // point numbers have the same endianness in memory as a bitfield struct
 // containing the corresponding parts.
 //
 // When set, we replace calls to ldexp() with manual bit packing, which is
 // faster and is unaffected by floating point environment.
-#ifdef ABSL_BIT_PACK_FLOATS
-#error ABSL_BIT_PACK_FLOATS cannot be directly set
+#ifdef Y_ABSL_BIT_PACK_FLOATS
+#error Y_ABSL_BIT_PACK_FLOATS cannot be directly set
 #elif defined(__x86_64__) || defined(_M_X64)
-#define ABSL_BIT_PACK_FLOATS 1
+#define Y_ABSL_BIT_PACK_FLOATS 1
 #endif
 
 // A note about subnormals:
@@ -57,7 +57,7 @@
 // narrower mantissas.
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace {
 
 template <typename FloatType>
@@ -104,7 +104,7 @@ struct FloatTraits<double> {
   // `exponent` must be exactly kMinNormalExponent, and a subnormal value is
   // made.
   static double Make(uint64_t mantissa, int exponent, bool sign) {
-#ifndef ABSL_BIT_PACK_FLOATS
+#ifndef Y_ABSL_BIT_PACK_FLOATS
     // Support ldexp no matter which namespace it's in.  Some platforms
     // incorrectly don't put it in namespace std.
     using namespace std;  // NOLINT
@@ -125,7 +125,7 @@ struct FloatTraits<double> {
     }
     dbl += mantissa;
     return y_absl::bit_cast<double>(dbl);
-#endif  // ABSL_BIT_PACK_FLOATS
+#endif  // Y_ABSL_BIT_PACK_FLOATS
   }
 };
 
@@ -144,7 +144,7 @@ struct FloatTraits<float> {
     return nanf(tagp);
   }
   static float Make(uint32_t mantissa, int exponent, bool sign) {
-#ifndef ABSL_BIT_PACK_FLOATS
+#ifndef Y_ABSL_BIT_PACK_FLOATS
     // Support ldexpf no matter which namespace it's in.  Some platforms
     // incorrectly don't put it in namespace std.
     using namespace std;  // NOLINT
@@ -165,7 +165,7 @@ struct FloatTraits<float> {
     }
     flt += mantissa;
     return y_absl::bit_cast<float>(flt);
-#endif  // ABSL_BIT_PACK_FLOATS
+#endif  // Y_ABSL_BIT_PACK_FLOATS
   }
 };
 
@@ -980,5 +980,5 @@ const int16_t kPower10ExponentTable[] = {
 };
 
 }  // namespace
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/charconv.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/charconv.h
index 1a115aa251..9b63016e3f 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/charconv.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/charconv.h
@@ -12,15 +12,15 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_CHARCONV_H_
-#define ABSL_STRINGS_CHARCONV_H_
+#ifndef Y_ABSL_STRINGS_CHARCONV_H_
+#define Y_ABSL_STRINGS_CHARCONV_H_
 
 #include <system_error>  // NOLINT(build/c++11)
 
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // Workalike compatibilty version of std::chars_format from C++17.
 //
@@ -114,7 +114,7 @@ inline chars_format& operator^=(chars_format& lhs, chars_format rhs) {
   return lhs;
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_CHARCONV_H_
+#endif  // Y_ABSL_STRINGS_CHARCONV_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/cord.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/cord.cc
index 0de4ea1b3c..262a84036b 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/cord.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/cord.cc
@@ -48,7 +48,7 @@
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 using ::y_absl::cord_internal::CordRep;
 using ::y_absl::cord_internal::CordRepBtree;
@@ -92,7 +92,7 @@ static constexpr uint64_t min_length[] = {
     0xffffffffffffffffull,  // Avoid overflow
 };
 
-static const int kMinLengthSize = ABSL_ARRAYSIZE(min_length);
+static const int kMinLengthSize = Y_ABSL_ARRAYSIZE(min_length);
 
 static inline bool btree_enabled() {
   return cord_internal::cord_btree_enabled.load(
@@ -505,7 +505,7 @@ void Cord::InlineRep::GetAppendRegion(char** region, size_t* size,
 static bool RepMemoryUsageDataEdge(const CordRep* rep,
                                    size_t* total_mem_usage) {
   size_t maybe_sub_size = 0;
-  if (ABSL_PREDICT_FALSE(rep->IsSubstring())) {
+  if (Y_ABSL_PREDICT_FALSE(rep->IsSubstring())) {
     maybe_sub_size = sizeof(cord_internal::CordRepSubstring);
     rep = rep->substring()->child;
   }
@@ -549,7 +549,7 @@ void Cord::InlineRep::AssignSlow(const Cord::InlineRep& src) {
   assert(&src != this);
   assert(is_tree() || src.is_tree());
   auto constexpr method = CordzUpdateTracker::kAssignCord;
-  if (ABSL_PREDICT_TRUE(!is_tree())) {
+  if (Y_ABSL_PREDICT_TRUE(!is_tree())) {
     EmplaceTree(CordRep::Ref(src.as_tree()), src.data_, method);
     return;
   }
@@ -935,7 +935,7 @@ static CordRep* RemoveSuffixFrom(CordRep* node, size_t n) {
 }
 
 void Cord::RemovePrefix(size_t n) {
-  ABSL_INTERNAL_CHECK(n <= size(),
+  Y_ABSL_INTERNAL_CHECK(n <= size(),
                       y_absl::StrCat("Requested prefix size ", n,
                                    " exceeds Cord's size ", size()));
   CordRep* tree = contents_.tree();
@@ -958,7 +958,7 @@ void Cord::RemovePrefix(size_t n) {
 }
 
 void Cord::RemoveSuffix(size_t n) {
-  ABSL_INTERNAL_CHECK(n <= size(),
+  Y_ABSL_INTERNAL_CHECK(n <= size(),
                       y_absl::StrCat("Requested suffix size ", n,
                                    " exceeds Cord's size ", size()));
   CordRep* tree = contents_.tree();
@@ -1085,7 +1085,7 @@ class CordForest {
       CordRep* node = pending.back();
       pending.pop_back();
       CheckNode(node);
-      if (ABSL_PREDICT_FALSE(!node->IsConcat())) {
+      if (Y_ABSL_PREDICT_FALSE(!node->IsConcat())) {
         AddNode(node);
         continue;
       }
@@ -1119,7 +1119,7 @@ class CordForest {
       root_length_ -= node->length;
       if (root_length_ == 0) break;
     }
-    ABSL_INTERNAL_CHECK(sum != nullptr, "Failed to locate sum node");
+    Y_ABSL_INTERNAL_CHECK(sum != nullptr, "Failed to locate sum node");
     return VerifyTree(sum);
   }
 
@@ -1178,11 +1178,11 @@ class CordForest {
   }
 
   static void CheckNode(CordRep* node) {
-    ABSL_INTERNAL_CHECK(node->length != 0u, "");
+    Y_ABSL_INTERNAL_CHECK(node->length != 0u, "");
     if (node->IsConcat()) {
-      ABSL_INTERNAL_CHECK(node->concat()->left != nullptr, "");
-      ABSL_INTERNAL_CHECK(node->concat()->right != nullptr, "");
-      ABSL_INTERNAL_CHECK(node->length == (node->concat()->left->length +
+      Y_ABSL_INTERNAL_CHECK(node->concat()->left != nullptr, "");
+      Y_ABSL_INTERNAL_CHECK(node->concat()->right != nullptr, "");
+      Y_ABSL_INTERNAL_CHECK(node->length == (node->concat()->left->length +
                                            node->concat()->right->length),
                           "");
     }
@@ -1510,7 +1510,7 @@ Cord::ChunkIterator& Cord::ChunkIterator::AdvanceStack() {
 }
 
 Cord Cord::ChunkIterator::AdvanceAndReadBytes(size_t n) {
-  ABSL_HARDENING_ASSERT(bytes_remaining_ >= n &&
+  Y_ABSL_HARDENING_ASSERT(bytes_remaining_ >= n &&
                         "Attempted to iterate past `end()`");
   Cord subcord;
   auto constexpr method = CordzUpdateTracker::kCordReader;
@@ -1712,7 +1712,7 @@ void Cord::ChunkIterator::AdvanceBytesSlowPath(size_t n) {
 }
 
 char Cord::operator[](size_t i) const {
-  ABSL_HARDENING_ASSERT(i < size());
+  Y_ABSL_HARDENING_ASSERT(i < size());
   size_t offset = i;
   const CordRep* rep = contents_.tree();
   if (rep == nullptr) {
@@ -1901,7 +1901,7 @@ static void DumpNode(CordRep* rep, bool include_data, std::ostream* os,
       indents.pop_back();
     }
   }
-  ABSL_INTERNAL_CHECK(indents.empty(), "");
+  Y_ABSL_INTERNAL_CHECK(indents.empty(), "");
 }
 
 static TString ReportError(CordRep* root, CordRep* node) {
@@ -1919,17 +1919,17 @@ static bool VerifyNode(CordRep* root, CordRep* start_node,
     CordRep* node = worklist.back();
     worklist.pop_back();
 
-    ABSL_INTERNAL_CHECK(node != nullptr, ReportError(root, node));
+    Y_ABSL_INTERNAL_CHECK(node != nullptr, ReportError(root, node));
     if (node != root) {
-      ABSL_INTERNAL_CHECK(node->length != 0, ReportError(root, node));
+      Y_ABSL_INTERNAL_CHECK(node->length != 0, ReportError(root, node));
     }
 
     if (node->IsConcat()) {
-      ABSL_INTERNAL_CHECK(node->concat()->left != nullptr,
+      Y_ABSL_INTERNAL_CHECK(node->concat()->left != nullptr,
                           ReportError(root, node));
-      ABSL_INTERNAL_CHECK(node->concat()->right != nullptr,
+      Y_ABSL_INTERNAL_CHECK(node->concat()->right != nullptr,
                           ReportError(root, node));
-      ABSL_INTERNAL_CHECK((node->length == node->concat()->left->length +
+      Y_ABSL_INTERNAL_CHECK((node->length == node->concat()->left->length +
                                                node->concat()->right->length),
                           ReportError(root, node));
       if (full_validation) {
@@ -1937,16 +1937,16 @@ static bool VerifyNode(CordRep* root, CordRep* start_node,
         worklist.push_back(node->concat()->left);
       }
     } else if (node->IsFlat()) {
-      ABSL_INTERNAL_CHECK(node->length <= node->flat()->Capacity(),
+      Y_ABSL_INTERNAL_CHECK(node->length <= node->flat()->Capacity(),
                           ReportError(root, node));
     } else if (node->IsExternal()) {
-      ABSL_INTERNAL_CHECK(node->external()->base != nullptr,
+      Y_ABSL_INTERNAL_CHECK(node->external()->base != nullptr,
                           ReportError(root, node));
     } else if (node->IsSubstring()) {
-      ABSL_INTERNAL_CHECK(
+      Y_ABSL_INTERNAL_CHECK(
           node->substring()->start < node->substring()->child->length,
           ReportError(root, node));
-      ABSL_INTERNAL_CHECK(node->substring()->start + node->length <=
+      Y_ABSL_INTERNAL_CHECK(node->substring()->start + node->length <=
                               node->substring()->child->length,
                           ReportError(root, node));
     }
@@ -2032,7 +2032,7 @@ size_t CordTestAccess::FlatTagToLength(uint8_t tag) {
   return cord_internal::TagToLength(tag);
 }
 uint8_t CordTestAccess::LengthToTag(size_t s) {
-  ABSL_INTERNAL_CHECK(s <= kMaxFlatLength, y_absl::StrCat("Invalid length ", s));
+  Y_ABSL_INTERNAL_CHECK(s <= kMaxFlatLength, y_absl::StrCat("Invalid length ", s));
   return cord_internal::AllocatedSizeToTag(s + cord_internal::kFlatOverhead);
 }
 size_t CordTestAccess::SizeofCordRepConcat() { return sizeof(CordRepConcat); }
@@ -2043,5 +2043,5 @@ size_t CordTestAccess::SizeofCordRepSubstring() {
   return sizeof(CordRepSubstring);
 }
 }  // namespace strings_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/cord.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/cord.h
index 62359e0cf8..8f14bb6f8c 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/cord.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/cord.h
@@ -58,8 +58,8 @@
 // const methods without synchronization. Copying a Cord produces a new instance
 // that can be used concurrently with the original in arbitrary ways.
 
-#ifndef ABSL_STRINGS_CORD_H_
-#define ABSL_STRINGS_CORD_H_
+#ifndef Y_ABSL_STRINGS_CORD_H_
+#define Y_ABSL_STRINGS_CORD_H_
 
 #include <algorithm>
 #include <cstddef>
@@ -93,7 +93,7 @@
 #include "y_absl/types/optional.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 class Cord;
 class CordTestPeer;
 template <typename Releaser>
@@ -921,11 +921,11 @@ class Cord {
   }
 };
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // allow a Cord to be logged
 extern std::ostream& operator<<(std::ostream& out, const Cord& cord);
@@ -1319,7 +1319,7 @@ inline void Cord::ChunkIterator::AdvanceBytesBtree(size_t n) {
 }
 
 inline Cord::ChunkIterator& Cord::ChunkIterator::operator++() {
-  ABSL_HARDENING_ASSERT(bytes_remaining_ > 0 &&
+  Y_ABSL_HARDENING_ASSERT(bytes_remaining_ > 0 &&
                         "Attempted to iterate past `end()`");
   assert(bytes_remaining_ >= current_chunk_.size());
   bytes_remaining_ -= current_chunk_.size();
@@ -1346,12 +1346,12 @@ inline bool Cord::ChunkIterator::operator!=(const ChunkIterator& other) const {
 }
 
 inline Cord::ChunkIterator::reference Cord::ChunkIterator::operator*() const {
-  ABSL_HARDENING_ASSERT(bytes_remaining_ != 0);
+  Y_ABSL_HARDENING_ASSERT(bytes_remaining_ != 0);
   return current_chunk_;
 }
 
 inline Cord::ChunkIterator::pointer Cord::ChunkIterator::operator->() const {
-  ABSL_HARDENING_ASSERT(bytes_remaining_ != 0);
+  Y_ABSL_HARDENING_ASSERT(bytes_remaining_ != 0);
   return &current_chunk_;
 }
 
@@ -1363,7 +1363,7 @@ inline void Cord::ChunkIterator::RemoveChunkPrefix(size_t n) {
 
 inline void Cord::ChunkIterator::AdvanceBytes(size_t n) {
   assert(bytes_remaining_ >= n);
-  if (ABSL_PREDICT_TRUE(n < current_chunk_.size())) {
+  if (Y_ABSL_PREDICT_TRUE(n < current_chunk_.size())) {
     RemoveChunkPrefix(n);
   } else if (n != 0) {
     btree_reader_ ? AdvanceBytesBtree(n) : AdvanceBytesSlowPath(n);
@@ -1387,7 +1387,7 @@ inline Cord::ChunkIterator Cord::ChunkRange::end() const {
 inline Cord::ChunkRange Cord::Chunks() const { return ChunkRange(this); }
 
 inline Cord::CharIterator& Cord::CharIterator::operator++() {
-  if (ABSL_PREDICT_TRUE(chunk_iterator_->size() > 1)) {
+  if (Y_ABSL_PREDICT_TRUE(chunk_iterator_->size() > 1)) {
     chunk_iterator_.RemoveChunkPrefix(1);
   } else {
     ++chunk_iterator_;
@@ -1515,7 +1515,7 @@ class CordTestAccess {
   static uint8_t LengthToTag(size_t s);
 };
 }  // namespace strings_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_CORD_H_
+#endif  // Y_ABSL_STRINGS_CORD_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/cord_test_helpers.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/cord_test_helpers.h
index 8dd7c05751..de754a2b86 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/cord_test_helpers.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/cord_test_helpers.h
@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef ABSL_STRINGS_CORD_TEST_HELPERS_H_
-#define ABSL_STRINGS_CORD_TEST_HELPERS_H_
+#ifndef Y_ABSL_STRINGS_CORD_TEST_HELPERS_H_
+#define Y_ABSL_STRINGS_CORD_TEST_HELPERS_H_
 
 #include <cstdint>
 #include <iostream>
@@ -27,7 +27,7 @@
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // Cord sizes relevant for testing
 enum class TestCordSize {
@@ -116,7 +116,7 @@ inline Cord MakeFragmentedCord(std::initializer_list<y_absl::string_view> list)
   return MakeFragmentedCord<std::initializer_list<y_absl::string_view>>(list);
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_CORD_TEST_HELPERS_H_
+#endif  // Y_ABSL_STRINGS_CORD_TEST_HELPERS_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/cordz_test_helpers.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/cordz_test_helpers.h
index bbb952f073..c753999bb4 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/cordz_test_helpers.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/cordz_test_helpers.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_CORDZ_TEST_HELPERS_H_
-#define ABSL_STRINGS_CORDZ_TEST_HELPERS_H_
+#ifndef Y_ABSL_STRINGS_CORDZ_TEST_HELPERS_H_
+#define Y_ABSL_STRINGS_CORDZ_TEST_HELPERS_H_
 
 #include <utility>
 
@@ -30,7 +30,7 @@
 #include "y_absl/strings/str_cat.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // Returns the CordzInfo for the cord, or nullptr if the cord is not sampled.
 inline const cord_internal::CordzInfo* GetCordzInfoForTesting(
@@ -141,11 +141,11 @@ template <typename... Args>
 Cord UnsampledCord(Args... args) {
   CordzSamplingIntervalHelper never(9999);
   Cord cord(std::forward<Args>(args)...);
-  ABSL_ASSERT(GetCordzInfoForTesting(cord) == nullptr);
+  Y_ABSL_ASSERT(GetCordzInfoForTesting(cord) == nullptr);
   return cord;
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_CORDZ_TEST_HELPERS_H_
+#endif  // Y_ABSL_STRINGS_CORDZ_TEST_HELPERS_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/escaping.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/escaping.cc
index 8c82740608..cd05355fa7 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/escaping.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/escaping.cc
@@ -34,7 +34,7 @@
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace {
 
 // These are used for the leave_nulls_escaped argument to CUnescapeInternal().
@@ -640,7 +640,7 @@ bool Base64UnescapeInternal(const char* src_param, size_t szsrc, char* dest,
 
     default:
       // state should have no other values at this point.
-      ABSL_RAW_LOG(FATAL, "This can't happen; base64 decoder state = %d",
+      Y_ABSL_RAW_LOG(FATAL, "This can't happen; base64 decoder state = %d",
                    state);
   }
 
@@ -945,5 +945,5 @@ TString BytesToHexString(y_absl::string_view from) {
   return result;
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/escaping.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/escaping.h
index 8868b87879..dde4f4f3ce 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/escaping.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/escaping.h
@@ -20,8 +20,8 @@
 // This header file contains string utilities involved in escaping and
 // unescaping strings in various ways.
 
-#ifndef ABSL_STRINGS_ESCAPING_H_
-#define ABSL_STRINGS_ESCAPING_H_
+#ifndef Y_ABSL_STRINGS_ESCAPING_H_
+#define Y_ABSL_STRINGS_ESCAPING_H_
 
 #include <cstddef>
 #include <util/generic/string.h>
@@ -33,7 +33,7 @@
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // CUnescape()
 //
@@ -158,7 +158,7 @@ TString HexStringToBytes(y_absl::string_view from);
 // `2*from.size()`.
 TString BytesToHexString(y_absl::string_view from);
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_ESCAPING_H_
+#endif  // Y_ABSL_STRINGS_ESCAPING_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/char_map.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/char_map.h
index 25428e304c..cee2e75f0d 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/char_map.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/char_map.h
@@ -17,8 +17,8 @@
 // A fast, bit-vector map for 8-bit unsigned characters.
 // This class is useful for non-character purposes as well.
 
-#ifndef ABSL_STRINGS_INTERNAL_CHAR_MAP_H_
-#define ABSL_STRINGS_INTERNAL_CHAR_MAP_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_CHAR_MAP_H_
+#define Y_ABSL_STRINGS_INTERNAL_CHAR_MAP_H_
 
 #include <cstddef>
 #include <cstdint>
@@ -28,7 +28,7 @@
 #include "y_absl/base/port.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 class Charmap {
@@ -53,7 +53,7 @@ class Charmap {
 
   // Returns true if and only if a character exists in both maps.
   bool IntersectsWith(const Charmap& c) const {
-    for (size_t i = 0; i < ABSL_ARRAYSIZE(m_); ++i) {
+    for (size_t i = 0; i < Y_ABSL_ARRAYSIZE(m_); ++i) {
       if ((m_[i] & c.m_[i]) != 0) return true;
     }
     return false;
@@ -150,7 +150,7 @@ constexpr Charmap GraphCharmap() { return PrintCharmap() & ~SpaceCharmap(); }
 constexpr Charmap PunctCharmap() { return GraphCharmap() & ~AlnumCharmap(); }
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_INTERNAL_CHAR_MAP_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_CHAR_MAP_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.cc
index 72a4fa188b..8bb5dc0d5c 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.cc
@@ -19,7 +19,7 @@
 #include <util/generic/string.h>
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 namespace {
@@ -158,12 +158,12 @@ const uint32_t* LargePowerOfFiveData(int i) {
 int LargePowerOfFiveSize(int i) { return 2 * i; }
 }  // namespace
 
-ABSL_DLL const uint32_t kFiveToNth[14] = {
+Y_ABSL_DLL const uint32_t kFiveToNth[14] = {
     1,     5,      25,      125,     625,      3125,      15625,
     78125, 390625, 1953125, 9765625, 48828125, 244140625, 1220703125,
 };
 
-ABSL_DLL const uint32_t kTenToNth[10] = {
+Y_ABSL_DLL const uint32_t kTenToNth[10] = {
     1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000,
 };
 
@@ -355,5 +355,5 @@ template class BigUnsigned<4>;
 template class BigUnsigned<84>;
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.h
index a77aab14dd..01fb544ec3 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_INTERNAL_CHARCONV_BIGINT_H_
-#define ABSL_STRINGS_INTERNAL_CHARCONV_BIGINT_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_CHARCONV_BIGINT_H_
+#define Y_ABSL_STRINGS_INTERNAL_CHARCONV_BIGINT_H_
 
 #include <algorithm>
 #include <cstdint>
@@ -26,7 +26,7 @@
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 // The largest power that 5 that can be raised to, and still fit in a uint32_t.
@@ -34,9 +34,9 @@ constexpr int kMaxSmallPowerOfFive = 13;
 // The largest power that 10 that can be raised to, and still fit in a uint32_t.
 constexpr int kMaxSmallPowerOfTen = 9;
 
-ABSL_DLL extern const uint32_t
+Y_ABSL_DLL extern const uint32_t
     kFiveToNth[kMaxSmallPowerOfFive + 1];
-ABSL_DLL extern const uint32_t kTenToNth[kMaxSmallPowerOfTen + 1];
+Y_ABSL_DLL extern const uint32_t kTenToNth[kMaxSmallPowerOfTen + 1];
 
 // Large, fixed-width unsigned integer.
 //
@@ -417,7 +417,7 @@ extern template class BigUnsigned<4>;
 extern template class BigUnsigned<84>;
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_INTERNAL_CHARCONV_BIGINT_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_CHARCONV_BIGINT_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_parse.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_parse.cc
index f0f78eb68c..6bfe3c7e5c 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_parse.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_parse.cc
@@ -22,7 +22,7 @@
 #include "y_absl/strings/internal/memutil.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace {
 
 // ParseFloat<10> will read the first 19 significant digits of the mantissa.
@@ -500,5 +500,5 @@ template ParsedFloat ParseFloat<16>(const char* begin, const char* end,
                                     chars_format format_flags);
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_parse.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_parse.h
index 3f942cd4cb..d17e26f24a 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_parse.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_parse.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_
-#define ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_
+#define Y_ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_
 
 #include <cstdint>
 
@@ -21,7 +21,7 @@
 #include "y_absl/strings/charconv.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 // Enum indicating whether a parsed float is a number or special value.
@@ -94,6 +94,6 @@ extern template ParsedFloat ParseFloat<16>(const char* begin, const char* end,
                                            y_absl::chars_format format_flags);
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
-#endif  // ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_internal.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_internal.cc
index 6fc39985d8..75cd0c044e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_internal.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_internal.cc
@@ -23,15 +23,15 @@
 #include "y_absl/strings/internal/cord_rep_ring.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace cord_internal {
 
-ABSL_CONST_INIT std::atomic<bool> cord_btree_enabled(kCordEnableBtreeDefault);
-ABSL_CONST_INIT std::atomic<bool> cord_ring_buffer_enabled(
+Y_ABSL_CONST_INIT std::atomic<bool> cord_btree_enabled(kCordEnableBtreeDefault);
+Y_ABSL_CONST_INIT std::atomic<bool> cord_ring_buffer_enabled(
     kCordEnableRingBufferDefault);
-ABSL_CONST_INIT std::atomic<bool> shallow_subcords_enabled(
+Y_ABSL_CONST_INIT std::atomic<bool> shallow_subcords_enabled(
     kCordShallowSubcordsDefault);
-ABSL_CONST_INIT std::atomic<bool> cord_btree_exhaustive_validation(false);
+Y_ABSL_CONST_INIT std::atomic<bool> cord_btree_exhaustive_validation(false);
 
 void CordRep::Destroy(CordRep* rep) {
   assert(rep != nullptr);
@@ -85,5 +85,5 @@ void CordRep::Destroy(CordRep* rep) {
 }
 
 }  // namespace cord_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_internal.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_internal.h
index 82f5ac7b81..80d02395f8 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_internal.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_internal.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_INTERNAL_CORD_INTERNAL_H_
-#define ABSL_STRINGS_INTERNAL_CORD_INTERNAL_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_CORD_INTERNAL_H_
+#define Y_ABSL_STRINGS_INTERNAL_CORD_INTERNAL_H_
 
 #include <atomic>
 #include <cassert>
@@ -30,7 +30,7 @@
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace cord_internal {
 
 class CordzInfo;
@@ -366,7 +366,7 @@ inline void CordRepExternal::Delete(CordRep* rep) {
 
 template <typename Str>
 struct ConstInitExternalStorage {
-  ABSL_CONST_INIT static CordRepExternal value;
+  Y_ABSL_CONST_INIT static CordRepExternal value;
 };
 
 template <typename Str>
@@ -395,7 +395,7 @@ static_assert(sizeof(cordz_info_t) >= sizeof(intptr_t), "");
 // endian value where the last byte in the host's representation holds 'value`,
 // with all other bytes being 0.
 static constexpr cordz_info_t BigEndianByte(unsigned char value) {
-#if defined(ABSL_IS_BIG_ENDIAN)
+#if defined(Y_ABSL_IS_BIG_ENDIAN)
   return value;
 #else
   return static_cast<cordz_info_t>(value) << ((sizeof(cordz_info_t) - 1) * 8);
@@ -534,7 +534,7 @@ class InlineData {
   // Requires `size` to be <= kMaxInline.
   // See the documentation on 'as_chars()' for more information and examples.
   void set_inline_size(size_t size) {
-    ABSL_ASSERT(size <= kMaxInline);
+    Y_ABSL_ASSERT(size <= kMaxInline);
     tag() = static_cast<char>(size << 1);
   }
 
@@ -608,13 +608,13 @@ inline void CordRep::Unref(CordRep* rep) {
   assert(rep != nullptr);
   // Expect refcount to be 0. Avoiding the cost of an atomic decrement should
   // typically outweigh the cost of an extra branch checking for ref == 1.
-  if (ABSL_PREDICT_FALSE(!rep->refcount.DecrementExpectHighRefcount())) {
+  if (Y_ABSL_PREDICT_FALSE(!rep->refcount.DecrementExpectHighRefcount())) {
     Destroy(rep);
   }
 }
 
 }  // namespace cord_internal
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
-#endif  // ABSL_STRINGS_INTERNAL_CORD_INTERNAL_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_CORD_INTERNAL_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_btree.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_btree.cc
index 93121c9958..5dcdab9cc5 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_btree.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_btree.cc
@@ -29,7 +29,7 @@
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace cord_internal {
 
 constexpr size_t CordRepBtree::kMaxCapacity;  // NOLINT: needed for c++ < c++17
@@ -262,19 +262,19 @@ struct StackOperations {
       case CordRepBtree::kPopped:
         tree = edge_type == kBack ? CordRepBtree::New(tree, result.tree)
                                   : CordRepBtree::New(result.tree, tree);
-        if (ABSL_PREDICT_FALSE(tree->height() > CordRepBtree::kMaxHeight)) {
+        if (Y_ABSL_PREDICT_FALSE(tree->height() > CordRepBtree::kMaxHeight)) {
           tree = CordRepBtree::Rebuild(tree);
-          ABSL_RAW_CHECK(tree->height() <= CordRepBtree::kMaxHeight,
+          Y_ABSL_RAW_CHECK(tree->height() <= CordRepBtree::kMaxHeight,
                          "Max height exceeded");
         }
         return tree;
       case CordRepBtree::kCopied:
         CordRep::Unref(tree);
-        ABSL_FALLTHROUGH_INTENDED;
+        Y_ABSL_FALLTHROUGH_INTENDED;
       case CordRepBtree::kSelf:
         return result.tree;
     }
-    ABSL_INTERNAL_UNREACHABLE;
+    Y_ABSL_INTERNAL_UNREACHABLE;
     return result.tree;
   }
 
@@ -390,12 +390,12 @@ void CordRepBtree::DestroyNonLeaf(CordRepBtree* tree, size_t begin,
 bool CordRepBtree::IsValid(const CordRepBtree* tree, bool shallow) {
 #define NODE_CHECK_VALID(x)                                           \
   if (!(x)) {                                                         \
-    ABSL_RAW_LOG(ERROR, "CordRepBtree::CheckValid() FAILED: %s", #x); \
+    Y_ABSL_RAW_LOG(ERROR, "CordRepBtree::CheckValid() FAILED: %s", #x); \
     return false;                                                     \
   }
 #define NODE_CHECK_EQ(x, y)                                                    \
   if ((x) != (y)) {                                                            \
-    ABSL_RAW_LOG(ERROR,                                                        \
+    Y_ABSL_RAW_LOG(ERROR,                                                        \
                  "CordRepBtree::CheckValid() FAILED: %s != %s (%s vs %s)", #x, \
                  #y, y_absl::StrCat(x).c_str(), y_absl::StrCat(y).c_str());        \
     return false;                                                              \
@@ -435,7 +435,7 @@ bool CordRepBtree::IsValid(const CordRepBtree* tree, bool shallow) {
 CordRepBtree* CordRepBtree::AssertValid(CordRepBtree* tree, bool shallow) {
   if (!IsValid(tree, shallow)) {
     Dump(tree, "CordRepBtree validation failed:", false, std::cout);
-    ABSL_RAW_LOG(FATAL, "CordRepBtree::CheckValid() FAILED");
+    Y_ABSL_RAW_LOG(FATAL, "CordRepBtree::CheckValid() FAILED");
   }
   return tree;
 }
@@ -444,7 +444,7 @@ const CordRepBtree* CordRepBtree::AssertValid(const CordRepBtree* tree,
                                               bool shallow) {
   if (!IsValid(tree, shallow)) {
     Dump(tree, "CordRepBtree validation failed:", false, std::cout);
-    ABSL_RAW_LOG(FATAL, "CordRepBtree::CheckValid() FAILED");
+    Y_ABSL_RAW_LOG(FATAL, "CordRepBtree::CheckValid() FAILED");
   }
   return tree;
 }
@@ -568,7 +568,7 @@ y_absl::string_view CordRepBtree::AddData<kFront>(y_absl::string_view data,
 template <EdgeType edge_type>
 CordRepBtree* CordRepBtree::AddData(CordRepBtree* tree, y_absl::string_view data,
                                     size_t extra) {
-  if (ABSL_PREDICT_FALSE(data.empty())) return tree;
+  if (Y_ABSL_PREDICT_FALSE(data.empty())) return tree;
 
   const size_t original_data_size = data.size();
   int depth = tree->height();
@@ -803,10 +803,10 @@ CordRep* CordRepBtree::RemoveSuffix(CordRepBtree* tree, size_t n) {
   assert(tree != nullptr);
   assert(n <= tree->length);
   const size_t len = tree->length;
-  if (ABSL_PREDICT_FALSE(n == 0)) {
+  if (Y_ABSL_PREDICT_FALSE(n == 0)) {
     return tree;
   }
-  if (ABSL_PREDICT_FALSE(n >= len)) {
+  if (Y_ABSL_PREDICT_FALSE(n >= len)) {
     CordRepBtree::Unref(tree);
     return nullptr;
   }
@@ -865,7 +865,7 @@ CordRep* CordRepBtree::RemoveSuffix(CordRepBtree* tree, size_t n) {
 CordRep* CordRepBtree::SubTree(size_t offset, size_t n) {
   assert(n <= this->length);
   assert(offset <= this->length - n);
-  if (ABSL_PREDICT_FALSE(n == 0)) return nullptr;
+  if (Y_ABSL_PREDICT_FALSE(n == 0)) return nullptr;
 
   CordRepBtree* node = this;
   int height = node->height();
@@ -942,7 +942,7 @@ bool CordRepBtree::IsFlat(size_t offset, const size_t n,
                           y_absl::string_view* fragment) const {
   assert(n <= this->length);
   assert(offset <= this->length - n);
-  if (ABSL_PREDICT_FALSE(n == 0)) return false;
+  if (Y_ABSL_PREDICT_FALSE(n == 0)) return false;
   int height = this->height();
   const CordRepBtree* node = this;
   for (;;) {
@@ -1022,7 +1022,7 @@ CordRepBtree* CordRepBtree::CreateSlow(CordRep* rep) {
 }
 
 CordRepBtree* CordRepBtree::AppendSlow(CordRepBtree* tree, CordRep* rep) {
-  if (ABSL_PREDICT_TRUE(rep->IsBtree())) {
+  if (Y_ABSL_PREDICT_TRUE(rep->IsBtree())) {
     return MergeTrees(tree, rep->btree());
   }
   auto consume = [&tree](CordRep* r, size_t offset, size_t length) {
@@ -1034,7 +1034,7 @@ CordRepBtree* CordRepBtree::AppendSlow(CordRepBtree* tree, CordRep* rep) {
 }
 
 CordRepBtree* CordRepBtree::PrependSlow(CordRepBtree* tree, CordRep* rep) {
-  if (ABSL_PREDICT_TRUE(rep->IsBtree())) {
+  if (Y_ABSL_PREDICT_TRUE(rep->IsBtree())) {
     return MergeTrees(rep->btree(), tree);
   }
   auto consume = [&tree](CordRep* r, size_t offset, size_t length) {
@@ -1124,5 +1124,5 @@ CordRepBtree* CordRepBtree::Rebuild(CordRepBtree* tree) {
 }
 
 }  // namespace cord_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_btree.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_btree.h
index 3ad8097cc8..8c78892520 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_btree.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_btree.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_H_
-#define ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_H_
+#define Y_ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_H_
 
 #include <cassert>
 #include <cstdint>
@@ -28,7 +28,7 @@
 #include "y_absl/types/span.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace cord_internal {
 
 class CordRepBtreeNavigator;
@@ -674,7 +674,7 @@ inline void CordRepBtree::Destroy(CordRepBtree* tree) {
 
 inline void CordRepBtree::Unref(y_absl::Span<CordRep* const> edges) {
   for (CordRep* edge : edges) {
-    if (ABSL_PREDICT_FALSE(!edge->refcount.Decrement())) {
+    if (Y_ABSL_PREDICT_FALSE(!edge->refcount.Decrement())) {
       CordRep::Destroy(edge);
     }
   }
@@ -722,7 +722,7 @@ inline void CordRepBtree::AlignBegin() {
   // effects, making the compiler emit register save/store/spills, and minimize
   // the size of code.
   const size_t delta = begin();
-  if (ABSL_PREDICT_FALSE(delta != 0)) {
+  if (Y_ABSL_PREDICT_FALSE(delta != 0)) {
     const size_t new_end = end() - delta;
     set_begin(0);
     set_end(new_end);
@@ -731,7 +731,7 @@ inline void CordRepBtree::AlignBegin() {
     // size, and then do overlapping load/store of up to 4 pointers (inlined as
     // XMM, YMM or ZMM load/store) and up to 2 pointers (XMM / YMM), which is a)
     // compact and b) not clobbering any registers.
-    ABSL_INTERNAL_ASSUME(new_end <= kMaxCapacity);
+    Y_ABSL_INTERNAL_ASSUME(new_end <= kMaxCapacity);
 #ifdef __clang__
 #pragma unroll 1
 #endif
@@ -749,7 +749,7 @@ inline void CordRepBtree::AlignEnd() {
     const size_t new_end = end() + delta;
     set_begin(new_begin);
     set_end(new_end);
-    ABSL_INTERNAL_ASSUME(new_end <= kMaxCapacity);
+    Y_ABSL_INTERNAL_ASSUME(new_end <= kMaxCapacity);
 #ifdef __clang__
 #pragma unroll 1
 #endif
@@ -860,16 +860,16 @@ inline Span<char> CordRepBtree::GetAppendBuffer(size_t size) {
       tree = tree->Edge(kBack)->btree();
       if (!tree->refcount.IsMutable()) return {};
       n2 = tree;
-      ABSL_FALLTHROUGH_INTENDED;
+      Y_ABSL_FALLTHROUGH_INTENDED;
     case 2:
       tree = tree->Edge(kBack)->btree();
       if (!tree->refcount.IsMutable()) return {};
       n1 = tree;
-      ABSL_FALLTHROUGH_INTENDED;
+      Y_ABSL_FALLTHROUGH_INTENDED;
     case 1:
       tree = tree->Edge(kBack)->btree();
       if (!tree->refcount.IsMutable()) return {};
-      ABSL_FALLTHROUGH_INTENDED;
+      Y_ABSL_FALLTHROUGH_INTENDED;
     case 0:
       CordRep* edge = tree->Edge(kBack);
       if (!edge->refcount.IsMutable()) return {};
@@ -882,13 +882,13 @@ inline Span<char> CordRepBtree::GetAppendBuffer(size_t size) {
       switch (height) {
         case 3:
           n3->length += delta;
-          ABSL_FALLTHROUGH_INTENDED;
+          Y_ABSL_FALLTHROUGH_INTENDED;
         case 2:
           n2->length += delta;
-          ABSL_FALLTHROUGH_INTENDED;
+          Y_ABSL_FALLTHROUGH_INTENDED;
         case 1:
           n1->length += delta;
-          ABSL_FALLTHROUGH_INTENDED;
+          Y_ABSL_FALLTHROUGH_INTENDED;
         case 0:
           tree->length += delta;
           return span;
@@ -905,14 +905,14 @@ extern template CordRepBtree* CordRepBtree::AddCordRep<CordRepBtree::kFront>(
     CordRepBtree* tree, CordRep* rep);
 
 inline CordRepBtree* CordRepBtree::Append(CordRepBtree* tree, CordRep* rep) {
-  if (ABSL_PREDICT_TRUE(IsDataEdge(rep))) {
+  if (Y_ABSL_PREDICT_TRUE(IsDataEdge(rep))) {
     return CordRepBtree::AddCordRep<kBack>(tree, rep);
   }
   return AppendSlow(tree, rep);
 }
 
 inline CordRepBtree* CordRepBtree::Prepend(CordRepBtree* tree, CordRep* rep) {
-  if (ABSL_PREDICT_TRUE(IsDataEdge(rep))) {
+  if (Y_ABSL_PREDICT_TRUE(IsDataEdge(rep))) {
     return CordRepBtree::AddCordRep<kFront>(tree, rep);
   }
   return PrependSlow(tree, rep);
@@ -933,7 +933,7 @@ inline const CordRepBtree* CordRepBtree::AssertValid(const CordRepBtree* tree,
 #endif
 
 }  // namespace cord_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_btree_navigator.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_btree_navigator.cc
index 6dae7bcd3e..a94d4e0ae6 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_btree_navigator.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_btree_navigator.cc
@@ -20,7 +20,7 @@
 #include "y_absl/strings/internal/cord_rep_btree.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace cord_internal {
 
 using ReadResult = CordRepBtreeNavigator::ReadResult;
@@ -181,5 +181,5 @@ ReadResult CordRepBtreeNavigator::Read(size_t edge_offset, size_t n) {
 }
 
 }  // namespace cord_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_btree_navigator.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_btree_navigator.h
index 40c58e3b3c..f4c09864e0 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_btree_navigator.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_btree_navigator.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_NAVIGATOR_H_
-#define ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_NAVIGATOR_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_NAVIGATOR_H_
+#define Y_ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_NAVIGATOR_H_
 
 #include <cassert>
 #include <iostream>
@@ -22,7 +22,7 @@
 #include "y_absl/strings/internal/cord_rep_btree.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace cord_internal {
 
 // CordRepBtreeNavigator is a bi-directional navigator allowing callers to
@@ -191,7 +191,7 @@ inline CordRepBtreeNavigator::Position CordRepBtreeNavigator::Seek(
   assert(btree() != nullptr);
   int height = height_;
   CordRepBtree* edge = node_[height];
-  if (ABSL_PREDICT_FALSE(offset >= edge->length)) return {nullptr, 0};
+  if (Y_ABSL_PREDICT_FALSE(offset >= edge->length)) return {nullptr, 0};
   CordRepBtree::Position index = edge->IndexOf(offset);
   index_[height] = static_cast<uint8_t>(index.index);
   while (--height >= 0) {
@@ -206,7 +206,7 @@ inline CordRepBtreeNavigator::Position CordRepBtreeNavigator::Seek(
 inline CordRepBtreeNavigator::Position CordRepBtreeNavigator::InitOffset(
     CordRepBtree* tree, size_t offset) {
   assert(tree != nullptr);
-  if (ABSL_PREDICT_FALSE(offset >= tree->length)) return {nullptr, 0};
+  if (Y_ABSL_PREDICT_FALSE(offset >= tree->length)) return {nullptr, 0};
   height_ = tree->height();
   node_[height_] = tree;
   return Seek(offset);
@@ -259,7 +259,7 @@ inline CordRep* CordRepBtreeNavigator::PreviousUp() {
 }
 
 }  // namespace cord_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_NAVIGATOR_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_NAVIGATOR_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_btree_reader.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_btree_reader.cc
index 0bc9dba2e6..53010139e2 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_btree_reader.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_btree_reader.cc
@@ -23,7 +23,7 @@
 #include "y_absl/strings/internal/cord_rep_flat.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace cord_internal {
 
 y_absl::string_view CordRepBtreeReader::Read(size_t n, size_t chunk_size,
@@ -64,5 +64,5 @@ y_absl::string_view CordRepBtreeReader::Read(size_t n, size_t chunk_size,
 }
 
 }  // namespace cord_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_btree_reader.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_btree_reader.h
index 00b2261f71..d5473df29d 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_btree_reader.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_btree_reader.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_READER_H_
-#define ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_READER_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_READER_H_
+#define Y_ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_READER_H_
 
 #include <cassert>
 
@@ -24,7 +24,7 @@
 #include "y_absl/strings/internal/cord_rep_flat.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace cord_internal {
 
 // CordRepBtreeReader implements logic to iterate over cord btrees.
@@ -183,7 +183,7 @@ inline y_absl::string_view CordRepBtreeReader::Skip(size_t skip) {
   // need to skip the current edge as well as `skip`.
   const size_t edge_length = navigator_.Current()->length;
   CordRepBtreeNavigator::Position pos = navigator_.Skip(skip + edge_length);
-  if (ABSL_PREDICT_FALSE(pos.edge == nullptr)) {
+  if (Y_ABSL_PREDICT_FALSE(pos.edge == nullptr)) {
     remaining_ = 0;
     return {};
   }
@@ -195,7 +195,7 @@ inline y_absl::string_view CordRepBtreeReader::Skip(size_t skip) {
 
 inline y_absl::string_view CordRepBtreeReader::Seek(size_t offset) {
   const CordRepBtreeNavigator::Position pos = navigator_.Seek(offset);
-  if (ABSL_PREDICT_FALSE(pos.edge == nullptr)) {
+  if (Y_ABSL_PREDICT_FALSE(pos.edge == nullptr)) {
     remaining_ = 0;
     return {};
   }
@@ -205,7 +205,7 @@ inline y_absl::string_view CordRepBtreeReader::Seek(size_t offset) {
 }
 
 }  // namespace cord_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_READER_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_CORD_REP_BTREE_READER_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_consume.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_consume.cc
index ffc0179e52..02a142d70a 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_consume.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_consume.cc
@@ -22,7 +22,7 @@
 #include "y_absl/strings/internal/cord_internal.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace cord_internal {
 
 namespace {
@@ -125,5 +125,5 @@ void ReverseConsume(CordRep* rep, ConsumeFn consume_fn) {
 }
 
 }  // namespace cord_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_consume.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_consume.h
index 7f6e5584f4..6e2b887a42 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_consume.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_consume.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_CONSUME_H_
-#define ABSL_STRINGS_INTERNAL_CORD_REP_CONSUME_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_CORD_REP_CONSUME_H_
+#define Y_ABSL_STRINGS_INTERNAL_CORD_REP_CONSUME_H_
 
 #include <functional>
 
@@ -21,7 +21,7 @@
 #include "y_absl/strings/internal/cord_internal.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace cord_internal {
 
 // Functor for the Consume() and ReverseConsume() functions:
@@ -44,7 +44,7 @@ void Consume(CordRep* rep, ConsumeFn consume_fn);
 void ReverseConsume(CordRep* rep, ConsumeFn consume_fn);
 
 }  // namespace cord_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_INTERNAL_CORD_REP_CONSUME_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_CORD_REP_CONSUME_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_flat.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_flat.h
index 976613031c..bcd5bf428e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_flat.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_flat.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_FLAT_H_
-#define ABSL_STRINGS_INTERNAL_CORD_REP_FLAT_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_CORD_REP_FLAT_H_
+#define Y_ABSL_STRINGS_INTERNAL_CORD_REP_FLAT_H_
 
 #include <cassert>
 #include <cstddef>
@@ -23,7 +23,7 @@
 #include "y_absl/strings/internal/cord_internal.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace cord_internal {
 
 // Note: all constants below are never ODR used and internal to cord, we define
@@ -140,7 +140,7 @@ inline const CordRepFlat* CordRep::flat() const {
 }
 
 }  // namespace cord_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_INTERNAL_CORD_REP_FLAT_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_CORD_REP_FLAT_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_ring.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_ring.cc
index 06c7e75bd8..d961db7192 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_ring.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_ring.cc
@@ -30,7 +30,7 @@
 #include "y_absl/strings/internal/cord_rep_flat.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace cord_internal {
 
 namespace {
@@ -45,7 +45,7 @@ inline bool IsFlatOrExternal(CordRep* rep) {
 
 // Verifies that n + extra <= kMaxCapacity: throws std::length_error otherwise.
 inline void CheckCapacity(size_t n, size_t extra) {
-  if (ABSL_PREDICT_FALSE(extra > CordRepRing::kMaxCapacity - n)) {
+  if (Y_ABSL_PREDICT_FALSE(extra > CordRepRing::kMaxCapacity - n)) {
     base_internal::ThrowStdLengthError("Maximum capacity exceeded");
   }
 }
@@ -594,7 +594,7 @@ CordRepRing::index_type CordRepRing::FindBinary(index_type head,
     head = larger ? after_mid : head;
     tail = larger ? tail : mid;
     assert(head != tail);
-  } while (ABSL_PREDICT_TRUE(count > kBinarySearchEndCount));
+  } while (Y_ABSL_PREDICT_TRUE(count > kBinarySearchEndCount));
   return head;
 }
 
@@ -767,5 +767,5 @@ CordRepRing* CordRepRing::RemoveSuffix(CordRepRing* rep, size_t len,
 }
 
 }  // namespace cord_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_ring.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_ring.h
index 5f9784d8da..b4bee354d8 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_ring.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_ring.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_RING_H_
-#define ABSL_STRINGS_INTERNAL_CORD_REP_RING_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_CORD_REP_RING_H_
+#define Y_ABSL_STRINGS_INTERNAL_CORD_REP_RING_H_
 
 #include <cassert>
 #include <cstddef>
@@ -27,7 +27,7 @@
 #include "y_absl/strings/internal/cord_rep_flat.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace cord_internal {
 
 // All operations modifying a ring buffer are implemented as static methods
@@ -601,7 +601,7 @@ inline bool CordRepRing::IsFlat(size_t offset, size_t len,
 std::ostream& operator<<(std::ostream& s, const CordRepRing& rep);
 
 }  // namespace cord_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_INTERNAL_CORD_REP_RING_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_CORD_REP_RING_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_ring_reader.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_ring_reader.h
index 3f64d04fae..52bceeb78d 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_ring_reader.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_ring_reader.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_RING_READER_H_
-#define ABSL_STRINGS_INTERNAL_CORD_REP_RING_READER_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_CORD_REP_RING_READER_H_
+#define Y_ABSL_STRINGS_INTERNAL_CORD_REP_RING_READER_H_
 
 #include <cassert>
 #include <cstddef>
@@ -24,7 +24,7 @@
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace cord_internal {
 
 // CordRepRingReader provides basic navigation over CordRepRing data.
@@ -112,7 +112,7 @@ class CordRepRingReader {
 };
 
 }  // namespace cord_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_INTERNAL_CORD_REP_RING_READER_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_CORD_REP_RING_READER_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_test_util.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_test_util.h
index 98dcc0d649..a92294e233 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_test_util.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_rep_test_util.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_TEST_UTIL_H_
-#define ABSL_STRINGS_INTERNAL_CORD_REP_TEST_UTIL_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_CORD_REP_TEST_UTIL_H_
+#define Y_ABSL_STRINGS_INTERNAL_CORD_REP_TEST_UTIL_H_
 
 #include <cassert>
 #include <memory>
@@ -29,7 +29,7 @@
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace cordrep_testing {
 
 inline cord_internal::CordRepSubstring* MakeSubstring(
@@ -166,7 +166,7 @@ inline void CordToString(cord_internal::CordRep* rep, TString& s) {
   } else if (rep->tag == cord_internal::EXTERNAL) {
     s.append(rep->external()->base + offset, length);
   } else {
-    ABSL_RAW_LOG(FATAL, "Unsupported tag %d", rep->tag);
+    Y_ABSL_RAW_LOG(FATAL, "Unsupported tag %d", rep->tag);
   }
 }
 
@@ -214,7 +214,7 @@ class AutoUnref {
 };
 
 }  // namespace cordrep_testing
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_INTERNAL_CORD_REP_TEST_UTIL_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_CORD_REP_TEST_UTIL_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_functions.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_functions.cc
index e9936f22fe..e6038c9b30 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_functions.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_functions.cc
@@ -25,7 +25,7 @@
 #include "y_absl/profiling/internal/exponential_biased.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace cord_internal {
 namespace {
 
@@ -35,18 +35,18 @@ std::atomic<int> g_cordz_mean_interval(50000);
 
 }  // namespace
 
-#ifdef ABSL_INTERNAL_CORDZ_ENABLED
+#ifdef Y_ABSL_INTERNAL_CORDZ_ENABLED
 
 // Special negative 'not initialized' per thread value for cordz_next_sample.
 static constexpr int64_t kInitCordzNextSample = -1;
 
-ABSL_CONST_INIT thread_local int64_t cordz_next_sample = kInitCordzNextSample;
+Y_ABSL_CONST_INIT thread_local int64_t cordz_next_sample = kInitCordzNextSample;
 
 // kIntervalIfDisabled is the number of profile-eligible events need to occur
 // before the code will confirm that cordz is still disabled.
 constexpr int64_t kIntervalIfDisabled = 1 << 16;
 
-ABSL_ATTRIBUTE_NOINLINE bool cordz_should_profile_slow() {
+Y_ABSL_ATTRIBUTE_NOINLINE bool cordz_should_profile_slow() {
 
   thread_local y_absl::profiling_internal::ExponentialBiased
       exponential_biased_generator;
@@ -81,7 +81,7 @@ void cordz_set_next_sample_for_testing(int64_t next_sample) {
   cordz_next_sample = next_sample;
 }
 
-#endif  // ABSL_INTERNAL_CORDZ_ENABLED
+#endif  // Y_ABSL_INTERNAL_CORDZ_ENABLED
 
 int32_t get_cordz_mean_interval() {
   return g_cordz_mean_interval.load(std::memory_order_acquire);
@@ -92,5 +92,5 @@ void set_cordz_mean_interval(int32_t mean_interval) {
 }
 
 }  // namespace cord_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_functions.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_functions.h
index 802efaa976..a43850aba9 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_functions.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_functions.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_CORDZ_FUNCTIONS_H_
-#define ABSL_STRINGS_CORDZ_FUNCTIONS_H_
+#ifndef Y_ABSL_STRINGS_CORDZ_FUNCTIONS_H_
+#define Y_ABSL_STRINGS_CORDZ_FUNCTIONS_H_
 
 #include <stdint.h>
 
@@ -22,7 +22,7 @@
 #include "y_absl/base/optimization.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace cord_internal {
 
 // Returns the current sample rate. This represents the average interval
@@ -41,19 +41,19 @@ void set_cordz_mean_interval(int32_t mean_interval);
 // Hashtablez is turned off completely in opensource builds.
 // MSVC's static atomics are dynamically initialized in debug mode, which breaks
 // sampling.
-#if defined(ABSL_HAVE_THREAD_LOCAL) && !defined(_MSC_VER)  && \
-    !defined(ABSL_BUILD_DLL) && !defined(ABSL_CONSUME_DLL) && \
+#if defined(Y_ABSL_HAVE_THREAD_LOCAL) && !defined(_MSC_VER)  && \
+    !defined(Y_ABSL_BUILD_DLL) && !defined(Y_ABSL_CONSUME_DLL) && \
     !defined(__ANDROID__) && !defined(__APPLE__)
-#define ABSL_INTERNAL_CORDZ_ENABLED 1
+#define Y_ABSL_INTERNAL_CORDZ_ENABLED 1
 #endif
 
-#ifdef ABSL_INTERNAL_CORDZ_ENABLED
+#ifdef Y_ABSL_INTERNAL_CORDZ_ENABLED
 
 // cordz_next_sample is the number of events until the next sample event. If
 // the value is 1 or less, the code will check on the next event if cordz is
 // enabled, and if so, will sample the Cord. cordz is only enabled when we can
 // use thread locals.
-ABSL_CONST_INIT extern thread_local int64_t cordz_next_sample;
+Y_ABSL_CONST_INIT extern thread_local int64_t cordz_next_sample;
 
 // Determines if the next sample should be profiled. If it is, the value pointed
 // at by next_sample will be set with the interval until the next sample.
@@ -61,7 +61,7 @@ bool cordz_should_profile_slow();
 
 // Returns true if the next cord should be sampled.
 inline bool cordz_should_profile() {
-  if (ABSL_PREDICT_TRUE(cordz_next_sample > 1)) {
+  if (Y_ABSL_PREDICT_TRUE(cordz_next_sample > 1)) {
     cordz_next_sample--;
     return false;
   }
@@ -71,15 +71,15 @@ inline bool cordz_should_profile() {
 // Sets the interval until the next sample (for testing only)
 void cordz_set_next_sample_for_testing(int64_t next_sample);
 
-#else  // ABSL_INTERNAL_CORDZ_ENABLED
+#else  // Y_ABSL_INTERNAL_CORDZ_ENABLED
 
 inline bool cordz_should_profile() { return false; }
 inline void cordz_set_next_sample_for_testing(int64_t) {}
 
-#endif  // ABSL_INTERNAL_CORDZ_ENABLED
+#endif  // Y_ABSL_INTERNAL_CORDZ_ENABLED
 
 }  // namespace cord_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_CORDZ_FUNCTIONS_H_
+#endif  // Y_ABSL_STRINGS_CORDZ_FUNCTIONS_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_handle.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_handle.cc
index 707c6d2a9b..56988f42bb 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_handle.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_handle.cc
@@ -15,16 +15,16 @@
 
 #include <atomic>
 
-#include "y_absl/base/internal/raw_logging.h"  // For ABSL_RAW_CHECK
+#include "y_absl/base/internal/raw_logging.h"  // For Y_ABSL_RAW_CHECK
 #include "y_absl/base/internal/spinlock.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace cord_internal {
 
 using ::y_absl::base_internal::SpinLockHolder;
 
-ABSL_CONST_INIT CordzHandle::Queue CordzHandle::global_queue_(y_absl::kConstInit);
+Y_ABSL_CONST_INIT CordzHandle::Queue CordzHandle::global_queue_(y_absl::kConstInit);
 
 CordzHandle::CordzHandle(bool is_snapshot) : is_snapshot_(is_snapshot) {
   if (is_snapshot) {
@@ -113,7 +113,7 @@ bool CordzHandle::DiagnosticsHandleIsSafeToInspect(
     if (p == handle) return !snapshot_found;
     if (p == this) snapshot_found = true;
   }
-  ABSL_ASSERT(snapshot_found);  // Assert that 'this' is in delete queue.
+  Y_ABSL_ASSERT(snapshot_found);  // Assert that 'this' is in delete queue.
   return true;
 }
 
@@ -135,5 +135,5 @@ CordzHandle::DiagnosticsGetSafeToInspectDeletedHandles() {
 }
 
 }  // namespace cord_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_handle.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_handle.h
index f181bc7d6b..5ab0cee569 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_handle.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_handle.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_CORDZ_HANDLE_H_
-#define ABSL_STRINGS_CORDZ_HANDLE_H_
+#ifndef Y_ABSL_STRINGS_CORDZ_HANDLE_H_
+#define Y_ABSL_STRINGS_CORDZ_HANDLE_H_
 
 #include <atomic>
 #include <vector>
@@ -24,7 +24,7 @@
 #include "y_absl/synchronization/mutex.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace cord_internal {
 
 // This base class allows multiple types of object (CordzInfo and
@@ -87,7 +87,7 @@ class CordzHandle {
                 y_absl::base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL) {}
 
     y_absl::base_internal::SpinLock mutex;
-    std::atomic<CordzHandle*> dq_tail ABSL_GUARDED_BY(mutex){nullptr};
+    std::atomic<CordzHandle*> dq_tail Y_ABSL_GUARDED_BY(mutex){nullptr};
 
     // Returns true if this delete queue is empty. This method does not acquire
     // the lock, but does a 'load acquire' observation on the delete queue tail.
@@ -97,18 +97,18 @@ class CordzHandle {
     // 'being constructed' snapshot instance. Practically, this means that any
     // such discovery (`find`, 'first' or 'next', etc) must have proper 'happens
     // before / after' semantics and atomic fences.
-    bool IsEmpty() const ABSL_NO_THREAD_SAFETY_ANALYSIS {
+    bool IsEmpty() const Y_ABSL_NO_THREAD_SAFETY_ANALYSIS {
       return dq_tail.load(std::memory_order_acquire) == nullptr;
     }
   };
 
   void ODRCheck() const {
 #ifndef NDEBUG
-    ABSL_RAW_CHECK(queue_ == &global_queue_, "ODR violation in Cord");
+    Y_ABSL_RAW_CHECK(queue_ == &global_queue_, "ODR violation in Cord");
 #endif
   }
 
-  ABSL_CONST_INIT static Queue global_queue_;
+  Y_ABSL_CONST_INIT static Queue global_queue_;
   Queue* const queue_ = &global_queue_;
   const bool is_snapshot_;
 
@@ -125,7 +125,7 @@ class CordzSnapshot : public CordzHandle {
 };
 
 }  // namespace cord_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_CORDZ_HANDLE_H_
+#endif  // Y_ABSL_STRINGS_CORDZ_HANDLE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_info.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_info.cc
index e3849a0b49..ae35341f2a 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_info.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_info.cc
@@ -28,14 +28,14 @@
 #include "y_absl/types/span.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace cord_internal {
 
 using ::y_absl::base_internal::SpinLockHolder;
 
 constexpr int CordzInfo::kMaxStackDepth;
 
-ABSL_CONST_INIT CordzInfo::List CordzInfo::global_list_{y_absl::kConstInit};
+Y_ABSL_CONST_INIT CordzInfo::List CordzInfo::global_list_{y_absl::kConstInit};
 
 namespace {
 
@@ -255,7 +255,7 @@ class CordRepAnalyzer {
 }  // namespace
 
 CordzInfo* CordzInfo::Head(const CordzSnapshot& snapshot) {
-  ABSL_ASSERT(snapshot.is_snapshot());
+  Y_ABSL_ASSERT(snapshot.is_snapshot());
 
   // We can do an 'unsafe' load of 'head', as we are guaranteed that the
   // instance it points to is kept alive by the provided CordzSnapshot, so we
@@ -264,17 +264,17 @@ CordzInfo* CordzInfo::Head(const CordzSnapshot& snapshot) {
   // delete queue: ODR violations may lead to 'snapshot' and 'global_list_'
   // being in different libraries / modules.
   CordzInfo* head = global_list_.head.load(std::memory_order_acquire);
-  ABSL_ASSERT(snapshot.DiagnosticsHandleIsSafeToInspect(head));
+  Y_ABSL_ASSERT(snapshot.DiagnosticsHandleIsSafeToInspect(head));
   return head;
 }
 
 CordzInfo* CordzInfo::Next(const CordzSnapshot& snapshot) const {
-  ABSL_ASSERT(snapshot.is_snapshot());
+  Y_ABSL_ASSERT(snapshot.is_snapshot());
 
   // Similar to the 'Head()' function, we do not need a mutex here.
   CordzInfo* next = ci_next_.load(std::memory_order_acquire);
-  ABSL_ASSERT(snapshot.DiagnosticsHandleIsSafeToInspect(this));
-  ABSL_ASSERT(snapshot.DiagnosticsHandleIsSafeToInspect(next));
+  Y_ABSL_ASSERT(snapshot.DiagnosticsHandleIsSafeToInspect(this));
+  Y_ABSL_ASSERT(snapshot.DiagnosticsHandleIsSafeToInspect(next));
   return next;
 }
 
@@ -348,7 +348,7 @@ CordzInfo::CordzInfo(CordRep* rep, const CordzInfo* src,
 CordzInfo::~CordzInfo() {
   // `rep_` is potentially kept alive if CordzInfo is included
   // in a collection snapshot (which should be rare).
-  if (ABSL_PREDICT_FALSE(rep_)) {
+  if (Y_ABSL_PREDICT_FALSE(rep_)) {
     CordRep::Unref(rep_);
   }
 }
@@ -374,15 +374,15 @@ void CordzInfo::Untrack() {
     CordzInfo* const prev = ci_prev_.load(std::memory_order_acquire);
 
     if (next) {
-      ABSL_ASSERT(next->ci_prev_.load(std::memory_order_acquire) == this);
+      Y_ABSL_ASSERT(next->ci_prev_.load(std::memory_order_acquire) == this);
       next->ci_prev_.store(prev, std::memory_order_release);
     }
     if (prev) {
-      ABSL_ASSERT(head != this);
-      ABSL_ASSERT(prev->ci_next_.load(std::memory_order_acquire) == this);
+      Y_ABSL_ASSERT(head != this);
+      Y_ABSL_ASSERT(prev->ci_next_.load(std::memory_order_acquire) == this);
       prev->ci_next_.store(next, std::memory_order_release);
     } else {
-      ABSL_ASSERT(head == this);
+      Y_ABSL_ASSERT(head == this);
       list_->head.store(next, std::memory_order_release);
     }
   }
@@ -404,13 +404,13 @@ void CordzInfo::Untrack() {
 }
 
 void CordzInfo::Lock(MethodIdentifier method)
-    ABSL_EXCLUSIVE_LOCK_FUNCTION(mutex_) {
+    Y_ABSL_EXCLUSIVE_LOCK_FUNCTION(mutex_) {
   mutex_.Lock();
   update_tracker_.LossyAdd(method);
   assert(rep_);
 }
 
-void CordzInfo::Unlock() ABSL_UNLOCK_FUNCTION(mutex_) {
+void CordzInfo::Unlock() Y_ABSL_UNLOCK_FUNCTION(mutex_) {
   bool tracked = rep_ != nullptr;
   mutex_.Unlock();
   if (!tracked) {
@@ -441,5 +441,5 @@ CordzStatistics CordzInfo::GetCordzStatistics() const {
 }
 
 }  // namespace cord_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_info.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_info.h
index e24214d259..fd89875933 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_info.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_info.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_CORDZ_INFO_H_
-#define ABSL_STRINGS_CORDZ_INFO_H_
+#ifndef Y_ABSL_STRINGS_CORDZ_INFO_H_
+#define Y_ABSL_STRINGS_CORDZ_INFO_H_
 
 #include <atomic>
 #include <cstdint>
@@ -32,7 +32,7 @@
 #include "y_absl/types/span.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace cord_internal {
 
 // CordzInfo tracks a profiled Cord. Each of these objects can be in two places.
@@ -44,7 +44,7 @@ namespace cord_internal {
 // and will either be deleted or appended to the global_delete_queue. If it is
 // placed on the global_delete_queue, the CordzInfo object will be cleaned in
 // the destructor of a CordzSampleToken object.
-class ABSL_LOCKABLE CordzInfo : public CordzHandle {
+class Y_ABSL_LOCKABLE CordzInfo : public CordzHandle {
  public:
   using MethodIdentifier = CordzUpdateTracker::MethodIdentifier;
 
@@ -121,45 +121,45 @@ class ABSL_LOCKABLE CordzInfo : public CordzHandle {
 
   // Retrieves the oldest existing CordzInfo.
   static CordzInfo* Head(const CordzSnapshot& snapshot)
-      ABSL_NO_THREAD_SAFETY_ANALYSIS;
+      Y_ABSL_NO_THREAD_SAFETY_ANALYSIS;
 
   // Retrieves the next oldest existing CordzInfo older than 'this' instance.
   CordzInfo* Next(const CordzSnapshot& snapshot) const
-      ABSL_NO_THREAD_SAFETY_ANALYSIS;
+      Y_ABSL_NO_THREAD_SAFETY_ANALYSIS;
 
   // Locks this instance for the update identified by `method`.
   // Increases the count for `method` in `update_tracker`.
-  void Lock(MethodIdentifier method) ABSL_EXCLUSIVE_LOCK_FUNCTION(mutex_);
+  void Lock(MethodIdentifier method) Y_ABSL_EXCLUSIVE_LOCK_FUNCTION(mutex_);
 
   // Unlocks this instance. If the contained `rep` has been set to null
   // indicating the Cord has been cleared or is otherwise no longer sampled,
   // then this method will delete this CordzInfo instance.
-  void Unlock() ABSL_UNLOCK_FUNCTION(mutex_);
+  void Unlock() Y_ABSL_UNLOCK_FUNCTION(mutex_);
 
   // Asserts that this CordzInfo instance is locked.
-  void AssertHeld() ABSL_ASSERT_EXCLUSIVE_LOCK(mutex_);
+  void AssertHeld() Y_ABSL_ASSERT_EXCLUSIVE_LOCK(mutex_);
 
   // Updates the `rep` property of this instance. This methods is invoked by
   // Cord logic each time the root node of a sampled Cord changes, and before
   // the old root reference count is deleted. This guarantees that collection
   // code can always safely take a reference on the tracked cord.
   // Requires a lock to be held through the `Lock()` method.
-  // TODO(b/117940323): annotate with ABSL_EXCLUSIVE_LOCKS_REQUIRED once all
+  // TODO(b/117940323): annotate with Y_ABSL_EXCLUSIVE_LOCKS_REQUIRED once all
   // Cord code is in a state where this can be proven true by the compiler.
   void SetCordRep(CordRep* rep);
 
   // Returns the current `rep` property of this instance with a reference
   // added, or null if this instance represents a cord that has since been
   // deleted or untracked.
-  CordRep* RefCordRep() const ABSL_LOCKS_EXCLUDED(mutex_);
+  CordRep* RefCordRep() const Y_ABSL_LOCKS_EXCLUDED(mutex_);
 
   // Returns the current value of `rep_` for testing purposes only.
-  CordRep* GetCordRepForTesting() const ABSL_NO_THREAD_SAFETY_ANALYSIS {
+  CordRep* GetCordRepForTesting() const Y_ABSL_NO_THREAD_SAFETY_ANALYSIS {
     return rep_;
   }
 
   // Sets the current value of `rep_` for testing purposes only.
-  void SetCordRepForTesting(CordRep* rep) ABSL_NO_THREAD_SAFETY_ANALYSIS {
+  void SetCordRepForTesting(CordRep* rep) Y_ABSL_NO_THREAD_SAFETY_ANALYSIS {
     rep_ = rep;
   }
 
@@ -193,7 +193,7 @@ class ABSL_LOCKABLE CordzInfo : public CordzHandle {
                 y_absl::base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL) {}
 
     SpinLock mutex;
-    std::atomic<CordzInfo*> head ABSL_GUARDED_BY(mutex){nullptr};
+    std::atomic<CordzInfo*> head Y_ABSL_GUARDED_BY(mutex){nullptr};
   };
 
   static constexpr int kMaxStackDepth = 64;
@@ -203,7 +203,7 @@ class ABSL_LOCKABLE CordzInfo : public CordzHandle {
   ~CordzInfo() override;
 
   // Sets `rep_` without holding a lock.
-  void UnsafeSetCordRep(CordRep* rep) ABSL_NO_THREAD_SAFETY_ANALYSIS;
+  void UnsafeSetCordRep(CordRep* rep) Y_ABSL_NO_THREAD_SAFETY_ANALYSIS;
 
   void Track();
 
@@ -220,7 +220,7 @@ class ABSL_LOCKABLE CordzInfo : public CordzHandle {
 
   void ODRCheck() const {
 #ifndef NDEBUG
-    ABSL_RAW_CHECK(list_ == &global_list_, "ODR violation in Cord");
+    Y_ABSL_RAW_CHECK(list_ == &global_list_, "ODR violation in Cord");
 #endif
   }
 
@@ -230,7 +230,7 @@ class ABSL_LOCKABLE CordzInfo : public CordzHandle {
   static void MaybeTrackCordImpl(InlineData& cord, const InlineData& src,
                                  MethodIdentifier method);
 
-  ABSL_CONST_INIT static List global_list_;
+  Y_ABSL_CONST_INIT static List global_list_;
   List* const list_ = &global_list_;
 
   // ci_prev_ and ci_next_ require the global list mutex to be held.
@@ -240,7 +240,7 @@ class ABSL_LOCKABLE CordzInfo : public CordzHandle {
   std::atomic<CordzInfo*> ci_next_{nullptr};
 
   mutable y_absl::Mutex mutex_;
-  CordRep* rep_ ABSL_GUARDED_BY(mutex_);
+  CordRep* rep_ Y_ABSL_GUARDED_BY(mutex_);
 
   void* stack_[kMaxStackDepth];
   void* parent_stack_[kMaxStackDepth];
@@ -252,28 +252,28 @@ class ABSL_LOCKABLE CordzInfo : public CordzHandle {
   const y_absl::Time create_time_;
 };
 
-inline ABSL_ATTRIBUTE_ALWAYS_INLINE void CordzInfo::MaybeTrackCord(
+inline Y_ABSL_ATTRIBUTE_ALWAYS_INLINE void CordzInfo::MaybeTrackCord(
     InlineData& cord, MethodIdentifier method) {
-  if (ABSL_PREDICT_FALSE(cordz_should_profile())) {
+  if (Y_ABSL_PREDICT_FALSE(cordz_should_profile())) {
     TrackCord(cord, method);
   }
 }
 
-inline ABSL_ATTRIBUTE_ALWAYS_INLINE void CordzInfo::MaybeTrackCord(
+inline Y_ABSL_ATTRIBUTE_ALWAYS_INLINE void CordzInfo::MaybeTrackCord(
     InlineData& cord, const InlineData& src, MethodIdentifier method) {
-  if (ABSL_PREDICT_FALSE(InlineData::is_either_profiled(cord, src))) {
+  if (Y_ABSL_PREDICT_FALSE(InlineData::is_either_profiled(cord, src))) {
     MaybeTrackCordImpl(cord, src, method);
   }
 }
 
-inline ABSL_ATTRIBUTE_ALWAYS_INLINE void CordzInfo::MaybeUntrackCord(
+inline Y_ABSL_ATTRIBUTE_ALWAYS_INLINE void CordzInfo::MaybeUntrackCord(
     CordzInfo* info) {
-  if (ABSL_PREDICT_FALSE(info)) {
+  if (Y_ABSL_PREDICT_FALSE(info)) {
     info->Untrack();
   }
 }
 
-inline void CordzInfo::AssertHeld() ABSL_ASSERT_EXCLUSIVE_LOCK(mutex_) {
+inline void CordzInfo::AssertHeld() Y_ABSL_ASSERT_EXCLUSIVE_LOCK(mutex_) {
 #ifndef NDEBUG
   mutex_.AssertHeld();
 #endif
@@ -286,13 +286,13 @@ inline void CordzInfo::SetCordRep(CordRep* rep) {
 
 inline void CordzInfo::UnsafeSetCordRep(CordRep* rep) { rep_ = rep; }
 
-inline CordRep* CordzInfo::RefCordRep() const ABSL_LOCKS_EXCLUDED(mutex_) {
+inline CordRep* CordzInfo::RefCordRep() const Y_ABSL_LOCKS_EXCLUDED(mutex_) {
   MutexLock lock(&mutex_);
   return rep_ ? CordRep::Ref(rep_) : nullptr;
 }
 
 }  // namespace cord_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_CORDZ_INFO_H_
+#endif  // Y_ABSL_STRINGS_CORDZ_INFO_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_sample_token.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_sample_token.cc
index f29678adb8..fda536c7f4 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_sample_token.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_sample_token.cc
@@ -19,7 +19,7 @@
 #include "y_absl/strings/internal/cordz_info.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace cord_internal {
 
 CordzSampleToken::Iterator& CordzSampleToken::Iterator::operator++() {
@@ -60,5 +60,5 @@ CordzSampleToken::Iterator::Iterator(const CordzSampleToken* token)
     : token_(token), current_(CordzInfo::Head(*token)) {}
 
 }  // namespace cord_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_sample_token.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_sample_token.h
index 85bed6dae8..8ef2f64dc6 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_sample_token.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_sample_token.h
@@ -16,11 +16,11 @@
 #include "y_absl/strings/internal/cordz_handle.h"
 #include "y_absl/strings/internal/cordz_info.h"
 
-#ifndef ABSL_STRINGS_CORDZ_SAMPLE_TOKEN_H_
-#define ABSL_STRINGS_CORDZ_SAMPLE_TOKEN_H_
+#ifndef Y_ABSL_STRINGS_CORDZ_SAMPLE_TOKEN_H_
+#define Y_ABSL_STRINGS_CORDZ_SAMPLE_TOKEN_H_
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace cord_internal {
 
 // The existence of a CordzSampleToken guarantees that a reader can traverse the
@@ -91,7 +91,7 @@ class CordzSampleToken : public CordzSnapshot {
 };
 
 }  // namespace cord_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_CORDZ_SAMPLE_TOKEN_H_
+#endif  // Y_ABSL_STRINGS_CORDZ_SAMPLE_TOKEN_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_statistics.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_statistics.h
index 34e7c34bd8..29ca3d1fcc 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_statistics.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_statistics.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_INTERNAL_CORDZ_STATISTICS_H_
-#define ABSL_STRINGS_INTERNAL_CORDZ_STATISTICS_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_CORDZ_STATISTICS_H_
+#define Y_ABSL_STRINGS_INTERNAL_CORDZ_STATISTICS_H_
 
 #include <cstdint>
 
@@ -21,7 +21,7 @@
 #include "y_absl/strings/internal/cordz_update_tracker.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace cord_internal {
 
 // CordzStatistics captures some meta information about a Cord's shape.
@@ -81,7 +81,7 @@ struct CordzStatistics {
 };
 
 }  // namespace cord_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_INTERNAL_CORDZ_STATISTICS_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_CORDZ_STATISTICS_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_update_scope.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_update_scope.h
index 66e0e8f51b..e6ff0c134c 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_update_scope.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_update_scope.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_INTERNAL_CORDZ_UPDATE_SCOPE_H_
-#define ABSL_STRINGS_INTERNAL_CORDZ_UPDATE_SCOPE_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_CORDZ_UPDATE_SCOPE_H_
+#define Y_ABSL_STRINGS_INTERNAL_CORDZ_UPDATE_SCOPE_H_
 
 #include "y_absl/base/config.h"
 #include "y_absl/base/optimization.h"
@@ -23,19 +23,19 @@
 #include "y_absl/strings/internal/cordz_update_tracker.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace cord_internal {
 
 // CordzUpdateScope scopes an update to the provided CordzInfo.
 // The class invokes `info->Lock(method)` and `info->Unlock()` to guard
 // cordrep updates. This class does nothing if `info` is null.
 // See also the 'Lock`, `Unlock` and `SetCordRep` methods in `CordzInfo`.
-class ABSL_SCOPED_LOCKABLE CordzUpdateScope {
+class Y_ABSL_SCOPED_LOCKABLE CordzUpdateScope {
  public:
   CordzUpdateScope(CordzInfo* info, CordzUpdateTracker::MethodIdentifier method)
-      ABSL_EXCLUSIVE_LOCK_FUNCTION(info)
+      Y_ABSL_EXCLUSIVE_LOCK_FUNCTION(info)
       : info_(info) {
-    if (ABSL_PREDICT_FALSE(info_)) {
+    if (Y_ABSL_PREDICT_FALSE(info_)) {
       info->Lock(method);
     }
   }
@@ -46,14 +46,14 @@ class ABSL_SCOPED_LOCKABLE CordzUpdateScope {
   CordzUpdateScope& operator=(CordzUpdateScope&& rhs) = delete;
   CordzUpdateScope& operator=(const CordzUpdateScope&) = delete;
 
-  ~CordzUpdateScope() ABSL_UNLOCK_FUNCTION() {
-    if (ABSL_PREDICT_FALSE(info_)) {
+  ~CordzUpdateScope() Y_ABSL_UNLOCK_FUNCTION() {
+    if (Y_ABSL_PREDICT_FALSE(info_)) {
       info_->Unlock();
     }
   }
 
   void SetCordRep(CordRep* rep) const {
-    if (ABSL_PREDICT_FALSE(info_)) {
+    if (Y_ABSL_PREDICT_FALSE(info_)) {
       info_->SetCordRep(rep);
     }
   }
@@ -65,7 +65,7 @@ class ABSL_SCOPED_LOCKABLE CordzUpdateScope {
 };
 
 }  // namespace cord_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_INTERNAL_CORDZ_UPDATE_SCOPE_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_CORDZ_UPDATE_SCOPE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_update_tracker.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_update_tracker.h
index 48a449b4bf..bb9fae0e6f 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_update_tracker.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_update_tracker.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_INTERNAL_CORDZ_UPDATE_TRACKER_H_
-#define ABSL_STRINGS_INTERNAL_CORDZ_UPDATE_TRACKER_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_CORDZ_UPDATE_TRACKER_H_
+#define Y_ABSL_STRINGS_INTERNAL_CORDZ_UPDATE_TRACKER_H_
 
 #include <atomic>
 #include <cstdint>
@@ -21,7 +21,7 @@
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace cord_internal {
 
 // CordzUpdateTracker tracks counters for Cord update methods.
@@ -115,7 +115,7 @@ class CordzUpdateTracker {
 };
 
 }  // namespace cord_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_INTERNAL_CORDZ_UPDATE_TRACKER_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_CORDZ_UPDATE_TRACKER_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/escaping.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/escaping.cc
index 01b8974983..1105bbe1f9 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/escaping.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/escaping.cc
@@ -18,7 +18,7 @@
 #include "y_absl/base/internal/raw_logging.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 const char kBase64Chars[] =
@@ -169,12 +169,12 @@ size_t Base64EscapeInternal(const unsigned char* src, size_t szsrc, char* dest,
     default:
       // Should not be reached: blocks of 4 bytes are handled
       // in the while loop before this switch statement.
-      ABSL_RAW_LOG(FATAL, "Logic problem? szsrc = %zu", szsrc);
+      Y_ABSL_RAW_LOG(FATAL, "Logic problem? szsrc = %zu", szsrc);
       break;
   }
   return (cur_dest - dest);
 }
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/escaping.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/escaping.h
index d62fc0fbcb..743ac2519d 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/escaping.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/escaping.h
@@ -12,18 +12,18 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_INTERNAL_ESCAPING_H_
-#define ABSL_STRINGS_INTERNAL_ESCAPING_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_ESCAPING_H_
+#define Y_ABSL_STRINGS_INTERNAL_ESCAPING_H_
 
 #include <cassert>
 
 #include "y_absl/strings/internal/resize_uninitialized.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
-ABSL_CONST_INIT extern const char kBase64Chars[];
+Y_ABSL_CONST_INIT extern const char kBase64Chars[];
 
 // Calculates how long a string will be when it is base64 encoded given its
 // length and whether or not the result should be padded.
@@ -52,7 +52,7 @@ void Base64EscapeInternal(const unsigned char* src, size_t szsrc, String* dest,
 }
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_INTERNAL_ESCAPING_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_ESCAPING_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/escaping_test_common.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/escaping_test_common.h
index f145127225..ff4471e8ac 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/escaping_test_common.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/escaping_test_common.h
@@ -15,14 +15,14 @@
 // This test contains common things needed by both escaping_test.cc and
 // escaping_benchmark.cc.
 
-#ifndef ABSL_STRINGS_INTERNAL_ESCAPING_TEST_COMMON_H_
-#define ABSL_STRINGS_INTERNAL_ESCAPING_TEST_COMMON_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_ESCAPING_TEST_COMMON_H_
+#define Y_ABSL_STRINGS_INTERNAL_ESCAPING_TEST_COMMON_H_
 
 #include <array>
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 struct base64_testcase {
@@ -127,7 +127,7 @@ inline const std::array<base64_testcase, 5>& base64_strings() {
 }
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_INTERNAL_ESCAPING_TEST_COMMON_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_ESCAPING_TEST_COMMON_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/memutil.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/memutil.cc
index 0ba6574fdb..3ef534118e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/memutil.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/memutil.cc
@@ -17,7 +17,7 @@
 #include <cstdlib>
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 int memcasecmp(const char* s1, const char* s2, size_t len) {
@@ -108,5 +108,5 @@ const char* memmatch(const char* phaystack, size_t haylen, const char* pneedle,
 }
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/memutil.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/memutil.h
index ee442fe25f..dfc1a2c293 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/memutil.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/memutil.h
@@ -59,8 +59,8 @@
 // --                      MEMCASEIS
 // strcount                MEMCOUNT       (strcount is from strutil.h)
 
-#ifndef ABSL_STRINGS_INTERNAL_MEMUTIL_H_
-#define ABSL_STRINGS_INTERNAL_MEMUTIL_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_MEMUTIL_H_
+#define Y_ABSL_STRINGS_INTERNAL_MEMUTIL_H_
 
 #include <cstddef>
 #include <cstring>
@@ -69,7 +69,7 @@
 #include "y_absl/strings/ascii.h"  // for y_absl::ascii_tolower
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 inline char* memcat(char* dest, size_t destlen, const char* src,
@@ -142,7 +142,7 @@ const char* memmatch(const char* phaystack, size_t haylen, const char* pneedle,
                      size_t neelen);
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_INTERNAL_MEMUTIL_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_MEMUTIL_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/numbers_test_common.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/numbers_test_common.h
index 12aec3ac11..fbb31cb65e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/numbers_test_common.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/numbers_test_common.h
@@ -15,8 +15,8 @@
 // This file contains common things needed by numbers_test.cc,
 // numbers_legacy_test.cc and numbers_benchmark.cc.
 
-#ifndef ABSL_STRINGS_INTERNAL_NUMBERS_TEST_COMMON_H_
-#define ABSL_STRINGS_INTERNAL_NUMBERS_TEST_COMMON_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_NUMBERS_TEST_COMMON_H_
+#define Y_ABSL_STRINGS_INTERNAL_NUMBERS_TEST_COMMON_H_
 
 #include <array>
 #include <cstdint>
@@ -26,7 +26,7 @@
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 template <typename IntType>
@@ -178,7 +178,7 @@ inline const std::array<uint64_test_case, 34>& strtouint64_test_cases() {
 }
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_INTERNAL_NUMBERS_TEST_COMMON_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_NUMBERS_TEST_COMMON_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/ostringstream.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/ostringstream.cc
index ba18857d83..c850f8abb1 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/ostringstream.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/ostringstream.cc
@@ -15,7 +15,7 @@
 #include "y_absl/strings/internal/ostringstream.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 OStringStream::Buf::int_type OStringStream::overflow(int c) {
@@ -32,5 +32,5 @@ std::streamsize OStringStream::xsputn(const char* s, std::streamsize n) {
 }
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/ostringstream.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/ostringstream.h
index d00cef9c23..f9e47f0071 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/ostringstream.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/ostringstream.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_INTERNAL_OSTRINGSTREAM_H_
-#define ABSL_STRINGS_INTERNAL_OSTRINGSTREAM_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_OSTRINGSTREAM_H_
+#define Y_ABSL_STRINGS_INTERNAL_OSTRINGSTREAM_H_
 
 #include <cassert>
 #include <ostream>
@@ -23,7 +23,7 @@
 #include "y_absl/base/port.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 // The same as std::ostringstream but appends to a user-specified TString,
@@ -83,7 +83,7 @@ class OStringStream : private std::basic_streambuf<char>, public std::ostream {
 };
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_INTERNAL_OSTRINGSTREAM_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_OSTRINGSTREAM_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/pow10_helper.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/pow10_helper.h
index e4d41d7e4e..fca0083e77 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/pow10_helper.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/pow10_helper.h
@@ -17,15 +17,15 @@
 // precise values are computed across the full range of doubles. We can't rely
 // on the pow() function, because not all standard libraries ship a version
 // that is precise.
-#ifndef ABSL_STRINGS_INTERNAL_POW10_HELPER_H_
-#define ABSL_STRINGS_INTERNAL_POW10_HELPER_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_POW10_HELPER_H_
+#define Y_ABSL_STRINGS_INTERNAL_POW10_HELPER_H_
 
 #include <vector>
 
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 // Computes the precise value of 10^exp. (I.e. the nearest representable
@@ -34,7 +34,7 @@ namespace strings_internal {
 double Pow10(int exp);
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_INTERNAL_POW10_HELPER_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_POW10_HELPER_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/resize_uninitialized.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/resize_uninitialized.h
index 14860bb237..984562257d 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/resize_uninitialized.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/resize_uninitialized.h
@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef ABSL_STRINGS_INTERNAL_RESIZE_UNINITIALIZED_H_
-#define ABSL_STRINGS_INTERNAL_RESIZE_UNINITIALIZED_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_RESIZE_UNINITIALIZED_H_
+#define Y_ABSL_STRINGS_INTERNAL_RESIZE_UNINITIALIZED_H_
 
 #include <algorithm>
 #include <util/generic/string.h>
@@ -26,7 +26,7 @@
 #include "y_absl/meta/type_traits.h"  //  for void_t
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 // In this type trait, we look for a __resize_default_init member function, and
@@ -113,7 +113,7 @@ void STLStringResizeUninitializedAmortized(string_type* s, size_t new_size) {
 }
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_INTERNAL_RESIZE_UNINITIALIZED_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_RESIZE_UNINITIALIZED_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/stl_type_traits.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/stl_type_traits.h
index db8d4635d0..f50eef9dee 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/stl_type_traits.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/stl_type_traits.h
@@ -22,8 +22,8 @@
 //
 // IWYU pragma: private, include "y_absl/strings/str_split.h"
 
-#ifndef ABSL_STRINGS_INTERNAL_STL_TYPE_TRAITS_H_
-#define ABSL_STRINGS_INTERNAL_STL_TYPE_TRAITS_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_STL_TYPE_TRAITS_H_
+#define Y_ABSL_STRINGS_INTERNAL_STL_TYPE_TRAITS_H_
 
 #include <array>
 #include <bitset>
@@ -40,7 +40,7 @@
 #include "y_absl/meta/type_traits.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 template <typename C, template <typename...> class T>
@@ -243,6 +243,6 @@ struct IsStrictlyBaseOfAndConvertibleToSTLContainer
                         IsConvertibleToSTLContainer<C>> {};
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
-#endif  // ABSL_STRINGS_INTERNAL_STL_TYPE_TRAITS_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_STL_TYPE_TRAITS_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.cc
index 8d5c3b61ac..5f4399c9da 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.cc
@@ -29,7 +29,7 @@
 #include "y_absl/strings/numbers.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace str_format_internal {
 namespace {
 
@@ -320,7 +320,7 @@ bool ConvertIntArg(T v, const FormatConversionSpecImpl conv,
       return ConvertFloatImpl(static_cast<double>(v), conv, sink);
 
     default:
-       ABSL_INTERNAL_ASSUME(false);
+       Y_ABSL_INTERNAL_ASSUME(false);
   }
 
   if (conv.is_basic()) {
@@ -478,11 +478,11 @@ IntegralConvertResult FormatConvertImpl(y_absl::uint128 v,
   return {ConvertIntArg(v, conv, sink)};
 }
 
-ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_();
+Y_ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_();
 
 
 
 }  // namespace str_format_internal
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.h
index 59b7bcc727..67ac59122b 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_ARG_H_
-#define ABSL_STRINGS_INTERNAL_STR_FORMAT_ARG_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_STR_FORMAT_ARG_H_
+#define Y_ABSL_STRINGS_INTERNAL_STR_FORMAT_ARG_H_
 
 #include <string.h>
 #include <wchar.h>
@@ -34,7 +34,7 @@
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 class Cord;
 class FormatCountCapture;
@@ -123,13 +123,13 @@ StringConvertResult FormatConvertImpl(const TString& v,
 StringConvertResult FormatConvertImpl(string_view v,
                                       FormatConversionSpecImpl conv,
                                       FormatSinkImpl* sink);
-#if defined(ABSL_HAVE_STD_STRING_VIEW) && !defined(ABSL_USES_STD_STRING_VIEW)
+#if defined(Y_ABSL_HAVE_STD_STRING_VIEW) && !defined(Y_ABSL_USES_STD_STRING_VIEW)
 inline StringConvertResult FormatConvertImpl(std::string_view v,
                                              FormatConversionSpecImpl conv,
                                              FormatSinkImpl* sink) {
   return FormatConvertImpl(y_absl::string_view(v.data(), v.size()), conv, sink);
 }
-#endif  // ABSL_HAVE_STD_STRING_VIEW && !ABSL_USES_STD_STRING_VIEW
+#endif  // Y_ABSL_HAVE_STD_STRING_VIEW && !Y_ABSL_USES_STD_STRING_VIEW
 
 ArgConvertResult<FormatConversionCharSetUnion(
     FormatConversionCharSetInternal::s, FormatConversionCharSetInternal::p)>
@@ -467,12 +467,12 @@ class FormatArgImpl {
   template <typename T>
   static bool Dispatch(Data arg, FormatConversionSpecImpl spec, void* out) {
     // A `none` conv indicates that we want the `int` conversion.
-    if (ABSL_PREDICT_FALSE(spec.conversion_char() ==
+    if (Y_ABSL_PREDICT_FALSE(spec.conversion_char() ==
                            FormatConversionCharInternal::kNone)) {
       return ToInt<T>(arg, static_cast<int*>(out), std::is_integral<T>(),
                       std::is_enum<T>());
     }
-    if (ABSL_PREDICT_FALSE(!Contains(ArgumentToConv<T>(),
+    if (Y_ABSL_PREDICT_FALSE(!Contains(ArgumentToConv<T>(),
                                      spec.conversion_char()))) {
       return false;
     }
@@ -486,43 +486,43 @@ class FormatArgImpl {
   Dispatcher dispatcher_;
 };
 
-#define ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(T, E)                     \
+#define Y_ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(T, E)                     \
   E template bool FormatArgImpl::Dispatch<T>(Data, FormatConversionSpecImpl, \
                                              void*)
 
-#define ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_(...)                   \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(str_format_internal::VoidPtr,     \
+#define Y_ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_(...)                   \
+  Y_ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(str_format_internal::VoidPtr,     \
                                              __VA_ARGS__);                     \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(bool, __VA_ARGS__);               \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(char, __VA_ARGS__);               \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(signed char, __VA_ARGS__);        \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned char, __VA_ARGS__);      \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(short, __VA_ARGS__); /* NOLINT */ \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned short,      /* NOLINT */ \
+  Y_ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(bool, __VA_ARGS__);               \
+  Y_ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(char, __VA_ARGS__);               \
+  Y_ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(signed char, __VA_ARGS__);        \
+  Y_ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned char, __VA_ARGS__);      \
+  Y_ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(short, __VA_ARGS__); /* NOLINT */ \
+  Y_ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned short,      /* NOLINT */ \
                                              __VA_ARGS__);                     \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(int, __VA_ARGS__);                \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned int, __VA_ARGS__);       \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(long, __VA_ARGS__); /* NOLINT */  \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned long,      /* NOLINT */  \
+  Y_ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(int, __VA_ARGS__);                \
+  Y_ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned int, __VA_ARGS__);       \
+  Y_ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(long, __VA_ARGS__); /* NOLINT */  \
+  Y_ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned long,      /* NOLINT */  \
                                              __VA_ARGS__);                     \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(long long, /* NOLINT */           \
+  Y_ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(long long, /* NOLINT */           \
                                              __VA_ARGS__);                     \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned long long, /* NOLINT */  \
+  Y_ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned long long, /* NOLINT */  \
                                              __VA_ARGS__);                     \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(int128, __VA_ARGS__);             \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(uint128, __VA_ARGS__);            \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(float, __VA_ARGS__);              \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(double, __VA_ARGS__);             \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(long double, __VA_ARGS__);        \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(const char*, __VA_ARGS__);        \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(TString, __VA_ARGS__);        \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(string_view, __VA_ARGS__)
+  Y_ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(int128, __VA_ARGS__);             \
+  Y_ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(uint128, __VA_ARGS__);            \
+  Y_ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(float, __VA_ARGS__);              \
+  Y_ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(double, __VA_ARGS__);             \
+  Y_ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(long double, __VA_ARGS__);        \
+  Y_ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(const char*, __VA_ARGS__);        \
+  Y_ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(TString, __VA_ARGS__);        \
+  Y_ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(string_view, __VA_ARGS__)
 
-ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_(extern);
+Y_ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_(extern);
 
 
 }  // namespace str_format_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_ARG_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_STR_FORMAT_ARG_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/bind.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/bind.cc
index 211ce25dea..d9e7ccaac9 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/bind.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/bind.cc
@@ -20,7 +20,7 @@
 #include <util/generic/string.h>
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace str_format_internal {
 
 namespace {
@@ -208,7 +208,7 @@ std::ostream& Streamable::Print(std::ostream& os) const {
 TString& AppendPack(TString* out, const UntypedFormatSpecImpl format,
                         y_absl::Span<const FormatArgImpl> args) {
   size_t orig = out->size();
-  if (ABSL_PREDICT_FALSE(!FormatUntyped(out, format, args))) {
+  if (Y_ABSL_PREDICT_FALSE(!FormatUntyped(out, format, args))) {
     out->erase(orig);
   }
   return *out;
@@ -217,7 +217,7 @@ TString& AppendPack(TString* out, const UntypedFormatSpecImpl format,
 TString FormatPack(const UntypedFormatSpecImpl format,
                        y_absl::Span<const FormatArgImpl> args) {
   TString out;
-  if (ABSL_PREDICT_FALSE(!FormatUntyped(&out, format, args))) {
+  if (Y_ABSL_PREDICT_FALSE(!FormatUntyped(&out, format, args))) {
     out.clear();
   }
   return out;
@@ -254,5 +254,5 @@ int SnprintF(char* output, size_t size, const UntypedFormatSpecImpl format,
 }
 
 }  // namespace str_format_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/bind.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/bind.h
index 3966610710..4f254951fd 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/bind.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/bind.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_BIND_H_
-#define ABSL_STRINGS_INTERNAL_STR_FORMAT_BIND_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_STR_FORMAT_BIND_H_
+#define Y_ABSL_STRINGS_INTERNAL_STR_FORMAT_BIND_H_
 
 #include <array>
 #include <cstdio>
@@ -27,7 +27,7 @@
 #include "y_absl/types/span.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 class UntypedFormatSpec;
 
@@ -88,7 +88,7 @@ class FormatSpecTemplate
   using Base = typename MakeDependent<UntypedFormatSpec, Args...>::type;
 
  public:
-#ifdef ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
+#ifdef Y_ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
 
   // Honeypot overload for when the string is not constexpr.
   // We use the 'unavailable' attribute to give a better compiler error than
@@ -126,12 +126,12 @@ class FormatSpecTemplate
       __attribute__((enable_if(ValidFormatImpl<Args...>(s), "bad format trap")))
       : Base(s) {}
 
-#else  // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
+#else  // Y_ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
 
   FormatSpecTemplate(const char* s) : Base(s) {}  // NOLINT
   FormatSpecTemplate(string_view s) : Base(s) {}  // NOLINT
 
-#endif  // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
+#endif  // Y_ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
 
   template <
       FormatConversionCharSet... C,
@@ -147,7 +147,7 @@ class Streamable {
   Streamable(const UntypedFormatSpecImpl& format,
              y_absl::Span<const FormatArgImpl> args)
       : format_(format) {
-    if (args.size() <= ABSL_ARRAYSIZE(few_args_)) {
+    if (args.size() <= Y_ABSL_ARRAYSIZE(few_args_)) {
       for (size_t i = 0; i < args.size(); ++i) {
         few_args_[i] = args[i];
       }
@@ -211,7 +211,7 @@ class StreamedWrapper {
 };
 
 }  // namespace str_format_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_BIND_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_STR_FORMAT_BIND_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/checker.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/checker.h
index 7c530d2507..a10724d870 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/checker.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/checker.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_CHECKER_H_
-#define ABSL_STRINGS_INTERNAL_STR_FORMAT_CHECKER_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_STR_FORMAT_CHECKER_H_
+#define Y_ABSL_STRINGS_INTERNAL_STR_FORMAT_CHECKER_H_
 
 #include "y_absl/base/attributes.h"
 #include "y_absl/strings/internal/str_format/arg.h"
@@ -21,14 +21,14 @@
 
 // Compile time check support for entry points.
 
-#ifndef ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
-#if ABSL_HAVE_ATTRIBUTE(enable_if) && !defined(__native_client__)
-#define ABSL_INTERNAL_ENABLE_FORMAT_CHECKER 1
-#endif  // ABSL_HAVE_ATTRIBUTE(enable_if) && !defined(__native_client__)
-#endif  // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
+#ifndef Y_ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
+#if Y_ABSL_HAVE_ATTRIBUTE(enable_if) && !defined(__native_client__)
+#define Y_ABSL_INTERNAL_ENABLE_FORMAT_CHECKER 1
+#endif  // Y_ABSL_HAVE_ATTRIBUTE(enable_if) && !defined(__native_client__)
+#endif  // Y_ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace str_format_internal {
 
 constexpr bool AllOf() { return true; }
@@ -38,7 +38,7 @@ constexpr bool AllOf(bool b, T... t) {
   return b && AllOf(t...);
 }
 
-#ifdef ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
+#ifdef Y_ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
 
 constexpr bool ContainsChar(const char* chars, char c) {
   return *chars == c || (*chars && ContainsChar(chars + 1, c));
@@ -324,10 +324,10 @@ constexpr bool ValidFormatImpl(string_view format) {
       .Run();
 }
 
-#endif  // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
+#endif  // Y_ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
 
 }  // namespace str_format_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_CHECKER_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_STR_FORMAT_CHECKER_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.cc
index f2a4169ae7..24e0ec7a13 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.cc
@@ -20,7 +20,7 @@
 #include <util/generic/string.h>
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace str_format_internal {
 
 TString FlagsToString(Flags v) {
@@ -33,17 +33,17 @@ TString FlagsToString(Flags v) {
   return s;
 }
 
-#define ABSL_INTERNAL_X_VAL(id) \
+#define Y_ABSL_INTERNAL_X_VAL(id) \
   constexpr y_absl::FormatConversionChar FormatConversionCharInternal::id;
-ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL, )
-#undef ABSL_INTERNAL_X_VAL
+Y_ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(Y_ABSL_INTERNAL_X_VAL, )
+#undef Y_ABSL_INTERNAL_X_VAL
 // NOLINTNEXTLINE(readability-redundant-declaration)
 constexpr y_absl::FormatConversionChar FormatConversionCharInternal::kNone;
 
-#define ABSL_INTERNAL_CHAR_SET_CASE(c) \
+#define Y_ABSL_INTERNAL_CHAR_SET_CASE(c) \
   constexpr FormatConversionCharSet FormatConversionCharSetInternal::c;
-ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_CHAR_SET_CASE, )
-#undef ABSL_INTERNAL_CHAR_SET_CASE
+Y_ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(Y_ABSL_INTERNAL_CHAR_SET_CASE, )
+#undef Y_ABSL_INTERNAL_CHAR_SET_CASE
 
 // NOLINTNEXTLINE(readability-redundant-declaration)
 constexpr FormatConversionCharSet FormatConversionCharSetInternal::kStar;
@@ -71,5 +71,5 @@ bool FormatSinkImpl::PutPaddedString(string_view value, int width,
 }
 
 }  // namespace str_format_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.h
index e5de5cb6a1..836bd1a10c 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.h
@@ -13,8 +13,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
-#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_EXTENSION_H_
-#define ABSL_STRINGS_INTERNAL_STR_FORMAT_EXTENSION_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_STR_FORMAT_EXTENSION_H_
+#define Y_ABSL_STRINGS_INTERNAL_STR_FORMAT_EXTENSION_H_
 
 #include <limits.h>
 
@@ -29,7 +29,7 @@
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 enum class FormatConversionChar : uint8_t;
 enum class FormatConversionCharSet : uint64_t;
@@ -156,7 +156,7 @@ inline std::ostream& operator<<(std::ostream& os, Flags v) {
 }
 
 // clang-format off
-#define ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(X_VAL, X_SEP) \
+#define Y_ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(X_VAL, X_SEP) \
   /* text */ \
   X_VAL(c) X_SEP X_VAL(s) X_SEP \
   /* ints */ \
@@ -193,11 +193,11 @@ struct FormatConversionCharInternal {
   };
   // clang-format on
  public:
-#define ABSL_INTERNAL_X_VAL(id)              \
+#define Y_ABSL_INTERNAL_X_VAL(id)              \
   static constexpr FormatConversionChar id = \
       static_cast<FormatConversionChar>(Enum::id);
-  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL, )
-#undef ABSL_INTERNAL_X_VAL
+  Y_ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(Y_ABSL_INTERNAL_X_VAL, )
+#undef Y_ABSL_INTERNAL_X_VAL
   static constexpr FormatConversionChar kNone =
       static_cast<FormatConversionChar>(Enum::kNone);
 };
@@ -205,11 +205,11 @@ struct FormatConversionCharInternal {
 
 inline FormatConversionChar FormatConversionCharFromChar(char c) {
   switch (c) {
-#define ABSL_INTERNAL_X_VAL(id) \
+#define Y_ABSL_INTERNAL_X_VAL(id) \
   case #id[0]:                  \
     return FormatConversionCharInternal::id;
-    ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL, )
-#undef ABSL_INTERNAL_X_VAL
+    Y_ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(Y_ABSL_INTERNAL_X_VAL, )
+#undef Y_ABSL_INTERNAL_X_VAL
   }
   return FormatConversionCharInternal::kNone;
 }
@@ -245,18 +245,18 @@ inline char FormatConversionCharToChar(FormatConversionChar c) {
   if (c == FormatConversionCharInternal::kNone) {
     return '\0';
 
-#define ABSL_INTERNAL_X_VAL(e)                       \
+#define Y_ABSL_INTERNAL_X_VAL(e)                       \
   } else if (c == FormatConversionCharInternal::e) { \
     return #e[0];
-#define ABSL_INTERNAL_X_SEP
-  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL,
-                                         ABSL_INTERNAL_X_SEP)
+#define Y_ABSL_INTERNAL_X_SEP
+  Y_ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(Y_ABSL_INTERNAL_X_VAL,
+                                         Y_ABSL_INTERNAL_X_SEP)
   } else {
     return '\0';
   }
 
-#undef ABSL_INTERNAL_X_VAL
-#undef ABSL_INTERNAL_X_SEP
+#undef Y_ABSL_INTERNAL_X_VAL
+#undef Y_ABSL_INTERNAL_X_SEP
 }
 
 // The associated char.
@@ -352,12 +352,12 @@ constexpr uint64_t FormatConversionCharToConvInt(FormatConversionChar c) {
 
 constexpr uint64_t FormatConversionCharToConvInt(char conv) {
   return
-#define ABSL_INTERNAL_CHAR_SET_CASE(c)                                 \
+#define Y_ABSL_INTERNAL_CHAR_SET_CASE(c)                                 \
   conv == #c[0]                                                        \
       ? FormatConversionCharToConvInt(FormatConversionCharInternal::c) \
       :
-      ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_CHAR_SET_CASE, )
-#undef ABSL_INTERNAL_CHAR_SET_CASE
+      Y_ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(Y_ABSL_INTERNAL_CHAR_SET_CASE, )
+#undef Y_ABSL_INTERNAL_CHAR_SET_CASE
                   conv == '*'
           ? 1
           : 0;
@@ -369,11 +369,11 @@ constexpr FormatConversionCharSet FormatConversionCharToConvValue(char conv) {
 }
 
 struct FormatConversionCharSetInternal {
-#define ABSL_INTERNAL_CHAR_SET_CASE(c)         \
+#define Y_ABSL_INTERNAL_CHAR_SET_CASE(c)         \
   static constexpr FormatConversionCharSet c = \
       FormatConversionCharToConvValue(#c[0]);
-  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_CHAR_SET_CASE, )
-#undef ABSL_INTERNAL_CHAR_SET_CASE
+  Y_ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(Y_ABSL_INTERNAL_CHAR_SET_CASE, )
+#undef Y_ABSL_INTERNAL_CHAR_SET_CASE
 
   // Used for width/precision '*' specification.
   static constexpr FormatConversionCharSet kStar =
@@ -439,7 +439,7 @@ inline size_t Excess(size_t used, size_t capacity) {
 
 }  // namespace str_format_internal
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_EXTENSION_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_STR_FORMAT_EXTENSION_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.cc
index c49062538d..4b3ff2f652 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.cc
@@ -35,7 +35,7 @@
 #include "y_absl/types/span.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace str_format_internal {
 
 namespace {
@@ -61,7 +61,7 @@ class StackArray {
   // Otherwise the caller will allocate the stack space unnecessarily for all
   // the variants even though it only calls one.
   template <size_t steps>
-  ABSL_ATTRIBUTE_NOINLINE static void RunWithCapacityImpl(Func f) {
+  Y_ABSL_ATTRIBUTE_NOINLINE static void RunWithCapacityImpl(Func f) {
     uint32_t values[steps * kStep]{};
     f(y_absl::MakeSpan(values));
   }
@@ -670,13 +670,13 @@ void FormatF(Int mantissa, int exp, const FormatState &state) {
 
     // Fallback to the slow stack-based approach if we can't do it in a 64 or
     // 128 bit state.
-    if (ABSL_PREDICT_FALSE(total_bits > 128)) {
+    if (Y_ABSL_PREDICT_FALSE(total_bits > 128)) {
       return FormatFPositiveExpSlow(mantissa, exp, state);
     }
   } else {
     // Fallback to the slow stack-based approach if we can't do it in a 64 or
     // 128 bit state.
-    if (ABSL_PREDICT_FALSE(exp < -128)) {
+    if (Y_ABSL_PREDICT_FALSE(exp < -128)) {
       return FormatFNegativeExpSlow(mantissa, -exp, state);
     }
   }
@@ -811,7 +811,7 @@ void FormatARound(bool precision_specified, const FormatState &state,
     // Need to round up.
     bool overflow = IncrementNibble(final_nibble_displayed, mantissa);
     *leading += (overflow ? 1 : 0);
-    if (ABSL_PREDICT_FALSE(*leading > 15)) {
+    if (Y_ABSL_PREDICT_FALSE(*leading > 15)) {
       // We have overflowed the leading digit. This would mean that we would
       // need two hex digits to the left of the dot, which is not allowed. So
       // adjust the mantissa and exponent so that the result is always 1.0eXXX.
@@ -836,7 +836,7 @@ void FormatANormalize(const HexFloatTypeParams float_traits, uint8_t *leading,
   // Normalize mantissa so that highest bit set is in MSB position, unless we
   // get interrupted by the exponent threshold.
   while (*mantissa && !(*mantissa & kHighIntBit)) {
-    if (ABSL_PREDICT_FALSE(*exp - 1 < float_traits.min_exponent)) {
+    if (Y_ABSL_PREDICT_FALSE(*exp - 1 < float_traits.min_exponent)) {
       *mantissa >>= (float_traits.min_exponent - *exp);
       *exp = float_traits.min_exponent;
       return;
@@ -1266,7 +1266,7 @@ bool FloatToBuffer(Decomposed<Float> decomposed, int precision, Buffer *out,
           static_cast<std::uint64_t>(decomposed.exponent), precision, out, exp))
     return true;
 
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
+#if defined(Y_ABSL_HAVE_INTRINSIC_INT128)
   // If that is not enough, try with __uint128_t.
   return CanFitMantissa<Float, __uint128_t>() &&
          FloatToBufferImpl<__uint128_t, Float, mode>(
@@ -1419,5 +1419,5 @@ bool ConvertFloatImpl(double v, const FormatConversionSpecImpl &conv,
 }
 
 }  // namespace str_format_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.h
index d93a415756..274264f007 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.h
@@ -12,13 +12,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_FLOAT_CONVERSION_H_
-#define ABSL_STRINGS_INTERNAL_STR_FORMAT_FLOAT_CONVERSION_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_STR_FORMAT_FLOAT_CONVERSION_H_
+#define Y_ABSL_STRINGS_INTERNAL_STR_FORMAT_FLOAT_CONVERSION_H_
 
 #include "y_absl/strings/internal/str_format/extension.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace str_format_internal {
 
 bool ConvertFloatImpl(float v, const FormatConversionSpecImpl &conv,
@@ -31,7 +31,7 @@ bool ConvertFloatImpl(long double v, const FormatConversionSpecImpl &conv,
                       FormatSinkImpl *sink);
 
 }  // namespace str_format_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_FLOAT_CONVERSION_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_STR_FORMAT_FLOAT_CONVERSION_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/output.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/output.cc
index ade3f67ef2..57c250b032 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/output.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/output.cc
@@ -18,7 +18,7 @@
 #include <cstring>
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace str_format_internal {
 
 namespace {
@@ -68,5 +68,5 @@ void FILERawSink::Write(string_view v) {
 }
 
 }  // namespace str_format_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/output.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/output.h
index 8fc46fbafa..7732b5e5e1 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/output.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/output.h
@@ -18,8 +18,8 @@
 // `BufferRawSink` is a simple output sink for a char buffer. Used by SnprintF.
 // `FILERawSink` is a std::FILE* based sink. Used by PrintF and FprintF.
 
-#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_OUTPUT_H_
-#define ABSL_STRINGS_INTERNAL_STR_FORMAT_OUTPUT_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_STR_FORMAT_OUTPUT_H_
+#define Y_ABSL_STRINGS_INTERNAL_STR_FORMAT_OUTPUT_H_
 
 #include <cstdio>
 #include <ostream>
@@ -29,7 +29,7 @@
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace str_format_internal {
 
 // RawSink implementation that writes into a char* buffer.
@@ -90,7 +90,7 @@ auto InvokeFlush(T* out, string_view s) -> decltype(AbslFormatFlush(out, s)) {
 }
 
 }  // namespace str_format_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_OUTPUT_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_STR_FORMAT_OUTPUT_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.cc
index af07e32fe5..76f68c9cb3 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.cc
@@ -28,7 +28,7 @@
 #include <unordered_set>
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace str_format_internal {
 
 using CC = FormatConversionCharInternal;
@@ -41,7 +41,7 @@ constexpr auto f_pos = Flags::kShowPos;
 constexpr auto f_left = Flags::kLeft;
 constexpr auto f_zero = Flags::kZero;
 
-ABSL_CONST_INIT const ConvTag kTags[256] = {
+Y_ABSL_CONST_INIT const ConvTag kTags[256] = {
     {},     {},    {},    {},    {},    {},     {},    {},     // 00-07
     {},     {},    {},    {},    {},    {},     {},    {},     // 08-0f
     {},     {},    {},    {},    {},    {},     {},    {},     // 10-17
@@ -104,9 +104,9 @@ const char *ConsumeConversion(const char *pos, const char *const end,
   char c;
   // Read the next char into `c` and update `pos`. Returns false if there are
   // no more chars to read.
-#define ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR()          \
+#define Y_ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR()          \
   do {                                                  \
-    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
+    if (Y_ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
     c = *pos++;                                         \
   } while (0)
 
@@ -117,25 +117,25 @@ const char *ConsumeConversion(const char *pos, const char *const end,
     // digit doesn't match the expected characters.
     int num_digits = std::numeric_limits<int>::digits10;
     for (;;) {
-      if (ABSL_PREDICT_FALSE(pos == end)) break;
+      if (Y_ABSL_PREDICT_FALSE(pos == end)) break;
       c = *pos++;
       if (!std::isdigit(c)) break;
       --num_digits;
-      if (ABSL_PREDICT_FALSE(!num_digits)) break;
+      if (Y_ABSL_PREDICT_FALSE(!num_digits)) break;
       digits = 10 * digits + c - '0';
     }
     return digits;
   };
 
   if (is_positional) {
-    ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
-    if (ABSL_PREDICT_FALSE(c < '1' || c > '9')) return nullptr;
+    Y_ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
+    if (Y_ABSL_PREDICT_FALSE(c < '1' || c > '9')) return nullptr;
     conv->arg_position = parse_digits();
     assert(conv->arg_position > 0);
-    if (ABSL_PREDICT_FALSE(c != '$')) return nullptr;
+    if (Y_ABSL_PREDICT_FALSE(c != '$')) return nullptr;
   }
 
-  ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
+  Y_ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
 
   // We should start with the basic flag on.
   assert(conv->flags == Flags::kBasic);
@@ -148,7 +148,7 @@ const char *ConsumeConversion(const char *pos, const char *const end,
       auto tag = GetTagForChar(c);
       if (tag.is_flags()) {
         conv->flags = conv->flags | tag.as_flags();
-        ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
+        Y_ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
       } else {
         break;
       }
@@ -158,7 +158,7 @@ const char *ConsumeConversion(const char *pos, const char *const end,
       if (c >= '0') {
         int maybe_width = parse_digits();
         if (!is_positional && c == '$') {
-          if (ABSL_PREDICT_FALSE(*next_arg != 0)) return nullptr;
+          if (Y_ABSL_PREDICT_FALSE(*next_arg != 0)) return nullptr;
           // Positional conversion.
           *next_arg = -1;
           return ConsumeConversion<true>(original_pos, end, conv, next_arg);
@@ -167,12 +167,12 @@ const char *ConsumeConversion(const char *pos, const char *const end,
         conv->width.set_value(maybe_width);
       } else if (c == '*') {
         conv->flags = conv->flags | Flags::kNonBasic;
-        ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
+        Y_ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
         if (is_positional) {
-          if (ABSL_PREDICT_FALSE(c < '1' || c > '9')) return nullptr;
+          if (Y_ABSL_PREDICT_FALSE(c < '1' || c > '9')) return nullptr;
           conv->width.set_from_arg(parse_digits());
-          if (ABSL_PREDICT_FALSE(c != '$')) return nullptr;
-          ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
+          if (Y_ABSL_PREDICT_FALSE(c != '$')) return nullptr;
+          Y_ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
         } else {
           conv->width.set_from_arg(++*next_arg);
         }
@@ -181,16 +181,16 @@ const char *ConsumeConversion(const char *pos, const char *const end,
 
     if (c == '.') {
       conv->flags = conv->flags | Flags::kNonBasic;
-      ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
+      Y_ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
       if (std::isdigit(c)) {
         conv->precision.set_value(parse_digits());
       } else if (c == '*') {
-        ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
+        Y_ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
         if (is_positional) {
-          if (ABSL_PREDICT_FALSE(c < '1' || c > '9')) return nullptr;
+          if (Y_ABSL_PREDICT_FALSE(c < '1' || c > '9')) return nullptr;
           conv->precision.set_from_arg(parse_digits());
           if (c != '$') return nullptr;
-          ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
+          Y_ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
         } else {
           conv->precision.set_from_arg(++*next_arg);
         }
@@ -202,24 +202,24 @@ const char *ConsumeConversion(const char *pos, const char *const end,
 
   auto tag = GetTagForChar(c);
 
-  if (ABSL_PREDICT_FALSE(!tag.is_conv())) {
-    if (ABSL_PREDICT_FALSE(!tag.is_length())) return nullptr;
+  if (Y_ABSL_PREDICT_FALSE(!tag.is_conv())) {
+    if (Y_ABSL_PREDICT_FALSE(!tag.is_length())) return nullptr;
 
     // It is a length modifier.
     using str_format_internal::LengthMod;
     LengthMod length_mod = tag.as_length();
-    ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
+    Y_ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
     if (c == 'h' && length_mod == LengthMod::h) {
       conv->length_mod = LengthMod::hh;
-      ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
+      Y_ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
     } else if (c == 'l' && length_mod == LengthMod::l) {
       conv->length_mod = LengthMod::ll;
-      ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
+      Y_ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
     } else {
       conv->length_mod = length_mod;
     }
     tag = GetTagForChar(c);
-    if (ABSL_PREDICT_FALSE(!tag.is_conv())) return nullptr;
+    if (Y_ABSL_PREDICT_FALSE(!tag.is_conv())) return nullptr;
   }
 
   assert(CheckFastPathSetting(*conv));
@@ -335,5 +335,5 @@ bool ParsedFormatBase::MatchesConversions(
 }
 
 }  // namespace str_format_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.h
index ba614bb8b4..68b6654be9 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_PARSER_H_
-#define ABSL_STRINGS_INTERNAL_STR_FORMAT_PARSER_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_STR_FORMAT_PARSER_H_
+#define Y_ABSL_STRINGS_INTERNAL_STR_FORMAT_PARSER_H_
 
 #include <limits.h>
 #include <stddef.h>
@@ -32,7 +32,7 @@
 #include "y_absl/strings/internal/str_format/extension.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace str_format_internal {
 
 enum class LengthMod : std::uint8_t { h, hh, l, ll, L, j, z, t, q, none };
@@ -157,14 +157,14 @@ bool ParseFormatString(string_view src, Consumer consumer) {
       return consumer.Append(string_view(p, end - p));
     }
     // We found a percent, so push the text run then process the percent.
-    if (ABSL_PREDICT_FALSE(!consumer.Append(string_view(p, percent - p)))) {
+    if (Y_ABSL_PREDICT_FALSE(!consumer.Append(string_view(p, percent - p)))) {
       return false;
     }
-    if (ABSL_PREDICT_FALSE(percent + 1 >= end)) return false;
+    if (Y_ABSL_PREDICT_FALSE(percent + 1 >= end)) return false;
 
     auto tag = GetTagForChar(percent[1]);
     if (tag.is_conv()) {
-      if (ABSL_PREDICT_FALSE(next_arg < 0)) {
+      if (Y_ABSL_PREDICT_FALSE(next_arg < 0)) {
         // This indicates an error in the format string.
         // The only way to get `next_arg < 0` here is to have a positional
         // argument first which sets next_arg to -1 and then a non-positional
@@ -179,20 +179,20 @@ bool ParseFormatString(string_view src, Consumer consumer) {
       UnboundConversion conv;
       conv.conv = tag.as_conv();
       conv.arg_position = ++next_arg;
-      if (ABSL_PREDICT_FALSE(
+      if (Y_ABSL_PREDICT_FALSE(
               !consumer.ConvertOne(conv, string_view(percent + 1, 1)))) {
         return false;
       }
     } else if (percent[1] != '%') {
       UnboundConversion conv;
       p = ConsumeUnboundConversion(percent + 1, end, &conv, &next_arg);
-      if (ABSL_PREDICT_FALSE(p == nullptr)) return false;
-      if (ABSL_PREDICT_FALSE(!consumer.ConvertOne(
+      if (Y_ABSL_PREDICT_FALSE(p == nullptr)) return false;
+      if (Y_ABSL_PREDICT_FALSE(!consumer.ConvertOne(
           conv, string_view(percent + 1, p - (percent + 1))))) {
         return false;
       }
     } else {
-      if (ABSL_PREDICT_FALSE(!consumer.Append("%"))) return false;
+      if (Y_ABSL_PREDICT_FALSE(!consumer.Append("%"))) return false;
       p = percent + 2;
       continue;
     }
@@ -308,13 +308,13 @@ template <FormatConversionCharSet... C>
 class ExtendedParsedFormat : public str_format_internal::ParsedFormatBase {
  public:
   explicit ExtendedParsedFormat(string_view format)
-#ifdef ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
+#ifdef Y_ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
       __attribute__((
           enable_if(str_format_internal::EnsureConstexpr(format),
                     "Format string is not constexpr."),
           enable_if(str_format_internal::ValidFormatImpl<C...>(format),
                     "Format specified does not match the template arguments.")))
-#endif  // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
+#endif  // Y_ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
       : ExtendedParsedFormat(format, false) {
   }
 
@@ -351,7 +351,7 @@ class ExtendedParsedFormat : public str_format_internal::ParsedFormatBase {
       : ParsedFormatBase(s, allow_ignored, {C...}) {}
 };
 }  // namespace str_format_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_PARSER_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_STR_FORMAT_PARSER_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_join_internal.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_join_internal.h
index 0a220fa33d..7313192abf 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_join_internal.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_join_internal.h
@@ -28,8 +28,8 @@
 //
 // IWYU pragma: private, include "y_absl/strings/str_join.h"
 
-#ifndef ABSL_STRINGS_INTERNAL_STR_JOIN_INTERNAL_H_
-#define ABSL_STRINGS_INTERNAL_STR_JOIN_INTERNAL_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_STR_JOIN_INTERNAL_H_
+#define Y_ABSL_STRINGS_INTERNAL_STR_JOIN_INTERNAL_H_
 
 #include <cstring>
 #include <iterator>
@@ -43,7 +43,7 @@
 #include "y_absl/strings/str_cat.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 //
@@ -308,7 +308,7 @@ TString JoinRange(const Range& range, y_absl::string_view separator) {
 }
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_INTERNAL_STR_JOIN_INTERNAL_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_STR_JOIN_INTERNAL_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_split_internal.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_split_internal.h
index 237864c0ed..ed68b2e195 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_split_internal.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_split_internal.h
@@ -26,8 +26,8 @@
 //
 // IWYU pragma: private, include "y_absl/strings/str_split.h"
 
-#ifndef ABSL_STRINGS_INTERNAL_STR_SPLIT_INTERNAL_H_
-#define ABSL_STRINGS_INTERNAL_STR_SPLIT_INTERNAL_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_STR_SPLIT_INTERNAL_H_
+#define Y_ABSL_STRINGS_INTERNAL_STR_SPLIT_INTERNAL_H_
 
 #include <array>
 #include <initializer_list>
@@ -47,7 +47,7 @@
 #endif  // _GLIBCXX_DEBUG
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 // This class is implicitly constructible from everything that y_absl::string_view
@@ -424,7 +424,7 @@ class Splitter {
 };
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_INTERNAL_STR_SPLIT_INTERNAL_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_STR_SPLIT_INTERNAL_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/string_constant.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/string_constant.h
index b18e821b49..f46e814eff 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/string_constant.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/string_constant.h
@@ -12,14 +12,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_INTERNAL_STRING_CONSTANT_H_
-#define ABSL_STRINGS_INTERNAL_STRING_CONSTANT_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_STRING_CONSTANT_H_
+#define Y_ABSL_STRINGS_INTERNAL_STRING_CONSTANT_H_
 
 #include "y_absl/meta/type_traits.h"
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 // StringConstant<T> represents a compile time string constant.
@@ -58,7 +58,7 @@ constexpr StringConstant<T> MakeStringConstant(T) {
 }
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_INTERNAL_STRING_CONSTANT_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_STRING_CONSTANT_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/utf8.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/utf8.cc
index 06b1cae79d..bccb5bf81e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/utf8.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/utf8.cc
@@ -17,7 +17,7 @@
 #include "y_absl/strings/internal/utf8.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 size_t EncodeUTF8Char(char *buffer, char32_t utf8_char) {
@@ -49,5 +49,5 @@ size_t EncodeUTF8Char(char *buffer, char32_t utf8_char) {
 }
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/utf8.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/utf8.h
index 1b2d6abd51..0ad5052c21 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/utf8.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/utf8.h
@@ -14,8 +14,8 @@
 //
 // UTF8 utilities, implemented to reduce dependencies.
 
-#ifndef ABSL_STRINGS_INTERNAL_UTF8_H_
-#define ABSL_STRINGS_INTERNAL_UTF8_H_
+#ifndef Y_ABSL_STRINGS_INTERNAL_UTF8_H_
+#define Y_ABSL_STRINGS_INTERNAL_UTF8_H_
 
 #include <cstddef>
 #include <cstdint>
@@ -23,7 +23,7 @@
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 // For Unicode code points 0 through 0x10FFFF, EncodeUTF8Char writes
@@ -44,7 +44,7 @@ enum { kMaxEncodedUTF8Size = 4 };
 size_t EncodeUTF8Char(char *buffer, char32_t utf8_char);
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_INTERNAL_UTF8_H_
+#endif  // Y_ABSL_STRINGS_INTERNAL_UTF8_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/match.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/match.cc
index 3197bdf432..f02fa9465b 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/match.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/match.cc
@@ -17,7 +17,7 @@
 #include "y_absl/strings/internal/memutil.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 bool EqualsIgnoreCase(y_absl::string_view piece1,
                       y_absl::string_view piece2) noexcept {
@@ -39,5 +39,5 @@ bool EndsWithIgnoreCase(y_absl::string_view text,
          EqualsIgnoreCase(text.substr(text.size() - suffix.size()), suffix);
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/match.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/match.h
index 4709abc93f..4564eff97e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/match.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/match.h
@@ -30,15 +30,15 @@
 // Note: The order of parameters in these functions is designed to mimic the
 // order an equivalent member function would exhibit;
 // e.g. `s.Contains(x)` ==> `y_absl::StrContains(s, x).
-#ifndef ABSL_STRINGS_MATCH_H_
-#define ABSL_STRINGS_MATCH_H_
+#ifndef Y_ABSL_STRINGS_MATCH_H_
+#define Y_ABSL_STRINGS_MATCH_H_
 
 #include <cstring>
 
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // StrContains()
 //
@@ -94,7 +94,7 @@ bool StartsWithIgnoreCase(y_absl::string_view text,
 bool EndsWithIgnoreCase(y_absl::string_view text,
                         y_absl::string_view suffix) noexcept;
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_MATCH_H_
+#endif  // Y_ABSL_STRINGS_MATCH_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/numbers.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/numbers.cc
index 528d044fa6..fec739ec89 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/numbers.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/numbers.cc
@@ -41,7 +41,7 @@
 #include "y_absl/strings/str_cat.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 bool SimpleAtof(y_absl::string_view str, float* out) {
   *out = 0.0;
@@ -106,7 +106,7 @@ bool SimpleAtod(y_absl::string_view str, double* out) {
 }
 
 bool SimpleAtob(y_absl::string_view str, bool* out) {
-  ABSL_RAW_CHECK(out != nullptr, "Output pointer must not be nullptr.");
+  Y_ABSL_RAW_CHECK(out != nullptr, "Output pointer must not be nullptr.");
   if (EqualsIgnoreCase(str, "true") || EqualsIgnoreCase(str, "t") ||
       EqualsIgnoreCase(str, "yes") || EqualsIgnoreCase(str, "y") ||
       EqualsIgnoreCase(str, "1")) {
@@ -567,15 +567,15 @@ size_t numbers_internal::SixDigitsToBuffer(double d, char* const buffer) {
     case -4:
       out[2] = '0';
       ++out;
-      ABSL_FALLTHROUGH_INTENDED;
+      Y_ABSL_FALLTHROUGH_INTENDED;
     case -3:
       out[2] = '0';
       ++out;
-      ABSL_FALLTHROUGH_INTENDED;
+      Y_ABSL_FALLTHROUGH_INTENDED;
     case -2:
       out[2] = '0';
       ++out;
-      ABSL_FALLTHROUGH_INTENDED;
+      Y_ABSL_FALLTHROUGH_INTENDED;
     case -1:
       out += 2;
       memcpy(out, &digits[0], 6);
@@ -730,8 +730,8 @@ inline bool safe_parse_sign_and_base(y_absl::string_view* text /*inout*/,
 // commonly used bases.
 template <typename IntType>
 struct LookupTables {
-  ABSL_CONST_INIT static const IntType kVmaxOverBase[];
-  ABSL_CONST_INIT static const IntType kVminOverBase[];
+  Y_ABSL_CONST_INIT static const IntType kVmaxOverBase[];
+  Y_ABSL_CONST_INIT static const IntType kVminOverBase[];
 };
 
 // An array initializer macro for X/base where base in [0, 36].
@@ -1024,10 +1024,10 @@ inline bool safe_uint_internal(y_absl::string_view text, IntType* value_p,
 namespace numbers_internal {
 
 // Digit conversion.
-ABSL_CONST_INIT ABSL_DLL const char kHexChar[] =
+Y_ABSL_CONST_INIT Y_ABSL_DLL const char kHexChar[] =
     "0123456789abcdef";
 
-ABSL_CONST_INIT ABSL_DLL const char kHexTable[513] =
+Y_ABSL_CONST_INIT Y_ABSL_DLL const char kHexTable[513] =
     "000102030405060708090a0b0c0d0e0f"
     "101112131415161718191a1b1c1d1e1f"
     "202122232425262728292a2b2c2d2e2f"
@@ -1045,7 +1045,7 @@ ABSL_CONST_INIT ABSL_DLL const char kHexTable[513] =
     "e0e1e2e3e4e5e6e7e8e9eaebecedeeef"
     "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff";
 
-ABSL_CONST_INIT ABSL_DLL const char two_ASCII_digits[100][2] = {
+Y_ABSL_CONST_INIT Y_ABSL_DLL const char two_ASCII_digits[100][2] = {
     {'0', '0'}, {'0', '1'}, {'0', '2'}, {'0', '3'}, {'0', '4'}, {'0', '5'},
     {'0', '6'}, {'0', '7'}, {'0', '8'}, {'0', '9'}, {'1', '0'}, {'1', '1'},
     {'1', '2'}, {'1', '3'}, {'1', '4'}, {'1', '5'}, {'1', '6'}, {'1', '7'},
@@ -1089,5 +1089,5 @@ bool safe_strtou128_base(y_absl::string_view text, uint128* value, int base) {
 }
 
 }  // namespace numbers_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/numbers.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/numbers.h
index ce181d8eb1..bb2a2c35c6 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/numbers.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/numbers.h
@@ -20,8 +20,8 @@
 // converting numbers to strings, use `StrCat()` or `StrAppend()` in str_cat.h,
 // which automatically detect and convert most number values appropriately.
 
-#ifndef ABSL_STRINGS_NUMBERS_H_
-#define ABSL_STRINGS_NUMBERS_H_
+#ifndef Y_ABSL_STRINGS_NUMBERS_H_
+#define Y_ABSL_STRINGS_NUMBERS_H_
 
 #if defined(__SSE4_2__) && !defined(__CUDACC__)
 #define _Y__SSE4_2__
@@ -59,7 +59,7 @@
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // SimpleAtoi()
 //
@@ -70,7 +70,7 @@ ABSL_NAMESPACE_BEGIN
 // encountered, this function returns `false`, leaving `out` in an unspecified
 // state.
 template <typename int_type>
-ABSL_MUST_USE_RESULT bool SimpleAtoi(y_absl::string_view str, int_type* out);
+Y_ABSL_MUST_USE_RESULT bool SimpleAtoi(y_absl::string_view str, int_type* out);
 
 // SimpleAtof()
 //
@@ -81,7 +81,7 @@ ABSL_MUST_USE_RESULT bool SimpleAtoi(y_absl::string_view str, int_type* out);
 // allowed formats for `str`, except SimpleAtof() is locale-independent and will
 // always use the "C" locale. If any errors are encountered, this function
 // returns `false`, leaving `out` in an unspecified state.
-ABSL_MUST_USE_RESULT bool SimpleAtof(y_absl::string_view str, float* out);
+Y_ABSL_MUST_USE_RESULT bool SimpleAtof(y_absl::string_view str, float* out);
 
 // SimpleAtod()
 //
@@ -92,7 +92,7 @@ ABSL_MUST_USE_RESULT bool SimpleAtof(y_absl::string_view str, float* out);
 // allowed formats for `str`, except SimpleAtod is locale-independent and will
 // always use the "C" locale. If any errors are encountered, this function
 // returns `false`, leaving `out` in an unspecified state.
-ABSL_MUST_USE_RESULT bool SimpleAtod(y_absl::string_view str, double* out);
+Y_ABSL_MUST_USE_RESULT bool SimpleAtod(y_absl::string_view str, double* out);
 
 // SimpleAtob()
 //
@@ -102,7 +102,7 @@ ABSL_MUST_USE_RESULT bool SimpleAtod(y_absl::string_view str, double* out);
 // are interpreted as boolean `false`: "false", "f", "no", "n", "0". If any
 // errors are encountered, this function returns `false`, leaving `out` in an
 // unspecified state.
-ABSL_MUST_USE_RESULT bool SimpleAtob(y_absl::string_view str, bool* out);
+Y_ABSL_MUST_USE_RESULT bool SimpleAtob(y_absl::string_view str, bool* out);
 
 // SimpleHexAtoi()
 //
@@ -115,28 +115,28 @@ ABSL_MUST_USE_RESULT bool SimpleAtob(y_absl::string_view str, bool* out);
 // by this function. If any errors are encountered, this function returns
 // `false`, leaving `out` in an unspecified state.
 template <typename int_type>
-ABSL_MUST_USE_RESULT bool SimpleHexAtoi(y_absl::string_view str, int_type* out);
+Y_ABSL_MUST_USE_RESULT bool SimpleHexAtoi(y_absl::string_view str, int_type* out);
 
 // Overloads of SimpleHexAtoi() for 128 bit integers.
-ABSL_MUST_USE_RESULT inline bool SimpleHexAtoi(y_absl::string_view str,
+Y_ABSL_MUST_USE_RESULT inline bool SimpleHexAtoi(y_absl::string_view str,
                                                y_absl::int128* out);
-ABSL_MUST_USE_RESULT inline bool SimpleHexAtoi(y_absl::string_view str,
+Y_ABSL_MUST_USE_RESULT inline bool SimpleHexAtoi(y_absl::string_view str,
                                                y_absl::uint128* out);
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 // End of public API.  Implementation details follow.
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace numbers_internal {
 
 // Digit conversion.
-ABSL_DLL extern const char kHexChar[17];  // 0123456789abcdef
-ABSL_DLL extern const char
+Y_ABSL_DLL extern const char kHexChar[17];  // 0123456789abcdef
+Y_ABSL_DLL extern const char
     kHexTable[513];  // 000102030405060708090a0b0c0d0e0f1011...
-ABSL_DLL extern const char
+Y_ABSL_DLL extern const char
     two_ASCII_digits[100][2];  // 00, 01, 02, 03...
 
 // Writes a two-character representation of 'i' to 'buf'. 'i' must be in the
@@ -207,7 +207,7 @@ char* FastIntToBuffer(int_type i, char* buffer) {
 // Implementation of SimpleAtoi, generalized to support arbitrary base (used
 // with base different from 10 elsewhere in Abseil implementation).
 template <typename int_type>
-ABSL_MUST_USE_RESULT bool safe_strtoi_base(y_absl::string_view s, int_type* out,
+Y_ABSL_MUST_USE_RESULT bool safe_strtoi_base(y_absl::string_view s, int_type* out,
                                            int base) {
   static_assert(sizeof(*out) == 4 || sizeof(*out) == 8,
                 "SimpleAtoi works only with 32-bit or 64-bit integers.");
@@ -273,36 +273,36 @@ inline size_t FastHexToBufferZeroPad16(uint64_t val, char* out) {
 }  // namespace numbers_internal
 
 template <typename int_type>
-ABSL_MUST_USE_RESULT bool SimpleAtoi(y_absl::string_view str, int_type* out) {
+Y_ABSL_MUST_USE_RESULT bool SimpleAtoi(y_absl::string_view str, int_type* out) {
   return numbers_internal::safe_strtoi_base(str, out, 10);
 }
 
-ABSL_MUST_USE_RESULT inline bool SimpleAtoi(y_absl::string_view str,
+Y_ABSL_MUST_USE_RESULT inline bool SimpleAtoi(y_absl::string_view str,
                                             y_absl::int128* out) {
   return numbers_internal::safe_strto128_base(str, out, 10);
 }
 
-ABSL_MUST_USE_RESULT inline bool SimpleAtoi(y_absl::string_view str,
+Y_ABSL_MUST_USE_RESULT inline bool SimpleAtoi(y_absl::string_view str,
                                             y_absl::uint128* out) {
   return numbers_internal::safe_strtou128_base(str, out, 10);
 }
 
 template <typename int_type>
-ABSL_MUST_USE_RESULT bool SimpleHexAtoi(y_absl::string_view str, int_type* out) {
+Y_ABSL_MUST_USE_RESULT bool SimpleHexAtoi(y_absl::string_view str, int_type* out) {
   return numbers_internal::safe_strtoi_base(str, out, 16);
 }
 
-ABSL_MUST_USE_RESULT inline bool SimpleHexAtoi(y_absl::string_view str,
+Y_ABSL_MUST_USE_RESULT inline bool SimpleHexAtoi(y_absl::string_view str,
                                                y_absl::int128* out) {
   return numbers_internal::safe_strto128_base(str, out, 16);
 }
 
-ABSL_MUST_USE_RESULT inline bool SimpleHexAtoi(y_absl::string_view str,
+Y_ABSL_MUST_USE_RESULT inline bool SimpleHexAtoi(y_absl::string_view str,
                                                y_absl::uint128* out) {
   return numbers_internal::safe_strtou128_base(str, out, 16);
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_NUMBERS_H_
+#endif  // Y_ABSL_STRINGS_NUMBERS_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_cat.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_cat.cc
index 9e11702eae..b598201d45 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_cat.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_cat.cc
@@ -25,7 +25,7 @@
 #include "y_absl/strings/numbers.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 AlphaNum::AlphaNum(Hex hex) {
   static_assert(numbers_internal::kFastToBufferSize >= 32,
@@ -242,5 +242,5 @@ void StrAppend(TString* dest, const AlphaNum& a, const AlphaNum& b,
   assert(out == begin + dest->size());
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_cat.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_cat.h
index a77c9ae906..4f5e6e4df6 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_cat.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_cat.h
@@ -50,8 +50,8 @@
 //
 // -----------------------------------------------------------------------------
 
-#ifndef ABSL_STRINGS_STR_CAT_H_
-#define ABSL_STRINGS_STR_CAT_H_
+#ifndef Y_ABSL_STRINGS_STR_CAT_H_
+#define Y_ABSL_STRINGS_STR_CAT_H_
 
 #include <array>
 #include <cstdint>
@@ -64,7 +64,7 @@
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 namespace strings_internal {
 // AlphaNumBuffer allows a way to pass a string to StrCat without having to do
@@ -327,21 +327,21 @@ void AppendPieces(TString* dest,
 
 }  // namespace strings_internal
 
-ABSL_MUST_USE_RESULT inline TString StrCat() { return TString(); }
+Y_ABSL_MUST_USE_RESULT inline TString StrCat() { return TString(); }
 
-ABSL_MUST_USE_RESULT inline TString StrCat(const AlphaNum& a) {
+Y_ABSL_MUST_USE_RESULT inline TString StrCat(const AlphaNum& a) {
   return TString(a.data(), a.size());
 }
 
-ABSL_MUST_USE_RESULT TString StrCat(const AlphaNum& a, const AlphaNum& b);
-ABSL_MUST_USE_RESULT TString StrCat(const AlphaNum& a, const AlphaNum& b,
+Y_ABSL_MUST_USE_RESULT TString StrCat(const AlphaNum& a, const AlphaNum& b);
+Y_ABSL_MUST_USE_RESULT TString StrCat(const AlphaNum& a, const AlphaNum& b,
                                         const AlphaNum& c);
-ABSL_MUST_USE_RESULT TString StrCat(const AlphaNum& a, const AlphaNum& b,
+Y_ABSL_MUST_USE_RESULT TString StrCat(const AlphaNum& a, const AlphaNum& b,
                                         const AlphaNum& c, const AlphaNum& d);
 
 // Support 5 or more arguments
 template <typename... AV>
-ABSL_MUST_USE_RESULT inline TString StrCat(
+Y_ABSL_MUST_USE_RESULT inline TString StrCat(
     const AlphaNum& a, const AlphaNum& b, const AlphaNum& c, const AlphaNum& d,
     const AlphaNum& e, const AV&... args) {
   return strings_internal::CatPieces(
@@ -405,7 +405,7 @@ SixDigits(double d) {
   return result;
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_STR_CAT_H_
+#endif  // Y_ABSL_STRINGS_STR_CAT_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_format.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_format.h
index 4079f38fb4..099cd1b26a 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_format.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_format.h
@@ -67,8 +67,8 @@
 // In addition, the `str_format` library provides extension points for
 // augmenting formatting to new types.  See "StrFormat Extensions" below.
 
-#ifndef ABSL_STRINGS_STR_FORMAT_H_
-#define ABSL_STRINGS_STR_FORMAT_H_
+#ifndef Y_ABSL_STRINGS_STR_FORMAT_H_
+#define Y_ABSL_STRINGS_STR_FORMAT_H_
 
 #include <cstdio>
 #include <util/generic/string.h>
@@ -80,7 +80,7 @@
 #include "y_absl/strings/internal/str_format/parser.h"  // IWYU pragma: export
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // UntypedFormatSpec
 //
@@ -335,7 +335,7 @@ using ParsedFormat = str_format_internal::ExtendedParsedFormat<
 //
 // Returns an empty string in case of error.
 template <typename... Args>
-ABSL_MUST_USE_RESULT TString StrFormat(const FormatSpec<Args...>& format,
+Y_ABSL_MUST_USE_RESULT TString StrFormat(const FormatSpec<Args...>& format,
                                            const Args&... args) {
   return str_format_internal::FormatPack(
       str_format_internal::UntypedFormatSpecImpl::Extract(format),
@@ -372,7 +372,7 @@ TString& StrAppendFormat(TString* dst,
 //
 //   std::cout << StreamFormat("%12.6f", 3.14);
 template <typename... Args>
-ABSL_MUST_USE_RESULT str_format_internal::Streamable StreamFormat(
+Y_ABSL_MUST_USE_RESULT str_format_internal::Streamable StreamFormat(
     const FormatSpec<Args...>& format, const Args&... args) {
   return str_format_internal::Streamable(
       str_format_internal::UntypedFormatSpecImpl::Extract(format),
@@ -558,7 +558,7 @@ using FormatArg = str_format_internal::FormatArgImpl;
 //     return std::move(out);
 //   }
 //
-ABSL_MUST_USE_RESULT inline bool FormatUntyped(
+Y_ABSL_MUST_USE_RESULT inline bool FormatUntyped(
     FormatRawSink raw_sink, const UntypedFormatSpec& format,
     y_absl::Span<const FormatArg> args) {
   return str_format_internal::FormatUntyped(
@@ -806,7 +806,7 @@ struct FormatConvertResult {
   bool value;
 };
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_STR_FORMAT_H_
+#endif  // Y_ABSL_STRINGS_STR_FORMAT_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_join.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_join.h
index 46a0323c6e..613934b466 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_join.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_join.h
@@ -43,8 +43,8 @@
 //
 // See comments on the `y_absl::StrJoin()` function for more examples.
 
-#ifndef ABSL_STRINGS_STR_JOIN_H_
-#define ABSL_STRINGS_STR_JOIN_H_
+#ifndef Y_ABSL_STRINGS_STR_JOIN_H_
+#define Y_ABSL_STRINGS_STR_JOIN_H_
 
 #include <cstdio>
 #include <cstring>
@@ -60,7 +60,7 @@
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // -----------------------------------------------------------------------------
 // Concept: Formatter
@@ -287,7 +287,7 @@ TString StrJoin(const std::tuple<T...>& value,
   return strings_internal::JoinAlgorithm(value, separator, AlphaNumFormatter());
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_STR_JOIN_H_
+#endif  // Y_ABSL_STRINGS_STR_JOIN_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_replace.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_replace.cc
index 77b78c6c16..1dc9915ea0 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_replace.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_replace.cc
@@ -17,7 +17,7 @@
 #include "y_absl/strings/str_cat.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 using FixedMapping =
@@ -78,5 +78,5 @@ int StrReplaceAll(strings_internal::FixedMapping replacements,
   return StrReplaceAll<strings_internal::FixedMapping>(replacements, target);
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_replace.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_replace.h
index 42c85616a0..af59f42e74 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_replace.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_replace.h
@@ -35,8 +35,8 @@
 //                                                {">", "&gt;"},
 //                                                {"\"", "&quot;"},
 //                                                {"'", "&#39;"}});
-#ifndef ABSL_STRINGS_STR_REPLACE_H_
-#define ABSL_STRINGS_STR_REPLACE_H_
+#ifndef Y_ABSL_STRINGS_STR_REPLACE_H_
+#define Y_ABSL_STRINGS_STR_REPLACE_H_
 
 #include <util/generic/string.h>
 #include <utility>
@@ -46,7 +46,7 @@
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // StrReplaceAll()
 //
@@ -65,7 +65,7 @@ ABSL_NAMESPACE_BEGIN
 //        {"$who", "Bob"},
 //        {"#Noun", "Apples"}});
 //   EXPECT_EQ("Bob bought 5 Apples. Thanks Bob!", s);
-ABSL_MUST_USE_RESULT TString StrReplaceAll(
+Y_ABSL_MUST_USE_RESULT TString StrReplaceAll(
     y_absl::string_view s,
     std::initializer_list<std::pair<y_absl::string_view, y_absl::string_view>>
         replacements);
@@ -213,7 +213,7 @@ int StrReplaceAll(const StrToStrMapping& replacements, TString* target) {
   return substitutions;
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_STR_REPLACE_H_
+#endif  // Y_ABSL_STRINGS_STR_REPLACE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_split.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_split.cc
index 5f9193e6ba..1c52a152f8 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_split.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_split.cc
@@ -27,7 +27,7 @@
 #include "y_absl/strings/ascii.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 namespace {
 
@@ -120,7 +120,7 @@ y_absl::string_view ByAnyChar::Find(y_absl::string_view text, size_t pos) const
 // ByLength
 //
 ByLength::ByLength(ptrdiff_t length) : length_(length) {
-  ABSL_RAW_CHECK(length > 0, "");
+  Y_ABSL_RAW_CHECK(length > 0, "");
 }
 
 y_absl::string_view ByLength::Find(y_absl::string_view text,
@@ -135,5 +135,5 @@ y_absl::string_view ByLength::Find(y_absl::string_view text,
   return y_absl::string_view(substr.data() + length_, 0);
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_split.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_split.h
index d32d54813e..6b3faa11ea 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_split.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/str_split.h
@@ -32,8 +32,8 @@
 //   // v[0] == "a", v[1] == "b", v[2] == "c"
 //
 // See StrSplit() below for more information.
-#ifndef ABSL_STRINGS_STR_SPLIT_H_
-#define ABSL_STRINGS_STR_SPLIT_H_
+#ifndef Y_ABSL_STRINGS_STR_SPLIT_H_
+#define Y_ABSL_STRINGS_STR_SPLIT_H_
 
 #include <algorithm>
 #include <cstddef>
@@ -50,7 +50,7 @@
 #include "y_absl/strings/strip.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 //------------------------------------------------------------------------------
 // Delimiters
@@ -542,7 +542,7 @@ StrSplit(StringType&& text, Delimiter d, Predicate p) {
       std::move(text), DelimiterType(d), std::move(p));
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_STR_SPLIT_H_
+#endif  // Y_ABSL_STRINGS_STR_SPLIT_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/string_view.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/string_view.cc
index 9893c7ab99..f58c65269b 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/string_view.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/string_view.cc
@@ -14,7 +14,7 @@
 
 #include "y_absl/strings/string_view.h"
 
-#ifndef ABSL_USES_STD_STRING_VIEW
+#ifndef Y_ABSL_USES_STD_STRING_VIEW
 
 #include <algorithm>
 #include <climits>
@@ -24,7 +24,7 @@
 #include "y_absl/strings/internal/memutil.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 namespace {
 void WritePadding(std::ostream& o, size_t pad) {
@@ -214,17 +214,17 @@ string_view::size_type string_view::find_last_not_of(
 // MSVC to choose only one definition for the symbol it decorates. See details
 // at https://msdn.microsoft.com/en-us/library/34h23df8(v=vs.100).aspx
 #ifdef _MSC_VER
-#define ABSL_STRING_VIEW_SELECTANY __declspec(selectany)
+#define Y_ABSL_STRING_VIEW_SELECTANY __declspec(selectany)
 #else
-#define ABSL_STRING_VIEW_SELECTANY
+#define Y_ABSL_STRING_VIEW_SELECTANY
 #endif
 
-ABSL_STRING_VIEW_SELECTANY
+Y_ABSL_STRING_VIEW_SELECTANY
 constexpr string_view::size_type string_view::npos;
-ABSL_STRING_VIEW_SELECTANY
+Y_ABSL_STRING_VIEW_SELECTANY
 constexpr string_view::size_type string_view::kMaxSize;
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_USES_STD_STRING_VIEW
+#endif  // Y_ABSL_USES_STD_STRING_VIEW
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/string_view.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/string_view.h
index c3906fe1c5..443759051e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/string_view.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/string_view.h
@@ -24,8 +24,8 @@
 //
 // This `y_absl::string_view` abstraction is designed to be a drop-in
 // replacement for the C++17 `std::string_view` abstraction.
-#ifndef ABSL_STRINGS_STRING_VIEW_H_
-#define ABSL_STRINGS_STRING_VIEW_H_
+#ifndef Y_ABSL_STRINGS_STRING_VIEW_H_
+#define Y_ABSL_STRINGS_STRING_VIEW_H_
 
 #include <algorithm>
 #include <cassert>
@@ -43,35 +43,35 @@
 #include "y_absl/base/optimization.h"
 #include "y_absl/base/port.h"
 
-#ifdef ABSL_USES_STD_STRING_VIEW
+#ifdef Y_ABSL_USES_STD_STRING_VIEW
 
 #include <string_view>  // IWYU pragma: export
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 using string_view = std::string_view;
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#else  // ABSL_USES_STD_STRING_VIEW
+#else  // Y_ABSL_USES_STD_STRING_VIEW
 
 #error "std::string_view should be used in all configurations"
 
-#if ABSL_HAVE_BUILTIN(__builtin_memcmp) || \
+#if Y_ABSL_HAVE_BUILTIN(__builtin_memcmp) || \
     (defined(__GNUC__) && !defined(__clang__))
-#define ABSL_INTERNAL_STRING_VIEW_MEMCMP __builtin_memcmp
-#else  // ABSL_HAVE_BUILTIN(__builtin_memcmp)
-#define ABSL_INTERNAL_STRING_VIEW_MEMCMP memcmp
-#endif  // ABSL_HAVE_BUILTIN(__builtin_memcmp)
+#define Y_ABSL_INTERNAL_STRING_VIEW_MEMCMP __builtin_memcmp
+#else  // Y_ABSL_HAVE_BUILTIN(__builtin_memcmp)
+#define Y_ABSL_INTERNAL_STRING_VIEW_MEMCMP memcmp
+#endif  // Y_ABSL_HAVE_BUILTIN(__builtin_memcmp)
 
 #if defined(__cplusplus) && __cplusplus >= 201402L
-#define ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR constexpr
+#define Y_ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR constexpr
 #else
-#define ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR
+#define Y_ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR
 #endif
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // y_absl::string_view
 //
@@ -190,7 +190,7 @@ class string_view {
   template <typename Allocator>
   string_view(  // NOLINT(runtime/explicit)
       const std::basic_string<char, std::char_traits<char>, Allocator>& str
-          ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
+          Y_ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
       // This is implemented in terms of `string_view(p, n)` so `str.size()`
       // doesn't need to be reevaluated after `ptr_` is set.
       // The length check is also skipped since it is unnecessary and causes
@@ -297,7 +297,7 @@ class string_view {
   // Returns the ith element of the `string_view` using the array operator.
   // Note that this operator does not perform any bounds checking.
   constexpr const_reference operator[](size_type i) const {
-    return ABSL_HARDENING_ASSERT(i < size()), ptr_[i];
+    return Y_ABSL_HARDENING_ASSERT(i < size()), ptr_[i];
   }
 
   // string_view::at()
@@ -306,7 +306,7 @@ class string_view {
   // and an exception of type `std::out_of_range` will be thrown on invalid
   // access.
   constexpr const_reference at(size_type i) const {
-    return ABSL_PREDICT_TRUE(i < size())
+    return Y_ABSL_PREDICT_TRUE(i < size())
                ? ptr_[i]
                : ((void)base_internal::ThrowStdOutOfRange(
                       "y_absl::string_view::at"),
@@ -317,14 +317,14 @@ class string_view {
   //
   // Returns the first element of a `string_view`.
   constexpr const_reference front() const {
-    return ABSL_HARDENING_ASSERT(!empty()), ptr_[0];
+    return Y_ABSL_HARDENING_ASSERT(!empty()), ptr_[0];
   }
 
   // string_view::back()
   //
   // Returns the last element of a `string_view`.
   constexpr const_reference back() const {
-    return ABSL_HARDENING_ASSERT(!empty()), ptr_[size() - 1];
+    return Y_ABSL_HARDENING_ASSERT(!empty()), ptr_[size() - 1];
   }
 
   // string_view::data()
@@ -342,8 +342,8 @@ class string_view {
   //
   // Removes the first `n` characters from the `string_view`. Note that the
   // underlying string is not changed, only the view.
-  ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR void remove_prefix(size_type n) {
-    ABSL_HARDENING_ASSERT(n <= length_);
+  Y_ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR void remove_prefix(size_type n) {
+    Y_ABSL_HARDENING_ASSERT(n <= length_);
     ptr_ += n;
     length_ -= n;
   }
@@ -352,15 +352,15 @@ class string_view {
   //
   // Removes the last `n` characters from the `string_view`. Note that the
   // underlying string is not changed, only the view.
-  ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR void remove_suffix(size_type n) {
-    ABSL_HARDENING_ASSERT(n <= length_);
+  Y_ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR void remove_suffix(size_type n) {
+    Y_ABSL_HARDENING_ASSERT(n <= length_);
     length_ -= n;
   }
 
   // string_view::swap()
   //
   // Swaps this `string_view` with another `string_view`.
-  ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR void swap(string_view& s) noexcept {
+  Y_ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR void swap(string_view& s) noexcept {
     auto t = *this;
     *this = s;
     s = t;
@@ -380,7 +380,7 @@ class string_view {
   // Copies the contents of the `string_view` at offset `pos` and length `n`
   // into `buf`.
   size_type copy(char* buf, size_type n, size_type pos = 0) const {
-    if (ABSL_PREDICT_FALSE(pos > length_)) {
+    if (Y_ABSL_PREDICT_FALSE(pos > length_)) {
       base_internal::ThrowStdOutOfRange("y_absl::string_view::copy");
     }
     size_type rlen = (std::min)(length_ - pos, n);
@@ -398,7 +398,7 @@ class string_view {
   // `pos > size`.
   // Use y_absl::ClippedSubstr if you need a truncating substr operation.
   constexpr string_view substr(size_type pos = 0, size_type n = npos) const {
-    return ABSL_PREDICT_FALSE(pos > length_)
+    return Y_ABSL_PREDICT_FALSE(pos > length_)
                ? (base_internal::ThrowStdOutOfRange(
                       "y_absl::string_view::substr"),
                   string_view())
@@ -415,7 +415,7 @@ class string_view {
     return CompareImpl(length_, x.length_,
                        Min(length_, x.length_) == 0
                            ? 0
-                           : ABSL_INTERNAL_STRING_VIEW_MEMCMP(
+                           : Y_ABSL_INTERNAL_STRING_VIEW_MEMCMP(
                                  ptr_, x.ptr_, Min(length_, x.length_)));
   }
 
@@ -608,7 +608,7 @@ class string_view {
       (std::numeric_limits<difference_type>::max)();
 
   static constexpr size_type CheckLengthInternal(size_type len) {
-    return ABSL_HARDENING_ASSERT(len <= kMaxSize), len;
+    return Y_ABSL_HARDENING_ASSERT(len <= kMaxSize), len;
   }
 
   static constexpr size_type StrlenInternal(const char* str) {
@@ -617,11 +617,11 @@ class string_view {
     const char* begin = str;
     while (*str != '\0') ++str;
     return str - begin;
-#elif ABSL_HAVE_BUILTIN(__builtin_strlen) || \
+#elif Y_ABSL_HAVE_BUILTIN(__builtin_strlen) || \
     (defined(__GNUC__) && !defined(__clang__))
     // GCC has __builtin_strlen according to
     // https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Other-Builtins.html, but
-    // ABSL_HAVE_BUILTIN doesn't detect that, so we use the extra checks above.
+    // Y_ABSL_HAVE_BUILTIN doesn't detect that, so we use the extra checks above.
     // __builtin_strlen is constexpr.
     return __builtin_strlen(str);
 #else
@@ -650,7 +650,7 @@ class string_view {
 constexpr bool operator==(string_view x, string_view y) noexcept {
   return x.size() == y.size() &&
          (x.empty() ||
-          ABSL_INTERNAL_STRING_VIEW_MEMCMP(x.data(), y.data(), x.size()) == 0);
+          Y_ABSL_INTERNAL_STRING_VIEW_MEMCMP(x.data(), y.data(), x.size()) == 0);
 }
 
 constexpr bool operator!=(string_view x, string_view y) noexcept {
@@ -676,16 +676,16 @@ constexpr bool operator>=(string_view x, string_view y) noexcept {
 // IO Insertion Operator
 std::ostream& operator<<(std::ostream& o, string_view piece);
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#undef ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR
-#undef ABSL_INTERNAL_STRING_VIEW_MEMCMP
+#undef Y_ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR
+#undef Y_ABSL_INTERNAL_STRING_VIEW_MEMCMP
 
-#endif  // ABSL_USES_STD_STRING_VIEW
+#endif  // Y_ABSL_USES_STD_STRING_VIEW
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // ClippedSubstr()
 //
@@ -706,7 +706,7 @@ constexpr string_view NullSafeStringView(const char* p) {
   return p ? string_view(p) : string_view();
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_STRING_VIEW_H_
+#endif  // Y_ABSL_STRINGS_STRING_VIEW_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/strip.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/strip.h
index 3164ff1ebc..c202cc68ba 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/strip.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/strip.h
@@ -18,8 +18,8 @@
 // -----------------------------------------------------------------------------
 //
 // This file contains various functions for stripping substrings from a string.
-#ifndef ABSL_STRINGS_STRIP_H_
-#define ABSL_STRINGS_STRIP_H_
+#ifndef Y_ABSL_STRINGS_STRIP_H_
+#define Y_ABSL_STRINGS_STRIP_H_
 
 #include <cstddef>
 #include <util/generic/string.h>
@@ -30,7 +30,7 @@
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // ConsumePrefix()
 //
@@ -68,7 +68,7 @@ inline bool ConsumeSuffix(y_absl::string_view* str, y_absl::string_view expected
 // Returns a view into the input string 'str' with the given 'prefix' removed,
 // but leaving the original string intact. If the prefix does not match at the
 // start of the string, returns the original string instead.
-ABSL_MUST_USE_RESULT inline y_absl::string_view StripPrefix(
+Y_ABSL_MUST_USE_RESULT inline y_absl::string_view StripPrefix(
     y_absl::string_view str, y_absl::string_view prefix) {
   if (y_absl::StartsWith(str, prefix)) str.remove_prefix(prefix.size());
   return str;
@@ -79,13 +79,13 @@ ABSL_MUST_USE_RESULT inline y_absl::string_view StripPrefix(
 // Returns a view into the input string 'str' with the given 'suffix' removed,
 // but leaving the original string intact. If the suffix does not match at the
 // end of the string, returns the original string instead.
-ABSL_MUST_USE_RESULT inline y_absl::string_view StripSuffix(
+Y_ABSL_MUST_USE_RESULT inline y_absl::string_view StripSuffix(
     y_absl::string_view str, y_absl::string_view suffix) {
   if (y_absl::EndsWith(str, suffix)) str.remove_suffix(suffix.size());
   return str;
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_STRIP_H_
+#endif  // Y_ABSL_STRINGS_STRIP_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/substitute.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/substitute.cc
index 177fba8cbe..5cee39e4a0 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/substitute.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/substitute.cc
@@ -23,7 +23,7 @@
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace substitute_internal {
 
 void SubstituteAndAppendArray(TString* output, y_absl::string_view format,
@@ -35,7 +35,7 @@ void SubstituteAndAppendArray(TString* output, y_absl::string_view format,
     if (format[i] == '$') {
       if (i + 1 >= format.size()) {
 #ifndef NDEBUG
-        ABSL_RAW_LOG(FATAL,
+        Y_ABSL_RAW_LOG(FATAL,
                      "Invalid y_absl::Substitute() format string: \"%s\".",
                      y_absl::CEscape(format).c_str());
 #endif
@@ -44,7 +44,7 @@ void SubstituteAndAppendArray(TString* output, y_absl::string_view format,
         int index = format[i + 1] - '0';
         if (static_cast<size_t>(index) >= num_args) {
 #ifndef NDEBUG
-          ABSL_RAW_LOG(
+          Y_ABSL_RAW_LOG(
               FATAL,
               "Invalid y_absl::Substitute() format string: asked for \"$"
               "%d\", but only %d args were given.  Full format string was: "
@@ -60,7 +60,7 @@ void SubstituteAndAppendArray(TString* output, y_absl::string_view format,
         ++i;  // Skip next char.
       } else {
 #ifndef NDEBUG
-        ABSL_RAW_LOG(FATAL,
+        Y_ABSL_RAW_LOG(FATAL,
                      "Invalid y_absl::Substitute() format string: \"%s\".",
                      y_absl::CEscape(format).c_str());
 #endif
@@ -168,5 +168,5 @@ Arg::Arg(Dec dec) {
 }
 
 }  // namespace substitute_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/substitute.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/substitute.h
index c31191fbda..f956619957 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/substitute.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/substitute.h
@@ -67,8 +67,8 @@
 //     e.g. "Hello $f".
 // In debug mode, i.e. #ifndef NDEBUG, such errors terminate the program.
 
-#ifndef ABSL_STRINGS_SUBSTITUTE_H_
-#define ABSL_STRINGS_SUBSTITUTE_H_
+#ifndef Y_ABSL_STRINGS_SUBSTITUTE_H_
+#define Y_ABSL_STRINGS_SUBSTITUTE_H_
 
 #include <cstring>
 #include <util/generic/string.h>
@@ -86,7 +86,7 @@
 #include "y_absl/strings/strip.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace substitute_internal {
 
 // Arg
@@ -192,7 +192,7 @@ void SubstituteAndAppendArray(TString* output, y_absl::string_view format,
                               const y_absl::string_view* args_array,
                               size_t num_args);
 
-#if defined(ABSL_BAD_CALL_IF)
+#if defined(Y_ABSL_BAD_CALL_IF)
 constexpr int CalculateOneBit(const char* format) {
   // Returns:
   // * 2^N for '$N' when N is in [0-9]
@@ -213,7 +213,7 @@ constexpr int PlaceholderBitmask(const char* format) {
                               : (CalculateOneBit(format + 1) |
                                  PlaceholderBitmask(SkipNumber(format + 1)));
 }
-#endif  // ABSL_BAD_CALL_IF
+#endif  // Y_ABSL_BAD_CALL_IF
 
 }  // namespace substitute_internal
 
@@ -247,7 +247,7 @@ inline void SubstituteAndAppend(TString* output, y_absl::string_view format,
                                 const substitute_internal::Arg& a0) {
   const y_absl::string_view args[] = {a0.piece()};
   substitute_internal::SubstituteAndAppendArray(output, format, args,
-                                                ABSL_ARRAYSIZE(args));
+                                                Y_ABSL_ARRAYSIZE(args));
 }
 
 inline void SubstituteAndAppend(TString* output, y_absl::string_view format,
@@ -255,7 +255,7 @@ inline void SubstituteAndAppend(TString* output, y_absl::string_view format,
                                 const substitute_internal::Arg& a1) {
   const y_absl::string_view args[] = {a0.piece(), a1.piece()};
   substitute_internal::SubstituteAndAppendArray(output, format, args,
-                                                ABSL_ARRAYSIZE(args));
+                                                Y_ABSL_ARRAYSIZE(args));
 }
 
 inline void SubstituteAndAppend(TString* output, y_absl::string_view format,
@@ -264,7 +264,7 @@ inline void SubstituteAndAppend(TString* output, y_absl::string_view format,
                                 const substitute_internal::Arg& a2) {
   const y_absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece()};
   substitute_internal::SubstituteAndAppendArray(output, format, args,
-                                                ABSL_ARRAYSIZE(args));
+                                                Y_ABSL_ARRAYSIZE(args));
 }
 
 inline void SubstituteAndAppend(TString* output, y_absl::string_view format,
@@ -275,7 +275,7 @@ inline void SubstituteAndAppend(TString* output, y_absl::string_view format,
   const y_absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
                                     a3.piece()};
   substitute_internal::SubstituteAndAppendArray(output, format, args,
-                                                ABSL_ARRAYSIZE(args));
+                                                Y_ABSL_ARRAYSIZE(args));
 }
 
 inline void SubstituteAndAppend(TString* output, y_absl::string_view format,
@@ -287,7 +287,7 @@ inline void SubstituteAndAppend(TString* output, y_absl::string_view format,
   const y_absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
                                     a3.piece(), a4.piece()};
   substitute_internal::SubstituteAndAppendArray(output, format, args,
-                                                ABSL_ARRAYSIZE(args));
+                                                Y_ABSL_ARRAYSIZE(args));
 }
 
 inline void SubstituteAndAppend(TString* output, y_absl::string_view format,
@@ -300,7 +300,7 @@ inline void SubstituteAndAppend(TString* output, y_absl::string_view format,
   const y_absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
                                     a3.piece(), a4.piece(), a5.piece()};
   substitute_internal::SubstituteAndAppendArray(output, format, args,
-                                                ABSL_ARRAYSIZE(args));
+                                                Y_ABSL_ARRAYSIZE(args));
 }
 
 inline void SubstituteAndAppend(TString* output, y_absl::string_view format,
@@ -315,7 +315,7 @@ inline void SubstituteAndAppend(TString* output, y_absl::string_view format,
                                     a3.piece(), a4.piece(), a5.piece(),
                                     a6.piece()};
   substitute_internal::SubstituteAndAppendArray(output, format, args,
-                                                ABSL_ARRAYSIZE(args));
+                                                Y_ABSL_ARRAYSIZE(args));
 }
 
 inline void SubstituteAndAppend(
@@ -328,7 +328,7 @@ inline void SubstituteAndAppend(
                                     a3.piece(), a4.piece(), a5.piece(),
                                     a6.piece(), a7.piece()};
   substitute_internal::SubstituteAndAppendArray(output, format, args,
-                                                ABSL_ARRAYSIZE(args));
+                                                Y_ABSL_ARRAYSIZE(args));
 }
 
 inline void SubstituteAndAppend(
@@ -342,7 +342,7 @@ inline void SubstituteAndAppend(
                                     a3.piece(), a4.piece(), a5.piece(),
                                     a6.piece(), a7.piece(), a8.piece()};
   substitute_internal::SubstituteAndAppendArray(output, format, args,
-                                                ABSL_ARRAYSIZE(args));
+                                                Y_ABSL_ARRAYSIZE(args));
 }
 
 inline void SubstituteAndAppend(
@@ -356,14 +356,14 @@ inline void SubstituteAndAppend(
       a0.piece(), a1.piece(), a2.piece(), a3.piece(), a4.piece(),
       a5.piece(), a6.piece(), a7.piece(), a8.piece(), a9.piece()};
   substitute_internal::SubstituteAndAppendArray(output, format, args,
-                                                ABSL_ARRAYSIZE(args));
+                                                Y_ABSL_ARRAYSIZE(args));
 }
 
-#if defined(ABSL_BAD_CALL_IF)
+#if defined(Y_ABSL_BAD_CALL_IF)
 // This body of functions catches cases where the number of placeholders
 // doesn't match the number of data arguments.
 void SubstituteAndAppend(TString* output, const char* format)
-    ABSL_BAD_CALL_IF(
+    Y_ABSL_BAD_CALL_IF(
         substitute_internal::PlaceholderBitmask(format) != 0,
         "There were no substitution arguments "
         "but this format string either has a $[0-9] in it or contains "
@@ -371,7 +371,7 @@ void SubstituteAndAppend(TString* output, const char* format)
 
 void SubstituteAndAppend(TString* output, const char* format,
                          const substitute_internal::Arg& a0)
-    ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 1,
+    Y_ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 1,
                      "There was 1 substitution argument given, but "
                      "this format string is missing its $0, contains "
                      "one of $1-$9, or contains an unescaped $ character (use "
@@ -380,7 +380,7 @@ void SubstituteAndAppend(TString* output, const char* format,
 void SubstituteAndAppend(TString* output, const char* format,
                          const substitute_internal::Arg& a0,
                          const substitute_internal::Arg& a1)
-    ABSL_BAD_CALL_IF(
+    Y_ABSL_BAD_CALL_IF(
         substitute_internal::PlaceholderBitmask(format) != 3,
         "There were 2 substitution arguments given, but this format string is "
         "missing its $0/$1, contains one of $2-$9, or contains an "
@@ -390,7 +390,7 @@ void SubstituteAndAppend(TString* output, const char* format,
                          const substitute_internal::Arg& a0,
                          const substitute_internal::Arg& a1,
                          const substitute_internal::Arg& a2)
-    ABSL_BAD_CALL_IF(
+    Y_ABSL_BAD_CALL_IF(
         substitute_internal::PlaceholderBitmask(format) != 7,
         "There were 3 substitution arguments given, but "
         "this format string is missing its $0/$1/$2, contains one of "
@@ -401,7 +401,7 @@ void SubstituteAndAppend(TString* output, const char* format,
                          const substitute_internal::Arg& a1,
                          const substitute_internal::Arg& a2,
                          const substitute_internal::Arg& a3)
-    ABSL_BAD_CALL_IF(
+    Y_ABSL_BAD_CALL_IF(
         substitute_internal::PlaceholderBitmask(format) != 15,
         "There were 4 substitution arguments given, but "
         "this format string is missing its $0-$3, contains one of "
@@ -413,7 +413,7 @@ void SubstituteAndAppend(TString* output, const char* format,
                          const substitute_internal::Arg& a2,
                          const substitute_internal::Arg& a3,
                          const substitute_internal::Arg& a4)
-    ABSL_BAD_CALL_IF(
+    Y_ABSL_BAD_CALL_IF(
         substitute_internal::PlaceholderBitmask(format) != 31,
         "There were 5 substitution arguments given, but "
         "this format string is missing its $0-$4, contains one of "
@@ -426,7 +426,7 @@ void SubstituteAndAppend(TString* output, const char* format,
                          const substitute_internal::Arg& a3,
                          const substitute_internal::Arg& a4,
                          const substitute_internal::Arg& a5)
-    ABSL_BAD_CALL_IF(
+    Y_ABSL_BAD_CALL_IF(
         substitute_internal::PlaceholderBitmask(format) != 63,
         "There were 6 substitution arguments given, but "
         "this format string is missing its $0-$5, contains one of "
@@ -437,7 +437,7 @@ void SubstituteAndAppend(
     const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
     const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
     const substitute_internal::Arg& a5, const substitute_internal::Arg& a6)
-    ABSL_BAD_CALL_IF(
+    Y_ABSL_BAD_CALL_IF(
         substitute_internal::PlaceholderBitmask(format) != 127,
         "There were 7 substitution arguments given, but "
         "this format string is missing its $0-$6, contains one of "
@@ -449,7 +449,7 @@ void SubstituteAndAppend(
     const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
     const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
     const substitute_internal::Arg& a7)
-    ABSL_BAD_CALL_IF(
+    Y_ABSL_BAD_CALL_IF(
         substitute_internal::PlaceholderBitmask(format) != 255,
         "There were 8 substitution arguments given, but "
         "this format string is missing its $0-$7, contains one of "
@@ -461,7 +461,7 @@ void SubstituteAndAppend(
     const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
     const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
     const substitute_internal::Arg& a7, const substitute_internal::Arg& a8)
-    ABSL_BAD_CALL_IF(
+    Y_ABSL_BAD_CALL_IF(
         substitute_internal::PlaceholderBitmask(format) != 511,
         "There were 9 substitution arguments given, but "
         "this format string is missing its $0-$8, contains a $9, or "
@@ -474,12 +474,12 @@ void SubstituteAndAppend(
     const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
     const substitute_internal::Arg& a7, const substitute_internal::Arg& a8,
     const substitute_internal::Arg& a9)
-    ABSL_BAD_CALL_IF(
+    Y_ABSL_BAD_CALL_IF(
         substitute_internal::PlaceholderBitmask(format) != 1023,
         "There were 10 substitution arguments given, but this "
         "format string either doesn't contain all of $0 through $9 or "
         "contains an unescaped $ character (use $$ instead)");
-#endif  // ABSL_BAD_CALL_IF
+#endif  // Y_ABSL_BAD_CALL_IF
 
 // Substitute()
 //
@@ -497,20 +497,20 @@ void SubstituteAndAppend(
 //  void VarMsg(y_absl::string_view format, const Args&... args) {
 //    TString s = y_absl::Substitute(format, args...);
 
-ABSL_MUST_USE_RESULT inline TString Substitute(y_absl::string_view format) {
+Y_ABSL_MUST_USE_RESULT inline TString Substitute(y_absl::string_view format) {
   TString result;
   SubstituteAndAppend(&result, format);
   return result;
 }
 
-ABSL_MUST_USE_RESULT inline TString Substitute(
+Y_ABSL_MUST_USE_RESULT inline TString Substitute(
     y_absl::string_view format, const substitute_internal::Arg& a0) {
   TString result;
   SubstituteAndAppend(&result, format, a0);
   return result;
 }
 
-ABSL_MUST_USE_RESULT inline TString Substitute(
+Y_ABSL_MUST_USE_RESULT inline TString Substitute(
     y_absl::string_view format, const substitute_internal::Arg& a0,
     const substitute_internal::Arg& a1) {
   TString result;
@@ -518,7 +518,7 @@ ABSL_MUST_USE_RESULT inline TString Substitute(
   return result;
 }
 
-ABSL_MUST_USE_RESULT inline TString Substitute(
+Y_ABSL_MUST_USE_RESULT inline TString Substitute(
     y_absl::string_view format, const substitute_internal::Arg& a0,
     const substitute_internal::Arg& a1, const substitute_internal::Arg& a2) {
   TString result;
@@ -526,7 +526,7 @@ ABSL_MUST_USE_RESULT inline TString Substitute(
   return result;
 }
 
-ABSL_MUST_USE_RESULT inline TString Substitute(
+Y_ABSL_MUST_USE_RESULT inline TString Substitute(
     y_absl::string_view format, const substitute_internal::Arg& a0,
     const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
     const substitute_internal::Arg& a3) {
@@ -535,7 +535,7 @@ ABSL_MUST_USE_RESULT inline TString Substitute(
   return result;
 }
 
-ABSL_MUST_USE_RESULT inline TString Substitute(
+Y_ABSL_MUST_USE_RESULT inline TString Substitute(
     y_absl::string_view format, const substitute_internal::Arg& a0,
     const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
     const substitute_internal::Arg& a3, const substitute_internal::Arg& a4) {
@@ -544,7 +544,7 @@ ABSL_MUST_USE_RESULT inline TString Substitute(
   return result;
 }
 
-ABSL_MUST_USE_RESULT inline TString Substitute(
+Y_ABSL_MUST_USE_RESULT inline TString Substitute(
     y_absl::string_view format, const substitute_internal::Arg& a0,
     const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
     const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
@@ -554,7 +554,7 @@ ABSL_MUST_USE_RESULT inline TString Substitute(
   return result;
 }
 
-ABSL_MUST_USE_RESULT inline TString Substitute(
+Y_ABSL_MUST_USE_RESULT inline TString Substitute(
     y_absl::string_view format, const substitute_internal::Arg& a0,
     const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
     const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
@@ -564,7 +564,7 @@ ABSL_MUST_USE_RESULT inline TString Substitute(
   return result;
 }
 
-ABSL_MUST_USE_RESULT inline TString Substitute(
+Y_ABSL_MUST_USE_RESULT inline TString Substitute(
     y_absl::string_view format, const substitute_internal::Arg& a0,
     const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
     const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
@@ -575,7 +575,7 @@ ABSL_MUST_USE_RESULT inline TString Substitute(
   return result;
 }
 
-ABSL_MUST_USE_RESULT inline TString Substitute(
+Y_ABSL_MUST_USE_RESULT inline TString Substitute(
     y_absl::string_view format, const substitute_internal::Arg& a0,
     const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
     const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
@@ -586,7 +586,7 @@ ABSL_MUST_USE_RESULT inline TString Substitute(
   return result;
 }
 
-ABSL_MUST_USE_RESULT inline TString Substitute(
+Y_ABSL_MUST_USE_RESULT inline TString Substitute(
     y_absl::string_view format, const substitute_internal::Arg& a0,
     const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
     const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
@@ -598,17 +598,17 @@ ABSL_MUST_USE_RESULT inline TString Substitute(
   return result;
 }
 
-#if defined(ABSL_BAD_CALL_IF)
+#if defined(Y_ABSL_BAD_CALL_IF)
 // This body of functions catches cases where the number of placeholders
 // doesn't match the number of data arguments.
 TString Substitute(const char* format)
-    ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 0,
+    Y_ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 0,
                      "There were no substitution arguments "
                      "but this format string either has a $[0-9] in it or "
                      "contains an unescaped $ character (use $$ instead)");
 
 TString Substitute(const char* format, const substitute_internal::Arg& a0)
-    ABSL_BAD_CALL_IF(
+    Y_ABSL_BAD_CALL_IF(
         substitute_internal::PlaceholderBitmask(format) != 1,
         "There was 1 substitution argument given, but "
         "this format string is missing its $0, contains one of $1-$9, "
@@ -616,7 +616,7 @@ TString Substitute(const char* format, const substitute_internal::Arg& a0)
 
 TString Substitute(const char* format, const substitute_internal::Arg& a0,
                        const substitute_internal::Arg& a1)
-    ABSL_BAD_CALL_IF(
+    Y_ABSL_BAD_CALL_IF(
         substitute_internal::PlaceholderBitmask(format) != 3,
         "There were 2 substitution arguments given, but "
         "this format string is missing its $0/$1, contains one of "
@@ -625,7 +625,7 @@ TString Substitute(const char* format, const substitute_internal::Arg& a0,
 TString Substitute(const char* format, const substitute_internal::Arg& a0,
                        const substitute_internal::Arg& a1,
                        const substitute_internal::Arg& a2)
-    ABSL_BAD_CALL_IF(
+    Y_ABSL_BAD_CALL_IF(
         substitute_internal::PlaceholderBitmask(format) != 7,
         "There were 3 substitution arguments given, but "
         "this format string is missing its $0/$1/$2, contains one of "
@@ -635,7 +635,7 @@ TString Substitute(const char* format, const substitute_internal::Arg& a0,
                        const substitute_internal::Arg& a1,
                        const substitute_internal::Arg& a2,
                        const substitute_internal::Arg& a3)
-    ABSL_BAD_CALL_IF(
+    Y_ABSL_BAD_CALL_IF(
         substitute_internal::PlaceholderBitmask(format) != 15,
         "There were 4 substitution arguments given, but "
         "this format string is missing its $0-$3, contains one of "
@@ -646,7 +646,7 @@ TString Substitute(const char* format, const substitute_internal::Arg& a0,
                        const substitute_internal::Arg& a2,
                        const substitute_internal::Arg& a3,
                        const substitute_internal::Arg& a4)
-    ABSL_BAD_CALL_IF(
+    Y_ABSL_BAD_CALL_IF(
         substitute_internal::PlaceholderBitmask(format) != 31,
         "There were 5 substitution arguments given, but "
         "this format string is missing its $0-$4, contains one of "
@@ -658,7 +658,7 @@ TString Substitute(const char* format, const substitute_internal::Arg& a0,
                        const substitute_internal::Arg& a3,
                        const substitute_internal::Arg& a4,
                        const substitute_internal::Arg& a5)
-    ABSL_BAD_CALL_IF(
+    Y_ABSL_BAD_CALL_IF(
         substitute_internal::PlaceholderBitmask(format) != 63,
         "There were 6 substitution arguments given, but "
         "this format string is missing its $0-$5, contains one of "
@@ -671,7 +671,7 @@ TString Substitute(const char* format, const substitute_internal::Arg& a0,
                        const substitute_internal::Arg& a4,
                        const substitute_internal::Arg& a5,
                        const substitute_internal::Arg& a6)
-    ABSL_BAD_CALL_IF(
+    Y_ABSL_BAD_CALL_IF(
         substitute_internal::PlaceholderBitmask(format) != 127,
         "There were 7 substitution arguments given, but "
         "this format string is missing its $0-$6, contains one of "
@@ -685,7 +685,7 @@ TString Substitute(const char* format, const substitute_internal::Arg& a0,
                        const substitute_internal::Arg& a5,
                        const substitute_internal::Arg& a6,
                        const substitute_internal::Arg& a7)
-    ABSL_BAD_CALL_IF(
+    Y_ABSL_BAD_CALL_IF(
         substitute_internal::PlaceholderBitmask(format) != 255,
         "There were 8 substitution arguments given, but "
         "this format string is missing its $0-$7, contains one of "
@@ -697,7 +697,7 @@ TString Substitute(
     const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
     const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
     const substitute_internal::Arg& a7, const substitute_internal::Arg& a8)
-    ABSL_BAD_CALL_IF(
+    Y_ABSL_BAD_CALL_IF(
         substitute_internal::PlaceholderBitmask(format) != 511,
         "There were 9 substitution arguments given, but "
         "this format string is missing its $0-$8, contains a $9, or "
@@ -710,14 +710,14 @@ TString Substitute(
     const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
     const substitute_internal::Arg& a7, const substitute_internal::Arg& a8,
     const substitute_internal::Arg& a9)
-    ABSL_BAD_CALL_IF(
+    Y_ABSL_BAD_CALL_IF(
         substitute_internal::PlaceholderBitmask(format) != 1023,
         "There were 10 substitution arguments given, but this "
         "format string either doesn't contain all of $0 through $9 or "
         "contains an unescaped $ character (use $$ instead)");
-#endif  // ABSL_BAD_CALL_IF
+#endif  // Y_ABSL_BAD_CALL_IF
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_STRINGS_SUBSTITUTE_H_
+#endif  // Y_ABSL_STRINGS_SUBSTITUTE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/barrier.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/barrier.cc
index b03f0ff559..1313637067 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/barrier.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/barrier.cc
@@ -18,7 +18,7 @@
 #include "y_absl/synchronization/mutex.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // Return whether int *arg is zero.
 static bool IsZero(void *arg) {
@@ -30,7 +30,7 @@ bool Barrier::Block() {
 
   this->num_to_block_--;
   if (this->num_to_block_ < 0) {
-    ABSL_RAW_LOG(
+    Y_ABSL_RAW_LOG(
         FATAL,
         "Block() called too many times.  num_to_block_=%d out of total=%d",
         this->num_to_block_, this->num_to_exit_);
@@ -40,7 +40,7 @@ bool Barrier::Block() {
 
   // Determine which thread can safely delete this Barrier object
   this->num_to_exit_--;
-  ABSL_RAW_CHECK(this->num_to_exit_ >= 0, "barrier underflow");
+  Y_ABSL_RAW_CHECK(this->num_to_exit_ >= 0, "barrier underflow");
 
   // If num_to_exit_ == 0 then all other threads in the barrier have
   // exited the Wait() and have released the Mutex so this thread is
@@ -48,5 +48,5 @@ bool Barrier::Block() {
   return this->num_to_exit_ == 0;
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/barrier.h b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/barrier.h
index 527bd42be0..c8ffc99428 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/barrier.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/barrier.h
@@ -16,14 +16,14 @@
 // barrier.h
 // -----------------------------------------------------------------------------
 
-#ifndef ABSL_SYNCHRONIZATION_BARRIER_H_
-#define ABSL_SYNCHRONIZATION_BARRIER_H_
+#ifndef Y_ABSL_SYNCHRONIZATION_BARRIER_H_
+#define Y_ABSL_SYNCHRONIZATION_BARRIER_H_
 
 #include "y_absl/base/thread_annotations.h"
 #include "y_absl/synchronization/mutex.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // Barrier
 //
@@ -70,10 +70,10 @@ class Barrier {
 
  private:
   Mutex lock_;
-  int num_to_block_ ABSL_GUARDED_BY(lock_);
-  int num_to_exit_ ABSL_GUARDED_BY(lock_);
+  int num_to_block_ Y_ABSL_GUARDED_BY(lock_);
+  int num_to_exit_ Y_ABSL_GUARDED_BY(lock_);
 };
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
-#endif  // ABSL_SYNCHRONIZATION_BARRIER_H_
+#endif  // Y_ABSL_SYNCHRONIZATION_BARRIER_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/blocking_counter.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/blocking_counter.cc
index 056185e51e..070aee26a4 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/blocking_counter.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/blocking_counter.cc
@@ -19,7 +19,7 @@
 #include "y_absl/base/internal/raw_logging.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 namespace {
 
@@ -32,12 +32,12 @@ BlockingCounter::BlockingCounter(int initial_count)
     : count_(initial_count),
       num_waiting_(0),
       done_{initial_count == 0 ? true : false} {
-  ABSL_RAW_CHECK(initial_count >= 0, "BlockingCounter initial_count negative");
+  Y_ABSL_RAW_CHECK(initial_count >= 0, "BlockingCounter initial_count negative");
 }
 
 bool BlockingCounter::DecrementCount() {
   int count = count_.fetch_sub(1, std::memory_order_acq_rel) - 1;
-  ABSL_RAW_CHECK(count >= 0,
+  Y_ABSL_RAW_CHECK(count >= 0,
                  "BlockingCounter::DecrementCount() called too many times");
   if (count == 0) {
     MutexLock l(&lock_);
@@ -52,7 +52,7 @@ void BlockingCounter::Wait() {
 
   // only one thread may call Wait(). To support more than one thread,
   // implement a counter num_to_exit, like in the Barrier class.
-  ABSL_RAW_CHECK(num_waiting_ == 0, "multiple threads called Wait()");
+  Y_ABSL_RAW_CHECK(num_waiting_ == 0, "multiple threads called Wait()");
   num_waiting_++;
 
   this->lock_.Await(Condition(IsDone, &this->done_));
@@ -63,5 +63,5 @@ void BlockingCounter::Wait() {
   // after we return from this method.
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/blocking_counter.h b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/blocking_counter.h
index a1644903e3..1f027613e2 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/blocking_counter.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/blocking_counter.h
@@ -17,8 +17,8 @@
 // blocking_counter.h
 // -----------------------------------------------------------------------------
 
-#ifndef ABSL_SYNCHRONIZATION_BLOCKING_COUNTER_H_
-#define ABSL_SYNCHRONIZATION_BLOCKING_COUNTER_H_
+#ifndef Y_ABSL_SYNCHRONIZATION_BLOCKING_COUNTER_H_
+#define Y_ABSL_SYNCHRONIZATION_BLOCKING_COUNTER_H_
 
 #include <atomic>
 
@@ -26,7 +26,7 @@
 #include "y_absl/synchronization/mutex.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // BlockingCounter
 //
@@ -91,11 +91,11 @@ class BlockingCounter {
  private:
   Mutex lock_;
   std::atomic<int> count_;
-  int num_waiting_ ABSL_GUARDED_BY(lock_);
-  bool done_ ABSL_GUARDED_BY(lock_);
+  int num_waiting_ Y_ABSL_GUARDED_BY(lock_);
+  bool done_ Y_ABSL_GUARDED_BY(lock_);
 };
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_SYNCHRONIZATION_BLOCKING_COUNTER_H_
+#endif  // Y_ABSL_SYNCHRONIZATION_BLOCKING_COUNTER_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/create_thread_identity.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/create_thread_identity.cc
index 3c5764eeb9..446b3b2c6b 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/create_thread_identity.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/create_thread_identity.cc
@@ -17,7 +17,7 @@
 
 // This file is a no-op if the required LowLevelAlloc support is missing.
 #include "y_absl/base/internal/low_level_alloc.h"
-#ifndef ABSL_LOW_LEVEL_ALLOC_MISSING
+#ifndef Y_ABSL_LOW_LEVEL_ALLOC_MISSING
 
 #include <string.h>
 
@@ -27,14 +27,14 @@
 #include "y_absl/synchronization/internal/per_thread_sem.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace synchronization_internal {
 
 // ThreadIdentity storage is persistent, we maintain a free-list of previously
 // released ThreadIdentity objects.
-ABSL_CONST_INIT static base_internal::SpinLock freelist_lock(
+Y_ABSL_CONST_INIT static base_internal::SpinLock freelist_lock(
     y_absl::kConstInit, base_internal::SCHEDULE_KERNEL_ONLY);
-ABSL_CONST_INIT static base_internal::ThreadIdentity* thread_identity_freelist;
+Y_ABSL_CONST_INIT static base_internal::ThreadIdentity* thread_identity_freelist;
 
 // A per-thread destructor for reclaiming associated ThreadIdentity objects.
 // Since we must preserve their storage we cache them for re-use.
@@ -134,7 +134,7 @@ base_internal::ThreadIdentity* CreateThreadIdentity() {
 }
 
 }  // namespace synchronization_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_LOW_LEVEL_ALLOC_MISSING
+#endif  // Y_ABSL_LOW_LEVEL_ALLOC_MISSING
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/create_thread_identity.h b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/create_thread_identity.h
index d93209f424..a7e22c04ac 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/create_thread_identity.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/create_thread_identity.h
@@ -22,14 +22,14 @@
 // and low_level_alloc) than accessing an existing one.  This separation allows
 // us to have a smaller //y_absl/base:base.
 
-#ifndef ABSL_SYNCHRONIZATION_INTERNAL_CREATE_THREAD_IDENTITY_H_
-#define ABSL_SYNCHRONIZATION_INTERNAL_CREATE_THREAD_IDENTITY_H_
+#ifndef Y_ABSL_SYNCHRONIZATION_INTERNAL_CREATE_THREAD_IDENTITY_H_
+#define Y_ABSL_SYNCHRONIZATION_INTERNAL_CREATE_THREAD_IDENTITY_H_
 
 #include "y_absl/base/internal/thread_identity.h"
 #include "y_absl/base/port.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace synchronization_internal {
 
 // Allocates and attaches a ThreadIdentity object for the calling thread.
@@ -47,14 +47,14 @@ void ReclaimThreadIdentity(void* v);
 inline base_internal::ThreadIdentity* GetOrCreateCurrentThreadIdentity() {
   base_internal::ThreadIdentity* identity =
       base_internal::CurrentThreadIdentityIfPresent();
-  if (ABSL_PREDICT_FALSE(identity == nullptr)) {
+  if (Y_ABSL_PREDICT_FALSE(identity == nullptr)) {
     return CreateThreadIdentity();
   }
   return identity;
 }
 
 }  // namespace synchronization_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_SYNCHRONIZATION_INTERNAL_CREATE_THREAD_IDENTITY_H_
+#endif  // Y_ABSL_SYNCHRONIZATION_INTERNAL_CREATE_THREAD_IDENTITY_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/futex.h b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/futex.h
index aea769d8ec..c59a7cc6ab 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/futex.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/futex.h
@@ -11,8 +11,8 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-#ifndef ABSL_SYNCHRONIZATION_INTERNAL_FUTEX_H_
-#define ABSL_SYNCHRONIZATION_INTERNAL_FUTEX_H_
+#ifndef Y_ABSL_SYNCHRONIZATION_INTERNAL_FUTEX_H_
+#define Y_ABSL_SYNCHRONIZATION_INTERNAL_FUTEX_H_
 
 #include "y_absl/base/config.h"
 
@@ -38,21 +38,21 @@
 #include "y_absl/base/optimization.h"
 #include "y_absl/synchronization/internal/kernel_timeout.h"
 
-#ifdef ABSL_INTERNAL_HAVE_FUTEX
-#error ABSL_INTERNAL_HAVE_FUTEX may not be set on the command line
+#ifdef Y_ABSL_INTERNAL_HAVE_FUTEX
+#error Y_ABSL_INTERNAL_HAVE_FUTEX may not be set on the command line
 #elif defined(__BIONIC__)
 // Bionic supports all the futex operations we need even when some of the futex
 // definitions are missing.
-#define ABSL_INTERNAL_HAVE_FUTEX
+#define Y_ABSL_INTERNAL_HAVE_FUTEX
 #elif defined(__linux__) && defined(FUTEX_CLOCK_REALTIME)
 // FUTEX_CLOCK_REALTIME requires Linux >= 2.6.28.
-#define ABSL_INTERNAL_HAVE_FUTEX
+#define Y_ABSL_INTERNAL_HAVE_FUTEX
 #endif
 
-#ifdef ABSL_INTERNAL_HAVE_FUTEX
+#ifdef Y_ABSL_INTERNAL_HAVE_FUTEX
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace synchronization_internal {
 
 // Some Android headers are missing these definitions even though they
@@ -104,7 +104,7 @@ class FutexImpl {
       err = syscall(SYS_futex, reinterpret_cast<int32_t *>(v),
                     FUTEX_WAIT | FUTEX_PRIVATE_FLAG, val, nullptr);
     }
-    if (ABSL_PREDICT_FALSE(err != 0)) {
+    if (Y_ABSL_PREDICT_FALSE(err != 0)) {
       err = -errno;
     }
     return err;
@@ -116,7 +116,7 @@ class FutexImpl {
     int err = syscall(SYS_futex, reinterpret_cast<int32_t *>(v),
                       FUTEX_WAIT_BITSET | FUTEX_PRIVATE_FLAG, val, abstime,
                       nullptr, bits);
-    if (ABSL_PREDICT_FALSE(err != 0)) {
+    if (Y_ABSL_PREDICT_FALSE(err != 0)) {
       err = -errno;
     }
     return err;
@@ -125,7 +125,7 @@ class FutexImpl {
   static int Wake(std::atomic<int32_t> *v, int32_t count) {
     int err = syscall(SYS_futex, reinterpret_cast<int32_t *>(v),
                       FUTEX_WAKE | FUTEX_PRIVATE_FLAG, count);
-    if (ABSL_PREDICT_FALSE(err < 0)) {
+    if (Y_ABSL_PREDICT_FALSE(err < 0)) {
       err = -errno;
     }
     return err;
@@ -136,7 +136,7 @@ class FutexImpl {
     int err = syscall(SYS_futex, reinterpret_cast<int32_t *>(v),
                       FUTEX_WAKE_BITSET | FUTEX_PRIVATE_FLAG, count, nullptr,
                       nullptr, bits);
-    if (ABSL_PREDICT_FALSE(err < 0)) {
+    if (Y_ABSL_PREDICT_FALSE(err < 0)) {
       err = -errno;
     }
     return err;
@@ -146,9 +146,9 @@ class FutexImpl {
 class Futex : public FutexImpl {};
 
 }  // namespace synchronization_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_INTERNAL_HAVE_FUTEX
+#endif  // Y_ABSL_INTERNAL_HAVE_FUTEX
 
-#endif  // ABSL_SYNCHRONIZATION_INTERNAL_FUTEX_H_
+#endif  // Y_ABSL_SYNCHRONIZATION_INTERNAL_FUTEX_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/graphcycles.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/graphcycles.cc
index d8987c1a98..89a9d77bf0 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/graphcycles.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/graphcycles.cc
@@ -31,7 +31,7 @@
 #include "y_absl/base/attributes.h"
 // This file is a no-op if the required LowLevelAlloc support is missing.
 #include "y_absl/base/internal/low_level_alloc.h"
-#ifndef ABSL_LOW_LEVEL_ALLOC_MISSING
+#ifndef Y_ABSL_LOW_LEVEL_ALLOC_MISSING
 
 #include "y_absl/synchronization/internal/graphcycles.h"
 
@@ -45,16 +45,16 @@
 // Do not use STL.   This module does not use standard memory allocation.
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace synchronization_internal {
 
 namespace {
 
 // Avoid LowLevelAlloc's default arena since it calls malloc hooks in
 // which people are doing things like acquiring Mutexes.
-ABSL_CONST_INIT static y_absl::base_internal::SpinLock arena_mu(
+Y_ABSL_CONST_INIT static y_absl::base_internal::SpinLock arena_mu(
     y_absl::kConstInit, base_internal::SCHEDULE_KERNEL_ONLY);
-ABSL_CONST_INIT static base_internal::LowLevelAlloc::Arena* arena;
+Y_ABSL_CONST_INIT static base_internal::LowLevelAlloc::Arena* arena;
 
 static void InitArenaIfNecessary() {
   arena_mu.Lock();
@@ -384,18 +384,18 @@ bool GraphCycles::CheckInvariants() const {
     Node* nx = r->nodes_[x];
     void* ptr = base_internal::UnhidePtr<void>(nx->masked_ptr);
     if (ptr != nullptr && static_cast<uint32_t>(r->ptrmap_.Find(ptr)) != x) {
-      ABSL_RAW_LOG(FATAL, "Did not find live node in hash table %u %p", x, ptr);
+      Y_ABSL_RAW_LOG(FATAL, "Did not find live node in hash table %u %p", x, ptr);
     }
     if (nx->visited) {
-      ABSL_RAW_LOG(FATAL, "Did not clear visited marker on node %u", x);
+      Y_ABSL_RAW_LOG(FATAL, "Did not clear visited marker on node %u", x);
     }
     if (!ranks.insert(nx->rank)) {
-      ABSL_RAW_LOG(FATAL, "Duplicate occurrence of rank %d", nx->rank);
+      Y_ABSL_RAW_LOG(FATAL, "Duplicate occurrence of rank %d", nx->rank);
     }
     HASH_FOR_EACH(y, nx->out) {
       Node* ny = r->nodes_[y];
       if (nx->rank >= ny->rank) {
-        ABSL_RAW_LOG(FATAL, "Edge %u->%d has bad rank assignment %d->%d", x, y,
+        Y_ABSL_RAW_LOG(FATAL, "Edge %u->%d has bad rank assignment %d->%d", x, y,
                      nx->rank, ny->rank);
       }
     }
@@ -676,7 +676,7 @@ void GraphCycles::UpdateStackTrace(GraphId id, int priority,
   if (n == nullptr || n->priority >= priority) {
     return;
   }
-  n->nstack = (*get_stack_trace)(n->stack, ABSL_ARRAYSIZE(n->stack));
+  n->nstack = (*get_stack_trace)(n->stack, Y_ABSL_ARRAYSIZE(n->stack));
   n->priority = priority;
 }
 
@@ -692,7 +692,7 @@ int GraphCycles::GetStackTrace(GraphId id, void*** ptr) {
 }
 
 }  // namespace synchronization_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_LOW_LEVEL_ALLOC_MISSING
+#endif  // Y_ABSL_LOW_LEVEL_ALLOC_MISSING
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/graphcycles.h b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/graphcycles.h
index eaf130bc29..ea39862db1 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/graphcycles.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/graphcycles.h
@@ -13,8 +13,8 @@
 // limitations under the License.
 //
 
-#ifndef ABSL_SYNCHRONIZATION_INTERNAL_GRAPHCYCLES_H_
-#define ABSL_SYNCHRONIZATION_INTERNAL_GRAPHCYCLES_H_
+#ifndef Y_ABSL_SYNCHRONIZATION_INTERNAL_GRAPHCYCLES_H_
+#define Y_ABSL_SYNCHRONIZATION_INTERNAL_GRAPHCYCLES_H_
 
 // GraphCycles detects the introduction of a cycle into a directed
 // graph that is being built up incrementally.
@@ -43,7 +43,7 @@
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace synchronization_internal {
 
 // Opaque identifier for a graph node.
@@ -135,7 +135,7 @@ class GraphCycles {
 };
 
 }  // namespace synchronization_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 #endif
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/kernel_timeout.h b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/kernel_timeout.h
index ee4078702d..b4c8b55f13 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/kernel_timeout.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/kernel_timeout.h
@@ -22,8 +22,8 @@
 // components that are friends of this class. Higher-level components
 // should build APIs based on y_absl::Time and y_absl::Duration.
 
-#ifndef ABSL_SYNCHRONIZATION_INTERNAL_KERNEL_TIMEOUT_H_
-#define ABSL_SYNCHRONIZATION_INTERNAL_KERNEL_TIMEOUT_H_
+#ifndef Y_ABSL_SYNCHRONIZATION_INTERNAL_KERNEL_TIMEOUT_H_
+#define Y_ABSL_SYNCHRONIZATION_INTERNAL_KERNEL_TIMEOUT_H_
 
 #include <time.h>
 
@@ -35,7 +35,7 @@
 #include "y_absl/time/time.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace synchronization_internal {
 
 class Futex;
@@ -129,7 +129,7 @@ inline struct timespec KernelTimeout::MakeAbsTimespec() {
   int64_t n = ns_;
   static const int64_t kNanosPerSecond = 1000 * 1000 * 1000;
   if (n == 0) {
-    ABSL_RAW_LOG(
+    Y_ABSL_RAW_LOG(
         ERROR, "Tried to create a timespec from a non-timeout; never do this.");
     // But we'll try to continue sanely.  no-timeout ~= saturated timeout.
     n = (std::numeric_limits<int64_t>::max)();
@@ -150,7 +150,7 @@ inline struct timespec KernelTimeout::MakeAbsTimespec() {
 }
 
 }  // namespace synchronization_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_SYNCHRONIZATION_INTERNAL_KERNEL_TIMEOUT_H_
+#endif  // Y_ABSL_SYNCHRONIZATION_INTERNAL_KERNEL_TIMEOUT_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/per_thread_sem.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/per_thread_sem.cc
index 3e40e812a9..85299308ad 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/per_thread_sem.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/per_thread_sem.cc
@@ -14,7 +14,7 @@
 
 // This file is a no-op if the required LowLevelAlloc support is missing.
 #include "y_absl/base/internal/low_level_alloc.h"
-#ifndef ABSL_LOW_LEVEL_ALLOC_MISSING
+#ifndef Y_ABSL_LOW_LEVEL_ALLOC_MISSING
 
 #include "y_absl/synchronization/internal/per_thread_sem.h"
 
@@ -25,7 +25,7 @@
 #include "y_absl/synchronization/internal/waiter.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace synchronization_internal {
 
 void PerThreadSem::SetThreadBlockedCounter(std::atomic<int> *counter) {
@@ -63,17 +63,17 @@ void PerThreadSem::Tick(base_internal::ThreadIdentity *identity) {
 }
 
 }  // namespace synchronization_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 extern "C" {
 
-ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemPost)(
+Y_ABSL_ATTRIBUTE_WEAK void Y_ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemPost)(
     y_absl::base_internal::ThreadIdentity *identity) {
   y_absl::synchronization_internal::Waiter::GetWaiter(identity)->Post();
 }
 
-ABSL_ATTRIBUTE_WEAK bool ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemWait)(
+Y_ABSL_ATTRIBUTE_WEAK bool Y_ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemWait)(
     y_absl::synchronization_internal::KernelTimeout t) {
   bool timeout = false;
   y_absl::base_internal::ThreadIdentity *identity;
@@ -103,4 +103,4 @@ ABSL_ATTRIBUTE_WEAK bool ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemWait)(
 
 }  // extern "C"
 
-#endif  // ABSL_LOW_LEVEL_ALLOC_MISSING
+#endif  // Y_ABSL_LOW_LEVEL_ALLOC_MISSING
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/per_thread_sem.h b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/per_thread_sem.h
index 2fc39ca130..5e5c875486 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/per_thread_sem.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/per_thread_sem.h
@@ -22,8 +22,8 @@
 // The semantics of PerThreadSem are the same as that of a counting semaphore.
 // Each thread maintains an abstract "count" value associated with its identity.
 
-#ifndef ABSL_SYNCHRONIZATION_INTERNAL_PER_THREAD_SEM_H_
-#define ABSL_SYNCHRONIZATION_INTERNAL_PER_THREAD_SEM_H_
+#ifndef Y_ABSL_SYNCHRONIZATION_INTERNAL_PER_THREAD_SEM_H_
+#define Y_ABSL_SYNCHRONIZATION_INTERNAL_PER_THREAD_SEM_H_
 
 #include <atomic>
 
@@ -32,7 +32,7 @@
 #include "y_absl/synchronization/internal/kernel_timeout.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 class Mutex;
 
@@ -86,7 +86,7 @@ class PerThreadSem {
 };
 
 }  // namespace synchronization_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 // In some build configurations we pass --detect-odr-violations to the
@@ -96,20 +96,20 @@ ABSL_NAMESPACE_END
 // By changing our extension points to be extern "C", we dodge this
 // check.
 extern "C" {
-void ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemPost)(
+void Y_ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemPost)(
     y_absl::base_internal::ThreadIdentity* identity);
-bool ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemWait)(
+bool Y_ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemWait)(
     y_absl::synchronization_internal::KernelTimeout t);
 }  // extern "C"
 
 void y_absl::synchronization_internal::PerThreadSem::Post(
     y_absl::base_internal::ThreadIdentity* identity) {
-  ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemPost)(identity);
+  Y_ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemPost)(identity);
 }
 
 bool y_absl::synchronization_internal::PerThreadSem::Wait(
     y_absl::synchronization_internal::KernelTimeout t) {
-  return ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemWait)(t);
+  return Y_ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemWait)(t);
 }
 
-#endif  // ABSL_SYNCHRONIZATION_INTERNAL_PER_THREAD_SEM_H_
+#endif  // Y_ABSL_SYNCHRONIZATION_INTERNAL_PER_THREAD_SEM_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/thread_pool.h b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/thread_pool.h
index 8b8912d494..7f821db7ed 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/thread_pool.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/thread_pool.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_SYNCHRONIZATION_INTERNAL_THREAD_POOL_H_
-#define ABSL_SYNCHRONIZATION_INTERNAL_THREAD_POOL_H_
+#ifndef Y_ABSL_SYNCHRONIZATION_INTERNAL_THREAD_POOL_H_
+#define Y_ABSL_SYNCHRONIZATION_INTERNAL_THREAD_POOL_H_
 
 #include <cassert>
 #include <cstddef>
@@ -26,7 +26,7 @@
 #include "y_absl/synchronization/mutex.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace synchronization_internal {
 
 // A simple ThreadPool implementation for tests.
@@ -61,7 +61,7 @@ class ThreadPool {
   }
 
  private:
-  bool WorkAvailable() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+  bool WorkAvailable() const Y_ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
     return !queue_.empty();
   }
 
@@ -82,12 +82,12 @@ class ThreadPool {
   }
 
   y_absl::Mutex mu_;
-  std::queue<std::function<void()>> queue_ ABSL_GUARDED_BY(mu_);
+  std::queue<std::function<void()>> queue_ Y_ABSL_GUARDED_BY(mu_);
   std::vector<std::thread> threads_;
 };
 
 }  // namespace synchronization_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_SYNCHRONIZATION_INTERNAL_THREAD_POOL_H_
+#endif  // Y_ABSL_SYNCHRONIZATION_INTERNAL_THREAD_POOL_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/waiter.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/waiter.cc
index 573ce9c6c5..b69a0513f6 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/waiter.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/waiter.cc
@@ -29,7 +29,7 @@
 #include <sys/syscall.h>
 #endif
 
-#ifdef ABSL_HAVE_SEMAPHORE_H
+#ifdef Y_ABSL_HAVE_SEMAPHORE_H
 #include <semaphore.h>
 #endif
 
@@ -50,7 +50,7 @@
 
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace synchronization_internal {
 
 static void MaybeBecomeIdle() {
@@ -65,7 +65,7 @@ static void MaybeBecomeIdle() {
   }
 }
 
-#if ABSL_WAITER_MODE == ABSL_WAITER_MODE_FUTEX
+#if Y_ABSL_WAITER_MODE == Y_ABSL_WAITER_MODE_FUTEX
 
 Waiter::Waiter() {
   futex_.store(0, std::memory_order_relaxed);
@@ -99,7 +99,7 @@ bool Waiter::Wait(KernelTimeout t) {
       } else if (err == -ETIMEDOUT) {
         return false;
       } else {
-        ABSL_RAW_LOG(FATAL, "Futex operation failed with error %d\n", err);
+        Y_ABSL_RAW_LOG(FATAL, "Futex operation failed with error %d\n", err);
       }
     }
     first_pass = false;
@@ -116,19 +116,19 @@ void Waiter::Post() {
 void Waiter::Poke() {
   // Wake one thread waiting on the futex.
   const int err = Futex::Wake(&futex_, 1);
-  if (ABSL_PREDICT_FALSE(err < 0)) {
-    ABSL_RAW_LOG(FATAL, "Futex operation failed with error %d\n", err);
+  if (Y_ABSL_PREDICT_FALSE(err < 0)) {
+    Y_ABSL_RAW_LOG(FATAL, "Futex operation failed with error %d\n", err);
   }
 }
 
-#elif ABSL_WAITER_MODE == ABSL_WAITER_MODE_CONDVAR
+#elif Y_ABSL_WAITER_MODE == Y_ABSL_WAITER_MODE_CONDVAR
 
 class PthreadMutexHolder {
  public:
   explicit PthreadMutexHolder(pthread_mutex_t *mu) : mu_(mu) {
     const int err = pthread_mutex_lock(mu_);
     if (err != 0) {
-      ABSL_RAW_LOG(FATAL, "pthread_mutex_lock failed: %d", err);
+      Y_ABSL_RAW_LOG(FATAL, "pthread_mutex_lock failed: %d", err);
     }
   }
 
@@ -138,7 +138,7 @@ class PthreadMutexHolder {
   ~PthreadMutexHolder() {
     const int err = pthread_mutex_unlock(mu_);
     if (err != 0) {
-      ABSL_RAW_LOG(FATAL, "pthread_mutex_unlock failed: %d", err);
+      Y_ABSL_RAW_LOG(FATAL, "pthread_mutex_unlock failed: %d", err);
     }
   }
 
@@ -149,12 +149,12 @@ class PthreadMutexHolder {
 Waiter::Waiter() {
   const int err = pthread_mutex_init(&mu_, 0);
   if (err != 0) {
-    ABSL_RAW_LOG(FATAL, "pthread_mutex_init failed: %d", err);
+    Y_ABSL_RAW_LOG(FATAL, "pthread_mutex_init failed: %d", err);
   }
 
   const int err2 = pthread_cond_init(&cv_, 0);
   if (err2 != 0) {
-    ABSL_RAW_LOG(FATAL, "pthread_cond_init failed: %d", err2);
+    Y_ABSL_RAW_LOG(FATAL, "pthread_cond_init failed: %d", err2);
   }
 
   waiter_count_ = 0;
@@ -164,12 +164,12 @@ Waiter::Waiter() {
 Waiter::~Waiter() {
   const int err = pthread_mutex_destroy(&mu_);
   if (err != 0) {
-    ABSL_RAW_LOG(FATAL, "pthread_mutex_destroy failed: %d", err);
+    Y_ABSL_RAW_LOG(FATAL, "pthread_mutex_destroy failed: %d", err);
   }
 
   const int err2 = pthread_cond_destroy(&cv_);
   if (err2 != 0) {
-    ABSL_RAW_LOG(FATAL, "pthread_cond_destroy failed: %d", err2);
+    Y_ABSL_RAW_LOG(FATAL, "pthread_cond_destroy failed: %d", err2);
   }
 }
 
@@ -191,7 +191,7 @@ bool Waiter::Wait(KernelTimeout t) {
     if (!t.has_timeout()) {
       const int err = pthread_cond_wait(&cv_, &mu_);
       if (err != 0) {
-        ABSL_RAW_LOG(FATAL, "pthread_cond_wait failed: %d", err);
+        Y_ABSL_RAW_LOG(FATAL, "pthread_cond_wait failed: %d", err);
       }
     } else {
       const int err = pthread_cond_timedwait(&cv_, &mu_, &abs_timeout);
@@ -200,7 +200,7 @@ bool Waiter::Wait(KernelTimeout t) {
         return false;
       }
       if (err != 0) {
-        ABSL_RAW_LOG(FATAL, "pthread_cond_timedwait failed: %d", err);
+        Y_ABSL_RAW_LOG(FATAL, "pthread_cond_timedwait failed: %d", err);
       }
     }
     first_pass = false;
@@ -225,24 +225,24 @@ void Waiter::Poke() {
 void Waiter::InternalCondVarPoke() {
   if (waiter_count_ != 0) {
     const int err = pthread_cond_signal(&cv_);
-    if (ABSL_PREDICT_FALSE(err != 0)) {
-      ABSL_RAW_LOG(FATAL, "pthread_cond_signal failed: %d", err);
+    if (Y_ABSL_PREDICT_FALSE(err != 0)) {
+      Y_ABSL_RAW_LOG(FATAL, "pthread_cond_signal failed: %d", err);
     }
   }
 }
 
-#elif ABSL_WAITER_MODE == ABSL_WAITER_MODE_SEM
+#elif Y_ABSL_WAITER_MODE == Y_ABSL_WAITER_MODE_SEM
 
 Waiter::Waiter() {
   if (sem_init(&sem_, 0, 0) != 0) {
-    ABSL_RAW_LOG(FATAL, "sem_init failed with errno %d\n", errno);
+    Y_ABSL_RAW_LOG(FATAL, "sem_init failed with errno %d\n", errno);
   }
   wakeups_.store(0, std::memory_order_relaxed);
 }
 
 Waiter::~Waiter() {
   if (sem_destroy(&sem_) != 0) {
-    ABSL_RAW_LOG(FATAL, "sem_destroy failed with errno %d\n", errno);
+    Y_ABSL_RAW_LOG(FATAL, "sem_destroy failed with errno %d\n", errno);
   }
 }
 
@@ -274,12 +274,12 @@ bool Waiter::Wait(KernelTimeout t) {
       if (!t.has_timeout()) {
         if (sem_wait(&sem_) == 0) break;
         if (errno == EINTR) continue;
-        ABSL_RAW_LOG(FATAL, "sem_wait failed: %d", errno);
+        Y_ABSL_RAW_LOG(FATAL, "sem_wait failed: %d", errno);
       } else {
         if (sem_timedwait(&sem_, &abs_timeout) == 0) break;
         if (errno == EINTR) continue;
         if (errno == ETIMEDOUT) return false;
-        ABSL_RAW_LOG(FATAL, "sem_timedwait failed: %d", errno);
+        Y_ABSL_RAW_LOG(FATAL, "sem_timedwait failed: %d", errno);
       }
     }
     first_pass = false;
@@ -296,11 +296,11 @@ void Waiter::Post() {
 
 void Waiter::Poke() {
   if (sem_post(&sem_) != 0) {  // Wake any semaphore waiter.
-    ABSL_RAW_LOG(FATAL, "sem_post failed with errno %d\n", errno);
+    Y_ABSL_RAW_LOG(FATAL, "sem_post failed with errno %d\n", errno);
   }
 }
 
-#elif ABSL_WAITER_MODE == ABSL_WAITER_MODE_WIN32
+#elif Y_ABSL_WAITER_MODE == Y_ABSL_WAITER_MODE_WIN32
 
 class Waiter::WinHelper {
  public:
@@ -318,7 +318,7 @@ class Waiter::WinHelper {
                 "`mu_storage_` does not have the same alignment as SRWLOCK");
 
   static_assert(sizeof(CONDITION_VARIABLE) == sizeof(void *),
-                "`ABSL_CONDITION_VARIABLE_STORAGE` does not have the same size "
+                "`Y_ABSL_CONDITION_VARIABLE_STORAGE` does not have the same size "
                 "as `CONDITION_VARIABLE`");
   static_assert(
       alignof(CONDITION_VARIABLE) == alignof(void *),
@@ -384,14 +384,14 @@ bool Waiter::Wait(KernelTimeout t) {
     // No wakeups available, time to wait.
     if (!SleepConditionVariableSRW(cv, mu, t.InMillisecondsFromNow(), 0)) {
       // GetLastError() returns a Win32 DWORD, but we assign to
-      // unsigned long to simplify the ABSL_RAW_LOG case below.  The uniform
+      // unsigned long to simplify the Y_ABSL_RAW_LOG case below.  The uniform
       // initialization guarantees this is not a narrowing conversion.
       const unsigned long err{GetLastError()};  // NOLINT(runtime/int)
       if (err == ERROR_TIMEOUT) {
         --waiter_count_;
         return false;
       } else {
-        ABSL_RAW_LOG(FATAL, "SleepConditionVariableSRW failed: %lu", err);
+        Y_ABSL_RAW_LOG(FATAL, "SleepConditionVariableSRW failed: %lu", err);
       }
     }
     first_pass = false;
@@ -420,9 +420,9 @@ void Waiter::InternalCondVarPoke() {
 }
 
 #else
-#error Unknown ABSL_WAITER_MODE
+#error Unknown Y_ABSL_WAITER_MODE
 #endif
 
 }  // namespace synchronization_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/waiter.h b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/waiter.h
index e6fede411f..4eb96ee824 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/waiter.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/internal/waiter.h
@@ -13,8 +13,8 @@
 // limitations under the License.
 //
 
-#ifndef ABSL_SYNCHRONIZATION_INTERNAL_WAITER_H_
-#define ABSL_SYNCHRONIZATION_INTERNAL_WAITER_H_
+#ifndef Y_ABSL_SYNCHRONIZATION_INTERNAL_WAITER_H_
+#define Y_ABSL_SYNCHRONIZATION_INTERNAL_WAITER_H_
 
 #include "y_absl/base/config.h"
 
@@ -28,7 +28,7 @@
 #include <linux/futex.h>
 #endif
 
-#ifdef ABSL_HAVE_SEMAPHORE_H
+#ifdef Y_ABSL_HAVE_SEMAPHORE_H
 #include <semaphore.h>
 #endif
 
@@ -40,25 +40,25 @@
 #include "y_absl/synchronization/internal/kernel_timeout.h"
 
 // May be chosen at compile time via -DABSL_FORCE_WAITER_MODE=<index>
-#define ABSL_WAITER_MODE_FUTEX 0
-#define ABSL_WAITER_MODE_SEM 1
-#define ABSL_WAITER_MODE_CONDVAR 2
-#define ABSL_WAITER_MODE_WIN32 3
+#define Y_ABSL_WAITER_MODE_FUTEX 0
+#define Y_ABSL_WAITER_MODE_SEM 1
+#define Y_ABSL_WAITER_MODE_CONDVAR 2
+#define Y_ABSL_WAITER_MODE_WIN32 3
 
-#if defined(ABSL_FORCE_WAITER_MODE)
-#define ABSL_WAITER_MODE ABSL_FORCE_WAITER_MODE
+#if defined(Y_ABSL_FORCE_WAITER_MODE)
+#define Y_ABSL_WAITER_MODE Y_ABSL_FORCE_WAITER_MODE
 #elif defined(_WIN32) && _WIN32_WINNT >= _WIN32_WINNT_VISTA
-#define ABSL_WAITER_MODE ABSL_WAITER_MODE_WIN32
-#elif defined(ABSL_INTERNAL_HAVE_FUTEX)
-#define ABSL_WAITER_MODE ABSL_WAITER_MODE_FUTEX
-#elif defined(ABSL_HAVE_SEMAPHORE_H)
-#define ABSL_WAITER_MODE ABSL_WAITER_MODE_SEM
+#define Y_ABSL_WAITER_MODE Y_ABSL_WAITER_MODE_WIN32
+#elif defined(Y_ABSL_INTERNAL_HAVE_FUTEX)
+#define Y_ABSL_WAITER_MODE Y_ABSL_WAITER_MODE_FUTEX
+#elif defined(Y_ABSL_HAVE_SEMAPHORE_H)
+#define Y_ABSL_WAITER_MODE Y_ABSL_WAITER_MODE_SEM
 #else
-#define ABSL_WAITER_MODE ABSL_WAITER_MODE_CONDVAR
+#define Y_ABSL_WAITER_MODE Y_ABSL_WAITER_MODE_CONDVAR
 #endif
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace synchronization_internal {
 
 // Waiter is an OS-specific semaphore.
@@ -96,7 +96,7 @@ class Waiter {
   }
 
   // How many periods to remain idle before releasing resources
-#ifndef ABSL_HAVE_THREAD_SANITIZER
+#ifndef Y_ABSL_HAVE_THREAD_SANITIZER
   static constexpr int kIdlePeriods = 60;
 #else
   // Memory consumption under ThreadSanitizer is a serious concern,
@@ -106,13 +106,13 @@ class Waiter {
 #endif
 
  private:
-#if ABSL_WAITER_MODE == ABSL_WAITER_MODE_FUTEX
+#if Y_ABSL_WAITER_MODE == Y_ABSL_WAITER_MODE_FUTEX
   // Futexes are defined by specification to be 32-bits.
   // Thus std::atomic<int32_t> must be just an int32_t with lockfree methods.
   std::atomic<int32_t> futex_;
   static_assert(sizeof(int32_t) == sizeof(futex_), "Wrong size for futex");
 
-#elif ABSL_WAITER_MODE == ABSL_WAITER_MODE_CONDVAR
+#elif Y_ABSL_WAITER_MODE == Y_ABSL_WAITER_MODE_CONDVAR
   // REQUIRES: mu_ must be held.
   void InternalCondVarPoke();
 
@@ -121,14 +121,14 @@ class Waiter {
   int waiter_count_;
   int wakeup_count_;  // Unclaimed wakeups.
 
-#elif ABSL_WAITER_MODE == ABSL_WAITER_MODE_SEM
+#elif Y_ABSL_WAITER_MODE == Y_ABSL_WAITER_MODE_SEM
   sem_t sem_;
   // This seems superfluous, but for Poke() we need to cause spurious
   // wakeups on the semaphore. Hence we can't actually use the
   // semaphore's count.
   std::atomic<int> wakeups_;
 
-#elif ABSL_WAITER_MODE == ABSL_WAITER_MODE_WIN32
+#elif Y_ABSL_WAITER_MODE == Y_ABSL_WAITER_MODE_WIN32
   // WinHelper - Used to define utilities for accessing the lock and
   // condition variable storage once the types are complete.
   class WinHelper;
@@ -144,12 +144,12 @@ class Waiter {
   int wakeup_count_;
 
 #else
-  #error Unknown ABSL_WAITER_MODE
+  #error Unknown Y_ABSL_WAITER_MODE
 #endif
 };
 
 }  // namespace synchronization_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_SYNCHRONIZATION_INTERNAL_WAITER_H_
+#endif  // Y_ABSL_SYNCHRONIZATION_INTERNAL_WAITER_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/mutex.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/mutex.cc
index babe5c4ada..09b7acbccd 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/mutex.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/mutex.cc
@@ -70,36 +70,36 @@ using y_absl::synchronization_internal::KernelTimeout;
 using y_absl::synchronization_internal::PerThreadSem;
 
 extern "C" {
-ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalMutexYield)() {
+Y_ABSL_ATTRIBUTE_WEAK void Y_ABSL_INTERNAL_C_SYMBOL(AbslInternalMutexYield)() {
   std::this_thread::yield();
 }
 }  // extern "C"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 namespace {
 
-#if defined(ABSL_HAVE_THREAD_SANITIZER)
+#if defined(Y_ABSL_HAVE_THREAD_SANITIZER)
 constexpr OnDeadlockCycle kDeadlockDetectionDefault = OnDeadlockCycle::kIgnore;
 #else
 constexpr OnDeadlockCycle kDeadlockDetectionDefault = OnDeadlockCycle::kAbort;
 #endif
 
-ABSL_CONST_INIT std::atomic<OnDeadlockCycle> synch_deadlock_detection(
+Y_ABSL_CONST_INIT std::atomic<OnDeadlockCycle> synch_deadlock_detection(
     kDeadlockDetectionDefault);
-ABSL_CONST_INIT std::atomic<bool> synch_check_invariants(false);
+Y_ABSL_CONST_INIT std::atomic<bool> synch_check_invariants(false);
 
-ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES
+Y_ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES
 y_absl::base_internal::AtomicHook<void (*)(int64_t wait_cycles)>
     submit_profile_data;
-ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES y_absl::base_internal::AtomicHook<void (*)(
+Y_ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES y_absl::base_internal::AtomicHook<void (*)(
     const char *msg, const void *obj, int64_t wait_cycles)>
     mutex_tracer;
-ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES
+Y_ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES
     y_absl::base_internal::AtomicHook<void (*)(const char *msg, const void *cv)>
         cond_var_tracer;
-ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES y_absl::base_internal::AtomicHook<
+Y_ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES y_absl::base_internal::AtomicHook<
     bool (*)(const void *pc, char *out, int out_size)>
     symbolizer(y_absl::Symbolize);
 
@@ -131,14 +131,14 @@ namespace {
 // See the comment in GetMutexGlobals() for more information.
 enum DelayMode { AGGRESSIVE, GENTLE };
 
-struct ABSL_CACHELINE_ALIGNED MutexGlobals {
+struct Y_ABSL_CACHELINE_ALIGNED MutexGlobals {
   y_absl::once_flag once;
   int spinloop_iterations = 0;
   int32_t mutex_sleep_limit[2] = {};
 };
 
 const MutexGlobals &GetMutexGlobals() {
-  ABSL_CONST_INIT static MutexGlobals data;
+  Y_ABSL_CONST_INIT static MutexGlobals data;
   y_absl::base_internal::LowLevelCallOnce(&data.once, [&]() {
     const int num_cpus = y_absl::base_internal::NumCPUs();
     data.spinloop_iterations = num_cpus > 1 ? 1500 : 0;
@@ -169,17 +169,17 @@ int MutexDelay(int32_t c, int mode) {
     c++;
   } else {
     SchedulingGuard::ScopedEnable enable_rescheduling;
-    ABSL_TSAN_MUTEX_PRE_DIVERT(nullptr, 0);
+    Y_ABSL_TSAN_MUTEX_PRE_DIVERT(nullptr, 0);
     if (c == limit) {
       // Yield once.
-      ABSL_INTERNAL_C_SYMBOL(AbslInternalMutexYield)();
+      Y_ABSL_INTERNAL_C_SYMBOL(AbslInternalMutexYield)();
       c++;
     } else {
       // Then wait.
       y_absl::SleepFor(y_absl::Microseconds(10));
       c = 0;
     }
-    ABSL_TSAN_MUTEX_POST_DIVERT(nullptr, 0);
+    Y_ABSL_TSAN_MUTEX_POST_DIVERT(nullptr, 0);
   }
   return c;
 }
@@ -221,12 +221,12 @@ static void AtomicClearBits(std::atomic<intptr_t>* pv, intptr_t bits,
 //------------------------------------------------------------------
 
 // Data for doing deadlock detection.
-ABSL_CONST_INIT static y_absl::base_internal::SpinLock deadlock_graph_mu(
+Y_ABSL_CONST_INIT static y_absl::base_internal::SpinLock deadlock_graph_mu(
     y_absl::kConstInit, base_internal::SCHEDULE_KERNEL_ONLY);
 
 // Graph used to detect deadlocks.
-ABSL_CONST_INIT static GraphCycles *deadlock_graph
-    ABSL_GUARDED_BY(deadlock_graph_mu) ABSL_PT_GUARDED_BY(deadlock_graph_mu);
+Y_ABSL_CONST_INIT static GraphCycles *deadlock_graph
+    Y_ABSL_GUARDED_BY(deadlock_graph_mu) Y_ABSL_PT_GUARDED_BY(deadlock_graph_mu);
 
 //------------------------------------------------------------------
 // An event mechanism for debugging mutex use.
@@ -287,7 +287,7 @@ static const struct {
     {0, "SignalAll on "},
 };
 
-ABSL_CONST_INIT static y_absl::base_internal::SpinLock synch_event_mu(
+Y_ABSL_CONST_INIT static y_absl::base_internal::SpinLock synch_event_mu(
     y_absl::kConstInit, base_internal::SCHEDULE_KERNEL_ONLY);
 
 // Hash table size; should be prime > 2.
@@ -296,10 +296,10 @@ static constexpr uint32_t kNSynchEvent = 1031;
 
 static struct SynchEvent {     // this is a trivial hash table for the events
   // struct is freed when refcount reaches 0
-  int refcount ABSL_GUARDED_BY(synch_event_mu);
+  int refcount Y_ABSL_GUARDED_BY(synch_event_mu);
 
   // buckets have linear, 0-terminated  chains
-  SynchEvent *next ABSL_GUARDED_BY(synch_event_mu);
+  SynchEvent *next Y_ABSL_GUARDED_BY(synch_event_mu);
 
   // Constant after initialization
   uintptr_t masked_addr;  // object at this address is called "name"
@@ -313,7 +313,7 @@ static struct SynchEvent {     // this is a trivial hash table for the events
 
   // Constant after initialization
   char name[1];         // actually longer---NUL-terminated string
-} * synch_event[kNSynchEvent] ABSL_GUARDED_BY(synch_event_mu);
+} * synch_event[kNSynchEvent] Y_ABSL_GUARDED_BY(synch_event_mu);
 
 // Ensure that the object at "addr" has a SynchEvent struct associated with it,
 // set "bits" in the word there (waiting until lockbit is clear before doing
@@ -424,15 +424,15 @@ static void PostSynchEvent(void *obj, int ev) {
   // or it explicitly says to log
   if (e == nullptr || e->log) {
     void *pcs[40];
-    int n = y_absl::GetStackTrace(pcs, ABSL_ARRAYSIZE(pcs), 1);
+    int n = y_absl::GetStackTrace(pcs, Y_ABSL_ARRAYSIZE(pcs), 1);
     // A buffer with enough space for the ASCII for all the PCs, even on a
     // 64-bit machine.
-    char buffer[ABSL_ARRAYSIZE(pcs) * 24];
+    char buffer[Y_ABSL_ARRAYSIZE(pcs) * 24];
     int pos = snprintf(buffer, sizeof (buffer), " @");
     for (int i = 0; i != n; i++) {
       pos += snprintf(&buffer[pos], sizeof (buffer) - pos, " %p", pcs[i]);
     }
-    ABSL_RAW_LOG(INFO, "%s%p %s %s", event_properties[ev].msg, obj,
+    Y_ABSL_RAW_LOG(INFO, "%s%p %s %s", event_properties[ev].msg, obj,
                  (e == nullptr ? "" : e->name), buffer);
   }
   const int flags = event_properties[ev].flags;
@@ -541,11 +541,11 @@ static PerThreadSynch *Synch_GetPerThread() {
 
 static PerThreadSynch *Synch_GetPerThreadAnnotated(Mutex *mu) {
   if (mu) {
-    ABSL_TSAN_MUTEX_PRE_DIVERT(mu, 0);
+    Y_ABSL_TSAN_MUTEX_PRE_DIVERT(mu, 0);
   }
   PerThreadSynch *w = Synch_GetPerThread();
   if (mu) {
-    ABSL_TSAN_MUTEX_POST_DIVERT(mu, 0);
+    Y_ABSL_TSAN_MUTEX_POST_DIVERT(mu, 0);
   }
   return w;
 }
@@ -561,24 +561,24 @@ static SynchLocksHeld *Synch_GetAllLocks() {
 // Post on "w"'s associated PerThreadSem.
 void Mutex::IncrementSynchSem(Mutex *mu, PerThreadSynch *w) {
   if (mu) {
-    ABSL_TSAN_MUTEX_PRE_DIVERT(mu, 0);
+    Y_ABSL_TSAN_MUTEX_PRE_DIVERT(mu, 0);
   }
   PerThreadSem::Post(w->thread_identity());
   if (mu) {
-    ABSL_TSAN_MUTEX_POST_DIVERT(mu, 0);
+    Y_ABSL_TSAN_MUTEX_POST_DIVERT(mu, 0);
   }
 }
 
 // Wait on "w"'s associated PerThreadSem; returns false if timeout expired.
 bool Mutex::DecrementSynchSem(Mutex *mu, PerThreadSynch *w, KernelTimeout t) {
   if (mu) {
-    ABSL_TSAN_MUTEX_PRE_DIVERT(mu, 0);
+    Y_ABSL_TSAN_MUTEX_PRE_DIVERT(mu, 0);
   }
   assert(w == Synch_GetPerThread());
   static_cast<void>(w);
   bool res = PerThreadSem::Wait(t);
   if (mu) {
-    ABSL_TSAN_MUTEX_POST_DIVERT(mu, 0);
+    Y_ABSL_TSAN_MUTEX_POST_DIVERT(mu, 0);
   }
   return res;
 }
@@ -586,8 +586,8 @@ bool Mutex::DecrementSynchSem(Mutex *mu, PerThreadSynch *w, KernelTimeout t) {
 // We're in a fatal signal handler that hopes to use Mutex and to get
 // lucky by not deadlocking.  We try to improve its chances of success
 // by effectively disabling some of the consistency checks.  This will
-// prevent certain ABSL_RAW_CHECK() statements from being triggered when
-// re-rentry is detected.  The ABSL_RAW_CHECK() statements are those in the
+// prevent certain Y_ABSL_RAW_CHECK() statements from being triggered when
+// re-rentry is detected.  The Y_ABSL_RAW_CHECK() statements are those in the
 // Mutex code checking that the "waitp" field has not been reused.
 void Mutex::InternalAttemptToUseMutexInFatalSignalHandler() {
   // Fix the per-thread state only if it exists.
@@ -717,7 +717,7 @@ static constexpr bool kDebugMode = false;
 static constexpr bool kDebugMode = true;
 #endif
 
-#ifdef ABSL_INTERNAL_HAVE_TSAN_INTERFACE
+#ifdef Y_ABSL_INTERNAL_HAVE_TSAN_INTERFACE
 static unsigned TsanFlags(Mutex::MuHow how) {
   return how == kShared ? __tsan_mutex_read_lock : 0;
 }
@@ -735,7 +735,7 @@ Mutex::~Mutex() {
   if (kDebugMode) {
     this->ForgetDeadlockInfo();
   }
-  ABSL_TSAN_MUTEX_DESTROY(this, __tsan_mutex_not_static);
+  Y_ABSL_TSAN_MUTEX_DESTROY(this, __tsan_mutex_not_static);
 }
 
 void Mutex::EnableDebugLog(const char *name) {
@@ -896,7 +896,7 @@ static PerThreadSynch *Enqueue(PerThreadSynch *head,
   }
 
   PerThreadSynch *s = waitp->thread;
-  ABSL_RAW_CHECK(
+  Y_ABSL_RAW_CHECK(
       s->waitp == nullptr ||    // normal case
           s->waitp == waitp ||  // Fer()---transfer from condition variable
           s->suppress_fatal_errors,
@@ -913,7 +913,7 @@ static PerThreadSynch *Enqueue(PerThreadSynch *head,
     head = s;                    // s is new head
   } else {
     PerThreadSynch *enqueue_after = nullptr;  // we'll put s after this element
-#ifdef ABSL_HAVE_PTHREAD_GETSCHEDPARAM
+#ifdef Y_ABSL_HAVE_PTHREAD_GETSCHEDPARAM
     int64_t now_cycles = base_internal::CycleClock::Now();
     if (s->next_priority_read_cycles < now_cycles) {
       // Every so often, update our idea of the thread's priority.
@@ -923,7 +923,7 @@ static PerThreadSynch *Enqueue(PerThreadSynch *head,
       struct sched_param param;
       const int err = pthread_getschedparam(pthread_self(), &policy, &param);
       if (err != 0) {
-        ABSL_RAW_LOG(ERROR, "pthread_getschedparam failed: %d", err);
+        Y_ABSL_RAW_LOG(ERROR, "pthread_getschedparam failed: %d", err);
       } else {
         s->priority = param.sched_priority;
         s->next_priority_read_cycles =
@@ -968,7 +968,7 @@ static PerThreadSynch *Enqueue(PerThreadSynch *head,
       // is impossible; enqueue_after's predecessors might also
       // incorrectly skip over s if we were to allow other
       // insertion points.
-      ABSL_RAW_CHECK(enqueue_after->skip == nullptr ||
+      Y_ABSL_RAW_CHECK(enqueue_after->skip == nullptr ||
                          MuEquivalentWaiter(enqueue_after, s),
                      "Mutex Enqueue failure");
 
@@ -1033,7 +1033,7 @@ static PerThreadSynch *DequeueAllWakeable(PerThreadSynch *head,
   bool skipped = false;
   do {
     if (w->wake) {                    // remove this element
-      ABSL_RAW_CHECK(pw->skip == nullptr, "bad skip in DequeueAllWakeable");
+      Y_ABSL_RAW_CHECK(pw->skip == nullptr, "bad skip in DequeueAllWakeable");
       // we're removing pw's successor so either pw->skip is zero or we should
       // already have removed pw since if pw->skip!=null, pw has the same
       // condition as w.
@@ -1120,7 +1120,7 @@ void Mutex::TryRemove(PerThreadSynch *s) {
 // if the wait extends past the absolute time specified, even if "s" is still
 // on the mutex queue.  In this case, remove "s" from the queue and return
 // true, otherwise return false.
-ABSL_XRAY_LOG_ARGS(1) void Mutex::Block(PerThreadSynch *s) {
+Y_ABSL_XRAY_LOG_ARGS(1) void Mutex::Block(PerThreadSynch *s) {
   while (s->state.load(std::memory_order_acquire) == PerThreadSynch::kQueued) {
     if (!DecrementSynchSem(this, s, s->waitp->timeout)) {
       // After a timeout, we go into a spin loop until we remove ourselves
@@ -1143,7 +1143,7 @@ ABSL_XRAY_LOG_ARGS(1) void Mutex::Block(PerThreadSynch *s) {
       s->waitp->cond = nullptr;  // condition no longer relevant for wakeups
     }
   }
-  ABSL_RAW_CHECK(s->waitp != nullptr || s->suppress_fatal_errors,
+  Y_ABSL_RAW_CHECK(s->waitp != nullptr || s->suppress_fatal_errors,
                  "detected illegal recursion in Mutex code");
   s->waitp = nullptr;
 }
@@ -1159,7 +1159,7 @@ PerThreadSynch *Mutex::Wakeup(PerThreadSynch *w) {
 }
 
 static GraphId GetGraphIdLocked(Mutex *mu)
-    ABSL_EXCLUSIVE_LOCKS_REQUIRED(deadlock_graph_mu) {
+    Y_ABSL_EXCLUSIVE_LOCKS_REQUIRED(deadlock_graph_mu) {
   if (!deadlock_graph) {  // (re)create the deadlock graph.
     deadlock_graph =
         new (base_internal::LowLevelAlloc::Alloc(sizeof(*deadlock_graph)))
@@ -1168,7 +1168,7 @@ static GraphId GetGraphIdLocked(Mutex *mu)
   return deadlock_graph->GetId(mu);
 }
 
-static GraphId GetGraphId(Mutex *mu) ABSL_LOCKS_EXCLUDED(deadlock_graph_mu) {
+static GraphId GetGraphId(Mutex *mu) Y_ABSL_LOCKS_EXCLUDED(deadlock_graph_mu) {
   deadlock_graph_mu.Lock();
   GraphId id = GetGraphIdLocked(mu);
   deadlock_graph_mu.Unlock();
@@ -1185,7 +1185,7 @@ static void LockEnter(Mutex* mu, GraphId id, SynchLocksHeld *held_locks) {
     i++;
   }
   if (i == n) {
-    if (n == ABSL_ARRAYSIZE(held_locks->locks)) {
+    if (n == Y_ABSL_ARRAYSIZE(held_locks->locks)) {
       held_locks->overflow = true;  // lost some data
     } else {                        // we have room for lock
       held_locks->locks[i].mu = mu;
@@ -1218,7 +1218,7 @@ static void LockLeave(Mutex* mu, GraphId id, SynchLocksHeld *held_locks) {
       }
       if (i == n) {  // mu missing means releasing unheld lock
         SynchEvent *mu_events = GetSynchEvent(mu);
-        ABSL_RAW_LOG(FATAL,
+        Y_ABSL_RAW_LOG(FATAL,
                      "thread releasing lock it does not hold: %p %s; "
                      ,
                      static_cast<void *>(mu),
@@ -1290,7 +1290,7 @@ static char *StackString(void **pcs, int n, char *buf, int maxlen,
 
 static char *CurrentStackString(char *buf, int maxlen, bool symbolize) {
   void *pcs[40];
-  return StackString(pcs, y_absl::GetStackTrace(pcs, ABSL_ARRAYSIZE(pcs), 2), buf,
+  return StackString(pcs, y_absl::GetStackTrace(pcs, Y_ABSL_ARRAYSIZE(pcs), 2), buf,
                      maxlen, symbolize);
 }
 
@@ -1364,7 +1364,7 @@ static GraphId DeadlockCheck(Mutex *mu) {
       number_of_reported_deadlocks++;
       // Symbolize only 2 first deadlock report to avoid huge slowdowns.
       bool symbolize = number_of_reported_deadlocks <= 2;
-      ABSL_RAW_LOG(ERROR, "Potential Mutex deadlock: %s",
+      Y_ABSL_RAW_LOG(ERROR, "Potential Mutex deadlock: %s",
                    CurrentStackString(b->buf, sizeof (b->buf), symbolize));
       int len = 0;
       for (int j = 0; j != all_locks->n; j++) {
@@ -1374,13 +1374,13 @@ static GraphId DeadlockCheck(Mutex *mu) {
           len += static_cast<int>(strlen(&b->buf[len]));
         }
       }
-      ABSL_RAW_LOG(ERROR,
+      Y_ABSL_RAW_LOG(ERROR,
                    "Acquiring y_absl::Mutex %p while holding %s; a cycle in the "
                    "historical lock ordering graph has been observed",
                    static_cast<void *>(mu), b->buf);
-      ABSL_RAW_LOG(ERROR, "Cycle: ");
+      Y_ABSL_RAW_LOG(ERROR, "Cycle: ");
       int path_len = deadlock_graph->FindPath(
-          mu_id, other_node_id, ABSL_ARRAYSIZE(b->path), b->path);
+          mu_id, other_node_id, Y_ABSL_ARRAYSIZE(b->path), b->path);
       for (int j = 0; j != path_len; j++) {
         GraphId id = b->path[j];
         Mutex *path_mu = static_cast<Mutex *>(deadlock_graph->Ptr(id));
@@ -1392,12 +1392,12 @@ static GraphId DeadlockCheck(Mutex *mu) {
         StackString(stack, depth, b->buf + strlen(b->buf),
                     static_cast<int>(sizeof(b->buf) - strlen(b->buf)),
                     symbolize);
-        ABSL_RAW_LOG(ERROR, "%s", b->buf);
+        Y_ABSL_RAW_LOG(ERROR, "%s", b->buf);
       }
       if (synch_deadlock_detection.load(std::memory_order_acquire) ==
           OnDeadlockCycle::kAbort) {
         deadlock_graph_mu.Unlock();  // avoid deadlock in fatal sighandler
-        ABSL_RAW_LOG(FATAL, "dying due to potential deadlock");
+        Y_ABSL_RAW_LOG(FATAL, "dying due to potential deadlock");
         return mu_id;
       }
       break;   // report at most one potential deadlock per acquisition
@@ -1441,7 +1441,7 @@ void Mutex::AssertNotHeld() const {
     for (int i = 0; i != locks->n; i++) {
       if (locks->locks[i].id == id) {
         SynchEvent *mu_events = GetSynchEvent(this);
-        ABSL_RAW_LOG(FATAL, "thread should not hold mutex %p %s",
+        Y_ABSL_RAW_LOG(FATAL, "thread should not hold mutex %p %s",
                      static_cast<const void *>(this),
                      (mu_events == nullptr ? "" : mu_events->name));
       }
@@ -1467,8 +1467,8 @@ static bool TryAcquireWithSpinning(std::atomic<intptr_t>* mu) {
   return false;
 }
 
-ABSL_XRAY_LOG_ARGS(1) void Mutex::Lock() {
-  ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
+Y_ABSL_XRAY_LOG_ARGS(1) void Mutex::Lock() {
+  Y_ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
   GraphId id = DebugOnlyDeadlockCheck(this);
   intptr_t v = mu_.load(std::memory_order_relaxed);
   // try fast acquire, then spin loop
@@ -1482,11 +1482,11 @@ ABSL_XRAY_LOG_ARGS(1) void Mutex::Lock() {
     }
   }
   DebugOnlyLockEnter(this, id);
-  ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
+  Y_ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
 }
 
-ABSL_XRAY_LOG_ARGS(1) void Mutex::ReaderLock() {
-  ABSL_TSAN_MUTEX_PRE_LOCK(this, __tsan_mutex_read_lock);
+Y_ABSL_XRAY_LOG_ARGS(1) void Mutex::ReaderLock() {
+  Y_ABSL_TSAN_MUTEX_PRE_LOCK(this, __tsan_mutex_read_lock);
   GraphId id = DebugOnlyDeadlockCheck(this);
   intptr_t v = mu_.load(std::memory_order_relaxed);
   // try fast acquire, then slow loop
@@ -1497,15 +1497,15 @@ ABSL_XRAY_LOG_ARGS(1) void Mutex::ReaderLock() {
     this->LockSlow(kShared, nullptr, 0);
   }
   DebugOnlyLockEnter(this, id);
-  ABSL_TSAN_MUTEX_POST_LOCK(this, __tsan_mutex_read_lock, 0);
+  Y_ABSL_TSAN_MUTEX_POST_LOCK(this, __tsan_mutex_read_lock, 0);
 }
 
 void Mutex::LockWhen(const Condition &cond) {
-  ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
+  Y_ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
   GraphId id = DebugOnlyDeadlockCheck(this);
   this->LockSlow(kExclusive, &cond, 0);
   DebugOnlyLockEnter(this, id);
-  ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
+  Y_ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
 }
 
 bool Mutex::LockWhenWithTimeout(const Condition &cond, y_absl::Duration timeout) {
@@ -1513,21 +1513,21 @@ bool Mutex::LockWhenWithTimeout(const Condition &cond, y_absl::Duration timeout)
 }
 
 bool Mutex::LockWhenWithDeadline(const Condition &cond, y_absl::Time deadline) {
-  ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
+  Y_ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
   GraphId id = DebugOnlyDeadlockCheck(this);
   bool res = LockSlowWithDeadline(kExclusive, &cond,
                                   KernelTimeout(deadline), 0);
   DebugOnlyLockEnter(this, id);
-  ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
+  Y_ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
   return res;
 }
 
 void Mutex::ReaderLockWhen(const Condition &cond) {
-  ABSL_TSAN_MUTEX_PRE_LOCK(this, __tsan_mutex_read_lock);
+  Y_ABSL_TSAN_MUTEX_PRE_LOCK(this, __tsan_mutex_read_lock);
   GraphId id = DebugOnlyDeadlockCheck(this);
   this->LockSlow(kShared, &cond, 0);
   DebugOnlyLockEnter(this, id);
-  ABSL_TSAN_MUTEX_POST_LOCK(this, __tsan_mutex_read_lock, 0);
+  Y_ABSL_TSAN_MUTEX_POST_LOCK(this, __tsan_mutex_read_lock, 0);
 }
 
 bool Mutex::ReaderLockWhenWithTimeout(const Condition &cond,
@@ -1537,11 +1537,11 @@ bool Mutex::ReaderLockWhenWithTimeout(const Condition &cond,
 
 bool Mutex::ReaderLockWhenWithDeadline(const Condition &cond,
                                        y_absl::Time deadline) {
-  ABSL_TSAN_MUTEX_PRE_LOCK(this, __tsan_mutex_read_lock);
+  Y_ABSL_TSAN_MUTEX_PRE_LOCK(this, __tsan_mutex_read_lock);
   GraphId id = DebugOnlyDeadlockCheck(this);
   bool res = LockSlowWithDeadline(kShared, &cond, KernelTimeout(deadline), 0);
   DebugOnlyLockEnter(this, id);
-  ABSL_TSAN_MUTEX_POST_LOCK(this, __tsan_mutex_read_lock, 0);
+  Y_ABSL_TSAN_MUTEX_POST_LOCK(this, __tsan_mutex_read_lock, 0);
   return res;
 }
 
@@ -1551,7 +1551,7 @@ void Mutex::Await(const Condition &cond) {
       this->AssertReaderHeld();
     }
   } else {              // normal case
-    ABSL_RAW_CHECK(this->AwaitCommon(cond, KernelTimeout::Never()),
+    Y_ABSL_RAW_CHECK(this->AwaitCommon(cond, KernelTimeout::Never()),
                    "condition untrue on return from Await");
   }
 }
@@ -1570,7 +1570,7 @@ bool Mutex::AwaitWithDeadline(const Condition &cond, y_absl::Time deadline) {
 
   KernelTimeout t{deadline};
   bool res = this->AwaitCommon(cond, t);
-  ABSL_RAW_CHECK(res || t.has_timeout(),
+  Y_ABSL_RAW_CHECK(res || t.has_timeout(),
                  "condition untrue on return from Await");
   return res;
 }
@@ -1579,7 +1579,7 @@ bool Mutex::AwaitCommon(const Condition &cond, KernelTimeout t) {
   this->AssertReaderHeld();
   MuHow how =
       (mu_.load(std::memory_order_relaxed) & kMuWriter) ? kExclusive : kShared;
-  ABSL_TSAN_MUTEX_PRE_UNLOCK(this, TsanFlags(how));
+  Y_ABSL_TSAN_MUTEX_PRE_UNLOCK(this, TsanFlags(how));
   SynchWaitParams waitp(
       how, &cond, t, nullptr /*no cvmu*/, Synch_GetPerThreadAnnotated(this),
       nullptr /*no cv_word*/);
@@ -1589,24 +1589,24 @@ bool Mutex::AwaitCommon(const Condition &cond, KernelTimeout t) {
   }
   this->UnlockSlow(&waitp);
   this->Block(waitp.thread);
-  ABSL_TSAN_MUTEX_POST_UNLOCK(this, TsanFlags(how));
-  ABSL_TSAN_MUTEX_PRE_LOCK(this, TsanFlags(how));
+  Y_ABSL_TSAN_MUTEX_POST_UNLOCK(this, TsanFlags(how));
+  Y_ABSL_TSAN_MUTEX_PRE_LOCK(this, TsanFlags(how));
   this->LockSlowLoop(&waitp, flags);
   bool res = waitp.cond != nullptr ||  // => cond known true from LockSlowLoop
              EvalConditionAnnotated(&cond, this, true, false, how == kShared);
-  ABSL_TSAN_MUTEX_POST_LOCK(this, TsanFlags(how), 0);
+  Y_ABSL_TSAN_MUTEX_POST_LOCK(this, TsanFlags(how), 0);
   return res;
 }
 
-ABSL_XRAY_LOG_ARGS(1) bool Mutex::TryLock() {
-  ABSL_TSAN_MUTEX_PRE_LOCK(this, __tsan_mutex_try_lock);
+Y_ABSL_XRAY_LOG_ARGS(1) bool Mutex::TryLock() {
+  Y_ABSL_TSAN_MUTEX_PRE_LOCK(this, __tsan_mutex_try_lock);
   intptr_t v = mu_.load(std::memory_order_relaxed);
   if ((v & (kMuWriter | kMuReader | kMuEvent)) == 0 &&  // try fast acquire
       mu_.compare_exchange_strong(v, kMuWriter | v,
                                   std::memory_order_acquire,
                                   std::memory_order_relaxed)) {
     DebugOnlyLockEnter(this);
-    ABSL_TSAN_MUTEX_POST_LOCK(this, __tsan_mutex_try_lock, 0);
+    Y_ABSL_TSAN_MUTEX_POST_LOCK(this, __tsan_mutex_try_lock, 0);
     return true;
   }
   if ((v & kMuEvent) != 0) {              // we're recording events
@@ -1616,19 +1616,19 @@ ABSL_XRAY_LOG_ARGS(1) bool Mutex::TryLock() {
             std::memory_order_acquire, std::memory_order_relaxed)) {
       DebugOnlyLockEnter(this);
       PostSynchEvent(this, SYNCH_EV_TRYLOCK_SUCCESS);
-      ABSL_TSAN_MUTEX_POST_LOCK(this, __tsan_mutex_try_lock, 0);
+      Y_ABSL_TSAN_MUTEX_POST_LOCK(this, __tsan_mutex_try_lock, 0);
       return true;
     } else {
       PostSynchEvent(this, SYNCH_EV_TRYLOCK_FAILED);
     }
   }
-  ABSL_TSAN_MUTEX_POST_LOCK(
+  Y_ABSL_TSAN_MUTEX_POST_LOCK(
       this, __tsan_mutex_try_lock | __tsan_mutex_try_lock_failed, 0);
   return false;
 }
 
-ABSL_XRAY_LOG_ARGS(1) bool Mutex::ReaderTryLock() {
-  ABSL_TSAN_MUTEX_PRE_LOCK(this,
+Y_ABSL_XRAY_LOG_ARGS(1) bool Mutex::ReaderTryLock() {
+  Y_ABSL_TSAN_MUTEX_PRE_LOCK(this,
                            __tsan_mutex_read_lock | __tsan_mutex_try_lock);
   intptr_t v = mu_.load(std::memory_order_relaxed);
   // The while-loops (here and below) iterate only if the mutex word keeps
@@ -1640,7 +1640,7 @@ ABSL_XRAY_LOG_ARGS(1) bool Mutex::ReaderTryLock() {
                                     std::memory_order_acquire,
                                     std::memory_order_relaxed)) {
       DebugOnlyLockEnter(this);
-      ABSL_TSAN_MUTEX_POST_LOCK(
+      Y_ABSL_TSAN_MUTEX_POST_LOCK(
           this, __tsan_mutex_read_lock | __tsan_mutex_try_lock, 0);
       return true;
     }
@@ -1655,7 +1655,7 @@ ABSL_XRAY_LOG_ARGS(1) bool Mutex::ReaderTryLock() {
                                       std::memory_order_relaxed)) {
         DebugOnlyLockEnter(this);
         PostSynchEvent(this, SYNCH_EV_READERTRYLOCK_SUCCESS);
-        ABSL_TSAN_MUTEX_POST_LOCK(
+        Y_ABSL_TSAN_MUTEX_POST_LOCK(
             this, __tsan_mutex_read_lock | __tsan_mutex_try_lock, 0);
         return true;
       }
@@ -1666,20 +1666,20 @@ ABSL_XRAY_LOG_ARGS(1) bool Mutex::ReaderTryLock() {
       PostSynchEvent(this, SYNCH_EV_READERTRYLOCK_FAILED);
     }
   }
-  ABSL_TSAN_MUTEX_POST_LOCK(this,
+  Y_ABSL_TSAN_MUTEX_POST_LOCK(this,
                             __tsan_mutex_read_lock | __tsan_mutex_try_lock |
                                 __tsan_mutex_try_lock_failed,
                             0);
   return false;
 }
 
-ABSL_XRAY_LOG_ARGS(1) void Mutex::Unlock() {
-  ABSL_TSAN_MUTEX_PRE_UNLOCK(this, 0);
+Y_ABSL_XRAY_LOG_ARGS(1) void Mutex::Unlock() {
+  Y_ABSL_TSAN_MUTEX_PRE_UNLOCK(this, 0);
   DebugOnlyLockLeave(this);
   intptr_t v = mu_.load(std::memory_order_relaxed);
 
   if (kDebugMode && ((v & (kMuWriter | kMuReader)) != kMuWriter)) {
-    ABSL_RAW_LOG(FATAL, "Mutex unlocked when destroyed or not locked: v=0x%x",
+    Y_ABSL_RAW_LOG(FATAL, "Mutex unlocked when destroyed or not locked: v=0x%x",
                  static_cast<unsigned>(v));
   }
 
@@ -1699,7 +1699,7 @@ ABSL_XRAY_LOG_ARGS(1) void Mutex::Unlock() {
   if (kDebugMode && should_try_cas != (x < y)) {
     // We would usually use PRIdPTR here, but is not correctly implemented
     // within the android toolchain.
-    ABSL_RAW_LOG(FATAL, "internal logic error %llx %llx %llx\n",
+    Y_ABSL_RAW_LOG(FATAL, "internal logic error %llx %llx %llx\n",
                  static_cast<long long>(v), static_cast<long long>(x),
                  static_cast<long long>(y));
   }
@@ -1711,7 +1711,7 @@ ABSL_XRAY_LOG_ARGS(1) void Mutex::Unlock() {
   } else {
     this->UnlockSlow(nullptr /*no waitp*/);  // take slow path
   }
-  ABSL_TSAN_MUTEX_POST_UNLOCK(this, 0);
+  Y_ABSL_TSAN_MUTEX_POST_UNLOCK(this, 0);
 }
 
 // Requires v to represent a reader-locked state.
@@ -1725,8 +1725,8 @@ static bool ExactlyOneReader(intptr_t v) {
   return (v & kMuMultipleWaitersMask) == 0;
 }
 
-ABSL_XRAY_LOG_ARGS(1) void Mutex::ReaderUnlock() {
-  ABSL_TSAN_MUTEX_PRE_UNLOCK(this, __tsan_mutex_read_lock);
+Y_ABSL_XRAY_LOG_ARGS(1) void Mutex::ReaderUnlock() {
+  Y_ABSL_TSAN_MUTEX_PRE_UNLOCK(this, __tsan_mutex_read_lock);
   DebugOnlyLockLeave(this);
   intptr_t v = mu_.load(std::memory_order_relaxed);
   assert((v & (kMuWriter|kMuReader)) == kMuReader);
@@ -1736,12 +1736,12 @@ ABSL_XRAY_LOG_ARGS(1) void Mutex::ReaderUnlock() {
     if (mu_.compare_exchange_strong(v, v - clear,
                                     std::memory_order_release,
                                     std::memory_order_relaxed)) {
-      ABSL_TSAN_MUTEX_POST_UNLOCK(this, __tsan_mutex_read_lock);
+      Y_ABSL_TSAN_MUTEX_POST_UNLOCK(this, __tsan_mutex_read_lock);
       return;
     }
   }
   this->UnlockSlow(nullptr /*no waitp*/);  // take slow path
-  ABSL_TSAN_MUTEX_POST_UNLOCK(this, __tsan_mutex_read_lock);
+  Y_ABSL_TSAN_MUTEX_POST_UNLOCK(this, __tsan_mutex_read_lock);
 }
 
 // The zap_desig_waker bitmask is used to clear the designated waker flag in
@@ -1763,9 +1763,9 @@ static const intptr_t ignore_waiting_writers[] = {
 };
 
 // Internal version of LockWhen().  See LockSlowWithDeadline()
-ABSL_ATTRIBUTE_NOINLINE void Mutex::LockSlow(MuHow how, const Condition *cond,
+Y_ABSL_ATTRIBUTE_NOINLINE void Mutex::LockSlow(MuHow how, const Condition *cond,
                                              int flags) {
-  ABSL_RAW_CHECK(
+  Y_ABSL_RAW_CHECK(
       this->LockSlowWithDeadline(how, cond, KernelTimeout::Never(), flags),
       "condition untrue on return from LockSlow");
 }
@@ -1779,7 +1779,7 @@ static inline bool EvalConditionAnnotated(const Condition *cond, Mutex *mu,
   // All memory accesses are ignored inside of mutex operations + for unlock
   // operation tsan considers that we've already released the mutex.
   bool res = false;
-#ifdef ABSL_INTERNAL_HAVE_TSAN_INTERFACE
+#ifdef Y_ABSL_INTERNAL_HAVE_TSAN_INTERFACE
   const int flags = read_lock ? __tsan_mutex_read_lock : 0;
   const int tryflags = flags | (trylock ? __tsan_mutex_try_lock : 0);
 #endif
@@ -1790,21 +1790,21 @@ static inline bool EvalConditionAnnotated(const Condition *cond, Mutex *mu,
     // Note: we can't simply do POST_LOCK, Eval, PRE_LOCK, because then tsan
     // will think the lock acquisition is recursive which will trigger
     // deadlock detector.
-    ABSL_TSAN_MUTEX_POST_LOCK(mu, tryflags, 0);
+    Y_ABSL_TSAN_MUTEX_POST_LOCK(mu, tryflags, 0);
     res = cond->Eval();
     // There is no "try" version of Unlock, so use flags instead of tryflags.
-    ABSL_TSAN_MUTEX_PRE_UNLOCK(mu, flags);
-    ABSL_TSAN_MUTEX_POST_UNLOCK(mu, flags);
-    ABSL_TSAN_MUTEX_PRE_LOCK(mu, tryflags);
+    Y_ABSL_TSAN_MUTEX_PRE_UNLOCK(mu, flags);
+    Y_ABSL_TSAN_MUTEX_POST_UNLOCK(mu, flags);
+    Y_ABSL_TSAN_MUTEX_PRE_LOCK(mu, tryflags);
   } else {
     // Similarly, for unlock we pretend that we have unlocked the mutex,
     // lock the mutex, evaluate the predicate, and start unlocking it again
     // to match the annotation at the end of outer unlock operation.
-    ABSL_TSAN_MUTEX_POST_UNLOCK(mu, flags);
-    ABSL_TSAN_MUTEX_PRE_LOCK(mu, flags);
-    ABSL_TSAN_MUTEX_POST_LOCK(mu, flags, 0);
+    Y_ABSL_TSAN_MUTEX_POST_UNLOCK(mu, flags);
+    Y_ABSL_TSAN_MUTEX_PRE_LOCK(mu, flags);
+    Y_ABSL_TSAN_MUTEX_POST_LOCK(mu, flags, 0);
     res = cond->Eval();
-    ABSL_TSAN_MUTEX_PRE_UNLOCK(mu, flags);
+    Y_ABSL_TSAN_MUTEX_PRE_UNLOCK(mu, flags);
   }
   // Prevent unused param warnings in non-TSAN builds.
   static_cast<void>(mu);
@@ -1828,11 +1828,11 @@ static inline bool EvalConditionIgnored(Mutex *mu, const Condition *cond) {
   // because missed synchronization can lead to false reports later.
   // So we "divert" (which un-ignores both memory accesses and synchronization)
   // and then separately turn on ignores of memory accesses.
-  ABSL_TSAN_MUTEX_PRE_DIVERT(mu, 0);
-  ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN();
+  Y_ABSL_TSAN_MUTEX_PRE_DIVERT(mu, 0);
+  Y_ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN();
   bool res = cond->Eval();
-  ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_END();
-  ABSL_TSAN_MUTEX_POST_DIVERT(mu, 0);
+  Y_ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_END();
+  Y_ABSL_TSAN_MUTEX_POST_DIVERT(mu, 0);
   static_cast<void>(mu);  // Prevent unused param warning in non-TSAN builds.
   return res;
 }
@@ -1883,8 +1883,8 @@ bool Mutex::LockSlowWithDeadline(MuHow how, const Condition *cond,
 // Arguments after the first are not evaluated unless the condition is true.
 #define RAW_CHECK_FMT(cond, ...)                                   \
   do {                                                             \
-    if (ABSL_PREDICT_FALSE(!(cond))) {                             \
-      ABSL_RAW_LOG(FATAL, "Check " #cond " failed: " __VA_ARGS__); \
+    if (Y_ABSL_PREDICT_FALSE(!(cond))) {                             \
+      Y_ABSL_RAW_LOG(FATAL, "Check " #cond " failed: " __VA_ARGS__); \
     }                                                              \
   } while (0)
 
@@ -1901,7 +1901,7 @@ static void CheckForMutexCorruption(intptr_t v, const char* label) {
   // save a branch in the common (correct) case of them not being coincident.
   static_assert(kMuReader << 3 == kMuWriter, "must match");
   static_assert(kMuWait << 3 == kMuWrWait, "must match");
-  if (ABSL_PREDICT_TRUE((w & (w << 3) & (kMuWriter | kMuWrWait)) == 0)) return;
+  if (Y_ABSL_PREDICT_TRUE((w & (w << 3) & (kMuWriter | kMuWrWait)) == 0)) return;
   RAW_CHECK_FMT((v & (kMuWriter | kMuReader)) != (kMuWriter | kMuReader),
                 "%s: Mutex corrupt: both reader and writer lock held: %p",
                 label, reinterpret_cast<void *>(v));
@@ -1919,7 +1919,7 @@ void Mutex::LockSlowLoop(SynchWaitParams *waitp, int flags) {
     PostSynchEvent(this,
          waitp->how == kExclusive?  SYNCH_EV_LOCK: SYNCH_EV_READERLOCK);
   }
-  ABSL_RAW_CHECK(
+  Y_ABSL_RAW_CHECK(
       waitp->thread->waitp == nullptr || waitp->thread->suppress_fatal_errors,
       "detected illegal recursion into Mutex code");
   for (;;) {
@@ -1948,7 +1948,7 @@ void Mutex::LockSlowLoop(SynchWaitParams *waitp, int flags) {
         PerThreadSynch *new_h = Enqueue(nullptr, waitp, v, flags);
         intptr_t nv = (v & zap_desig_waker[flags & kMuHasBlocked] & kMuLow) |
                       kMuWait;
-        ABSL_RAW_CHECK(new_h != nullptr, "Enqueue to empty list failed");
+        Y_ABSL_RAW_CHECK(new_h != nullptr, "Enqueue to empty list failed");
         if (waitp->how == kExclusive && (v & kMuReader) != 0) {
           nv |= kMuWrWait;
         }
@@ -1993,7 +1993,7 @@ void Mutex::LockSlowLoop(SynchWaitParams *waitp, int flags) {
         PerThreadSynch *h = GetPerThreadSynch(v);
         PerThreadSynch *new_h = Enqueue(h, waitp, v, flags);
         intptr_t wr_wait = 0;
-        ABSL_RAW_CHECK(new_h != nullptr, "Enqueue to list failed");
+        Y_ABSL_RAW_CHECK(new_h != nullptr, "Enqueue to list failed");
         if (waitp->how == kExclusive && (v & kMuReader) != 0) {
           wr_wait = kMuWrWait;      // give priority to a waiting writer
         }
@@ -2011,13 +2011,13 @@ void Mutex::LockSlowLoop(SynchWaitParams *waitp, int flags) {
         c = 0;
       }
     }
-    ABSL_RAW_CHECK(
+    Y_ABSL_RAW_CHECK(
         waitp->thread->waitp == nullptr || waitp->thread->suppress_fatal_errors,
         "detected illegal recursion into Mutex code");
     // delay, then try again
     c = synchronization_internal::MutexDelay(c, GENTLE);
   }
-  ABSL_RAW_CHECK(
+  Y_ABSL_RAW_CHECK(
       waitp->thread->waitp == nullptr || waitp->thread->suppress_fatal_errors,
       "detected illegal recursion into Mutex code");
   if ((v & kMuEvent) != 0) {
@@ -2032,7 +2032,7 @@ void Mutex::LockSlowLoop(SynchWaitParams *waitp, int flags) {
 // which holds the lock but is not runnable because its condition is false
 // or it is in the process of blocking on a condition variable; it must requeue
 // itself on the mutex/condvar to wait for its condition to become true.
-ABSL_ATTRIBUTE_NOINLINE void Mutex::UnlockSlow(SynchWaitParams *waitp) {
+Y_ABSL_ATTRIBUTE_NOINLINE void Mutex::UnlockSlow(SynchWaitParams *waitp) {
   SchedulingGuard::ScopedDisable disable_rescheduling;
   intptr_t v = mu_.load(std::memory_order_relaxed);
   this->AssertReaderHeld();
@@ -2054,7 +2054,7 @@ ABSL_ATTRIBUTE_NOINLINE void Mutex::UnlockSlow(SynchWaitParams *waitp) {
   intptr_t wr_wait = 0;        // set to kMuWrWait if we wake a reader and a
                                // later writer could have acquired the lock
                                // (starvation avoidance)
-  ABSL_RAW_CHECK(waitp == nullptr || waitp->thread->waitp == nullptr ||
+  Y_ABSL_RAW_CHECK(waitp == nullptr || waitp->thread->waitp == nullptr ||
                      waitp->thread->suppress_fatal_errors,
                  "detected illegal recursion into Mutex code");
   // This loop finds threads wake_list to wakeup if any, and removes them from
@@ -2085,7 +2085,7 @@ ABSL_ATTRIBUTE_NOINLINE void Mutex::UnlockSlow(SynchWaitParams *waitp) {
       if ((v & kMuWait) == 0) {       // no one to wake
         intptr_t nv;
         bool do_enqueue = true;  // always Enqueue() the first time
-        ABSL_RAW_CHECK(waitp != nullptr,
+        Y_ABSL_RAW_CHECK(waitp != nullptr,
                        "UnlockSlow is confused");  // about to sleep
         do {    // must loop to release spinlock as reader count may change
           v = mu_.load(std::memory_order_relaxed);
@@ -2130,7 +2130,7 @@ ABSL_ATTRIBUTE_NOINLINE void Mutex::UnlockSlow(SynchWaitParams *waitp) {
         intptr_t nv = v;       // normally just release spinlock
         if (waitp != nullptr) {  // but waitp!=nullptr => must queue ourselves
           PerThreadSynch *new_h = Enqueue(h, waitp, v, kMuIsCond);
-          ABSL_RAW_CHECK(new_h != nullptr,
+          Y_ABSL_RAW_CHECK(new_h != nullptr,
                          "waiters disappeared during Enqueue()!");
           nv &= kMuLow;
           nv |= kMuWait | reinterpret_cast<intptr_t>(new_h);
@@ -2142,14 +2142,14 @@ ABSL_ATTRIBUTE_NOINLINE void Mutex::UnlockSlow(SynchWaitParams *waitp) {
 
       // Either we didn't search before, or we marked the queue
       // as "maybe_unlocking" and no one else should have changed it.
-      ABSL_RAW_CHECK(old_h == nullptr || h->maybe_unlocking,
+      Y_ABSL_RAW_CHECK(old_h == nullptr || h->maybe_unlocking,
                      "Mutex queue changed beneath us");
 
       // The lock is becoming free, and there's a waiter
       if (old_h != nullptr &&
           !old_h->may_skip) {                  // we used old_h as a terminator
         old_h->may_skip = true;                // allow old_h to skip once more
-        ABSL_RAW_CHECK(old_h->skip == nullptr, "illegal skip from head");
+        Y_ABSL_RAW_CHECK(old_h->skip == nullptr, "illegal skip from head");
         if (h != old_h && MuEquivalentWaiter(old_h, old_h->next)) {
           old_h->skip = old_h->next;  // old_h not head & can skip to successor
         }
@@ -2213,7 +2213,7 @@ ABSL_ATTRIBUTE_NOINLINE void Mutex::UnlockSlow(SynchWaitParams *waitp) {
 
         h->may_skip = false;  // ensure we never skip past h in future searches
                               // even if other waiters are queued after it.
-        ABSL_RAW_CHECK(h->skip == nullptr, "illegal skip from head");
+        Y_ABSL_RAW_CHECK(h->skip == nullptr, "illegal skip from head");
 
         h->maybe_unlocking = true;  // we're about to scan the waiter list
                                     // without the spinlock held.
@@ -2274,7 +2274,7 @@ ABSL_ATTRIBUTE_NOINLINE void Mutex::UnlockSlow(SynchWaitParams *waitp) {
 
         continue;  // restart for(;;)-loop to wakeup w or to find more waiters
       }
-      ABSL_RAW_CHECK(pw->next == w, "pw not w's predecessor");
+      Y_ABSL_RAW_CHECK(pw->next == w, "pw not w's predecessor");
       // The first (and perhaps only) waiter we've chosen to wake is w, whose
       // predecessor is pw.  If w is a reader, we must wake all the other
       // waiters with wake==true as well.  We may also need to queue
@@ -2296,7 +2296,7 @@ ABSL_ATTRIBUTE_NOINLINE void Mutex::UnlockSlow(SynchWaitParams *waitp) {
         // CondVar
       }
 
-      ABSL_RAW_CHECK(wake_list != kPerThreadSynchNull,
+      Y_ABSL_RAW_CHECK(wake_list != kPerThreadSynchNull,
                      "unexpected empty wake list");
 
       if (h != nullptr) {  // there are waiters left
@@ -2326,9 +2326,9 @@ ABSL_ATTRIBUTE_NOINLINE void Mutex::UnlockSlow(SynchWaitParams *waitp) {
       int64_t wait_cycles =
           base_internal::CycleClock::Now() - enqueue_timestamp;
       mutex_tracer("slow release", this, wait_cycles);
-      ABSL_TSAN_MUTEX_PRE_DIVERT(this, 0);
+      Y_ABSL_TSAN_MUTEX_PRE_DIVERT(this, 0);
       submit_profile_data(enqueue_timestamp);
-      ABSL_TSAN_MUTEX_POST_DIVERT(this, 0);
+      Y_ABSL_TSAN_MUTEX_POST_DIVERT(this, 0);
     }
   }
 }
@@ -2353,11 +2353,11 @@ void Mutex::Trans(MuHow how) {
 void Mutex::Fer(PerThreadSynch *w) {
   SchedulingGuard::ScopedDisable disable_rescheduling;
   int c = 0;
-  ABSL_RAW_CHECK(w->waitp->cond == nullptr,
+  Y_ABSL_RAW_CHECK(w->waitp->cond == nullptr,
                  "Mutex::Fer while waiting on Condition");
-  ABSL_RAW_CHECK(!w->waitp->timeout.has_timeout(),
+  Y_ABSL_RAW_CHECK(!w->waitp->timeout.has_timeout(),
                  "Mutex::Fer while in timed wait");
-  ABSL_RAW_CHECK(w->waitp->cv_word == nullptr,
+  Y_ABSL_RAW_CHECK(w->waitp->cv_word == nullptr,
                  "Mutex::Fer with pending CondVar queueing");
   for (;;) {
     intptr_t v = mu_.load(std::memory_order_relaxed);
@@ -2378,7 +2378,7 @@ void Mutex::Fer(PerThreadSynch *w) {
       if ((v & (kMuSpin|kMuWait)) == 0) {       // no waiters
         // This thread tries to become the one and only waiter.
         PerThreadSynch *new_h = Enqueue(nullptr, w->waitp, v, kMuIsCond);
-        ABSL_RAW_CHECK(new_h != nullptr,
+        Y_ABSL_RAW_CHECK(new_h != nullptr,
                        "Enqueue failed");  // we must queue ourselves
         if (mu_.compare_exchange_strong(
                 v, reinterpret_cast<intptr_t>(new_h) | (v & kMuLow) | kMuWait,
@@ -2389,7 +2389,7 @@ void Mutex::Fer(PerThreadSynch *w) {
                  mu_.compare_exchange_strong(v, v | kMuSpin | kMuWait)) {
         PerThreadSynch *h = GetPerThreadSynch(v);
         PerThreadSynch *new_h = Enqueue(h, w->waitp, v, kMuIsCond);
-        ABSL_RAW_CHECK(new_h != nullptr,
+        Y_ABSL_RAW_CHECK(new_h != nullptr,
                        "Enqueue failed");  // we must queue ourselves
         do {
           v = mu_.load(std::memory_order_relaxed);
@@ -2408,7 +2408,7 @@ void Mutex::Fer(PerThreadSynch *w) {
 void Mutex::AssertHeld() const {
   if ((mu_.load(std::memory_order_relaxed) & kMuWriter) == 0) {
     SynchEvent *e = GetSynchEvent(this);
-    ABSL_RAW_LOG(FATAL, "thread should hold write lock on Mutex %p %s",
+    Y_ABSL_RAW_LOG(FATAL, "thread should hold write lock on Mutex %p %s",
                  static_cast<const void *>(this),
                  (e == nullptr ? "" : e->name));
   }
@@ -2417,7 +2417,7 @@ void Mutex::AssertHeld() const {
 void Mutex::AssertReaderHeld() const {
   if ((mu_.load(std::memory_order_relaxed) & (kMuReader | kMuWriter)) == 0) {
     SynchEvent *e = GetSynchEvent(this);
-    ABSL_RAW_LOG(
+    Y_ABSL_RAW_LOG(
         FATAL, "thread should hold at least a read lock on Mutex %p %s",
         static_cast<const void *>(this), (e == nullptr ? "" : e->name));
   }
@@ -2516,7 +2516,7 @@ static void CondVarEnqueue(SynchWaitParams *waitp) {
     c = synchronization_internal::MutexDelay(c, GENTLE);
     v = cv_word->load(std::memory_order_relaxed);
   }
-  ABSL_RAW_CHECK(waitp->thread->waitp == nullptr, "waiting when shouldn't be");
+  Y_ABSL_RAW_CHECK(waitp->thread->waitp == nullptr, "waiting when shouldn't be");
   waitp->thread->waitp = waitp;      // prepare ourselves for waiting
   PerThreadSynch *h = reinterpret_cast<PerThreadSynch *>(v & ~kCvLow);
   if (h == nullptr) {  // add this thread to waiter list
@@ -2536,7 +2536,7 @@ bool CondVar::WaitCommon(Mutex *mutex, KernelTimeout t) {
 
   intptr_t mutex_v = mutex->mu_.load(std::memory_order_relaxed);
   Mutex::MuHow mutex_how = ((mutex_v & kMuWriter) != 0) ? kExclusive : kShared;
-  ABSL_TSAN_MUTEX_PRE_UNLOCK(mutex, TsanFlags(mutex_how));
+  Y_ABSL_TSAN_MUTEX_PRE_UNLOCK(mutex, TsanFlags(mutex_how));
 
   // maybe trace this call
   intptr_t v = cv_.load(std::memory_order_relaxed);
@@ -2562,7 +2562,7 @@ bool CondVar::WaitCommon(Mutex *mutex, KernelTimeout t) {
     }
   }
 
-  ABSL_RAW_CHECK(waitp.thread->waitp != nullptr, "not waiting when should be");
+  Y_ABSL_RAW_CHECK(waitp.thread->waitp != nullptr, "not waiting when should be");
   waitp.thread->waitp = nullptr;  // cleanup
 
   // maybe trace this call
@@ -2575,10 +2575,10 @@ bool CondVar::WaitCommon(Mutex *mutex, KernelTimeout t) {
   // by lock of the mutex. We've annotated start of unlock in the beginning
   // of the function. Now, finish unlock and annotate lock of the mutex.
   // (Trans is effectively lock).
-  ABSL_TSAN_MUTEX_POST_UNLOCK(mutex, TsanFlags(mutex_how));
-  ABSL_TSAN_MUTEX_PRE_LOCK(mutex, TsanFlags(mutex_how));
+  Y_ABSL_TSAN_MUTEX_POST_UNLOCK(mutex, TsanFlags(mutex_how));
+  Y_ABSL_TSAN_MUTEX_PRE_LOCK(mutex, TsanFlags(mutex_how));
   mutex->Trans(mutex_how);  // Reacquire mutex
-  ABSL_TSAN_MUTEX_POST_LOCK(mutex, TsanFlags(mutex_how), 0);
+  Y_ABSL_TSAN_MUTEX_POST_LOCK(mutex, TsanFlags(mutex_how), 0);
   return rc;
 }
 
@@ -2613,7 +2613,7 @@ void CondVar::Wakeup(PerThreadSynch *w) {
 
 void CondVar::Signal() {
   SchedulingGuard::ScopedDisable disable_rescheduling;
-  ABSL_TSAN_MUTEX_PRE_SIGNAL(nullptr, 0);
+  Y_ABSL_TSAN_MUTEX_PRE_SIGNAL(nullptr, 0);
   intptr_t v;
   int c = 0;
   for (v = cv_.load(std::memory_order_relaxed); v != 0;
@@ -2642,17 +2642,17 @@ void CondVar::Signal() {
       if ((v & kCvEvent) != 0) {
         PostSynchEvent(this, SYNCH_EV_SIGNAL);
       }
-      ABSL_TSAN_MUTEX_POST_SIGNAL(nullptr, 0);
+      Y_ABSL_TSAN_MUTEX_POST_SIGNAL(nullptr, 0);
       return;
     } else {
       c = synchronization_internal::MutexDelay(c, GENTLE);
     }
   }
-  ABSL_TSAN_MUTEX_POST_SIGNAL(nullptr, 0);
+  Y_ABSL_TSAN_MUTEX_POST_SIGNAL(nullptr, 0);
 }
 
 void CondVar::SignalAll () {
-  ABSL_TSAN_MUTEX_PRE_SIGNAL(nullptr, 0);
+  Y_ABSL_TSAN_MUTEX_PRE_SIGNAL(nullptr, 0);
   intptr_t v;
   int c = 0;
   for (v = cv_.load(std::memory_order_relaxed); v != 0;
@@ -2679,24 +2679,24 @@ void CondVar::SignalAll () {
       if ((v & kCvEvent) != 0) {
         PostSynchEvent(this, SYNCH_EV_SIGNALALL);
       }
-      ABSL_TSAN_MUTEX_POST_SIGNAL(nullptr, 0);
+      Y_ABSL_TSAN_MUTEX_POST_SIGNAL(nullptr, 0);
       return;
     } else {
       // try again after a delay
       c = synchronization_internal::MutexDelay(c, GENTLE);
     }
   }
-  ABSL_TSAN_MUTEX_POST_SIGNAL(nullptr, 0);
+  Y_ABSL_TSAN_MUTEX_POST_SIGNAL(nullptr, 0);
 }
 
 void ReleasableMutexLock::Release() {
-  ABSL_RAW_CHECK(this->mu_ != nullptr,
+  Y_ABSL_RAW_CHECK(this->mu_ != nullptr,
                  "ReleasableMutexLock::Release may only be called once");
   this->mu_->Unlock();
   this->mu_ = nullptr;
 }
 
-#ifdef ABSL_HAVE_THREAD_SANITIZER
+#ifdef Y_ABSL_HAVE_THREAD_SANITIZER
 extern "C" void __tsan_read1(void *addr);
 #else
 #define __tsan_read1(addr)  // do nothing if TSan not enabled
@@ -2747,5 +2747,5 @@ bool Condition::GuaranteedEqual(const Condition *a, const Condition *b) {
          a->arg_ == b->arg_ && a->method_ == b->method_;
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/mutex.h b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/mutex.h
index 0762a852df..fab53e867b 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/mutex.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/mutex.h
@@ -55,8 +55,8 @@
 // this header file is limited, as a result. Please consult the Mutex guide for
 // more complete information and examples.
 
-#ifndef ABSL_SYNCHRONIZATION_MUTEX_H_
-#define ABSL_SYNCHRONIZATION_MUTEX_H_
+#ifndef Y_ABSL_SYNCHRONIZATION_MUTEX_H_
+#define Y_ABSL_SYNCHRONIZATION_MUTEX_H_
 
 #include <atomic>
 #include <cstdint>
@@ -74,7 +74,7 @@
 #include "y_absl/time/time.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 class Condition;
 struct SynchWaitParams;
@@ -128,7 +128,7 @@ struct SynchWaitParams;
 //
 // See also `MutexLock`, below, for scoped `Mutex` acquisition.
 
-class ABSL_LOCKABLE Mutex {
+class Y_ABSL_LOCKABLE Mutex {
  public:
   // Creates a `Mutex` that is not held by anyone. This constructor is
   // typically used for Mutexes allocated on the heap or the stack.
@@ -147,7 +147,7 @@ class ABSL_LOCKABLE Mutex {
   //
   // Example usage:
   //   namespace foo {
-  //   ABSL_CONST_INIT y_absl::Mutex mu(y_absl::kConstInit);
+  //   Y_ABSL_CONST_INIT y_absl::Mutex mu(y_absl::kConstInit);
   //   }
   explicit constexpr Mutex(y_absl::ConstInitType);
 
@@ -157,27 +157,27 @@ class ABSL_LOCKABLE Mutex {
   //
   // Blocks the calling thread, if necessary, until this `Mutex` is free, and
   // then acquires it exclusively. (This lock is also known as a "write lock.")
-  void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION();
+  void Lock() Y_ABSL_EXCLUSIVE_LOCK_FUNCTION();
 
   // Mutex::Unlock()
   //
   // Releases this `Mutex` and returns it from the exclusive/write state to the
   // free state. Calling thread must hold the `Mutex` exclusively.
-  void Unlock() ABSL_UNLOCK_FUNCTION();
+  void Unlock() Y_ABSL_UNLOCK_FUNCTION();
 
   // Mutex::TryLock()
   //
   // If the mutex can be acquired without blocking, does so exclusively and
   // returns `true`. Otherwise, returns `false`. Returns `true` with high
   // probability if the `Mutex` was free.
-  bool TryLock() ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(true);
+  bool TryLock() Y_ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(true);
 
   // Mutex::AssertHeld()
   //
   // Return immediately if this thread holds the `Mutex` exclusively (in write
   // mode). Otherwise, may report an error (typically by crashing with a
   // diagnostic), or may return immediately.
-  void AssertHeld() const ABSL_ASSERT_EXCLUSIVE_LOCK();
+  void AssertHeld() const Y_ABSL_ASSERT_EXCLUSIVE_LOCK();
 
   // ---------------------------------------------------------------------------
   // Reader-Writer Locking
@@ -218,28 +218,28 @@ class ABSL_LOCKABLE Mutex {
   // `ReaderLock()` will block if some other thread has an exclusive/writer lock
   // on the mutex.
 
-  void ReaderLock() ABSL_SHARED_LOCK_FUNCTION();
+  void ReaderLock() Y_ABSL_SHARED_LOCK_FUNCTION();
 
   // Mutex::ReaderUnlock()
   //
   // Releases a read share of this `Mutex`. `ReaderUnlock` may return a mutex to
   // the free state if this thread holds the last reader lock on the mutex. Note
   // that you cannot call `ReaderUnlock()` on a mutex held in write mode.
-  void ReaderUnlock() ABSL_UNLOCK_FUNCTION();
+  void ReaderUnlock() Y_ABSL_UNLOCK_FUNCTION();
 
   // Mutex::ReaderTryLock()
   //
   // If the mutex can be acquired without blocking, acquires this mutex for
   // shared access and returns `true`. Otherwise, returns `false`. Returns
   // `true` with high probability if the `Mutex` was free or shared.
-  bool ReaderTryLock() ABSL_SHARED_TRYLOCK_FUNCTION(true);
+  bool ReaderTryLock() Y_ABSL_SHARED_TRYLOCK_FUNCTION(true);
 
   // Mutex::AssertReaderHeld()
   //
   // Returns immediately if this thread holds the `Mutex` in at least shared
   // mode (read mode). Otherwise, may report an error (typically by
   // crashing with a diagnostic), or may return immediately.
-  void AssertReaderHeld() const ABSL_ASSERT_SHARED_LOCK();
+  void AssertReaderHeld() const Y_ABSL_ASSERT_SHARED_LOCK();
 
   // Mutex::WriterLock()
   // Mutex::WriterUnlock()
@@ -250,11 +250,11 @@ class ABSL_LOCKABLE Mutex {
   // These methods may be used (along with the complementary `Reader*()`
   // methods) to distingish simple exclusive `Mutex` usage (`Lock()`,
   // etc.) from reader/writer lock usage.
-  void WriterLock() ABSL_EXCLUSIVE_LOCK_FUNCTION() { this->Lock(); }
+  void WriterLock() Y_ABSL_EXCLUSIVE_LOCK_FUNCTION() { this->Lock(); }
 
-  void WriterUnlock() ABSL_UNLOCK_FUNCTION() { this->Unlock(); }
+  void WriterUnlock() Y_ABSL_UNLOCK_FUNCTION() { this->Unlock(); }
 
-  bool WriterTryLock() ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(true) {
+  bool WriterTryLock() Y_ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(true) {
     return this->TryLock();
   }
 
@@ -308,11 +308,11 @@ class ABSL_LOCKABLE Mutex {
   // be acquired, then atomically acquires this `Mutex`. `LockWhen()` is
   // logically equivalent to `*Lock(); Await();` though they may have different
   // performance characteristics.
-  void LockWhen(const Condition &cond) ABSL_EXCLUSIVE_LOCK_FUNCTION();
+  void LockWhen(const Condition &cond) Y_ABSL_EXCLUSIVE_LOCK_FUNCTION();
 
-  void ReaderLockWhen(const Condition &cond) ABSL_SHARED_LOCK_FUNCTION();
+  void ReaderLockWhen(const Condition &cond) Y_ABSL_SHARED_LOCK_FUNCTION();
 
-  void WriterLockWhen(const Condition &cond) ABSL_EXCLUSIVE_LOCK_FUNCTION() {
+  void WriterLockWhen(const Condition &cond) Y_ABSL_EXCLUSIVE_LOCK_FUNCTION() {
     this->LockWhen(cond);
   }
 
@@ -353,11 +353,11 @@ class ABSL_LOCKABLE Mutex {
   //
   // Negative timeouts are equivalent to a zero timeout.
   bool LockWhenWithTimeout(const Condition &cond, y_absl::Duration timeout)
-      ABSL_EXCLUSIVE_LOCK_FUNCTION();
+      Y_ABSL_EXCLUSIVE_LOCK_FUNCTION();
   bool ReaderLockWhenWithTimeout(const Condition &cond, y_absl::Duration timeout)
-      ABSL_SHARED_LOCK_FUNCTION();
+      Y_ABSL_SHARED_LOCK_FUNCTION();
   bool WriterLockWhenWithTimeout(const Condition &cond, y_absl::Duration timeout)
-      ABSL_EXCLUSIVE_LOCK_FUNCTION() {
+      Y_ABSL_EXCLUSIVE_LOCK_FUNCTION() {
     return this->LockWhenWithTimeout(cond, timeout);
   }
 
@@ -373,11 +373,11 @@ class ABSL_LOCKABLE Mutex {
   //
   // Deadlines in the past are equivalent to an immediate deadline.
   bool LockWhenWithDeadline(const Condition &cond, y_absl::Time deadline)
-      ABSL_EXCLUSIVE_LOCK_FUNCTION();
+      Y_ABSL_EXCLUSIVE_LOCK_FUNCTION();
   bool ReaderLockWhenWithDeadline(const Condition &cond, y_absl::Time deadline)
-      ABSL_SHARED_LOCK_FUNCTION();
+      Y_ABSL_SHARED_LOCK_FUNCTION();
   bool WriterLockWhenWithDeadline(const Condition &cond, y_absl::Time deadline)
-      ABSL_EXCLUSIVE_LOCK_FUNCTION() {
+      Y_ABSL_EXCLUSIVE_LOCK_FUNCTION() {
     return this->LockWhenWithDeadline(cond, deadline);
   }
 
@@ -403,7 +403,7 @@ class ABSL_LOCKABLE Mutex {
   // Mutex::EnableDebugLog()
   //
   // Cause all subsequent uses of this `Mutex` to be logged via
-  // `ABSL_RAW_LOG(INFO)`. Log entries are tagged with `name` if no previous
+  // `Y_ABSL_RAW_LOG(INFO)`. Log entries are tagged with `name` if no previous
   // call to `EnableInvariantDebugging()` or `EnableDebugLog()` has been made.
   //
   // Note: This method substantially reduces `Mutex` performance.
@@ -468,9 +468,9 @@ class ABSL_LOCKABLE Mutex {
                             synchronization_internal::KernelTimeout t,
                             int flags);
   void LockSlow(MuHow how, const Condition *cond,
-                int flags) ABSL_ATTRIBUTE_COLD;
+                int flags) Y_ABSL_ATTRIBUTE_COLD;
   // slow path release
-  void UnlockSlow(SynchWaitParams *waitp) ABSL_ATTRIBUTE_COLD;
+  void UnlockSlow(SynchWaitParams *waitp) Y_ABSL_ATTRIBUTE_COLD;
   // Common code between Await() and AwaitWithTimeout/Deadline()
   bool AwaitCommon(const Condition &cond,
                    synchronization_internal::KernelTimeout t);
@@ -515,14 +515,14 @@ class ABSL_LOCKABLE Mutex {
 // private:
 //   Mutex mu_;
 // };
-class ABSL_SCOPED_LOCKABLE MutexLock {
+class Y_ABSL_SCOPED_LOCKABLE MutexLock {
  public:
   // Constructors
 
   // Calls `mu->Lock()` and returns when that call returns. That is, `*mu` is
   // guaranteed to be locked when this object is constructed. Requires that
   // `mu` be dereferenceable.
-  explicit MutexLock(Mutex *mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) : mu_(mu) {
+  explicit MutexLock(Mutex *mu) Y_ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) : mu_(mu) {
     this->mu_->Lock();
   }
 
@@ -530,7 +530,7 @@ class ABSL_SCOPED_LOCKABLE MutexLock {
   // the above, the condition given by `cond` is also guaranteed to hold when
   // this object is constructed.
   explicit MutexLock(Mutex *mu, const Condition &cond)
-      ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
+      Y_ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
       : mu_(mu) {
     this->mu_->LockWhen(cond);
   }
@@ -540,7 +540,7 @@ class ABSL_SCOPED_LOCKABLE MutexLock {
   MutexLock& operator=(const MutexLock&) = delete;
   MutexLock& operator=(MutexLock&&) = delete;
 
-  ~MutexLock() ABSL_UNLOCK_FUNCTION() { this->mu_->Unlock(); }
+  ~MutexLock() Y_ABSL_UNLOCK_FUNCTION() { this->mu_->Unlock(); }
 
  private:
   Mutex *const mu_;
@@ -550,14 +550,14 @@ class ABSL_SCOPED_LOCKABLE MutexLock {
 //
 // The `ReaderMutexLock` is a helper class, like `MutexLock`, which acquires and
 // releases a shared lock on a `Mutex` via RAII.
-class ABSL_SCOPED_LOCKABLE ReaderMutexLock {
+class Y_ABSL_SCOPED_LOCKABLE ReaderMutexLock {
  public:
-  explicit ReaderMutexLock(Mutex *mu) ABSL_SHARED_LOCK_FUNCTION(mu) : mu_(mu) {
+  explicit ReaderMutexLock(Mutex *mu) Y_ABSL_SHARED_LOCK_FUNCTION(mu) : mu_(mu) {
     mu->ReaderLock();
   }
 
   explicit ReaderMutexLock(Mutex *mu, const Condition &cond)
-      ABSL_SHARED_LOCK_FUNCTION(mu)
+      Y_ABSL_SHARED_LOCK_FUNCTION(mu)
       : mu_(mu) {
     mu->ReaderLockWhen(cond);
   }
@@ -567,7 +567,7 @@ class ABSL_SCOPED_LOCKABLE ReaderMutexLock {
   ReaderMutexLock& operator=(const ReaderMutexLock&) = delete;
   ReaderMutexLock& operator=(ReaderMutexLock&&) = delete;
 
-  ~ReaderMutexLock() ABSL_UNLOCK_FUNCTION() { this->mu_->ReaderUnlock(); }
+  ~ReaderMutexLock() Y_ABSL_UNLOCK_FUNCTION() { this->mu_->ReaderUnlock(); }
 
  private:
   Mutex *const mu_;
@@ -577,15 +577,15 @@ class ABSL_SCOPED_LOCKABLE ReaderMutexLock {
 //
 // The `WriterMutexLock` is a helper class, like `MutexLock`, which acquires and
 // releases a write (exclusive) lock on a `Mutex` via RAII.
-class ABSL_SCOPED_LOCKABLE WriterMutexLock {
+class Y_ABSL_SCOPED_LOCKABLE WriterMutexLock {
  public:
-  explicit WriterMutexLock(Mutex *mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
+  explicit WriterMutexLock(Mutex *mu) Y_ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
       : mu_(mu) {
     mu->WriterLock();
   }
 
   explicit WriterMutexLock(Mutex *mu, const Condition &cond)
-      ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
+      Y_ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
       : mu_(mu) {
     mu->WriterLockWhen(cond);
   }
@@ -595,7 +595,7 @@ class ABSL_SCOPED_LOCKABLE WriterMutexLock {
   WriterMutexLock& operator=(const WriterMutexLock&) = delete;
   WriterMutexLock& operator=(WriterMutexLock&&) = delete;
 
-  ~WriterMutexLock() ABSL_UNLOCK_FUNCTION() { this->mu_->WriterUnlock(); }
+  ~WriterMutexLock() Y_ABSL_UNLOCK_FUNCTION() { this->mu_->WriterUnlock(); }
 
  private:
   Mutex *const mu_;
@@ -635,7 +635,7 @@ class ABSL_SCOPED_LOCKABLE WriterMutexLock {
 // Example using LockWhen/Unlock:
 //
 //   // assume count_ is not internal reference count
-//   int count_ ABSL_GUARDED_BY(mu_);
+//   int count_ Y_ABSL_GUARDED_BY(mu_);
 //   Condition count_is_zero(+[](int *count) { return *count == 0; }, &count_);
 //
 //   mu_.LockWhen(count_is_zero);
@@ -849,7 +849,7 @@ class CondVar {
   // CondVar::EnableDebugLog()
   //
   // Causes all subsequent uses of this `CondVar` to be logged via
-  // `ABSL_RAW_LOG(INFO)`. Log entries are tagged with `name` if `name != 0`.
+  // `Y_ABSL_RAW_LOG(INFO)`. Log entries are tagged with `name` if `name != 0`.
   // Note: this method substantially reduces `CondVar` performance.
   void EnableDebugLog(const char *name);
 
@@ -871,9 +871,9 @@ class CondVar {
 // MutexLockMaybe
 //
 // MutexLockMaybe is like MutexLock, but is a no-op when mu is null.
-class ABSL_SCOPED_LOCKABLE MutexLockMaybe {
+class Y_ABSL_SCOPED_LOCKABLE MutexLockMaybe {
  public:
-  explicit MutexLockMaybe(Mutex *mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
+  explicit MutexLockMaybe(Mutex *mu) Y_ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
       : mu_(mu) {
     if (this->mu_ != nullptr) {
       this->mu_->Lock();
@@ -881,14 +881,14 @@ class ABSL_SCOPED_LOCKABLE MutexLockMaybe {
   }
 
   explicit MutexLockMaybe(Mutex *mu, const Condition &cond)
-      ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
+      Y_ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
       : mu_(mu) {
     if (this->mu_ != nullptr) {
       this->mu_->LockWhen(cond);
     }
   }
 
-  ~MutexLockMaybe() ABSL_UNLOCK_FUNCTION() {
+  ~MutexLockMaybe() Y_ABSL_UNLOCK_FUNCTION() {
     if (this->mu_ != nullptr) { this->mu_->Unlock(); }
   }
 
@@ -904,24 +904,24 @@ class ABSL_SCOPED_LOCKABLE MutexLockMaybe {
 //
 // ReleasableMutexLock is like MutexLock, but permits `Release()` of its
 // mutex before destruction. `Release()` may be called at most once.
-class ABSL_SCOPED_LOCKABLE ReleasableMutexLock {
+class Y_ABSL_SCOPED_LOCKABLE ReleasableMutexLock {
  public:
-  explicit ReleasableMutexLock(Mutex *mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
+  explicit ReleasableMutexLock(Mutex *mu) Y_ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
       : mu_(mu) {
     this->mu_->Lock();
   }
 
   explicit ReleasableMutexLock(Mutex *mu, const Condition &cond)
-      ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
+      Y_ABSL_EXCLUSIVE_LOCK_FUNCTION(mu)
       : mu_(mu) {
     this->mu_->LockWhen(cond);
   }
 
-  ~ReleasableMutexLock() ABSL_UNLOCK_FUNCTION() {
+  ~ReleasableMutexLock() Y_ABSL_UNLOCK_FUNCTION() {
     if (this->mu_ != nullptr) { this->mu_->Unlock(); }
   }
 
-  void Release() ABSL_UNLOCK_FUNCTION();
+  void Release() Y_ABSL_UNLOCK_FUNCTION();
 
  private:
   Mutex *mu_;
@@ -932,7 +932,7 @@ class ABSL_SCOPED_LOCKABLE ReleasableMutexLock {
 };
 
 inline Mutex::Mutex() : mu_(0) {
-  ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
+  Y_ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
 }
 
 inline constexpr Mutex::Mutex(y_absl::ConstInitType) : mu_(0) {}
@@ -1035,7 +1035,7 @@ void RegisterCondVarTracer(void (*fn)(const char *msg, const void *cv));
 // DEPRECATED: The default symbolizer function is y_absl::Symbolize() and the
 // ability to register a different hook for symbolizing stack traces will be
 // removed on or after 2023-05-01.
-ABSL_DEPRECATED("y_absl::RegisterSymbolizer() is deprecated and will be removed "
+Y_ABSL_DEPRECATED("y_absl::RegisterSymbolizer() is deprecated and will be removed "
                 "on or after 2023-05-01")
 void RegisterSymbolizer(bool (*fn)(const void *pc, char *out, int out_size));
 
@@ -1066,7 +1066,7 @@ enum class OnDeadlockCycle {
 // the manner chosen here.
 void SetMutexDeadlockDetectionMode(OnDeadlockCycle mode);
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 // In some build configurations we pass --detect-odr-violations to the
@@ -1076,7 +1076,7 @@ ABSL_NAMESPACE_END
 // By changing our extension points to be extern "C", we dodge this
 // check.
 extern "C" {
-void ABSL_INTERNAL_C_SYMBOL(AbslInternalMutexYield)();
+void Y_ABSL_INTERNAL_C_SYMBOL(AbslInternalMutexYield)();
 }  // extern "C"
 
-#endif  // ABSL_SYNCHRONIZATION_MUTEX_H_
+#endif  // Y_ABSL_SYNCHRONIZATION_MUTEX_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/notification.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/notification.cc
index 0b5c5a5e48..f6e779f248 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/notification.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/notification.cc
@@ -22,14 +22,14 @@
 #include "y_absl/time/time.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 void Notification::Notify() {
   MutexLock l(&this->mutex_);
 
 #ifndef NDEBUG
-  if (ABSL_PREDICT_FALSE(notified_yet_.load(std::memory_order_relaxed))) {
-    ABSL_RAW_LOG(
+  if (Y_ABSL_PREDICT_FALSE(notified_yet_.load(std::memory_order_relaxed))) {
+    Y_ABSL_RAW_LOG(
         FATAL,
         "Notify() method called more than once for Notification object %p",
         static_cast<void *>(this));
@@ -74,5 +74,5 @@ bool Notification::WaitForNotificationWithDeadline(y_absl::Time deadline) const
   return notified;
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/notification.h b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/notification.h
index eea7090f18..0794cc35e9 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/notification.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/synchronization/notification.h
@@ -47,8 +47,8 @@
 //  * Y receives a `true` return value from either `HasBeenNotified()` or
 //    `WaitForNotificationWithTimeout()`.
 
-#ifndef ABSL_SYNCHRONIZATION_NOTIFICATION_H_
-#define ABSL_SYNCHRONIZATION_NOTIFICATION_H_
+#ifndef Y_ABSL_SYNCHRONIZATION_NOTIFICATION_H_
+#define Y_ABSL_SYNCHRONIZATION_NOTIFICATION_H_
 
 #include <atomic>
 
@@ -57,7 +57,7 @@
 #include "y_absl/time/time.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // -----------------------------------------------------------------------------
 // Notification
@@ -117,7 +117,7 @@ class Notification {
   std::atomic<bool> notified_yet_;  // written under mutex_
 };
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_SYNCHRONIZATION_NOTIFICATION_H_
+#endif  // Y_ABSL_SYNCHRONIZATION_NOTIFICATION_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time.cc
index f24bac91e8..b97ec570bf 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time.cc
@@ -21,7 +21,7 @@
 #include "y_absl/time/time.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 namespace {
 
@@ -169,5 +169,5 @@ std::ostream& operator<<(std::ostream& os, CivilSecond s) {
 
 }  // namespace time_internal
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time.h
index 64fb6da494..32ca3cfda4 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/civil_time.h
@@ -67,8 +67,8 @@
 //   // Valid in C++14
 //   constexpr y_absl::CivilDay cd(1969, 07, 20);
 
-#ifndef ABSL_TIME_CIVIL_TIME_H_
-#define ABSL_TIME_CIVIL_TIME_H_
+#ifndef Y_ABSL_TIME_CIVIL_TIME_H_
+#define Y_ABSL_TIME_CIVIL_TIME_H_
 
 #include <util/generic/string.h>
 
@@ -76,7 +76,7 @@
 #include "y_absl/time/internal/cctz/include/cctz/civil_time.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 namespace time_internal {
 struct second_tag : cctz::detail::second_tag {};
@@ -532,7 +532,7 @@ std::ostream& operator<<(std::ostream& os, CivilSecond s);
 
 }  // namespace time_internal
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_TIME_CIVIL_TIME_H_
+#endif  // Y_ABSL_TIME_CIVIL_TIME_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/clock.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/clock.cc
index dcc12b5633..78cea0b6cc 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/clock.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/clock.cc
@@ -35,7 +35,7 @@
 #include "y_absl/base/thread_annotations.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 Time Now() {
   // TODO(bww): Get a timespec instead so we don't have to divide.
   int64_t n = y_absl::GetCurrentTimeNanos();
@@ -45,18 +45,18 @@ Time Now() {
   }
   return time_internal::FromUnixDuration(y_absl::Nanoseconds(n));
 }
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 // Decide if we should use the fast GetCurrentTimeNanos() algorithm
 // based on the cyclecounter, otherwise just get the time directly
 // from the OS on every call. This can be chosen at compile-time via
 // -DABSL_USE_CYCLECLOCK_FOR_GET_CURRENT_TIME_NANOS=[0|1]
-#ifndef ABSL_USE_CYCLECLOCK_FOR_GET_CURRENT_TIME_NANOS
-#if ABSL_USE_UNSCALED_CYCLECLOCK
-#define ABSL_USE_CYCLECLOCK_FOR_GET_CURRENT_TIME_NANOS 1
+#ifndef Y_ABSL_USE_CYCLECLOCK_FOR_GET_CURRENT_TIME_NANOS
+#if Y_ABSL_USE_UNSCALED_CYCLECLOCK
+#define Y_ABSL_USE_CYCLECLOCK_FOR_GET_CURRENT_TIME_NANOS 1
 #else
-#define ABSL_USE_CYCLECLOCK_FOR_GET_CURRENT_TIME_NANOS 0
+#define Y_ABSL_USE_CYCLECLOCK_FOR_GET_CURRENT_TIME_NANOS 0
 #endif
 #endif
 
@@ -72,11 +72,11 @@ ABSL_NAMESPACE_END
   ::y_absl::time_internal::GetCurrentTimeNanosFromSystem()
 #endif
 
-#if !ABSL_USE_CYCLECLOCK_FOR_GET_CURRENT_TIME_NANOS
+#if !Y_ABSL_USE_CYCLECLOCK_FOR_GET_CURRENT_TIME_NANOS
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 int64_t GetCurrentTimeNanos() { return GET_CURRENT_TIME_NANOS_FROM_SYSTEM(); }
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 #else  // Use the cyclecounter-based implementation below.
 
@@ -87,7 +87,7 @@ ABSL_NAMESPACE_END
 #endif
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace time_internal {
 // This is a friend wrapper around UnscaledCycleClock::Now()
 // (needed to access UnscaledCycleClock).
@@ -169,7 +169,7 @@ struct TimeSample {
   uint64_t min_cycles_per_sample = 0;  // approx cycles before next sample
 };
 
-struct ABSL_CACHELINE_ALIGNED TimeState {
+struct Y_ABSL_CACHELINE_ALIGNED TimeState {
   std::atomic<uint64_t> seq{0};
   TimeSampleAtomic last_sample;  // the last sample; under seq
 
@@ -180,7 +180,7 @@ struct ABSL_CACHELINE_ALIGNED TimeState {
   int64_t stats_slow_paths{0};
   int64_t stats_fast_slow_paths{0};
 
-  uint64_t last_now_cycles ABSL_GUARDED_BY(lock){0};
+  uint64_t last_now_cycles Y_ABSL_GUARDED_BY(lock){0};
 
   // Used by GetCurrentTimeNanosFromKernel().
   // We try to read clock values at about the same time as the kernel clock.
@@ -196,7 +196,7 @@ struct ABSL_CACHELINE_ALIGNED TimeState {
   y_absl::base_internal::SpinLock lock{y_absl::kConstInit,
                                      base_internal::SCHEDULE_KERNEL_ONLY};
 };
-ABSL_CONST_INIT static TimeState time_state{};
+Y_ABSL_CONST_INIT static TimeState time_state{};
 
 // Return the time in ns as told by the kernel interface.  Place in *cycleclock
 // the value of the cycleclock at about the time of the syscall.
@@ -207,7 +207,7 @@ ABSL_CONST_INIT static TimeState time_state{};
 // reinitialization of the outer algorithm should occur.)
 static int64_t GetCurrentTimeNanosFromKernel(uint64_t last_cycleclock,
                                              uint64_t *cycleclock)
-    ABSL_EXCLUSIVE_LOCKS_REQUIRED(time_state.lock) {
+    Y_ABSL_EXCLUSIVE_LOCKS_REQUIRED(time_state.lock) {
   uint64_t local_approx_syscall_time_in_cycles =  // local copy
       time_state.approx_syscall_time_in_cycles.load(std::memory_order_relaxed);
 
@@ -255,7 +255,7 @@ static int64_t GetCurrentTimeNanosFromKernel(uint64_t last_cycleclock,
   return current_time_nanos_from_system;
 }
 
-static int64_t GetCurrentTimeNanosSlowPath() ABSL_ATTRIBUTE_COLD;
+static int64_t GetCurrentTimeNanosSlowPath() Y_ABSL_ATTRIBUTE_COLD;
 
 // Read the contents of *atomic into *sample.
 // Each field is read atomically, but to maintain atomicity between fields,
@@ -381,7 +381,7 @@ static uint64_t SafeDivideAndScale(uint64_t a, uint64_t b) {
 
 static uint64_t UpdateLastSample(
     uint64_t now_cycles, uint64_t now_ns, uint64_t delta_cycles,
-    const struct TimeSample *sample) ABSL_ATTRIBUTE_COLD;
+    const struct TimeSample *sample) Y_ABSL_ATTRIBUTE_COLD;
 
 // The slow path of GetCurrentTimeNanos().  This is taken while gathering
 // initial samples, when enough time has elapsed since the last sample, and if
@@ -394,9 +394,9 @@ static uint64_t UpdateLastSample(
 //
 // TODO(y_absl-team): Remove this attribute when our compiler is smart enough
 // to do the right thing.
-ABSL_ATTRIBUTE_NOINLINE
+Y_ABSL_ATTRIBUTE_NOINLINE
 static int64_t GetCurrentTimeNanosSlowPath()
-    ABSL_LOCKS_EXCLUDED(time_state.lock) {
+    Y_ABSL_LOCKS_EXCLUDED(time_state.lock) {
   // Serialize access to slow-path.  Fast-path readers are not blocked yet, and
   // code below must not modify last_sample until the seqlock is acquired.
   time_state.lock.Lock();
@@ -441,7 +441,7 @@ static int64_t GetCurrentTimeNanosSlowPath()
 static uint64_t UpdateLastSample(uint64_t now_cycles, uint64_t now_ns,
                                  uint64_t delta_cycles,
                                  const struct TimeSample *sample)
-    ABSL_EXCLUSIVE_LOCKS_REQUIRED(time_state.lock) {
+    Y_ABSL_EXCLUSIVE_LOCKS_REQUIRED(time_state.lock) {
   uint64_t estimated_base_ns = now_ns;
   uint64_t lock_value =
       SeqAcquire(&time_state.seq);  // acquire seqlock to block readers
@@ -535,12 +535,12 @@ static uint64_t UpdateLastSample(uint64_t now_cycles, uint64_t now_ns,
 
   return estimated_base_ns;
 }
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
-#endif  // ABSL_USE_CYCLECLOCK_FOR_GET_CURRENT_TIME_NANOS
+#endif  // Y_ABSL_USE_CYCLECLOCK_FOR_GET_CURRENT_TIME_NANOS
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace {
 
 // Returns the maximum duration that SleepOnce() can sleep for.
@@ -568,12 +568,12 @@ void SleepOnce(y_absl::Duration to_sleep) {
 }
 
 }  // namespace
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 extern "C" {
 
-ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalSleepFor)(
+Y_ABSL_ATTRIBUTE_WEAK void Y_ABSL_INTERNAL_C_SYMBOL(AbslInternalSleepFor)(
     y_absl::Duration duration) {
   while (duration > y_absl::ZeroDuration()) {
     y_absl::Duration to_sleep = std::min(duration, y_absl::MaxSleep());
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/clock.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/clock.h
index 178b96d828..1369748e6a 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/clock.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/clock.h
@@ -19,14 +19,14 @@
 // This header file contains utility functions for working with the system-wide
 // realtime clock. For descriptions of the main time abstractions used within
 // this header file, consult the time.h header file.
-#ifndef ABSL_TIME_CLOCK_H_
-#define ABSL_TIME_CLOCK_H_
+#ifndef Y_ABSL_TIME_CLOCK_H_
+#define Y_ABSL_TIME_CLOCK_H_
 
 #include "y_absl/base/macros.h"
 #include "y_absl/time/time.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // Now()
 //
@@ -50,7 +50,7 @@ int64_t GetCurrentTimeNanos();
 // * Returns immediately when passed a nonpositive duration.
 void SleepFor(y_absl::Duration duration);
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 // -----------------------------------------------------------------------------
@@ -64,11 +64,11 @@ ABSL_NAMESPACE_END
 // By changing our extension points to be extern "C", we dodge this
 // check.
 extern "C" {
-void ABSL_INTERNAL_C_SYMBOL(AbslInternalSleepFor)(y_absl::Duration duration);
+void Y_ABSL_INTERNAL_C_SYMBOL(AbslInternalSleepFor)(y_absl::Duration duration);
 }  // extern "C"
 
 inline void y_absl::SleepFor(y_absl::Duration duration) {
-  ABSL_INTERNAL_C_SYMBOL(AbslInternalSleepFor)(duration);
+  Y_ABSL_INTERNAL_C_SYMBOL(AbslInternalSleepFor)(duration);
 }
 
-#endif  // ABSL_TIME_CLOCK_H_
+#endif  // Y_ABSL_TIME_CLOCK_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/duration.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/duration.cc
index d4914556e6..cc646c8870 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/duration.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/duration.cc
@@ -74,7 +74,7 @@
 #include "y_absl/time/time.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 namespace {
 
@@ -715,12 +715,12 @@ struct DisplayUnit {
   int prec;
   double pow10;
 };
-ABSL_CONST_INIT const DisplayUnit kDisplayNano = {"ns", 2, 1e2};
-ABSL_CONST_INIT const DisplayUnit kDisplayMicro = {"us", 5, 1e5};
-ABSL_CONST_INIT const DisplayUnit kDisplayMilli = {"ms", 8, 1e8};
-ABSL_CONST_INIT const DisplayUnit kDisplaySec = {"s", 11, 1e11};
-ABSL_CONST_INIT const DisplayUnit kDisplayMin = {"m", -1, 0.0};  // prec ignored
-ABSL_CONST_INIT const DisplayUnit kDisplayHour = {"h", -1,
+Y_ABSL_CONST_INIT const DisplayUnit kDisplayNano = {"ns", 2, 1e2};
+Y_ABSL_CONST_INIT const DisplayUnit kDisplayMicro = {"us", 5, 1e5};
+Y_ABSL_CONST_INIT const DisplayUnit kDisplayMilli = {"ms", 8, 1e8};
+Y_ABSL_CONST_INIT const DisplayUnit kDisplaySec = {"s", 11, 1e11};
+Y_ABSL_CONST_INIT const DisplayUnit kDisplayMin = {"m", -1, 0.0};  // prec ignored
+Y_ABSL_CONST_INIT const DisplayUnit kDisplayHour = {"h", -1,
                                                   0.0};  // prec ignored
 
 void AppendNumberUnit(TString* out, int64_t n, DisplayUnit unit) {
@@ -870,7 +870,7 @@ bool ConsumeDurationUnit(const char** start, const char* end, Duration* unit) {
         default:
           break;
       }
-      ABSL_FALLTHROUGH_INTENDED;
+      Y_ABSL_FALLTHROUGH_INTENDED;
     case 1:
       switch (**start) {
         case 's':
@@ -950,5 +950,5 @@ bool ParseFlag(const TString& text, Duration* dst, TString* ) {
 
 TString UnparseFlag(Duration d) { return FormatDuration(d); }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/format.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/format.cc
index c75e4ec21a..5e8bd8f7ba 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/format.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/format.cc
@@ -25,13 +25,13 @@
 namespace cctz = y_absl::time_internal::cctz;
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
-ABSL_DLL extern const char RFC3339_full[] = "%Y-%m-%d%ET%H:%M:%E*S%Ez";
-ABSL_DLL extern const char RFC3339_sec[] = "%Y-%m-%d%ET%H:%M:%S%Ez";
+Y_ABSL_DLL extern const char RFC3339_full[] = "%Y-%m-%d%ET%H:%M:%E*S%Ez";
+Y_ABSL_DLL extern const char RFC3339_sec[] = "%Y-%m-%d%ET%H:%M:%S%Ez";
 
-ABSL_DLL extern const char RFC1123_full[] = "%a, %d %b %E4Y %H:%M:%S %z";
-ABSL_DLL extern const char RFC1123_no_wday[] = "%d %b %E4Y %H:%M:%S %z";
+Y_ABSL_DLL extern const char RFC1123_full[] = "%a, %d %b %E4Y %H:%M:%S %z";
+Y_ABSL_DLL extern const char RFC1123_no_wday[] = "%d %b %E4Y %H:%M:%S %z";
 
 namespace {
 
@@ -156,5 +156,5 @@ TString UnparseFlag(y_absl::Time t) {
   return y_absl::FormatTime(RFC3339_full, t, y_absl::UTCTimeZone());
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/civil_time.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/civil_time.h
index be60a54dbe..07e581dbe2 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/civil_time.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/civil_time.h
@@ -12,14 +12,14 @@
 //   See the License for the specific language governing permissions and
 //   limitations under the License.
 
-#ifndef ABSL_TIME_INTERNAL_CCTZ_CIVIL_TIME_H_
-#define ABSL_TIME_INTERNAL_CCTZ_CIVIL_TIME_H_
+#ifndef Y_ABSL_TIME_INTERNAL_CCTZ_CIVIL_TIME_H_
+#define Y_ABSL_TIME_INTERNAL_CCTZ_CIVIL_TIME_H_
 
 #include "y_absl/base/config.h"
 #include "y_absl/time/internal/cctz/include/cctz/civil_time_detail.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace time_internal {
 namespace cctz {
 
@@ -326,7 +326,7 @@ using detail::get_yearday;
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_TIME_INTERNAL_CCTZ_CIVIL_TIME_H_
+#endif  // Y_ABSL_TIME_INTERNAL_CCTZ_CIVIL_TIME_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/civil_time_detail.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/civil_time_detail.h
index 0e71a7cd33..f2385d6754 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/civil_time_detail.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/civil_time_detail.h
@@ -12,8 +12,8 @@
 //   See the License for the specific language governing permissions and
 //   limitations under the License.
 
-#ifndef ABSL_TIME_INTERNAL_CCTZ_CIVIL_TIME_DETAIL_H_
-#define ABSL_TIME_INTERNAL_CCTZ_CIVIL_TIME_DETAIL_H_
+#ifndef Y_ABSL_TIME_INTERNAL_CCTZ_CIVIL_TIME_DETAIL_H_
+#define Y_ABSL_TIME_INTERNAL_CCTZ_CIVIL_TIME_DETAIL_H_
 
 #include <cstdint>
 #include <limits>
@@ -34,7 +34,7 @@
 #endif
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace time_internal {
 namespace cctz {
 
@@ -618,11 +618,11 @@ std::ostream& operator<<(std::ostream& os, weekday wd);
 }  // namespace detail
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 #undef CONSTEXPR_M
 #undef CONSTEXPR_F
 #undef CONSTEXPR_D
 
-#endif  // ABSL_TIME_INTERNAL_CCTZ_CIVIL_TIME_DETAIL_H_
+#endif  // Y_ABSL_TIME_INTERNAL_CCTZ_CIVIL_TIME_DETAIL_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/time_zone.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/time_zone.h
index 524654df4b..3c213c1da4 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/time_zone.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/time_zone.h
@@ -17,8 +17,8 @@
 // times (represented by cctz::civil_second) using the rules defined by
 // a time zone (cctz::time_zone).
 
-#ifndef ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_H_
-#define ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_H_
+#ifndef Y_ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_H_
+#define Y_ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_H_
 
 #include <chrono>
 #include <cstdint>
@@ -30,7 +30,7 @@
 #include "y_absl/time/internal/cctz/include/cctz/civil_time.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace time_internal {
 namespace cctz {
 
@@ -453,7 +453,7 @@ inline bool join_seconds(const time_point<seconds>& sec, const femtoseconds&,
 }  // namespace detail
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_H_
+#endif  // Y_ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/zone_info_source.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/zone_info_source.h
index fd6dc4bbb0..e5a43b3e30 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/zone_info_source.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/include/cctz/zone_info_source.h
@@ -12,8 +12,8 @@
 //   See the License for the specific language governing permissions and
 //   limitations under the License.
 
-#ifndef ABSL_TIME_INTERNAL_CCTZ_ZONE_INFO_SOURCE_H_
-#define ABSL_TIME_INTERNAL_CCTZ_ZONE_INFO_SOURCE_H_
+#ifndef Y_ABSL_TIME_INTERNAL_CCTZ_ZONE_INFO_SOURCE_H_
+#define Y_ABSL_TIME_INTERNAL_CCTZ_ZONE_INFO_SOURCE_H_
 
 #include <cstddef>
 #include <functional>
@@ -23,7 +23,7 @@
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace time_internal {
 namespace cctz {
 
@@ -43,11 +43,11 @@ class ZoneInfoSource {
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace time_internal {
 namespace cctz_extension {
 
@@ -96,7 +96,7 @@ extern ZoneInfoSourceFactory zone_info_source_factory;
 
 }  // namespace cctz_extension
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_TIME_INTERNAL_CCTZ_ZONE_INFO_SOURCE_H_
+#endif  // Y_ABSL_TIME_INTERNAL_CCTZ_ZONE_INFO_SOURCE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/civil_time_detail.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/civil_time_detail.cc
index 61dbfc96ab..e5139d44ff 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/civil_time_detail.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/civil_time_detail.cc
@@ -21,7 +21,7 @@
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace time_internal {
 namespace cctz {
 namespace detail {
@@ -90,5 +90,5 @@ std::ostream& operator<<(std::ostream& os, weekday wd) {
 }  // namespace detail
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_fixed.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_fixed.cc
index 3a22cbea1d..a204acf61d 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_fixed.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_fixed.cc
@@ -23,7 +23,7 @@
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace time_internal {
 namespace cctz {
 
@@ -136,5 +136,5 @@ TString FixedOffsetToAbbr(const seconds& offset) {
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_fixed.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_fixed.h
index 39b24e5a32..3ccf9df5aa 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_fixed.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_fixed.h
@@ -12,8 +12,8 @@
 //   See the License for the specific language governing permissions and
 //   limitations under the License.
 
-#ifndef ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_FIXED_H_
-#define ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_FIXED_H_
+#ifndef Y_ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_FIXED_H_
+#define Y_ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_FIXED_H_
 
 #include <util/generic/string.h>
 
@@ -21,7 +21,7 @@
 #include "y_absl/time/internal/cctz/include/cctz/time_zone.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace time_internal {
 namespace cctz {
 
@@ -46,7 +46,7 @@ TString FixedOffsetToAbbr(const seconds& offset);
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_FIXED_H_
+#endif  // Y_ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_FIXED_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_format.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_format.cc
index 2f9597018b..1f6a76ad49 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_format.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_format.cc
@@ -49,7 +49,7 @@
 #include "time_zone_if.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace time_internal {
 namespace cctz {
 namespace detail {
@@ -1025,5 +1025,5 @@ bool parse(const TString& format, const TString& input,
 }  // namespace detail
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_if.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_if.cc
index 2fe6d23c71..26074ebe75 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_if.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_if.cc
@@ -19,7 +19,7 @@
 #include "time_zone_libc.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace time_internal {
 namespace cctz {
 
@@ -41,5 +41,5 @@ TimeZoneIf::~TimeZoneIf() {}
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_if.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_if.h
index 10312badc2..949bfff7ae 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_if.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_if.h
@@ -12,8 +12,8 @@
 //   See the License for the specific language governing permissions and
 //   limitations under the License.
 
-#ifndef ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_IF_H_
-#define ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_IF_H_
+#ifndef Y_ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_IF_H_
+#define Y_ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_IF_H_
 
 #include <chrono>
 #include <cstdint>
@@ -25,7 +25,7 @@
 #include "y_absl/time/internal/cctz/include/cctz/time_zone.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace time_internal {
 namespace cctz {
 
@@ -71,7 +71,7 @@ inline time_point<seconds> FromUnixSeconds(std::int_fast64_t t) {
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_IF_H_
+#endif  // Y_ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_IF_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_impl.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_impl.cc
index 3810defe3c..09cab23ef4 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_impl.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_impl.cc
@@ -25,7 +25,7 @@
 #include "time_zone_fixed.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace time_internal {
 namespace cctz {
 
@@ -109,5 +109,5 @@ const time_zone::Impl* time_zone::Impl::UTCImpl() {
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_impl.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_impl.h
index c014ab41df..76dc84496a 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_impl.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_impl.h
@@ -12,8 +12,8 @@
 //   See the License for the specific language governing permissions and
 //   limitations under the License.
 
-#ifndef ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_IMPL_H_
-#define ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_IMPL_H_
+#ifndef Y_ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_IMPL_H_
+#define Y_ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_IMPL_H_
 
 #include <memory>
 #include <util/generic/string.h>
@@ -25,7 +25,7 @@
 #include "time_zone_info.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace time_internal {
 namespace cctz {
 
@@ -87,7 +87,7 @@ class time_zone::Impl {
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_IMPL_H_
+#endif  // Y_ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_IMPL_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_info.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_info.cc
index 72f7bdc3ca..cf61e49c80 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_info.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_info.cc
@@ -52,7 +52,7 @@
 #include "time_zone_posix.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace time_internal {
 namespace cctz {
 
@@ -1023,5 +1023,5 @@ bool TimeZoneInfo::PrevTransition(const time_point<seconds>& tp,
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_info.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_info.h
index e55fd51847..52948a362d 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_info.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_info.h
@@ -12,8 +12,8 @@
 //   See the License for the specific language governing permissions and
 //   limitations under the License.
 
-#ifndef ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_INFO_H_
-#define ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_INFO_H_
+#ifndef Y_ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_INFO_H_
+#define Y_ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_INFO_H_
 
 #include <atomic>
 #include <cstddef>
@@ -29,7 +29,7 @@
 #include "tzfile.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace time_internal {
 namespace cctz {
 
@@ -131,7 +131,7 @@ class TimeZoneInfo : public TimeZoneIf {
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_INFO_H_
+#endif  // Y_ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_INFO_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_libc.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_libc.cc
index a73832fc29..9f713ea5eb 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_libc.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_libc.cc
@@ -34,7 +34,7 @@ extern long altzone;
 #endif
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace time_internal {
 namespace cctz {
 
@@ -311,5 +311,5 @@ TString TimeZoneLibC::Description() const {
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_libc.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_libc.h
index fc926fecf7..1360a366c3 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_libc.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_libc.h
@@ -12,8 +12,8 @@
 //   See the License for the specific language governing permissions and
 //   limitations under the License.
 
-#ifndef ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_LIBC_H_
-#define ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_LIBC_H_
+#ifndef Y_ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_LIBC_H_
+#define Y_ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_LIBC_H_
 
 #include <util/generic/string.h>
 
@@ -21,7 +21,7 @@
 #include "time_zone_if.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace time_internal {
 namespace cctz {
 
@@ -49,7 +49,7 @@ class TimeZoneLibC : public TimeZoneIf {
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_LIBC_H_
+#endif  // Y_ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_LIBC_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_lookup.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_lookup.cc
index 92c9208d6d..4f26734918 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_lookup.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_lookup.cc
@@ -43,7 +43,7 @@
 #include "time_zone_impl.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace time_internal {
 namespace cctz {
 
@@ -232,5 +232,5 @@ time_zone local_time_zone() {
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_posix.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_posix.cc
index 4096503915..8856a6138e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_posix.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_posix.cc
@@ -22,7 +22,7 @@
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace time_internal {
 namespace cctz {
 
@@ -155,5 +155,5 @@ bool ParsePosixSpec(const TString& spec, PosixTimeZone* res) {
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_posix.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_posix.h
index e9de2b77ad..3eaa5384c7 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_posix.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/time_zone_posix.h
@@ -49,8 +49,8 @@
 //     }
 //   }
 
-#ifndef ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_POSIX_H_
-#define ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_POSIX_H_
+#ifndef Y_ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_POSIX_H_
+#define Y_ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_POSIX_H_
 
 #include <cstdint>
 #include <util/generic/string.h>
@@ -58,7 +58,7 @@
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace time_internal {
 namespace cctz {
 
@@ -126,7 +126,7 @@ bool ParsePosixSpec(const TString& spec, PosixTimeZone* res);
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_POSIX_H_
+#endif  // Y_ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_POSIX_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/zone_info_source.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/zone_info_source.cc
index be58c20fb3..8342abe891 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/zone_info_source.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/cctz/src/zone_info_source.cc
@@ -17,7 +17,7 @@
 #include "y_absl/base/config.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace time_internal {
 namespace cctz {
 
@@ -27,11 +27,11 @@ TString ZoneInfoSource::Version() const { return TString(); }
 
 }  // namespace cctz
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace time_internal {
 namespace cctz_extension {
 
@@ -68,38 +68,38 @@ ZoneInfoSourceFactory default_factory = DefaultFactory;
 #if defined(_M_IX86) || defined(_M_ARM)
 #pragma comment(                                                                                                         \
     linker,                                                                                                              \
-    "/alternatename:?zone_info_source_factory@cctz_extension@time_internal@" ABSL_INTERNAL_MANGLED_NS                    \
-    "@@3P6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                 \
-    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                   \
-    "@@@std@@@std@@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@" ABSL_INTERNAL_MANGLED_BACKREFERENCE      \
-    "@ABV?$function@$$A6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                   \
-    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                   \
-    "@@@std@@@std@@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@2@@Z@" ABSL_INTERNAL_MANGLED_BACKREFERENCE \
-    "@@ZA=?default_factory@cctz_extension@time_internal@" ABSL_INTERNAL_MANGLED_NS                                       \
-    "@@3P6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                 \
-    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                   \
-    "@@@std@@@std@@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@" ABSL_INTERNAL_MANGLED_BACKREFERENCE      \
-    "@ABV?$function@$$A6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                   \
-    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                   \
-    "@@@std@@@std@@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@2@@Z@" ABSL_INTERNAL_MANGLED_BACKREFERENCE \
+    "/alternatename:?zone_info_source_factory@cctz_extension@time_internal@" Y_ABSL_INTERNAL_MANGLED_NS                    \
+    "@@3P6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" Y_ABSL_INTERNAL_MANGLED_NS                                 \
+    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" Y_ABSL_INTERNAL_MANGLED_NS                                   \
+    "@@@std@@@std@@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@" Y_ABSL_INTERNAL_MANGLED_BACKREFERENCE      \
+    "@ABV?$function@$$A6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" Y_ABSL_INTERNAL_MANGLED_NS                   \
+    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" Y_ABSL_INTERNAL_MANGLED_NS                                   \
+    "@@@std@@@std@@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@2@@Z@" Y_ABSL_INTERNAL_MANGLED_BACKREFERENCE \
+    "@@ZA=?default_factory@cctz_extension@time_internal@" Y_ABSL_INTERNAL_MANGLED_NS                                       \
+    "@@3P6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" Y_ABSL_INTERNAL_MANGLED_NS                                 \
+    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" Y_ABSL_INTERNAL_MANGLED_NS                                   \
+    "@@@std@@@std@@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@" Y_ABSL_INTERNAL_MANGLED_BACKREFERENCE      \
+    "@ABV?$function@$$A6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" Y_ABSL_INTERNAL_MANGLED_NS                   \
+    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" Y_ABSL_INTERNAL_MANGLED_NS                                   \
+    "@@@std@@@std@@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@2@@Z@" Y_ABSL_INTERNAL_MANGLED_BACKREFERENCE \
     "@@ZA")
 #elif defined(_M_IA_64) || defined(_M_AMD64) || defined(_M_ARM64)
 #pragma comment(                                                                                                          \
     linker,                                                                                                               \
-    "/alternatename:?zone_info_source_factory@cctz_extension@time_internal@" ABSL_INTERNAL_MANGLED_NS                     \
-    "@@3P6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                  \
-    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                    \
-    "@@@std@@@std@@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@" ABSL_INTERNAL_MANGLED_BACKREFERENCE      \
-    "@AEBV?$function@$$A6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                   \
-    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                    \
-    "@@@std@@@std@@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@2@@Z@" ABSL_INTERNAL_MANGLED_BACKREFERENCE \
-    "@@ZEA=?default_factory@cctz_extension@time_internal@" ABSL_INTERNAL_MANGLED_NS                                       \
-    "@@3P6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                  \
-    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                    \
-    "@@@std@@@std@@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@" ABSL_INTERNAL_MANGLED_BACKREFERENCE      \
-    "@AEBV?$function@$$A6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                   \
-    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" ABSL_INTERNAL_MANGLED_NS                                    \
-    "@@@std@@@std@@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@2@@Z@" ABSL_INTERNAL_MANGLED_BACKREFERENCE \
+    "/alternatename:?zone_info_source_factory@cctz_extension@time_internal@" Y_ABSL_INTERNAL_MANGLED_NS                     \
+    "@@3P6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" Y_ABSL_INTERNAL_MANGLED_NS                                  \
+    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" Y_ABSL_INTERNAL_MANGLED_NS                                    \
+    "@@@std@@@std@@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@" Y_ABSL_INTERNAL_MANGLED_BACKREFERENCE      \
+    "@AEBV?$function@$$A6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" Y_ABSL_INTERNAL_MANGLED_NS                   \
+    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" Y_ABSL_INTERNAL_MANGLED_NS                                    \
+    "@@@std@@@std@@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@2@@Z@" Y_ABSL_INTERNAL_MANGLED_BACKREFERENCE \
+    "@@ZEA=?default_factory@cctz_extension@time_internal@" Y_ABSL_INTERNAL_MANGLED_NS                                       \
+    "@@3P6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" Y_ABSL_INTERNAL_MANGLED_NS                                  \
+    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" Y_ABSL_INTERNAL_MANGLED_NS                                    \
+    "@@@std@@@std@@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@" Y_ABSL_INTERNAL_MANGLED_BACKREFERENCE      \
+    "@AEBV?$function@$$A6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@" Y_ABSL_INTERNAL_MANGLED_NS                   \
+    "@@U?$default_delete@VZoneInfoSource@cctz@time_internal@" Y_ABSL_INTERNAL_MANGLED_NS                                    \
+    "@@@std@@@std@@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@2@@Z@" Y_ABSL_INTERNAL_MANGLED_BACKREFERENCE \
     "@@ZEA")
 #else
 #error Unsupported MSVC platform
@@ -111,5 +111,5 @@ ZoneInfoSourceFactory zone_info_source_factory = DefaultFactory;
 
 }  // namespace cctz_extension
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/get_current_time_chrono.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/get_current_time_chrono.inc
index ef28e97e5a..23754a8d93 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/get_current_time_chrono.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/get_current_time_chrono.inc
@@ -16,7 +16,7 @@
 #include <cstdint>
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace time_internal {
 
 static int64_t GetCurrentTimeNanosFromSystem() {
@@ -27,5 +27,5 @@ static int64_t GetCurrentTimeNanosFromSystem() {
 }
 
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/get_current_time_posix.inc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/get_current_time_posix.inc
index 1068fea026..a0d43c8e0c 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/get_current_time_posix.inc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/get_current_time_posix.inc
@@ -7,18 +7,18 @@
 #include "y_absl/base/internal/raw_logging.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace time_internal {
 
 static int64_t GetCurrentTimeNanosFromSystem() {
   const int64_t kNanosPerSecond = 1000 * 1000 * 1000;
   struct timespec ts;
-  ABSL_RAW_CHECK(clock_gettime(CLOCK_REALTIME, &ts) == 0,
+  Y_ABSL_RAW_CHECK(clock_gettime(CLOCK_REALTIME, &ts) == 0,
                  "Failed to read real-time clock.");
   return (int64_t{ts.tv_sec} * kNanosPerSecond +
           int64_t{ts.tv_nsec});
 }
 
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/test_util.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/test_util.h
index 22b991b836..d95ab15752 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/test_util.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/internal/test_util.h
@@ -12,22 +12,22 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_TIME_INTERNAL_TEST_UTIL_H_
-#define ABSL_TIME_INTERNAL_TEST_UTIL_H_
+#ifndef Y_ABSL_TIME_INTERNAL_TEST_UTIL_H_
+#define Y_ABSL_TIME_INTERNAL_TEST_UTIL_H_
 
 #include <util/generic/string.h>
 
 #include "y_absl/time/time.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace time_internal {
 
 // Loads the named timezone, but dies on any failure.
 y_absl::TimeZone LoadTimeZone(const TString& name);
 
 }  // namespace time_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_TIME_INTERNAL_TEST_UTIL_H_
+#endif  // Y_ABSL_TIME_INTERNAL_TEST_UTIL_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/time.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/time/time.cc
index 441638b256..68da5f1588 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/time.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/time.cc
@@ -47,7 +47,7 @@
 namespace cctz = y_absl::time_internal::cctz;
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 namespace {
 
@@ -496,5 +496,5 @@ struct tm ToTM(y_absl::Time t, y_absl::TimeZone tz) {
   return tm;
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/time/time.h b/contrib/restricted/abseil-cpp-tstring/y_absl/time/time.h
index 16150ad3b6..e3df4abd21 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/time/time.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/time/time.h
@@ -59,8 +59,8 @@
 //       "My flight will land in Sydney on %Y-%m-%d at %H:%M:%S",
 //       landing, syd);
 
-#ifndef ABSL_TIME_TIME_H_
-#define ABSL_TIME_TIME_H_
+#ifndef Y_ABSL_TIME_TIME_H_
+#define Y_ABSL_TIME_TIME_H_
 
 #if !defined(_MSC_VER)
 #include <sys/time.h>
@@ -89,7 +89,7 @@ struct timeval;
 #include "y_absl/time/internal/cctz/include/cctz/time_zone.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 class Duration;  // Defined below
 class Time;      // Defined below
@@ -488,12 +488,12 @@ Duration Hours(T n) {
 //
 //   y_absl::Duration d = y_absl::Milliseconds(1500);
 //   int64_t isec = y_absl::ToInt64Seconds(d);  // isec == 1
-ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Nanoseconds(Duration d);
-ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Microseconds(Duration d);
-ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Milliseconds(Duration d);
-ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Seconds(Duration d);
-ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Minutes(Duration d);
-ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Hours(Duration d);
+Y_ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Nanoseconds(Duration d);
+Y_ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Microseconds(Duration d);
+Y_ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Milliseconds(Duration d);
+Y_ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Seconds(Duration d);
+Y_ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Minutes(Duration d);
+Y_ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Hours(Duration d);
 
 // ToDoubleNanoSeconds()
 // ToDoubleMicroseconds()
@@ -510,12 +510,12 @@ ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Hours(Duration d);
 //
 //   y_absl::Duration d = y_absl::Milliseconds(1500);
 //   double dsec = y_absl::ToDoubleSeconds(d);  // dsec == 1.5
-ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleNanoseconds(Duration d);
-ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleMicroseconds(Duration d);
-ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleMilliseconds(Duration d);
-ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleSeconds(Duration d);
-ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleMinutes(Duration d);
-ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleHours(Duration d);
+Y_ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleNanoseconds(Duration d);
+Y_ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleMicroseconds(Duration d);
+Y_ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleMilliseconds(Duration d);
+Y_ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleSeconds(Duration d);
+Y_ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleMinutes(Duration d);
+Y_ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleHours(Duration d);
 
 // FromChrono()
 //
@@ -591,9 +591,9 @@ bool AbslParseFlag(y_absl::string_view text, Duration* dst, TString* error);
 // the format specified by `y_absl::ParseDuration()`.
 TString AbslUnparseFlag(Duration d);
 
-ABSL_DEPRECATED("Use AbslParseFlag() instead.")
+Y_ABSL_DEPRECATED("Use AbslParseFlag() instead.")
 bool ParseFlag(const TString& text, Duration* dst, TString* error);
-ABSL_DEPRECATED("Use AbslUnparseFlag() instead.")
+Y_ABSL_DEPRECATED("Use AbslUnparseFlag() instead.")
 TString UnparseFlag(Duration d);
 
 // Time
@@ -875,9 +875,9 @@ bool AbslParseFlag(y_absl::string_view text, Time* t, TString* error);
 // the format specified by `y_absl::ParseTime()`.
 TString AbslUnparseFlag(Time t);
 
-ABSL_DEPRECATED("Use AbslParseFlag() instead.")
+Y_ABSL_DEPRECATED("Use AbslParseFlag() instead.")
 bool ParseFlag(const TString& text, Time* t, TString* error);
-ABSL_DEPRECATED("Use AbslUnparseFlag() instead.")
+Y_ABSL_DEPRECATED("Use AbslUnparseFlag() instead.")
 TString UnparseFlag(Time t);
 
 // TimeZone
@@ -1257,15 +1257,15 @@ struct tm ToTM(Time t, TimeZone tz);
 // time with UTC offset.  Also note the use of "%Y": RFC3339 mandates that
 // years have exactly four digits, but we allow them to take their natural
 // width.
-ABSL_DLL extern const char RFC3339_full[];  // %Y-%m-%d%ET%H:%M:%E*S%Ez
-ABSL_DLL extern const char RFC3339_sec[];   // %Y-%m-%d%ET%H:%M:%S%Ez
+Y_ABSL_DLL extern const char RFC3339_full[];  // %Y-%m-%d%ET%H:%M:%E*S%Ez
+Y_ABSL_DLL extern const char RFC3339_sec[];   // %Y-%m-%d%ET%H:%M:%S%Ez
 
 // RFC1123_full
 // RFC1123_no_wday
 //
 // FormatTime()/ParseTime() format specifiers for RFC1123 date/time strings.
-ABSL_DLL extern const char RFC1123_full[];     // %a, %d %b %E4Y %H:%M:%S %z
-ABSL_DLL extern const char RFC1123_no_wday[];  // %d %b %E4Y %H:%M:%S %z
+Y_ABSL_DLL extern const char RFC1123_full[];     // %a, %d %b %E4Y %H:%M:%S %z
+Y_ABSL_DLL extern const char RFC1123_no_wday[];  // %d %b %E4Y %H:%M:%S %z
 
 // FormatTime()
 //
@@ -1610,7 +1610,7 @@ constexpr Time FromTimeT(time_t t) {
   return time_internal::FromUnixDuration(Seconds(t));
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_TIME_TIME_H_
+#endif  // Y_ABSL_TIME_TIME_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/any.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/any.h
index f03d940ed9..e4ffc9ddce 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/any.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/any.h
@@ -50,26 +50,26 @@
 // Abseil has also released an `y_absl::variant` type (a C++11 compatible version
 // of the C++17 `std::variant`), which is generally preferred for use over
 // `y_absl::any`.
-#ifndef ABSL_TYPES_ANY_H_
-#define ABSL_TYPES_ANY_H_
+#ifndef Y_ABSL_TYPES_ANY_H_
+#define Y_ABSL_TYPES_ANY_H_
 
 #include "y_absl/base/config.h"
 #include "y_absl/utility/utility.h"
 
-#ifdef ABSL_USES_STD_ANY
+#ifdef Y_ABSL_USES_STD_ANY
 
 #include <any>  // IWYU pragma: export
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 using std::any;
 using std::any_cast;
 using std::bad_any_cast;
 using std::make_any;
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#else  // ABSL_USES_STD_ANY
+#else  // Y_ABSL_USES_STD_ANY
 
 #include <algorithm>
 #include <cstddef>
@@ -87,14 +87,14 @@ ABSL_NAMESPACE_END
 
 // NOTE: This macro is an implementation detail that is undefined at the bottom
 // of the file. It is not intended for expansion directly from user code.
-#ifdef ABSL_ANY_DETAIL_HAS_RTTI
-#error ABSL_ANY_DETAIL_HAS_RTTI cannot be directly set
+#ifdef Y_ABSL_ANY_DETAIL_HAS_RTTI
+#error Y_ABSL_ANY_DETAIL_HAS_RTTI cannot be directly set
 #elif !defined(__GNUC__) || defined(__GXX_RTTI)
-#define ABSL_ANY_DETAIL_HAS_RTTI 1
+#define Y_ABSL_ANY_DETAIL_HAS_RTTI 1
 #endif  // !defined(__GNUC__) || defined(__GXX_RTTI)
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 class any;
 
@@ -348,7 +348,7 @@ class any {
   // returns `false`.
   bool has_value() const noexcept { return obj_ != nullptr; }
 
-#if ABSL_ANY_DETAIL_HAS_RTTI
+#if Y_ABSL_ANY_DETAIL_HAS_RTTI
   // Returns: typeid(T) if *this has a contained object of type T, otherwise
   // typeid(void).
   const std::type_info& type() const noexcept {
@@ -358,7 +358,7 @@ class any {
 
     return typeid(void);
   }
-#endif  // ABSL_ANY_DETAIL_HAS_RTTI
+#endif  // Y_ABSL_ANY_DETAIL_HAS_RTTI
 
  private:
   // Tagged type-erased abstraction for holding a cloneable object.
@@ -367,9 +367,9 @@ class any {
     virtual ~ObjInterface() = default;
     virtual std::unique_ptr<ObjInterface> Clone() const = 0;
     virtual const void* ObjTypeId() const noexcept = 0;
-#if ABSL_ANY_DETAIL_HAS_RTTI
+#if Y_ABSL_ANY_DETAIL_HAS_RTTI
     virtual const std::type_info& Type() const noexcept = 0;
-#endif  // ABSL_ANY_DETAIL_HAS_RTTI
+#endif  // Y_ABSL_ANY_DETAIL_HAS_RTTI
   };
 
   // Hold a value of some queryable type, with an ability to Clone it.
@@ -386,9 +386,9 @@ class any {
 
     const void* ObjTypeId() const noexcept final { return IdForType<T>(); }
 
-#if ABSL_ANY_DETAIL_HAS_RTTI
+#if Y_ABSL_ANY_DETAIL_HAS_RTTI
     const std::type_info& Type() const noexcept final { return typeid(T); }
-#endif  // ABSL_ANY_DETAIL_HAS_RTTI
+#endif  // Y_ABSL_ANY_DETAIL_HAS_RTTI
 
     T value;
   };
@@ -518,11 +518,11 @@ T* any_cast(any* operand) noexcept {
              : nullptr;
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#undef ABSL_ANY_DETAIL_HAS_RTTI
+#undef Y_ABSL_ANY_DETAIL_HAS_RTTI
 
-#endif  // ABSL_USES_STD_ANY
+#endif  // Y_ABSL_USES_STD_ANY
 
-#endif  // ABSL_TYPES_ANY_H_
+#endif  // Y_ABSL_TYPES_ANY_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_any_cast.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_any_cast.cc
index 29916186da..14ed288ece 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_any_cast.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_any_cast.cc
@@ -14,7 +14,7 @@
 
 #include "y_absl/types/bad_any_cast.h"
 
-#ifndef ABSL_USES_STD_ANY
+#ifndef Y_ABSL_USES_STD_ANY
 
 #include <cstdlib>
 
@@ -22,7 +22,7 @@
 #include "y_absl/base/internal/raw_logging.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 bad_any_cast::~bad_any_cast() = default;
 
@@ -31,16 +31,16 @@ const char* bad_any_cast::what() const noexcept { return "Bad any cast"; }
 namespace any_internal {
 
 void ThrowBadAnyCast() {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef Y_ABSL_HAVE_EXCEPTIONS
   throw bad_any_cast();
 #else
-  ABSL_RAW_LOG(FATAL, "Bad any cast");
+  Y_ABSL_RAW_LOG(FATAL, "Bad any cast");
   std::abort();
 #endif
 }
 
 }  // namespace any_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_USES_STD_ANY
+#endif  // Y_ABSL_USES_STD_ANY
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_any_cast.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_any_cast.h
index 92c3bfe522..a459f8c272 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_any_cast.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_any_cast.h
@@ -18,27 +18,27 @@
 //
 // This header file defines the `y_absl::bad_any_cast` type.
 
-#ifndef ABSL_TYPES_BAD_ANY_CAST_H_
-#define ABSL_TYPES_BAD_ANY_CAST_H_
+#ifndef Y_ABSL_TYPES_BAD_ANY_CAST_H_
+#define Y_ABSL_TYPES_BAD_ANY_CAST_H_
 
 #include <typeinfo>
 
 #include "y_absl/base/config.h"
 
-#ifdef ABSL_USES_STD_ANY
+#ifdef Y_ABSL_USES_STD_ANY
 
 #include <any>
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 using std::bad_any_cast;
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#else  // ABSL_USES_STD_ANY
+#else  // Y_ABSL_USES_STD_ANY
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // -----------------------------------------------------------------------------
 // bad_any_cast
@@ -67,9 +67,9 @@ namespace any_internal {
 [[noreturn]] void ThrowBadAnyCast();
 
 }  // namespace any_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_USES_STD_ANY
+#endif  // Y_ABSL_USES_STD_ANY
 
-#endif  // ABSL_TYPES_BAD_ANY_CAST_H_
+#endif  // Y_ABSL_TYPES_BAD_ANY_CAST_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access.cc
index e583756cd5..29740a4838 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access.cc
@@ -14,7 +14,7 @@
 
 #include "y_absl/types/bad_optional_access.h"
 
-#ifndef ABSL_USES_STD_OPTIONAL
+#ifndef Y_ABSL_USES_STD_OPTIONAL
 
 #include <cstdlib>
 
@@ -22,7 +22,7 @@
 #include "y_absl/base/internal/raw_logging.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 bad_optional_access::~bad_optional_access() = default;
 
@@ -33,16 +33,16 @@ const char* bad_optional_access::what() const noexcept {
 namespace optional_internal {
 
 void throw_bad_optional_access() {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef Y_ABSL_HAVE_EXCEPTIONS
   throw bad_optional_access();
 #else
-  ABSL_RAW_LOG(FATAL, "Bad optional access");
+  Y_ABSL_RAW_LOG(FATAL, "Bad optional access");
   abort();
 #endif
 }
 
 }  // namespace optional_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_USES_STD_OPTIONAL
+#endif  // Y_ABSL_USES_STD_OPTIONAL
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access.h
index 7420ade10f..59bbb9b097 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access.h
@@ -18,27 +18,27 @@
 //
 // This header file defines the `y_absl::bad_optional_access` type.
 
-#ifndef ABSL_TYPES_BAD_OPTIONAL_ACCESS_H_
-#define ABSL_TYPES_BAD_OPTIONAL_ACCESS_H_
+#ifndef Y_ABSL_TYPES_BAD_OPTIONAL_ACCESS_H_
+#define Y_ABSL_TYPES_BAD_OPTIONAL_ACCESS_H_
 
 #include <stdexcept>
 
 #include "y_absl/base/config.h"
 
-#ifdef ABSL_USES_STD_OPTIONAL
+#ifdef Y_ABSL_USES_STD_OPTIONAL
 
 #include <optional>
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 using std::bad_optional_access;
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#else  // ABSL_USES_STD_OPTIONAL
+#else  // Y_ABSL_USES_STD_OPTIONAL
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // -----------------------------------------------------------------------------
 // bad_optional_access
@@ -67,12 +67,12 @@ class bad_optional_access : public std::exception {
 namespace optional_internal {
 
 // throw delegator
-[[noreturn]] ABSL_DLL void throw_bad_optional_access();
+[[noreturn]] Y_ABSL_DLL void throw_bad_optional_access();
 
 }  // namespace optional_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_USES_STD_OPTIONAL
+#endif  // Y_ABSL_USES_STD_OPTIONAL
 
-#endif  // ABSL_TYPES_BAD_OPTIONAL_ACCESS_H_
+#endif  // Y_ABSL_TYPES_BAD_OPTIONAL_ACCESS_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_variant_access.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_variant_access.cc
index 77df7736a9..51345713a8 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_variant_access.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_variant_access.cc
@@ -14,7 +14,7 @@
 
 #include "y_absl/types/bad_variant_access.h"
 
-#ifndef ABSL_USES_STD_VARIANT
+#ifndef Y_ABSL_USES_STD_VARIANT
 
 #include <cstdlib>
 #include <stdexcept>
@@ -23,7 +23,7 @@
 #include "y_absl/base/internal/raw_logging.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 //////////////////////////
 // [variant.bad.access] //
@@ -38,19 +38,19 @@ const char* bad_variant_access::what() const noexcept {
 namespace variant_internal {
 
 void ThrowBadVariantAccess() {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef Y_ABSL_HAVE_EXCEPTIONS
   throw bad_variant_access();
 #else
-  ABSL_RAW_LOG(FATAL, "Bad variant access");
+  Y_ABSL_RAW_LOG(FATAL, "Bad variant access");
   abort();  // TODO(calabrese) Remove once RAW_LOG FATAL is noreturn.
 #endif
 }
 
 void Rethrow() {
-#ifdef ABSL_HAVE_EXCEPTIONS
+#ifdef Y_ABSL_HAVE_EXCEPTIONS
   throw;
 #else
-  ABSL_RAW_LOG(FATAL,
+  Y_ABSL_RAW_LOG(FATAL,
                "Internal error in y_absl::variant implementation. Attempted to "
                "rethrow an exception when building with exceptions disabled.");
   abort();  // TODO(calabrese) Remove once RAW_LOG FATAL is noreturn.
@@ -58,7 +58,7 @@ void Rethrow() {
 }
 
 }  // namespace variant_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_USES_STD_VARIANT
+#endif  // Y_ABSL_USES_STD_VARIANT
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_variant_access.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_variant_access.h
index 6e41782e78..0cdb14e5cd 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_variant_access.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_variant_access.h
@@ -18,27 +18,27 @@
 //
 // This header file defines the `y_absl::bad_variant_access` type.
 
-#ifndef ABSL_TYPES_BAD_VARIANT_ACCESS_H_
-#define ABSL_TYPES_BAD_VARIANT_ACCESS_H_
+#ifndef Y_ABSL_TYPES_BAD_VARIANT_ACCESS_H_
+#define Y_ABSL_TYPES_BAD_VARIANT_ACCESS_H_
 
 #include <stdexcept>
 
 #include "y_absl/base/config.h"
 
-#ifdef ABSL_USES_STD_VARIANT
+#ifdef Y_ABSL_USES_STD_VARIANT
 
 #include <variant>
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 using std::bad_variant_access;
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#else  // ABSL_USES_STD_VARIANT
+#else  // Y_ABSL_USES_STD_VARIANT
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // -----------------------------------------------------------------------------
 // bad_variant_access
@@ -70,13 +70,13 @@ class bad_variant_access : public std::exception {
 
 namespace variant_internal {
 
-[[noreturn]] ABSL_DLL void ThrowBadVariantAccess();
-[[noreturn]] ABSL_DLL void Rethrow();
+[[noreturn]] Y_ABSL_DLL void ThrowBadVariantAccess();
+[[noreturn]] Y_ABSL_DLL void Rethrow();
 
 }  // namespace variant_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_USES_STD_VARIANT
+#endif  // Y_ABSL_USES_STD_VARIANT
 
-#endif  // ABSL_TYPES_BAD_VARIANT_ACCESS_H_
+#endif  // Y_ABSL_TYPES_BAD_VARIANT_ACCESS_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/compare.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/compare.h
index 4c8cf2f59f..0787fd5393 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/compare.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/compare.h
@@ -27,8 +27,8 @@
 // (`std::weak_equality`, etc.) and are designed to be drop-in replacements
 // for code compliant with C++20.
 
-#ifndef ABSL_TYPES_COMPARE_H_
-#define ABSL_TYPES_COMPARE_H_
+#ifndef Y_ABSL_TYPES_COMPARE_H_
+#define Y_ABSL_TYPES_COMPARE_H_
 
 #include <cstddef>
 #include <cstdint>
@@ -39,7 +39,7 @@
 #include "y_absl/meta/type_traits.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace compare_internal {
 
 using value_type = int8_t;
@@ -82,28 +82,28 @@ enum class ncmp : value_type { unordered = -127 };
 
 // Define macros to allow for creation or emulation of C++17 inline variables
 // based on whether the feature is supported. Note: we can't use
-// ABSL_INTERNAL_INLINE_CONSTEXPR here because the variables here are of
+// Y_ABSL_INTERNAL_INLINE_CONSTEXPR here because the variables here are of
 // incomplete types so they need to be defined after the types are complete.
 #ifdef __cpp_inline_variables
 
 // A no-op expansion that can be followed by a semicolon at class level.
-#define ABSL_COMPARE_INLINE_BASECLASS_DECL(name) static_assert(true, "")
+#define Y_ABSL_COMPARE_INLINE_BASECLASS_DECL(name) static_assert(true, "")
 
-#define ABSL_COMPARE_INLINE_SUBCLASS_DECL(type, name) \
+#define Y_ABSL_COMPARE_INLINE_SUBCLASS_DECL(type, name) \
   static const type name
 
-#define ABSL_COMPARE_INLINE_INIT(type, name, init) \
+#define Y_ABSL_COMPARE_INLINE_INIT(type, name, init) \
   inline constexpr type type::name(init)
 
 #else  // __cpp_inline_variables
 
-#define ABSL_COMPARE_INLINE_BASECLASS_DECL(name) \
-  ABSL_CONST_INIT static const T name
+#define Y_ABSL_COMPARE_INLINE_BASECLASS_DECL(name) \
+  Y_ABSL_CONST_INIT static const T name
 
 // A no-op expansion that can be followed by a semicolon at class level.
-#define ABSL_COMPARE_INLINE_SUBCLASS_DECL(type, name) static_assert(true, "")
+#define Y_ABSL_COMPARE_INLINE_SUBCLASS_DECL(type, name) static_assert(true, "")
 
-#define ABSL_COMPARE_INLINE_INIT(type, name, init) \
+#define Y_ABSL_COMPARE_INLINE_INIT(type, name, init) \
   template <typename T>                            \
   const T compare_internal::type##_base<T>::name(init)
 
@@ -114,39 +114,39 @@ enum class ncmp : value_type { unordered = -127 };
 // aren't available in C++11).
 template <typename T>
 struct weak_equality_base {
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(nonequivalent);
+  Y_ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
+  Y_ABSL_COMPARE_INLINE_BASECLASS_DECL(nonequivalent);
 };
 
 template <typename T>
 struct strong_equality_base {
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(equal);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(nonequal);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(nonequivalent);
+  Y_ABSL_COMPARE_INLINE_BASECLASS_DECL(equal);
+  Y_ABSL_COMPARE_INLINE_BASECLASS_DECL(nonequal);
+  Y_ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
+  Y_ABSL_COMPARE_INLINE_BASECLASS_DECL(nonequivalent);
 };
 
 template <typename T>
 struct partial_ordering_base {
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(less);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(greater);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(unordered);
+  Y_ABSL_COMPARE_INLINE_BASECLASS_DECL(less);
+  Y_ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
+  Y_ABSL_COMPARE_INLINE_BASECLASS_DECL(greater);
+  Y_ABSL_COMPARE_INLINE_BASECLASS_DECL(unordered);
 };
 
 template <typename T>
 struct weak_ordering_base {
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(less);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(greater);
+  Y_ABSL_COMPARE_INLINE_BASECLASS_DECL(less);
+  Y_ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
+  Y_ABSL_COMPARE_INLINE_BASECLASS_DECL(greater);
 };
 
 template <typename T>
 struct strong_ordering_base {
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(less);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(equal);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
-  ABSL_COMPARE_INLINE_BASECLASS_DECL(greater);
+  Y_ABSL_COMPARE_INLINE_BASECLASS_DECL(less);
+  Y_ABSL_COMPARE_INLINE_BASECLASS_DECL(equal);
+  Y_ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
+  Y_ABSL_COMPARE_INLINE_BASECLASS_DECL(greater);
 };
 
 }  // namespace compare_internal
@@ -158,8 +158,8 @@ class weak_equality
   friend struct compare_internal::weak_equality_base<weak_equality>;
 
  public:
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_equality, equivalent);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_equality, nonequivalent);
+  Y_ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_equality, equivalent);
+  Y_ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_equality, nonequivalent);
 
   // Comparisons
   friend constexpr bool operator==(
@@ -190,9 +190,9 @@ class weak_equality
  private:
   compare_internal::value_type value_;
 };
-ABSL_COMPARE_INLINE_INIT(weak_equality, equivalent,
+Y_ABSL_COMPARE_INLINE_INIT(weak_equality, equivalent,
                          compare_internal::eq::equivalent);
-ABSL_COMPARE_INLINE_INIT(weak_equality, nonequivalent,
+Y_ABSL_COMPARE_INLINE_INIT(weak_equality, nonequivalent,
                          compare_internal::eq::nonequivalent);
 
 class strong_equality
@@ -202,10 +202,10 @@ class strong_equality
   friend struct compare_internal::strong_equality_base<strong_equality>;
 
  public:
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, equal);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, nonequal);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, equivalent);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, nonequivalent);
+  Y_ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, equal);
+  Y_ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, nonequal);
+  Y_ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, equivalent);
+  Y_ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, nonequivalent);
 
   // Conversion
   constexpr operator weak_equality() const noexcept {  // NOLINT
@@ -241,12 +241,12 @@ class strong_equality
  private:
   compare_internal::value_type value_;
 };
-ABSL_COMPARE_INLINE_INIT(strong_equality, equal, compare_internal::eq::equal);
-ABSL_COMPARE_INLINE_INIT(strong_equality, nonequal,
+Y_ABSL_COMPARE_INLINE_INIT(strong_equality, equal, compare_internal::eq::equal);
+Y_ABSL_COMPARE_INLINE_INIT(strong_equality, nonequal,
                          compare_internal::eq::nonequal);
-ABSL_COMPARE_INLINE_INIT(strong_equality, equivalent,
+Y_ABSL_COMPARE_INLINE_INIT(strong_equality, equivalent,
                          compare_internal::eq::equivalent);
-ABSL_COMPARE_INLINE_INIT(strong_equality, nonequivalent,
+Y_ABSL_COMPARE_INLINE_INIT(strong_equality, nonequivalent,
                          compare_internal::eq::nonequivalent);
 
 class partial_ordering
@@ -265,10 +265,10 @@ class partial_ordering
   }
 
  public:
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, less);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, equivalent);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, greater);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, unordered);
+  Y_ABSL_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, less);
+  Y_ABSL_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, equivalent);
+  Y_ABSL_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, greater);
+  Y_ABSL_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, unordered);
 
   // Conversion
   constexpr operator weak_equality() const noexcept {  // NOLINT
@@ -336,12 +336,12 @@ class partial_ordering
  private:
   compare_internal::value_type value_;
 };
-ABSL_COMPARE_INLINE_INIT(partial_ordering, less, compare_internal::ord::less);
-ABSL_COMPARE_INLINE_INIT(partial_ordering, equivalent,
+Y_ABSL_COMPARE_INLINE_INIT(partial_ordering, less, compare_internal::ord::less);
+Y_ABSL_COMPARE_INLINE_INIT(partial_ordering, equivalent,
                          compare_internal::eq::equivalent);
-ABSL_COMPARE_INLINE_INIT(partial_ordering, greater,
+Y_ABSL_COMPARE_INLINE_INIT(partial_ordering, greater,
                          compare_internal::ord::greater);
-ABSL_COMPARE_INLINE_INIT(partial_ordering, unordered,
+Y_ABSL_COMPARE_INLINE_INIT(partial_ordering, unordered,
                          compare_internal::ncmp::unordered);
 
 class weak_ordering
@@ -353,9 +353,9 @@ class weak_ordering
   friend struct compare_internal::weak_ordering_base<weak_ordering>;
 
  public:
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_ordering, less);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_ordering, equivalent);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_ordering, greater);
+  Y_ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_ordering, less);
+  Y_ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_ordering, equivalent);
+  Y_ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_ordering, greater);
 
   // Conversions
   constexpr operator weak_equality() const noexcept {  // NOLINT
@@ -428,10 +428,10 @@ class weak_ordering
  private:
   compare_internal::value_type value_;
 };
-ABSL_COMPARE_INLINE_INIT(weak_ordering, less, compare_internal::ord::less);
-ABSL_COMPARE_INLINE_INIT(weak_ordering, equivalent,
+Y_ABSL_COMPARE_INLINE_INIT(weak_ordering, less, compare_internal::ord::less);
+Y_ABSL_COMPARE_INLINE_INIT(weak_ordering, equivalent,
                          compare_internal::eq::equivalent);
-ABSL_COMPARE_INLINE_INIT(weak_ordering, greater,
+Y_ABSL_COMPARE_INLINE_INIT(weak_ordering, greater,
                          compare_internal::ord::greater);
 
 class strong_ordering
@@ -443,10 +443,10 @@ class strong_ordering
   friend struct compare_internal::strong_ordering_base<strong_ordering>;
 
  public:
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, less);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, equal);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, equivalent);
-  ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, greater);
+  Y_ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, less);
+  Y_ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, equal);
+  Y_ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, equivalent);
+  Y_ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, greater);
 
   // Conversions
   constexpr operator weak_equality() const noexcept {  // NOLINT
@@ -527,16 +527,16 @@ class strong_ordering
  private:
   compare_internal::value_type value_;
 };
-ABSL_COMPARE_INLINE_INIT(strong_ordering, less, compare_internal::ord::less);
-ABSL_COMPARE_INLINE_INIT(strong_ordering, equal, compare_internal::eq::equal);
-ABSL_COMPARE_INLINE_INIT(strong_ordering, equivalent,
+Y_ABSL_COMPARE_INLINE_INIT(strong_ordering, less, compare_internal::ord::less);
+Y_ABSL_COMPARE_INLINE_INIT(strong_ordering, equal, compare_internal::eq::equal);
+Y_ABSL_COMPARE_INLINE_INIT(strong_ordering, equivalent,
                          compare_internal::eq::equivalent);
-ABSL_COMPARE_INLINE_INIT(strong_ordering, greater,
+Y_ABSL_COMPARE_INLINE_INIT(strong_ordering, greater,
                          compare_internal::ord::greater);
 
-#undef ABSL_COMPARE_INLINE_BASECLASS_DECL
-#undef ABSL_COMPARE_INLINE_SUBCLASS_DECL
-#undef ABSL_COMPARE_INLINE_INIT
+#undef Y_ABSL_COMPARE_INLINE_BASECLASS_DECL
+#undef Y_ABSL_COMPARE_INLINE_SUBCLASS_DECL
+#undef Y_ABSL_COMPARE_INLINE_INIT
 
 namespace compare_internal {
 // We also provide these comparator adapter functions for internal y_absl use.
@@ -594,7 +594,7 @@ constexpr y_absl::weak_ordering do_three_way_comparison(const Compare &compare,
 }
 
 }  // namespace compare_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_TYPES_COMPARE_H_
+#endif  // Y_ABSL_TYPES_COMPARE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_aliases.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_aliases.h
index ae9df53bf9..ea1fc50f50 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_aliases.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_aliases.h
@@ -19,18 +19,18 @@
 // This file contains type aliases of common ConformanceProfiles and Archetypes
 // so that they can be directly used by name without creating them from scratch.
 
-#ifndef ABSL_TYPES_INTERNAL_CONFORMANCE_ALIASES_H_
-#define ABSL_TYPES_INTERNAL_CONFORMANCE_ALIASES_H_
+#ifndef Y_ABSL_TYPES_INTERNAL_CONFORMANCE_ALIASES_H_
+#define Y_ABSL_TYPES_INTERNAL_CONFORMANCE_ALIASES_H_
 
 #include "y_absl/types/internal/conformance_archetype.h"
 #include "y_absl/types/internal/conformance_profile.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace types_internal {
 
 // Creates both a Profile and a corresponding Archetype with root name "name".
-#define ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(name, ...)                \
+#define Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(name, ...)                \
   struct name##Profile : __VA_ARGS__ {};                                    \
                                                                             \
   using name##Archetype = ::y_absl::types_internal::Archetype<name##Profile>; \
@@ -40,110 +40,110 @@ namespace types_internal {
       ::y_absl::types_internal::StrongProfileTypedef<name##Profile,           \
                                                    AbslInternalProfileTag>>
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasTrivialDefaultConstructor,
     ConformanceProfile<default_constructible::trivial>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasNothrowDefaultConstructor,
     ConformanceProfile<default_constructible::nothrow>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasDefaultConstructor, ConformanceProfile<default_constructible::yes>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasTrivialMoveConstructor, ConformanceProfile<default_constructible::maybe,
                                                   move_constructible::trivial>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasNothrowMoveConstructor, ConformanceProfile<default_constructible::maybe,
                                                   move_constructible::nothrow>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasMoveConstructor,
     ConformanceProfile<default_constructible::maybe, move_constructible::yes>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasTrivialCopyConstructor,
     ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
                        copy_constructible::trivial>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasNothrowCopyConstructor,
     ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
                        copy_constructible::nothrow>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasCopyConstructor,
     ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
                        copy_constructible::yes>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasTrivialMoveAssign,
     ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
                        copy_constructible::maybe, move_assignable::trivial>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasNothrowMoveAssign,
     ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
                        copy_constructible::maybe, move_assignable::nothrow>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasMoveAssign,
     ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
                        copy_constructible::maybe, move_assignable::yes>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasTrivialCopyAssign,
     ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
                        copy_constructible::maybe, move_assignable::maybe,
                        copy_assignable::trivial>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasNothrowCopyAssign,
     ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
                        copy_constructible::maybe, move_assignable::maybe,
                        copy_assignable::nothrow>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasCopyAssign,
     ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
                        copy_constructible::maybe, move_assignable::maybe,
                        copy_assignable::yes>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasTrivialDestructor,
     ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
                        copy_constructible::maybe, move_assignable::maybe,
                        copy_assignable::maybe, destructible::trivial>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasNothrowDestructor,
     ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
                        copy_constructible::maybe, move_assignable::maybe,
                        copy_assignable::maybe, destructible::nothrow>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasDestructor,
     ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
                        copy_constructible::maybe, move_assignable::maybe,
                        copy_assignable::maybe, destructible::yes>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasNothrowEquality,
     ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
                        copy_constructible::maybe, move_assignable::maybe,
                        copy_assignable::maybe, destructible::maybe,
                        equality_comparable::nothrow>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasEquality,
     ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
                        copy_constructible::maybe, move_assignable::maybe,
                        copy_assignable::maybe, destructible::maybe,
                        equality_comparable::yes>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasNothrowInequality,
     ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
                        copy_constructible::maybe, move_assignable::maybe,
@@ -151,14 +151,14 @@ ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
                        equality_comparable::maybe,
                        inequality_comparable::nothrow>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasInequality,
     ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
                        copy_constructible::maybe, move_assignable::maybe,
                        copy_assignable::maybe, destructible::maybe,
                        equality_comparable::maybe, inequality_comparable::yes>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasNothrowLessThan,
     ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
                        copy_constructible::maybe, move_assignable::maybe,
@@ -166,7 +166,7 @@ ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
                        equality_comparable::maybe, inequality_comparable::maybe,
                        less_than_comparable::nothrow>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasLessThan,
     ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
                        copy_constructible::maybe, move_assignable::maybe,
@@ -174,7 +174,7 @@ ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
                        equality_comparable::maybe, inequality_comparable::maybe,
                        less_than_comparable::yes>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasNothrowLessEqual,
     ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
                        copy_constructible::maybe, move_assignable::maybe,
@@ -183,7 +183,7 @@ ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
                        less_than_comparable::maybe,
                        less_equal_comparable::nothrow>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasLessEqual,
     ConformanceProfile<default_constructible::maybe, move_constructible::maybe,
                        copy_constructible::maybe, move_assignable::maybe,
@@ -192,7 +192,7 @@ ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
                        less_than_comparable::maybe,
                        less_equal_comparable::yes>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasNothrowGreaterEqual,
     ConformanceProfile<
         default_constructible::maybe, move_constructible::maybe,
@@ -201,7 +201,7 @@ ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
         inequality_comparable::maybe, less_than_comparable::maybe,
         less_equal_comparable::maybe, greater_equal_comparable::nothrow>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasGreaterEqual,
     ConformanceProfile<
         default_constructible::maybe, move_constructible::maybe,
@@ -210,7 +210,7 @@ ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
         inequality_comparable::maybe, less_than_comparable::maybe,
         less_equal_comparable::maybe, greater_equal_comparable::yes>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasNothrowGreaterThan,
     ConformanceProfile<
         default_constructible::maybe, move_constructible::maybe,
@@ -220,7 +220,7 @@ ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
         less_equal_comparable::maybe, greater_equal_comparable::maybe,
         greater_than_comparable::nothrow>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasGreaterThan,
     ConformanceProfile<
         default_constructible::maybe, move_constructible::maybe,
@@ -230,7 +230,7 @@ ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
         less_equal_comparable::maybe, greater_equal_comparable::maybe,
         greater_than_comparable::yes>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasNothrowSwap,
     ConformanceProfile<
         default_constructible::maybe, move_constructible::maybe,
@@ -240,7 +240,7 @@ ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
         less_equal_comparable::maybe, greater_equal_comparable::maybe,
         greater_than_comparable::maybe, swappable::nothrow>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasSwap,
     ConformanceProfile<
         default_constructible::maybe, move_constructible::maybe,
@@ -250,7 +250,7 @@ ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
         less_equal_comparable::maybe, greater_equal_comparable::maybe,
         greater_than_comparable::maybe, swappable::yes>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HasStdHashSpecialization,
     ConformanceProfile<
         default_constructible::maybe, move_constructible::maybe,
@@ -264,93 +264,93 @@ ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
 ////     The remaining aliases are combinations of the previous aliases.    ////
 ////////////////////////////////////////////////////////////////////////////////
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     Equatable, CombineProfiles<HasEqualityProfile, HasInequalityProfile>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     Comparable,
     CombineProfiles<EquatableProfile, HasLessThanProfile, HasLessEqualProfile,
                     HasGreaterEqualProfile, HasGreaterThanProfile>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     NothrowEquatable,
     CombineProfiles<HasNothrowEqualityProfile, HasNothrowInequalityProfile>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     NothrowComparable,
     CombineProfiles<NothrowEquatableProfile, HasNothrowLessThanProfile,
                     HasNothrowLessEqualProfile, HasNothrowGreaterEqualProfile,
                     HasNothrowGreaterThanProfile>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     Value,
     CombineProfiles<HasNothrowMoveConstructorProfile, HasCopyConstructorProfile,
                     HasNothrowMoveAssignProfile, HasCopyAssignProfile,
                     HasNothrowDestructorProfile, HasNothrowSwapProfile>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     EquatableValue, CombineProfiles<EquatableProfile, ValueProfile>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     ComparableValue, CombineProfiles<ComparableProfile, ValueProfile>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     DefaultConstructibleValue,
     CombineProfiles<HasDefaultConstructorProfile, ValueProfile>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     NothrowMoveConstructible, CombineProfiles<HasNothrowMoveConstructorProfile,
                                               HasNothrowDestructorProfile>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     EquatableNothrowMoveConstructible,
     CombineProfiles<EquatableProfile, NothrowMoveConstructibleProfile>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     ComparableNothrowMoveConstructible,
     CombineProfiles<ComparableProfile, NothrowMoveConstructibleProfile>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     DefaultConstructibleNothrowMoveConstructible,
     CombineProfiles<HasDefaultConstructorProfile,
                     NothrowMoveConstructibleProfile>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     CopyConstructible,
     CombineProfiles<HasNothrowMoveConstructorProfile, HasCopyConstructorProfile,
                     HasNothrowDestructorProfile>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     EquatableCopyConstructible,
     CombineProfiles<EquatableProfile, CopyConstructibleProfile>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     ComparableCopyConstructible,
     CombineProfiles<ComparableProfile, CopyConstructibleProfile>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     DefaultConstructibleCopyConstructible,
     CombineProfiles<HasDefaultConstructorProfile, CopyConstructibleProfile>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     NothrowMovable,
     CombineProfiles<HasNothrowMoveConstructorProfile,
                     HasNothrowMoveAssignProfile, HasNothrowDestructorProfile,
                     HasNothrowSwapProfile>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     EquatableNothrowMovable,
     CombineProfiles<EquatableProfile, NothrowMovableProfile>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     ComparableNothrowMovable,
     CombineProfiles<ComparableProfile, NothrowMovableProfile>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     DefaultConstructibleNothrowMovable,
     CombineProfiles<HasDefaultConstructorProfile, NothrowMovableProfile>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     TrivialSpecialMemberFunctions,
     CombineProfiles<HasTrivialDefaultConstructorProfile,
                     HasTrivialMoveConstructorProfile,
@@ -358,29 +358,29 @@ ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
                     HasTrivialMoveAssignProfile, HasTrivialCopyAssignProfile,
                     HasTrivialDestructorProfile, HasNothrowSwapProfile>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     TriviallyComplete,
     CombineProfiles<TrivialSpecialMemberFunctionsProfile, ComparableProfile,
                     HasStdHashSpecializationProfile>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HashableNothrowMoveConstructible,
     CombineProfiles<HasStdHashSpecializationProfile,
                     NothrowMoveConstructibleProfile>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HashableCopyConstructible,
     CombineProfiles<HasStdHashSpecializationProfile, CopyConstructibleProfile>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HashableNothrowMovable,
     CombineProfiles<HasStdHashSpecializationProfile, NothrowMovableProfile>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     HashableValue,
     CombineProfiles<HasStdHashSpecializationProfile, ValueProfile>);
 
-ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
+Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS(
     ComparableHashableValue,
     CombineProfiles<HashableValueProfile, ComparableProfile>);
 
@@ -439,9 +439,9 @@ using ExpandSupportedProfiles = Receiver<
 // (potentially) non-noexcept moves.
 
 }  // namespace types_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#undef ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS
+#undef Y_ABSL_INTERNAL_PROFILE_AND_ARCHETYPE_ALIAS
 
-#endif  // ABSL_TYPES_INTERNAL_CONFORMANCE_ALIASES_H_
+#endif  // Y_ABSL_TYPES_INTERNAL_CONFORMANCE_ALIASES_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_archetype.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_archetype.h
index dc27d05df3..670df4f6e5 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_archetype.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_archetype.h
@@ -31,8 +31,8 @@
 // a Conformance Profile as a template argument and its instantiations are a
 // minimum-conforming model of that profile.
 
-#ifndef ABSL_TYPES_INTERNAL_CONFORMANCE_ARCHETYPE_H_
-#define ABSL_TYPES_INTERNAL_CONFORMANCE_ARCHETYPE_H_
+#ifndef Y_ABSL_TYPES_INTERNAL_CONFORMANCE_ARCHETYPE_H_
+#define Y_ABSL_TYPES_INTERNAL_CONFORMANCE_ARCHETYPE_H_
 
 #include <cstddef>
 #include <functional>
@@ -43,7 +43,7 @@
 #include "y_absl/types/internal/conformance_profile.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace types_internal {
 
 // A minimum-conforming implementation of a type with properties specified in
@@ -915,7 +915,7 @@ struct ExceptionalBool {
 //
 // NOTE: Non-nothrow operators throw via their result's conversion to bool even
 // though the operation itself is noexcept.
-#define ABSL_TYPES_INTERNAL_OP(enum_name, op)                                \
+#define Y_ABSL_TYPES_INTERNAL_OP(enum_name, op)                                \
   template <class Prof>                                                      \
   y_absl::enable_if_t<!PropertiesOfT<Prof>::is_##enum_name, bool> operator op( \
       const Archetype<Prof>&, const Archetype<Prof>&) = delete;              \
@@ -934,14 +934,14 @@ struct ExceptionalBool {
                                                 rhs.archetype_state);        \
   }
 
-ABSL_TYPES_INTERNAL_OP(equality_comparable, ==);
-ABSL_TYPES_INTERNAL_OP(inequality_comparable, !=);
-ABSL_TYPES_INTERNAL_OP(less_than_comparable, <);
-ABSL_TYPES_INTERNAL_OP(less_equal_comparable, <=);
-ABSL_TYPES_INTERNAL_OP(greater_equal_comparable, >=);
-ABSL_TYPES_INTERNAL_OP(greater_than_comparable, >);
+Y_ABSL_TYPES_INTERNAL_OP(equality_comparable, ==);
+Y_ABSL_TYPES_INTERNAL_OP(inequality_comparable, !=);
+Y_ABSL_TYPES_INTERNAL_OP(less_than_comparable, <);
+Y_ABSL_TYPES_INTERNAL_OP(less_equal_comparable, <=);
+Y_ABSL_TYPES_INTERNAL_OP(greater_equal_comparable, >=);
+Y_ABSL_TYPES_INTERNAL_OP(greater_than_comparable, >);
 
-#undef ABSL_TYPES_INTERNAL_OP
+#undef Y_ABSL_TYPES_INTERNAL_OP
 
 // Base class for std::hash specializations when an Archetype doesn't support
 // hashing.
@@ -962,7 +962,7 @@ struct EnabledHash {
 };
 
 }  // namespace types_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 namespace std {
@@ -975,4 +975,4 @@ struct hash<::y_absl::types_internal::Archetype<Prof>>
 
 }  // namespace std
 
-#endif  // ABSL_TYPES_INTERNAL_CONFORMANCE_ARCHETYPE_H_
+#endif  // Y_ABSL_TYPES_INTERNAL_CONFORMANCE_ARCHETYPE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_profile.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_profile.h
index b19165a4b9..e4ad1ba3f5 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_profile.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_profile.h
@@ -33,8 +33,8 @@
 // Regularity Profile. For more information regarding archetypes, see
 // "conformance_archetypes.h".
 
-#ifndef ABSL_TYPES_INTERNAL_CONFORMANCE_PROFILE_H_
-#define ABSL_TYPES_INTERNAL_CONFORMANCE_PROFILE_H_
+#ifndef Y_ABSL_TYPES_INTERNAL_CONFORMANCE_PROFILE_H_
+#define Y_ABSL_TYPES_INTERNAL_CONFORMANCE_PROFILE_H_
 
 #include <set>
 #include <type_traits>
@@ -53,7 +53,7 @@
 // TODO(calabrese) Add support for extending profiles.
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace types_internal {
 
 // Converts an enum to its underlying integral value.
@@ -318,44 +318,44 @@ void ExpectModelOfImpl(ConformanceErrors* errors, Enum min_support,
   }
 }
 
-#define ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM(description, name) \
+#define Y_ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM(description, name) \
   enum class name { maybe, yes, nothrow, trivial };                   \
                                                                       \
   constexpr const char* PropertyName(name v) { return description; }  \
   static_assert(true, "")  // Force a semicolon when using this macro.
 
-ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for default construction",
+Y_ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for default construction",
                                            default_constructible);
-ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for move construction",
+Y_ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for move construction",
                                            move_constructible);
-ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for copy construction",
+Y_ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for copy construction",
                                            copy_constructible);
-ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for move assignment",
+Y_ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for move assignment",
                                            move_assignable);
-ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for copy assignment",
+Y_ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for copy assignment",
                                            copy_assignable);
-ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for destruction",
+Y_ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM("support for destruction",
                                            destructible);
 
-#undef ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM
+#undef Y_ABSL_INTERNAL_SPECIAL_MEMBER_FUNCTION_ENUM
 
-#define ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM(description, name)     \
+#define Y_ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM(description, name)     \
   enum class name { maybe, yes, nothrow };                           \
                                                                      \
   constexpr const char* PropertyName(name v) { return description; } \
   static_assert(true, "")  // Force a semicolon when using this macro.
 
-ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for ==", equality_comparable);
-ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for !=", inequality_comparable);
-ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for <", less_than_comparable);
-ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for <=", less_equal_comparable);
-ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for >=",
+Y_ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for ==", equality_comparable);
+Y_ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for !=", inequality_comparable);
+Y_ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for <", less_than_comparable);
+Y_ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for <=", less_equal_comparable);
+Y_ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for >=",
                                       greater_equal_comparable);
-ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for >", greater_than_comparable);
+Y_ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for >", greater_than_comparable);
 
-ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for swap", swappable);
+Y_ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM("support for swap", swappable);
 
-#undef ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM
+#undef Y_ABSL_INTERNAL_INTRINSIC_FUNCTION_ENUM
 
 enum class hashable { maybe, yes };
 
@@ -366,7 +366,7 @@ constexpr const char* PropertyName(hashable v) {
 template <class T>
 using AlwaysFalse = std::false_type;
 
-#define ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(name, property)   \
+#define Y_ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(name, property)   \
   template <class T>                                                        \
   constexpr property property##_support_of() {                              \
     return std::is_##property<T>::value                                     \
@@ -385,24 +385,24 @@ using AlwaysFalse = std::false_type;
                         property##_support_of<T>());                        \
   }
 
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(DefaultConstructible,
+Y_ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(DefaultConstructible,
                                                   default_constructible);
 
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(MoveConstructible,
+Y_ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(MoveConstructible,
                                                   move_constructible);
 
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(CopyConstructible,
+Y_ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(CopyConstructible,
                                                   copy_constructible);
 
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(MoveAssignable,
+Y_ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(MoveAssignable,
                                                   move_assignable);
 
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(CopyAssignable,
+Y_ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(CopyAssignable,
                                                   copy_assignable);
 
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(Destructible, destructible);
+Y_ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER(Destructible, destructible);
 
-#undef ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER
+#undef Y_ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_SPECIAL_MEMBER
 
 void BoolFunction(bool) noexcept;
 
@@ -452,7 +452,7 @@ struct IsNothrowOpable {
 // support a specific comparison operation has and a function for reporting an
 // error if a given type's support for that operation does not meet the expected
 // requirements.
-#define ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(name, property, op)      \
+#define Y_ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(name, property, op)      \
   template <class T,                                                           \
             class Result = std::integral_constant<                             \
                 bool, noexcept((BoolFunction)(std::declval<const T&>() op      \
@@ -480,25 +480,25 @@ struct IsNothrowOpable {
 //
 // Generate the necessary support-checking and error reporting functions for
 // each of the comparison operators.
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(EqualityComparable,
+Y_ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(EqualityComparable,
                                               equality_comparable, ==);
 
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(InequalityComparable,
+Y_ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(InequalityComparable,
                                               inequality_comparable, !=);
 
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(LessThanComparable,
+Y_ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(LessThanComparable,
                                               less_than_comparable, <);
 
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(LessEqualComparable,
+Y_ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(LessEqualComparable,
                                               less_equal_comparable, <=);
 
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(GreaterEqualComparable,
+Y_ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(GreaterEqualComparable,
                                               greater_equal_comparable, >=);
 
-ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(GreaterThanComparable,
+Y_ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON(GreaterThanComparable,
                                               greater_than_comparable, >);
 
-#undef ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON
+#undef Y_ABSL_INTERNAL_PESSIMISTIC_MODEL_OF_COMPARISON
 //
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -692,7 +692,7 @@ struct SyntacticConformanceProfileOf {
       conservative_hashable_support_of<T, ShouldCheckHashability>::Invoke()>;
 };
 
-#define ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF_IMPL(type, name)     \
+#define Y_ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF_IMPL(type, name)     \
   template <default_constructible DefaultConstructibleValue,                   \
             move_constructible MoveConstructibleValue,                         \
             copy_constructible CopyConstructibleValue,                         \
@@ -714,28 +714,28 @@ struct SyntacticConformanceProfileOf {
       GreaterEqualComparableValue, GreaterThanComparableValue, SwappableValue, \
       HashableValue>::name
 
-#define ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(type)           \
-  ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF_IMPL(type,            \
+#define Y_ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(type)           \
+  Y_ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF_IMPL(type,            \
                                                          type##_support); \
-  ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF_IMPL(bool, is_##type)
-
-ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(default_constructible);
-ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(move_constructible);
-ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(copy_constructible);
-ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(move_assignable);
-ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(copy_assignable);
-ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(destructible);
-ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(equality_comparable);
-ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(inequality_comparable);
-ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(less_than_comparable);
-ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(less_equal_comparable);
-ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(greater_equal_comparable);
-ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(greater_than_comparable);
-ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(swappable);
-ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(hashable);
-
-#undef ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF
-#undef ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF_IMPL
+  Y_ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF_IMPL(bool, is_##type)
+
+Y_ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(default_constructible);
+Y_ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(move_constructible);
+Y_ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(copy_constructible);
+Y_ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(move_assignable);
+Y_ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(copy_assignable);
+Y_ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(destructible);
+Y_ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(equality_comparable);
+Y_ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(inequality_comparable);
+Y_ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(less_than_comparable);
+Y_ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(less_equal_comparable);
+Y_ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(greater_equal_comparable);
+Y_ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(greater_than_comparable);
+Y_ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(swappable);
+Y_ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF(hashable);
+
+#undef Y_ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF
+#undef Y_ABSL_INTERNAL_CONFORMANCE_TESTING_DATA_MEMBER_DEF_IMPL
 
 // Retrieve the enum with the minimum underlying value.
 // Note: std::min is not constexpr in C++11, which is why this is necessary.
@@ -925,7 +925,7 @@ struct IsProfile : IsProfileImpl<T>::type {};
 struct RegularityDomain {};
 
 }  // namespace types_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_TYPES_INTERNAL_CONFORMANCE_PROFILE_H_
+#endif  // Y_ABSL_TYPES_INTERNAL_CONFORMANCE_PROFILE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_testing.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_testing.h
index 799ba18e46..dcbfbb7504 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_testing.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_testing.h
@@ -17,8 +17,8 @@
 // -----------------------------------------------------------------------------
 //
 
-#ifndef ABSL_TYPES_INTERNAL_CONFORMANCE_TESTING_H_
-#define ABSL_TYPES_INTERNAL_CONFORMANCE_TESTING_H_
+#ifndef Y_ABSL_TYPES_INTERNAL_CONFORMANCE_TESTING_H_
+#define Y_ABSL_TYPES_INTERNAL_CONFORMANCE_TESTING_H_
 
 ////////////////////////////////////////////////////////////////////////////////
 //                                                                            //
@@ -50,7 +50,7 @@
 #include "y_absl/utility/utility.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace types_internal {
 
 // Returns true if the compiler incorrectly greedily instantiates constexpr
@@ -155,7 +155,7 @@ TString PrepareGivenContext(const Decls&... decls) {
 // Function objects that perform a check for each comparison operator         //
 ////////////////////////////////////////////////////////////////////////////////
 
-#define ABSL_INTERNAL_EXPECT_OP(name, op)                                   \
+#define Y_ABSL_INTERNAL_EXPECT_OP(name, op)                                   \
   struct Expect##name {                                                     \
     template <class T>                                                      \
     void operator()(y_absl::string_view test_name, y_absl::string_view context, \
@@ -206,14 +206,14 @@ TString PrepareGivenContext(const Decls&... decls) {
     ConformanceErrors* errors;                                              \
   }
 
-ABSL_INTERNAL_EXPECT_OP(Eq, ==);
-ABSL_INTERNAL_EXPECT_OP(Ne, !=);
-ABSL_INTERNAL_EXPECT_OP(Lt, <);
-ABSL_INTERNAL_EXPECT_OP(Le, <=);
-ABSL_INTERNAL_EXPECT_OP(Ge, >=);
-ABSL_INTERNAL_EXPECT_OP(Gt, >);
+Y_ABSL_INTERNAL_EXPECT_OP(Eq, ==);
+Y_ABSL_INTERNAL_EXPECT_OP(Ne, !=);
+Y_ABSL_INTERNAL_EXPECT_OP(Lt, <);
+Y_ABSL_INTERNAL_EXPECT_OP(Le, <=);
+Y_ABSL_INTERNAL_EXPECT_OP(Ge, >=);
+Y_ABSL_INTERNAL_EXPECT_OP(Gt, >);
 
-#undef ABSL_INTERNAL_EXPECT_OP
+#undef Y_ABSL_INTERNAL_EXPECT_OP
 
 // A function object that verifies that two objects hash to the same value by
 // way of the std::hash specialization.
@@ -1159,7 +1159,7 @@ struct ExpectConformanceOf {
   template <class Fun,
             y_absl::enable_if_t<std::is_same<
                 ResultOfGeneratorT<GeneratorType<Fun>>, T>::value>** = nullptr>
-  ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses...,
+  Y_ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses...,
                                            EquivalenceClassType<Fun>>
   initializer(GeneratorType<Fun> fun) && {
     return {
@@ -1173,7 +1173,7 @@ struct ExpectConformanceOf {
                               y_absl::conjunction<std::is_convertible<
                                   TestNames, y_absl::string_view>...>::value>** =
                 nullptr>
-  ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses...>
+  Y_ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses...>
   due_to(TestNames&&... test_names) && {
     (InsertEach)(&expected_failed_tests,
                  y_absl::AsciiStrToLower(y_absl::string_view(test_names))...);
@@ -1186,7 +1186,7 @@ struct ExpectConformanceOf {
                               y_absl::conjunction<std::is_convertible<
                                   TestNames, y_absl::string_view>...>::value>** =
                 nullptr>
-  ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses...>
+  Y_ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses...>
   due_to(TestNames&&... test_names) && {
     // TODO(calabrese) Instead have DUE_TO only exist via a CRTP base.
     // This would produce better errors messages than the static_assert.
@@ -1205,7 +1205,7 @@ struct ExpectConformanceOf {
   template <class Fun,
             y_absl::enable_if_t<std::is_same<
                 ResultOfGeneratorT<GeneratorType<Fun>>, T>::value>** = nullptr>
-  ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses...,
+  Y_ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses...,
                                            EquivalenceClassType<Fun>>
   dont_class_directly_stateful_initializer(GeneratorType<Fun> fun) && {
     return {
@@ -1220,7 +1220,7 @@ struct ExpectConformanceOf {
       class... Funs,
       y_absl::void_t<y_absl::enable_if_t<std::is_same<
           ResultOfGeneratorT<GeneratorType<Funs>>, T>::value>...>** = nullptr>
-  ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses...,
+  Y_ABSL_MUST_USE_RESULT ExpectConformanceOf<ExpectSuccess, T, EqClasses...,
                                            EquivalenceClassType<Funs...>>
   equivalence_class(GeneratorType<Funs>... funs) && {
     return {{std::tuple_cat(
@@ -1234,7 +1234,7 @@ struct ExpectConformanceOf {
   template <
       class ProfRange,
       y_absl::enable_if_t<IsProfileOrProfileRange<ProfRange>::value>** = nullptr>
-  ABSL_MUST_USE_RESULT ::testing::AssertionResult with_strict_profile(
+  Y_ABSL_MUST_USE_RESULT ::testing::AssertionResult with_strict_profile(
       ProfRange /*profile*/) {
     ConformanceErrors test_result =
         (ExpectRegularityImpl<
@@ -1250,7 +1250,7 @@ struct ExpectConformanceOf {
   // refined that a profile suggests, such as a type having a noexcept copy
   // constructor when all that is required is that the copy constructor exists).
   template <class Prof, y_absl::enable_if_t<IsProfile<Prof>::value>** = nullptr>
-  ABSL_MUST_USE_RESULT ::testing::AssertionResult with_loose_profile(
+  Y_ABSL_MUST_USE_RESULT ::testing::AssertionResult with_loose_profile(
       Prof /*profile*/) {
     ConformanceErrors test_result =
         (ExpectRegularityImpl<
@@ -1285,20 +1285,20 @@ struct EquivalenceClassMaker {
 // A top-level macro that begins the builder pattern.
 //
 // The argument here takes the datatype to be tested.
-#define ABSL_INTERNAL_ASSERT_CONFORMANCE_OF(...)                            \
+#define Y_ABSL_INTERNAL_ASSERT_CONFORMANCE_OF(...)                            \
   GTEST_AMBIGUOUS_ELSE_BLOCKER_                                             \
-  if ABSL_INTERNAL_LPAREN                                                   \
+  if Y_ABSL_INTERNAL_LPAREN                                                   \
   const ::testing::AssertionResult gtest_ar =                               \
-      ABSL_INTERNAL_LPAREN ::y_absl::types_internal::ExpectConformanceOfType< \
+      Y_ABSL_INTERNAL_LPAREN ::y_absl::types_internal::ExpectConformanceOfType< \
           __VA_ARGS__>()
 
 // Akin to ASSERT_CONFORMANCE_OF except that it expects failure and tries to
 // match text.
-#define ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(...)                            \
+#define Y_ABSL_INTERNAL_ASSERT_NONCONFORMANCE_OF(...)                            \
   GTEST_AMBIGUOUS_ELSE_BLOCKER_                                                \
-  if ABSL_INTERNAL_LPAREN                                                      \
+  if Y_ABSL_INTERNAL_LPAREN                                                      \
   const ::testing::AssertionResult gtest_ar =                                  \
-      ABSL_INTERNAL_LPAREN ::y_absl::types_internal::ExpectNonconformanceOfType< \
+      Y_ABSL_INTERNAL_LPAREN ::y_absl::types_internal::ExpectNonconformanceOfType< \
           __VA_ARGS__>()
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1319,7 +1319,7 @@ struct EquivalenceClassMaker {
 // preprocessing so that it can be used in error reports.
 #define INITIALIZER(...)                         \
   initializer(::y_absl::types_internal::Generator( \
-      [] { return __VA_ARGS__; }, ABSL_INTERNAL_STRINGIZE(__VA_ARGS__)))
+      [] { return __VA_ARGS__; }, Y_ABSL_INTERNAL_STRINGIZE(__VA_ARGS__)))
 
 // Specify a value to be tested.
 //
@@ -1328,7 +1328,7 @@ struct EquivalenceClassMaker {
 // during preprocessing so that it can be used in error reports.
 #define STATEFUL_INITIALIZER(...)                         \
   stateful_initializer(::y_absl::types_internal::Generator( \
-      [&] { return __VA_ARGS__; }, ABSL_INTERNAL_STRINGIZE(__VA_ARGS__)))
+      [&] { return __VA_ARGS__; }, Y_ABSL_INTERNAL_STRINGIZE(__VA_ARGS__)))
 
 // Used in the builder-pattern.
 //
@@ -1337,8 +1337,8 @@ struct EquivalenceClassMaker {
 // knows that they are supposed to represent the same logical value (the values
 // compare the same, hash the same, etc.).
 #define EQUIVALENCE_CLASS(...)                    \
-  equivalence_class(ABSL_INTERNAL_TRANSFORM_ARGS( \
-      ABSL_INTERNAL_PREPEND_EQ_MAKER, __VA_ARGS__))
+  equivalence_class(Y_ABSL_INTERNAL_TRANSFORM_ARGS( \
+      Y_ABSL_INTERNAL_PREPEND_EQ_MAKER, __VA_ARGS__))
 
 // An invocation of this or WITH_STRICT_PROFILE must end the builder-pattern.
 // It takes a Profile as its argument.
@@ -1353,7 +1353,7 @@ struct EquivalenceClassMaker {
 #define WITH_LOOSE_PROFILE(...)                                      \
   with_loose_profile(                                                \
       ::y_absl::types_internal::MakeLooseProfileRangeT<__VA_ARGS__>()) \
-      ABSL_INTERNAL_RPAREN ABSL_INTERNAL_RPAREN;                     \
+      Y_ABSL_INTERNAL_RPAREN Y_ABSL_INTERNAL_RPAREN;                     \
   else GTEST_FATAL_FAILURE_(gtest_ar.failure_message())  // NOLINT
 
 // An invocation of this or WITH_STRICT_PROFILE must end the builder-pattern.
@@ -1371,16 +1371,16 @@ struct EquivalenceClassMaker {
 #define WITH_STRICT_PROFILE(...)                                      \
   with_strict_profile(                                                \
       ::y_absl::types_internal::MakeStrictProfileRangeT<__VA_ARGS__>()) \
-      ABSL_INTERNAL_RPAREN ABSL_INTERNAL_RPAREN;                      \
+      Y_ABSL_INTERNAL_RPAREN Y_ABSL_INTERNAL_RPAREN;                      \
   else GTEST_FATAL_FAILURE_(gtest_ar.failure_message())  // NOLINT
 
 // Internal macro that is used in the internals of the EDSL when forming
 // equivalence classes.
-#define ABSL_INTERNAL_PREPEND_EQ_MAKER(arg) \
+#define Y_ABSL_INTERNAL_PREPEND_EQ_MAKER(arg) \
   ::y_absl::types_internal::EquivalenceClassMaker().arg
 
 }  // namespace types_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_TYPES_INTERNAL_CONFORMANCE_TESTING_H_
+#endif  // Y_ABSL_TYPES_INTERNAL_CONFORMANCE_TESTING_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_testing_helpers.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_testing_helpers.h
index 920b5c23ea..2f08136db7 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_testing_helpers.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/conformance_testing_helpers.h
@@ -12,24 +12,24 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_TYPES_INTERNAL_CONFORMANCE_TESTING_HELPERS_H_
-#define ABSL_TYPES_INTERNAL_CONFORMANCE_TESTING_HELPERS_H_
+#ifndef Y_ABSL_TYPES_INTERNAL_CONFORMANCE_TESTING_HELPERS_H_
+#define Y_ABSL_TYPES_INTERNAL_CONFORMANCE_TESTING_HELPERS_H_
 
 // Checks to determine whether or not we can use abi::__cxa_demangle
 #if (defined(__ANDROID__) || defined(ANDROID)) && !defined(OS_ANDROID)
-#define ABSL_INTERNAL_OS_ANDROID
+#define Y_ABSL_INTERNAL_OS_ANDROID
 #endif
 
 // We support certain compilers only.  See demangle.h for details.
 #if defined(OS_ANDROID) && (defined(__i386__) || defined(__x86_64__))
-#define ABSL_TYPES_INTERNAL_HAS_CXA_DEMANGLE 0
+#define Y_ABSL_TYPES_INTERNAL_HAS_CXA_DEMANGLE 0
 #elif (__GNUC__ >= 4 || (__GNUC__ >= 3 && __GNUC_MINOR__ >= 4)) && \
     !defined(__mips__)
-#define ABSL_TYPES_INTERNAL_HAS_CXA_DEMANGLE 1
+#define Y_ABSL_TYPES_INTERNAL_HAS_CXA_DEMANGLE 1
 #elif defined(__clang__) && !defined(_MSC_VER)
-#define ABSL_TYPES_INTERNAL_HAS_CXA_DEMANGLE 1
+#define Y_ABSL_TYPES_INTERNAL_HAS_CXA_DEMANGLE 1
 #else
-#define ABSL_TYPES_INTERNAL_HAS_CXA_DEMANGLE 0
+#define Y_ABSL_TYPES_INTERNAL_HAS_CXA_DEMANGLE 0
 #endif
 
 #include <tuple>
@@ -40,21 +40,21 @@
 #include "y_absl/strings/string_view.h"
 #include "y_absl/utility/utility.h"
 
-#if ABSL_TYPES_INTERNAL_HAS_CXA_DEMANGLE
+#if Y_ABSL_TYPES_INTERNAL_HAS_CXA_DEMANGLE
 #include <cxxabi.h>
 
 #include <cstdlib>
 #endif
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace types_internal {
 
 // Return a readable name for type T.
 template <class T>
 y_absl::string_view NameOfImpl() {
 // TODO(calabrese) Investigate using debugging:internal_demangle as a fallback.
-#if ABSL_TYPES_INTERNAL_HAS_CXA_DEMANGLE
+#if Y_ABSL_TYPES_INTERNAL_HAS_CXA_DEMANGLE
   int status = 0;
   char* demangled_name = nullptr;
 
@@ -368,24 +368,24 @@ struct If</*Condition =*/true> {
 };
 
 //
-// ABSL_INTERNAL_STRINGIZE(...)
+// Y_ABSL_INTERNAL_STRINGIZE(...)
 //
 // This variadic macro transforms its arguments into a c-string literal after
 // expansion.
 //
 // Example:
 //
-//   ABSL_INTERNAL_STRINGIZE(std::array<int, 10>)
+//   Y_ABSL_INTERNAL_STRINGIZE(std::array<int, 10>)
 //
 // Results in:
 //
 //   "std::array<int, 10>"
-#define ABSL_INTERNAL_STRINGIZE(...) ABSL_INTERNAL_STRINGIZE_IMPL((__VA_ARGS__))
-#define ABSL_INTERNAL_STRINGIZE_IMPL(arg) ABSL_INTERNAL_STRINGIZE_IMPL2 arg
-#define ABSL_INTERNAL_STRINGIZE_IMPL2(...) #__VA_ARGS__
+#define Y_ABSL_INTERNAL_STRINGIZE(...) Y_ABSL_INTERNAL_STRINGIZE_IMPL((__VA_ARGS__))
+#define Y_ABSL_INTERNAL_STRINGIZE_IMPL(arg) Y_ABSL_INTERNAL_STRINGIZE_IMPL2 arg
+#define Y_ABSL_INTERNAL_STRINGIZE_IMPL2(...) #__VA_ARGS__
 
 }  // namespace types_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_TYPES_INTERNAL_CONFORMANCE_TESTING_HELPERS_H_
+#endif  // Y_ABSL_TYPES_INTERNAL_CONFORMANCE_TESTING_HELPERS_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/optional.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/optional.h
index 1004a6a68a..9b20551d2e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/optional.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/optional.h
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
-#ifndef ABSL_TYPES_INTERNAL_OPTIONAL_H_
-#define ABSL_TYPES_INTERNAL_OPTIONAL_H_
+#ifndef Y_ABSL_TYPES_INTERNAL_OPTIONAL_H_
+#define Y_ABSL_TYPES_INTERNAL_OPTIONAL_H_
 
 #include <functional>
 #include <new>
@@ -25,7 +25,7 @@
 #include "y_absl/meta/type_traits.h"
 #include "y_absl/utility/utility.h"
 
-// ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS
+// Y_ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS
 //
 // Inheriting constructors is supported in GCC 4.8+, Clang 3.3+ and MSVC 2015.
 // __cpp_inheriting_constructors is a predefined macro and a recommended way to
@@ -44,17 +44,17 @@
 // constexpr Foo foo(0);  // doesn't work on MSVC 2015
 #if defined(__clang__)
 #if __has_feature(cxx_inheriting_constructors)
-#define ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS 1
+#define Y_ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS 1
 #endif
 #elif (defined(__GNUC__) &&                                       \
        (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 8)) || \
     (__cpp_inheriting_constructors >= 200802) ||                  \
     (defined(_MSC_VER) && _MSC_VER >= 1910)
-#define ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS 1
+#define Y_ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS 1
 #endif
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // Forward declaration
 template <typename T>
@@ -137,7 +137,7 @@ template <typename T>
 class optional_data_base : public optional_data_dtor_base<T> {
  protected:
   using base = optional_data_dtor_base<T>;
-#ifdef ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS
+#ifdef Y_ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS
   using base::base;
 #else
   optional_data_base() = default;
@@ -180,7 +180,7 @@ class optional_data;
 template <typename T>
 class optional_data<T, true> : public optional_data_base<T> {
  protected:
-#ifdef ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS
+#ifdef Y_ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS
   using optional_data_base<T>::optional_data_base;
 #else
   optional_data() = default;
@@ -194,7 +194,7 @@ class optional_data<T, true> : public optional_data_base<T> {
 template <typename T>
 class optional_data<T, false> : public optional_data_base<T> {
  protected:
-#ifdef ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS
+#ifdef Y_ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS
   using optional_data_base<T>::optional_data_base;
 #else
   template <typename... Args>
@@ -388,9 +388,9 @@ struct optional_hash_base<T, decltype(std::hash<y_absl::remove_const_t<T> >()(
 };
 
 }  // namespace optional_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#undef ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS
+#undef Y_ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS
 
-#endif  // ABSL_TYPES_INTERNAL_OPTIONAL_H_
+#endif  // Y_ABSL_TYPES_INTERNAL_OPTIONAL_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/parentheses.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/parentheses.h
index 5aebee8fde..5b40bc6c36 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/parentheses.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/parentheses.h
@@ -24,11 +24,11 @@
 // The parentheses macros are used when wanting to require a rescan before
 // expansion of parenthesized text appearing after a function-style macro name.
 
-#ifndef ABSL_TYPES_INTERNAL_PARENTHESES_H_
-#define ABSL_TYPES_INTERNAL_PARENTHESES_H_
+#ifndef Y_ABSL_TYPES_INTERNAL_PARENTHESES_H_
+#define Y_ABSL_TYPES_INTERNAL_PARENTHESES_H_
 
-#define ABSL_INTERNAL_LPAREN (
+#define Y_ABSL_INTERNAL_LPAREN (
 
-#define ABSL_INTERNAL_RPAREN )
+#define Y_ABSL_INTERNAL_RPAREN )
 
-#endif  // ABSL_TYPES_INTERNAL_PARENTHESES_H_
+#endif  // Y_ABSL_TYPES_INTERNAL_PARENTHESES_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/span.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/span.h
index 6b36c3b0d0..0ff6119f9e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/span.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/span.h
@@ -13,8 +13,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
-#ifndef ABSL_TYPES_INTERNAL_SPAN_H_
-#define ABSL_TYPES_INTERNAL_SPAN_H_
+#ifndef Y_ABSL_TYPES_INTERNAL_SPAN_H_
+#define Y_ABSL_TYPES_INTERNAL_SPAN_H_
 
 #include <algorithm>
 #include <cstddef>
@@ -26,7 +26,7 @@
 #include "y_absl/meta/type_traits.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 namespace span_internal {
 // A constexpr min function
@@ -122,7 +122,7 @@ template <typename From, typename To>
 using EnableIfConvertibleTo =
     typename std::enable_if<IsConvertible<From, To>::value>::type;
 }  // namespace span_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_TYPES_INTERNAL_SPAN_H_
+#endif  // Y_ABSL_TYPES_INTERNAL_SPAN_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/transform_args.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/transform_args.h
index 4a0ab42ac4..bee8916221 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/transform_args.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/transform_args.h
@@ -19,27 +19,27 @@
 // This file contains a higher-order macro that "transforms" each element of a
 // a variadic argument by a provided secondary macro.
 
-#ifndef ABSL_TYPES_INTERNAL_TRANSFORM_ARGS_H_
-#define ABSL_TYPES_INTERNAL_TRANSFORM_ARGS_H_
+#ifndef Y_ABSL_TYPES_INTERNAL_TRANSFORM_ARGS_H_
+#define Y_ABSL_TYPES_INTERNAL_TRANSFORM_ARGS_H_
 
 //
-// ABSL_INTERNAL_CAT(a, b)
+// Y_ABSL_INTERNAL_CAT(a, b)
 //
 // This macro takes two arguments and concatenates them together via ## after
 // expansion.
 //
 // Example:
 //
-//   ABSL_INTERNAL_CAT(foo_, bar)
+//   Y_ABSL_INTERNAL_CAT(foo_, bar)
 //
 // Results in:
 //
 //   foo_bar
-#define ABSL_INTERNAL_CAT(a, b) ABSL_INTERNAL_CAT_IMPL(a, b)
-#define ABSL_INTERNAL_CAT_IMPL(a, b) a##b
+#define Y_ABSL_INTERNAL_CAT(a, b) Y_ABSL_INTERNAL_CAT_IMPL(a, b)
+#define Y_ABSL_INTERNAL_CAT_IMPL(a, b) a##b
 
 //
-// ABSL_INTERNAL_TRANSFORM_ARGS(m, ...)
+// Y_ABSL_INTERNAL_TRANSFORM_ARGS(m, ...)
 //
 // This macro takes another macro as an argument followed by a trailing series
 // of additional parameters (up to 32 additional arguments). It invokes the
@@ -48,156 +48,156 @@
 //
 // Example:
 //
-//   ABSL_INTERNAL_TRANSFORM_ARGS(MY_MACRO, a, b, c)
+//   Y_ABSL_INTERNAL_TRANSFORM_ARGS(MY_MACRO, a, b, c)
 //
 // Results in:
 //
 //   MY_MACRO(a), MY_MACRO(b), MY_MACRO(c)
 //
 // TODO(calabrese) Handle no arguments as a special case.
-#define ABSL_INTERNAL_TRANSFORM_ARGS(m, ...)             \
-  ABSL_INTERNAL_CAT(ABSL_INTERNAL_TRANSFORM_ARGS,        \
-                    ABSL_INTERNAL_NUM_ARGS(__VA_ARGS__)) \
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS(m, ...)             \
+  Y_ABSL_INTERNAL_CAT(Y_ABSL_INTERNAL_TRANSFORM_ARGS,        \
+                    Y_ABSL_INTERNAL_NUM_ARGS(__VA_ARGS__)) \
   (m, __VA_ARGS__)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS1(m, a0) m(a0)
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS1(m, a0) m(a0)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS2(m, a0, a1) m(a0), m(a1)
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS2(m, a0, a1) m(a0), m(a1)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS3(m, a0, a1, a2) m(a0), m(a1), m(a2)
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS3(m, a0, a1, a2) m(a0), m(a1), m(a2)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS4(m, a0, a1, a2, a3) \
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS4(m, a0, a1, a2, a3) \
   m(a0), m(a1), m(a2), m(a3)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS5(m, a0, a1, a2, a3, a4) \
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS5(m, a0, a1, a2, a3, a4) \
   m(a0), m(a1), m(a2), m(a3), m(a4)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS6(m, a0, a1, a2, a3, a4, a5) \
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS6(m, a0, a1, a2, a3, a4, a5) \
   m(a0), m(a1), m(a2), m(a3), m(a4), m(a5)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS7(m, a0, a1, a2, a3, a4, a5, a6) \
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS7(m, a0, a1, a2, a3, a4, a5, a6) \
   m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS8(m, a0, a1, a2, a3, a4, a5, a6, a7) \
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS8(m, a0, a1, a2, a3, a4, a5, a6, a7) \
   m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS9(m, a0, a1, a2, a3, a4, a5, a6, a7, a8) \
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS9(m, a0, a1, a2, a3, a4, a5, a6, a7, a8) \
   m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS10(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS10(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
                                        a9)                                    \
   m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS11(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS11(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
                                        a9, a10)                               \
   m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9), m(a10)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS12(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS12(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
                                        a9, a10, a11)                          \
   m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
       m(a10), m(a11)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS13(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS13(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
                                        a9, a10, a11, a12)                     \
   m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
       m(a10), m(a11), m(a12)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS14(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS14(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
                                        a9, a10, a11, a12, a13)                \
   m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
       m(a10), m(a11), m(a12), m(a13)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS15(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS15(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
                                        a9, a10, a11, a12, a13, a14)           \
   m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
       m(a10), m(a11), m(a12), m(a13), m(a14)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS16(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS16(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
                                        a9, a10, a11, a12, a13, a14, a15)      \
   m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
       m(a10), m(a11), m(a12), m(a13), m(a14), m(a15)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS17(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS17(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
                                        a9, a10, a11, a12, a13, a14, a15, a16) \
   m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
       m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS18(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS18(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
                                        a9, a10, a11, a12, a13, a14, a15, a16, \
                                        a17)                                   \
   m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
       m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS19(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS19(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
                                        a9, a10, a11, a12, a13, a14, a15, a16, \
                                        a17, a18)                              \
   m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
       m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS20(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS20(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
                                        a9, a10, a11, a12, a13, a14, a15, a16, \
                                        a17, a18, a19)                         \
   m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
       m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
       m(a19)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS21(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS21(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
                                        a9, a10, a11, a12, a13, a14, a15, a16, \
                                        a17, a18, a19, a20)                    \
   m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
       m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
       m(a19), m(a20)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS22(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS22(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
                                        a9, a10, a11, a12, a13, a14, a15, a16, \
                                        a17, a18, a19, a20, a21)               \
   m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
       m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
       m(a19), m(a20), m(a21)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS23(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS23(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
                                        a9, a10, a11, a12, a13, a14, a15, a16, \
                                        a17, a18, a19, a20, a21, a22)          \
   m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
       m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
       m(a19), m(a20), m(a21), m(a22)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS24(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS24(m, a0, a1, a2, a3, a4, a5, a6, a7, a8, \
                                        a9, a10, a11, a12, a13, a14, a15, a16, \
                                        a17, a18, a19, a20, a21, a22, a23)     \
   m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
       m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
       m(a19), m(a20), m(a21), m(a22), m(a23)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS25(m, a0, a1, a2, a3, a4, a5, a6, a7, a8,  \
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS25(m, a0, a1, a2, a3, a4, a5, a6, a7, a8,  \
                                        a9, a10, a11, a12, a13, a14, a15, a16,  \
                                        a17, a18, a19, a20, a21, a22, a23, a24) \
   m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),        \
       m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18),  \
       m(a19), m(a20), m(a21), m(a22), m(a23), m(a24)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS26(                                       \
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS26(                                       \
     m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,  \
     a16, a17, a18, a19, a20, a21, a22, a23, a24, a25)                         \
   m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
       m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
       m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS27(                                       \
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS27(                                       \
     m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,  \
     a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26)                    \
   m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
       m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
       m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS28(                                       \
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS28(                                       \
     m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,  \
     a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27)               \
   m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
       m(a10), m(a11), m(a12), m(a13), m(a14), m(a15), m(a16), m(a17), m(a18), \
       m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26), m(a27)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS29(                                       \
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS29(                                       \
     m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,  \
     a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28)          \
   m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
@@ -205,7 +205,7 @@
       m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26), m(a27), \
       m(a28)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS30(                                       \
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS30(                                       \
     m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,  \
     a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29)     \
   m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),       \
@@ -213,7 +213,7 @@
       m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26), m(a27), \
       m(a28), m(a29)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS31(                                        \
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS31(                                        \
     m, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,   \
     a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30) \
   m(a0), m(a1), m(a2), m(a3), m(a4), m(a5), m(a6), m(a7), m(a8), m(a9),        \
@@ -221,7 +221,7 @@
       m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26), m(a27),  \
       m(a28), m(a29), m(a30)
 
-#define ABSL_INTERNAL_TRANSFORM_ARGS32(m, a0, a1, a2, a3, a4, a5, a6, a7, a8,  \
+#define Y_ABSL_INTERNAL_TRANSFORM_ARGS32(m, a0, a1, a2, a3, a4, a5, a6, a7, a8,  \
                                        a9, a10, a11, a12, a13, a14, a15, a16,  \
                                        a17, a18, a19, a20, a21, a22, a23, a24, \
                                        a25, a26, a27, a28, a29, a30, a31)      \
@@ -230,17 +230,17 @@
       m(a19), m(a20), m(a21), m(a22), m(a23), m(a24), m(a25), m(a26), m(a27),  \
       m(a28), m(a29), m(a30), m(a31)
 
-#define ABSL_INTERNAL_NUM_ARGS_IMPL(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,    \
+#define Y_ABSL_INTERNAL_NUM_ARGS_IMPL(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,    \
                                     a10, a11, a12, a13, a14, a15, a16, a17,    \
                                     a18, a19, a20, a21, a22, a23, a24, a25,    \
                                     a26, a27, a28, a29, a30, a31, result, ...) \
   result
 
-#define ABSL_INTERNAL_FORCE_EXPANSION(...) __VA_ARGS__
+#define Y_ABSL_INTERNAL_FORCE_EXPANSION(...) __VA_ARGS__
 
-#define ABSL_INTERNAL_NUM_ARGS(...)                                            \
-  ABSL_INTERNAL_FORCE_EXPANSION(ABSL_INTERNAL_NUM_ARGS_IMPL(                   \
+#define Y_ABSL_INTERNAL_NUM_ARGS(...)                                            \
+  Y_ABSL_INTERNAL_FORCE_EXPANSION(Y_ABSL_INTERNAL_NUM_ARGS_IMPL(                   \
       __VA_ARGS__, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, \
       17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, ))
 
-#endif  // ABSL_TYPES_INTERNAL_TRANSFORM_ARGS_H_
+#endif  // Y_ABSL_TYPES_INTERNAL_TRANSFORM_ARGS_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/variant.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/variant.h
index 4495fb4de6..606d985526 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/variant.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/internal/variant.h
@@ -16,8 +16,8 @@
 // separate file to avoid cluttering the top of the API header with
 // implementation details.
 
-#ifndef ABSL_TYPES_variant_internal_H_
-#define ABSL_TYPES_variant_internal_H_
+#ifndef Y_ABSL_TYPES_variant_internal_H_
+#define Y_ABSL_TYPES_variant_internal_H_
 
 #include <cassert>
 #include <cstddef>
@@ -37,15 +37,15 @@
 #include "y_absl/types/bad_variant_access.h"
 #include "y_absl/utility/utility.h"
 
-#if !defined(ABSL_USES_STD_VARIANT)
+#if !defined(Y_ABSL_USES_STD_VARIANT)
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 template <class... Types>
 class variant;
 
-ABSL_INTERNAL_INLINE_CONSTEXPR(size_t, variant_npos, static_cast<size_t>(-1));
+Y_ABSL_INTERNAL_INLINE_CONSTEXPR(size_t, variant_npos, static_cast<size_t>(-1));
 
 template <class T>
 struct variant_size;
@@ -272,7 +272,7 @@ struct UnreachableSwitchCase {
   template <class Op>
   [[noreturn]] static VisitIndicesResultT<Op, std::size_t> Run(
       Op&& /*ignored*/) {
-#if ABSL_HAVE_BUILTIN(__builtin_unreachable) || \
+#if Y_ABSL_HAVE_BUILTIN(__builtin_unreachable) || \
     (defined(__GNUC__) && !defined(__clang__))
     __builtin_unreachable();
 #elif defined(_MSC_VER)
@@ -301,7 +301,7 @@ struct ReachableSwitchCase {
 // power of 2 is because the number was picked to correspond to a power of 2
 // amount of "normal" alternatives, plus one for the possibility of the user
 // providing "monostate" in addition to the more natural alternatives.
-ABSL_INTERNAL_INLINE_CONSTEXPR(std::size_t, MaxUnrolledVisitCases, 33);
+Y_ABSL_INTERNAL_INLINE_CONSTEXPR(std::size_t, MaxUnrolledVisitCases, 33);
 
 // Note: The default-definition is for unreachable cases.
 template <bool IsReachable>
@@ -423,7 +423,7 @@ struct VisitIndicesSwitch {
       case 32:
         return PickCase<Op, 32, EndIndex>::Run(y_absl::forward<Op>(op));
       default:
-        ABSL_ASSERT(i == variant_npos);
+        Y_ABSL_ASSERT(i == variant_npos);
         return y_absl::base_internal::invoke(y_absl::forward<Op>(op), NPos());
     }
   }
@@ -608,7 +608,7 @@ struct VariantCoreAccess {
   // Access a variant alternative, throwing if the index is incorrect.
   template <std::size_t I, class Variant>
   static VariantAccessResult<I, Variant> CheckedAccess(Variant&& self) {
-    if (ABSL_PREDICT_FALSE(self.index_ != I)) {
+    if (Y_ABSL_PREDICT_FALSE(self.index_ != I)) {
       TypedThrowBadVariantAccess<VariantAccessResult<I, Variant>>();
     }
 
@@ -1639,8 +1639,8 @@ struct VariantHashBase<Variant,
 };
 
 }  // namespace variant_internal
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // !defined(ABSL_USES_STD_VARIANT)
-#endif  // ABSL_TYPES_variant_internal_H_
+#endif  // !defined(Y_ABSL_USES_STD_VARIANT)
+#endif  // Y_ABSL_TYPES_variant_internal_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/optional.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/optional.h
index d4ef0bb57b..6c988a64ce 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/optional.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/optional.h
@@ -32,27 +32,27 @@
 // `y_absl::optional` is a C++11 compatible version of the C++17 `std::optional`
 // abstraction and is designed to be a drop-in replacement for code compliant
 // with C++17.
-#ifndef ABSL_TYPES_OPTIONAL_H_
-#define ABSL_TYPES_OPTIONAL_H_
+#ifndef Y_ABSL_TYPES_OPTIONAL_H_
+#define Y_ABSL_TYPES_OPTIONAL_H_
 
 #include "y_absl/base/config.h"   // TODO(calabrese) IWYU removal?
 #include "y_absl/utility/utility.h"
 
-#ifdef ABSL_USES_STD_OPTIONAL
+#ifdef Y_ABSL_USES_STD_OPTIONAL
 
 #include <optional>  // IWYU pragma: export
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 using std::bad_optional_access;
 using std::optional;
 using std::make_optional;
 using std::nullopt_t;
 using std::nullopt;
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#else  // ABSL_USES_STD_OPTIONAL
+#else  // Y_ABSL_USES_STD_OPTIONAL
 
 #include <cassert>
 #include <functional>
@@ -67,7 +67,7 @@ ABSL_NAMESPACE_END
 #include "y_absl/types/internal/optional.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // nullopt_t
 //
@@ -82,7 +82,7 @@ struct nullopt_t {
 //
 // A tag constant of type `y_absl::nullopt_t` used to indicate an empty
 // `y_absl::optional` in certain functions, such as construction or assignment.
-ABSL_INTERNAL_INLINE_CONSTEXPR(nullopt_t, nullopt,
+Y_ABSL_INTERNAL_INLINE_CONSTEXPR(nullopt_t, nullopt,
                                nullopt_t(optional_internal::init_t()));
 
 // -----------------------------------------------------------------------------
@@ -109,7 +109,7 @@ ABSL_INTERNAL_INLINE_CONSTEXPR(nullopt_t, nullopt,
 //      guaranteed copy elision.
 //    * The move constructor's `noexcept` specification is stronger, i.e. if the
 //      default allocator is non-throwing (via setting
-//      `ABSL_ALLOCATOR_NOTHROW`), it evaluates to `noexcept(true)`, because
+//      `Y_ABSL_ALLOCATOR_NOTHROW`), it evaluates to `noexcept(true)`, because
 //      we assume
 //       a) move constructors should only throw due to allocation failure and
 //       b) if T's move constructor allocates, it uses the same allocation
@@ -336,7 +336,7 @@ class optional : private optional_internal::optional_data<T>,
   // optional::reset()
   //
   // Destroys the inner `T` value of an `y_absl::optional` if one is present.
-  ABSL_ATTRIBUTE_REINITIALIZES void reset() noexcept { this->destruct(); }
+  Y_ABSL_ATTRIBUTE_REINITIALIZES void reset() noexcept { this->destruct(); }
 
   // optional::emplace()
   //
@@ -412,11 +412,11 @@ class optional : private optional_internal::optional_data<T>,
   //
   // If you need myOpt->foo in constexpr, use (*myOpt).foo instead.
   const T* operator->() const {
-    ABSL_HARDENING_ASSERT(this->engaged_);
+    Y_ABSL_HARDENING_ASSERT(this->engaged_);
     return std::addressof(this->data_);
   }
   T* operator->() {
-    ABSL_HARDENING_ASSERT(this->engaged_);
+    Y_ABSL_HARDENING_ASSERT(this->engaged_);
     return std::addressof(this->data_);
   }
 
@@ -425,17 +425,17 @@ class optional : private optional_internal::optional_data<T>,
   // Accesses the underlying `T` value of an `optional`. If the `optional` is
   // empty, behavior is undefined.
   constexpr const T& operator*() const& {
-    return ABSL_HARDENING_ASSERT(this->engaged_), reference();
+    return Y_ABSL_HARDENING_ASSERT(this->engaged_), reference();
   }
   T& operator*() & {
-    ABSL_HARDENING_ASSERT(this->engaged_);
+    Y_ABSL_HARDENING_ASSERT(this->engaged_);
     return reference();
   }
   constexpr const T&& operator*() const && {
-    return ABSL_HARDENING_ASSERT(this->engaged_), y_absl::move(reference());
+    return Y_ABSL_HARDENING_ASSERT(this->engaged_), y_absl::move(reference());
   }
   T&& operator*() && {
-    ABSL_HARDENING_ASSERT(this->engaged_);
+    Y_ABSL_HARDENING_ASSERT(this->engaged_);
     return std::move(reference());
   }
 
@@ -757,7 +757,7 @@ constexpr auto operator>=(const U& v, const optional<T>& x)
   return static_cast<bool>(x) ? static_cast<bool>(v >= *x) : true;
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 namespace std {
@@ -769,8 +769,8 @@ struct hash<y_absl::optional<T> >
 
 }  // namespace std
 
-#undef ABSL_MSVC_CONSTEXPR_BUG_IN_UNION_LIKE_CLASS
+#undef Y_ABSL_MSVC_CONSTEXPR_BUG_IN_UNION_LIKE_CLASS
 
-#endif  // ABSL_USES_STD_OPTIONAL
+#endif  // Y_ABSL_USES_STD_OPTIONAL
 
-#endif  // ABSL_TYPES_OPTIONAL_H_
+#endif  // Y_ABSL_TYPES_OPTIONAL_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/span.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/span.h
index 1490b2f1b2..5961eb9927 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/span.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/span.h
@@ -49,8 +49,8 @@
 //    * `y_absl::Span` has an explicit mutable-reference constructor
 //
 // For more information, see the class comments below.
-#ifndef ABSL_TYPES_SPAN_H_
-#define ABSL_TYPES_SPAN_H_
+#ifndef Y_ABSL_TYPES_SPAN_H_
+#define Y_ABSL_TYPES_SPAN_H_
 
 #include <algorithm>
 #include <cassert>
@@ -68,7 +68,7 @@
 #include "y_absl/types/internal/span.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 //------------------------------------------------------------------------------
 // Span
@@ -244,7 +244,7 @@ class Span {
   template <typename LazyT = T,
             typename = EnableIfConstView<LazyT>>
   Span(std::initializer_list<value_type> v
-           ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept  // NOLINT(runtime/explicit)
+           Y_ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept  // NOLINT(runtime/explicit)
       : Span(v.begin(), v.size()) {}
 
   // Accessors
@@ -275,14 +275,14 @@ class Span {
   // Returns a reference to the i'th element of this span.
   constexpr reference operator[](size_type i) const noexcept {
     // MSVC 2015 accepts this as constexpr, but not ptr_[i]
-    return ABSL_HARDENING_ASSERT(i < size()), *(data() + i);
+    return Y_ABSL_HARDENING_ASSERT(i < size()), *(data() + i);
   }
 
   // Span::at()
   //
   // Returns a reference to the i'th element of this span.
   constexpr reference at(size_type i) const {
-    return ABSL_PREDICT_TRUE(i < size())  //
+    return Y_ABSL_PREDICT_TRUE(i < size())  //
                ? *(data() + i)
                : (base_internal::ThrowStdOutOfRange(
                       "Span::at failed bounds check"),
@@ -294,7 +294,7 @@ class Span {
   // Returns a reference to the first element of this span. The span must not
   // be empty.
   constexpr reference front() const noexcept {
-    return ABSL_HARDENING_ASSERT(size() > 0), *data();
+    return Y_ABSL_HARDENING_ASSERT(size() > 0), *data();
   }
 
   // Span::back()
@@ -302,7 +302,7 @@ class Span {
   // Returns a reference to the last element of this span. The span must not
   // be empty.
   constexpr reference back() const noexcept {
-    return ABSL_HARDENING_ASSERT(size() > 0), *(data() + size() - 1);
+    return Y_ABSL_HARDENING_ASSERT(size() > 0), *(data() + size() - 1);
   }
 
   // Span::begin()
@@ -367,7 +367,7 @@ class Span {
   //
   // Removes the first `n` elements from the span.
   void remove_prefix(size_type n) noexcept {
-    ABSL_HARDENING_ASSERT(size() >= n);
+    Y_ABSL_HARDENING_ASSERT(size() >= n);
     ptr_ += n;
     len_ -= n;
   }
@@ -376,7 +376,7 @@ class Span {
   //
   // Removes the last `n` elements from the span.
   void remove_suffix(size_type n) noexcept {
-    ABSL_HARDENING_ASSERT(size() >= n);
+    Y_ABSL_HARDENING_ASSERT(size() >= n);
     len_ -= n;
   }
 
@@ -664,7 +664,7 @@ constexpr Span<T> MakeSpan(T* ptr, size_t size) noexcept {
 
 template <int&... ExplicitArgumentBarrier, typename T>
 Span<T> MakeSpan(T* begin, T* end) noexcept {
-  return ABSL_HARDENING_ASSERT(begin <= end), Span<T>(begin, end - begin);
+  return Y_ABSL_HARDENING_ASSERT(begin <= end), Span<T>(begin, end - begin);
 }
 
 template <int&... ExplicitArgumentBarrier, typename C>
@@ -709,7 +709,7 @@ constexpr Span<const T> MakeConstSpan(T* ptr, size_t size) noexcept {
 
 template <int&... ExplicitArgumentBarrier, typename T>
 Span<const T> MakeConstSpan(T* begin, T* end) noexcept {
-  return ABSL_HARDENING_ASSERT(begin <= end), Span<const T>(begin, end - begin);
+  return Y_ABSL_HARDENING_ASSERT(begin <= end), Span<const T>(begin, end - begin);
 }
 
 template <int&... ExplicitArgumentBarrier, typename C>
@@ -721,6 +721,6 @@ template <int&... ExplicitArgumentBarrier, typename T, size_t N>
 constexpr Span<const T> MakeConstSpan(const T (&array)[N]) noexcept {
   return Span<const T>(array, N);
 }
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
-#endif  // ABSL_TYPES_SPAN_H_
+#endif  // Y_ABSL_TYPES_SPAN_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/types/variant.h b/contrib/restricted/abseil-cpp-tstring/y_absl/types/variant.h
index b3d7235018..dd21ab9e97 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/types/variant.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/types/variant.h
@@ -39,18 +39,18 @@
 // abstraction and is designed to be a drop-in replacement for code compliant
 // with C++17.
 
-#ifndef ABSL_TYPES_VARIANT_H_
-#define ABSL_TYPES_VARIANT_H_
+#ifndef Y_ABSL_TYPES_VARIANT_H_
+#define Y_ABSL_TYPES_VARIANT_H_
 
 #include "y_absl/base/config.h"
 #include "y_absl/utility/utility.h"
 
-#ifdef ABSL_USES_STD_VARIANT
+#ifdef Y_ABSL_USES_STD_VARIANT
 
 #include <variant>  // IWYU pragma: export
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 using std::bad_variant_access;
 using std::get;
 using std::get_if;
@@ -63,10 +63,10 @@ using std::variant_npos;
 using std::variant_size;
 using std::variant_size_v;
 using std::visit;
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#else  // ABSL_USES_STD_VARIANT
+#else  // Y_ABSL_USES_STD_VARIANT
 
 #include <functional>
 #include <new>
@@ -79,7 +79,7 @@ ABSL_NAMESPACE_END
 #include "y_absl/types/internal/variant.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // -----------------------------------------------------------------------------
 // y_absl::variant
@@ -803,7 +803,7 @@ operator>=(const variant<Types...>& a, const variant<Types...>& b) {
                    a.index());
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 namespace std {
@@ -821,10 +821,10 @@ struct hash<y_absl::variant<T...>>
 
 }  // namespace std
 
-#endif  // ABSL_USES_STD_VARIANT
+#endif  // Y_ABSL_USES_STD_VARIANT
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 namespace variant_internal {
 
 // Helper visitor for converting a variant<Ts...>` into another type (mostly
@@ -860,7 +860,7 @@ To ConvertVariantTo(Variant&& variant) {
                      std::forward<Variant>(variant));
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_TYPES_VARIANT_H_
+#endif  // Y_ABSL_TYPES_VARIANT_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/utility/utility.h b/contrib/restricted/abseil-cpp-tstring/y_absl/utility/utility.h
index c2e4d91d43..7ea0d452a5 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/utility/utility.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/utility/utility.h
@@ -37,8 +37,8 @@
 //  https://en.cppreference.com/w/cpp/utility/apply
 //  http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3658.html
 
-#ifndef ABSL_UTILITY_UTILITY_H_
-#define ABSL_UTILITY_UTILITY_H_
+#ifndef Y_ABSL_UTILITY_UTILITY_H_
+#define Y_ABSL_UTILITY_UTILITY_H_
 
 #include <cstddef>
 #include <cstdlib>
@@ -51,7 +51,7 @@
 #include "y_absl/meta/type_traits.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN
+Y_ABSL_NAMESPACE_BEGIN
 
 // integer_sequence
 //
@@ -159,12 +159,12 @@ using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
 
 // Tag types
 
-#ifdef ABSL_USES_STD_OPTIONAL
+#ifdef Y_ABSL_USES_STD_OPTIONAL
 
 using std::in_place_t;
 using std::in_place;
 
-#else  // ABSL_USES_STD_OPTIONAL
+#else  // Y_ABSL_USES_STD_OPTIONAL
 
 // in_place_t
 //
@@ -173,11 +173,11 @@ using std::in_place;
 // `std::in_place_t`.
 struct in_place_t {};
 
-ABSL_INTERNAL_INLINE_CONSTEXPR(in_place_t, in_place, {});
+Y_ABSL_INTERNAL_INLINE_CONSTEXPR(in_place_t, in_place, {});
 
-#endif  // ABSL_USES_STD_OPTIONAL
+#endif  // Y_ABSL_USES_STD_OPTIONAL
 
-#if defined(ABSL_USES_STD_ANY) || defined(ABSL_USES_STD_VARIANT)
+#if defined(Y_ABSL_USES_STD_ANY) || defined(Y_ABSL_USES_STD_VARIANT)
 using std::in_place_type;
 using std::in_place_type_t;
 #else
@@ -192,9 +192,9 @@ using in_place_type_t = void (*)(utility_internal::InPlaceTypeTag<T>);
 
 template <typename T>
 void in_place_type(utility_internal::InPlaceTypeTag<T>) {}
-#endif  // ABSL_USES_STD_ANY || ABSL_USES_STD_VARIANT
+#endif  // Y_ABSL_USES_STD_ANY || Y_ABSL_USES_STD_VARIANT
 
-#ifdef ABSL_USES_STD_VARIANT
+#ifdef Y_ABSL_USES_STD_VARIANT
 using std::in_place_index;
 using std::in_place_index_t;
 #else
@@ -209,7 +209,7 @@ using in_place_index_t = void (*)(utility_internal::InPlaceIndexTag<I>);
 
 template <size_t I>
 void in_place_index(utility_internal::InPlaceIndexTag<I>) {}
-#endif  // ABSL_USES_STD_VARIANT
+#endif  // Y_ABSL_USES_STD_VARIANT
 
 // Constexpr move and forward
 
@@ -344,7 +344,7 @@ constexpr T make_from_tuple(Tuple&& tup) {
           std::tuple_size<y_absl::decay_t<Tuple>>::value>{});
 }
 
-ABSL_NAMESPACE_END
+Y_ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_UTILITY_UTILITY_H_
+#endif  // Y_ABSL_UTILITY_UTILITY_H_