intermediate changes

ref:c67faec740b4d59ed47c6dfdc7076c904650af60

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()

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

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();
 }

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 {

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_

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_

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_

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_

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_

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_