intermediate changes

ref:c67faec740b4d59ed47c6dfdc7076c904650af60

9 files changed, 72 insertions, 72 deletions

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_