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

5 files changed, 1473 insertions, 1473 deletions

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..563cfb3f6f 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
@@ -1,349 +1,349 @@
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// This file provides CityHash64() and related functions.
-//
-// It's probably possible to create even faster hash functions by
-// writing a program that systematically explores some of the space of
-// possible hash functions, by using SIMD instructions, or by
-// compromising on hash quality.
-
+// Copyright 2018 The Abseil Authors. 
+// 
+// Licensed under the Apache License, Version 2.0 (the "License"); 
+// you may not use this file except in compliance with the License. 
+// You may obtain a copy of the License at 
+// 
+//      https://www.apache.org/licenses/LICENSE-2.0 
+// 
+// Unless required by applicable law or agreed to in writing, software 
+// distributed under the License is distributed on an "AS IS" BASIS, 
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+// See the License for the specific language governing permissions and 
+// limitations under the License. 
+// 
+// This file provides CityHash64() and related functions. 
+// 
+// It's probably possible to create even faster hash functions by 
+// writing a program that systematically explores some of the space of 
+// possible hash functions, by using SIMD instructions, or by 
+// compromising on hash quality. 
+ 
 #include "y_absl/hash/internal/city.h"
-
-#include <string.h>  // for memcpy and memset
-#include <algorithm>
-
+ 
+#include <string.h>  // for memcpy and memset 
+#include <algorithm> 
+ 
 #include "y_absl/base/config.h"
 #include "y_absl/base/internal/endian.h"
 #include "y_absl/base/internal/unaligned_access.h"
 #include "y_absl/base/optimization.h"
-
+ 
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-namespace hash_internal {
-
-#ifdef ABSL_IS_BIG_ENDIAN
+namespace hash_internal { 
+ 
+#ifdef 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
-#define uint32_in_expected_order(x) (x)
-#define uint64_in_expected_order(x) (x)
-#endif
-
-static uint64_t Fetch64(const char *p) {
-  return uint64_in_expected_order(ABSL_INTERNAL_UNALIGNED_LOAD64(p));
-}
-
-static uint32_t Fetch32(const char *p) {
-  return uint32_in_expected_order(ABSL_INTERNAL_UNALIGNED_LOAD32(p));
-}
-
-// Some primes between 2^63 and 2^64 for various uses.
-static const uint64_t k0 = 0xc3a5c85c97cb3127ULL;
-static const uint64_t k1 = 0xb492b66fbe98f273ULL;
-static const uint64_t k2 = 0x9ae16a3b2f90404fULL;
-
-// Magic numbers for 32-bit hashing.  Copied from Murmur3.
-static const uint32_t c1 = 0xcc9e2d51;
-static const uint32_t c2 = 0x1b873593;
-
-// A 32-bit to 32-bit integer hash copied from Murmur3.
-static uint32_t fmix(uint32_t h) {
-  h ^= h >> 16;
-  h *= 0x85ebca6b;
-  h ^= h >> 13;
-  h *= 0xc2b2ae35;
-  h ^= h >> 16;
-  return h;
-}
-
-static uint32_t Rotate32(uint32_t val, int shift) {
-  // Avoid shifting by 32: doing so yields an undefined result.
-  return shift == 0 ? val : ((val >> shift) | (val << (32 - shift)));
-}
-
-#undef PERMUTE3
-#define PERMUTE3(a, b, c) \
-  do {                    \
-    std::swap(a, b);      \
-    std::swap(a, c);      \
-  } while (0)
-
-static uint32_t Mur(uint32_t a, uint32_t h) {
-  // Helper from Murmur3 for combining two 32-bit values.
-  a *= c1;
-  a = Rotate32(a, 17);
-  a *= c2;
-  h ^= a;
-  h = Rotate32(h, 19);
-  return h * 5 + 0xe6546b64;
-}
-
-static uint32_t Hash32Len13to24(const char *s, size_t len) {
-  uint32_t a = Fetch32(s - 4 + (len >> 1));
-  uint32_t b = Fetch32(s + 4);
-  uint32_t c = Fetch32(s + len - 8);
-  uint32_t d = Fetch32(s + (len >> 1));
-  uint32_t e = Fetch32(s);
-  uint32_t f = Fetch32(s + len - 4);
-  uint32_t h = len;
-
-  return fmix(Mur(f, Mur(e, Mur(d, Mur(c, Mur(b, Mur(a, h)))))));
-}
-
-static uint32_t Hash32Len0to4(const char *s, size_t len) {
-  uint32_t b = 0;
-  uint32_t c = 9;
-  for (size_t i = 0; i < len; i++) {
-    signed char v = s[i];
-    b = b * c1 + v;
-    c ^= b;
-  }
-  return fmix(Mur(b, Mur(len, c)));
-}
-
-static uint32_t Hash32Len5to12(const char *s, size_t len) {
-  uint32_t a = len, b = len * 5, c = 9, d = b;
-  a += Fetch32(s);
-  b += Fetch32(s + len - 4);
-  c += Fetch32(s + ((len >> 1) & 4));
-  return fmix(Mur(c, Mur(b, Mur(a, d))));
-}
-
-uint32_t CityHash32(const char *s, size_t len) {
-  if (len <= 24) {
-    return len <= 12
-               ? (len <= 4 ? Hash32Len0to4(s, len) : Hash32Len5to12(s, len))
-               : Hash32Len13to24(s, len);
-  }
-
-  // len > 24
-  uint32_t h = len, g = c1 * len, f = g;
-
-  uint32_t a0 = Rotate32(Fetch32(s + len - 4) * c1, 17) * c2;
-  uint32_t a1 = Rotate32(Fetch32(s + len - 8) * c1, 17) * c2;
-  uint32_t a2 = Rotate32(Fetch32(s + len - 16) * c1, 17) * c2;
-  uint32_t a3 = Rotate32(Fetch32(s + len - 12) * c1, 17) * c2;
-  uint32_t a4 = Rotate32(Fetch32(s + len - 20) * c1, 17) * c2;
-  h ^= a0;
-  h = Rotate32(h, 19);
-  h = h * 5 + 0xe6546b64;
-  h ^= a2;
-  h = Rotate32(h, 19);
-  h = h * 5 + 0xe6546b64;
-  g ^= a1;
-  g = Rotate32(g, 19);
-  g = g * 5 + 0xe6546b64;
-  g ^= a3;
-  g = Rotate32(g, 19);
-  g = g * 5 + 0xe6546b64;
-  f += a4;
-  f = Rotate32(f, 19);
-  f = f * 5 + 0xe6546b64;
-  size_t iters = (len - 1) / 20;
-  do {
-    uint32_t b0 = Rotate32(Fetch32(s) * c1, 17) * c2;
-    uint32_t b1 = Fetch32(s + 4);
-    uint32_t b2 = Rotate32(Fetch32(s + 8) * c1, 17) * c2;
-    uint32_t b3 = Rotate32(Fetch32(s + 12) * c1, 17) * c2;
-    uint32_t b4 = Fetch32(s + 16);
-    h ^= b0;
-    h = Rotate32(h, 18);
-    h = h * 5 + 0xe6546b64;
-    f += b1;
-    f = Rotate32(f, 19);
-    f = f * c1;
-    g += b2;
-    g = Rotate32(g, 18);
-    g = g * 5 + 0xe6546b64;
-    h ^= b3 + b1;
-    h = Rotate32(h, 19);
-    h = h * 5 + 0xe6546b64;
-    g ^= b4;
+#else 
+#define uint32_in_expected_order(x) (x) 
+#define uint64_in_expected_order(x) (x) 
+#endif 
+ 
+static uint64_t Fetch64(const char *p) { 
+  return uint64_in_expected_order(ABSL_INTERNAL_UNALIGNED_LOAD64(p)); 
+} 
+ 
+static uint32_t Fetch32(const char *p) { 
+  return uint32_in_expected_order(ABSL_INTERNAL_UNALIGNED_LOAD32(p)); 
+} 
+ 
+// Some primes between 2^63 and 2^64 for various uses. 
+static const uint64_t k0 = 0xc3a5c85c97cb3127ULL; 
+static const uint64_t k1 = 0xb492b66fbe98f273ULL; 
+static const uint64_t k2 = 0x9ae16a3b2f90404fULL; 
+ 
+// Magic numbers for 32-bit hashing.  Copied from Murmur3. 
+static const uint32_t c1 = 0xcc9e2d51; 
+static const uint32_t c2 = 0x1b873593; 
+ 
+// A 32-bit to 32-bit integer hash copied from Murmur3. 
+static uint32_t fmix(uint32_t h) { 
+  h ^= h >> 16; 
+  h *= 0x85ebca6b; 
+  h ^= h >> 13; 
+  h *= 0xc2b2ae35; 
+  h ^= h >> 16; 
+  return h; 
+} 
+ 
+static uint32_t Rotate32(uint32_t val, int shift) { 
+  // Avoid shifting by 32: doing so yields an undefined result. 
+  return shift == 0 ? val : ((val >> shift) | (val << (32 - shift))); 
+} 
+ 
+#undef PERMUTE3 
+#define PERMUTE3(a, b, c) \ 
+  do {                    \ 
+    std::swap(a, b);      \ 
+    std::swap(a, c);      \ 
+  } while (0) 
+ 
+static uint32_t Mur(uint32_t a, uint32_t h) { 
+  // Helper from Murmur3 for combining two 32-bit values. 
+  a *= c1; 
+  a = Rotate32(a, 17); 
+  a *= c2; 
+  h ^= a; 
+  h = Rotate32(h, 19); 
+  return h * 5 + 0xe6546b64; 
+} 
+ 
+static uint32_t Hash32Len13to24(const char *s, size_t len) { 
+  uint32_t a = Fetch32(s - 4 + (len >> 1)); 
+  uint32_t b = Fetch32(s + 4); 
+  uint32_t c = Fetch32(s + len - 8); 
+  uint32_t d = Fetch32(s + (len >> 1)); 
+  uint32_t e = Fetch32(s); 
+  uint32_t f = Fetch32(s + len - 4); 
+  uint32_t h = len; 
+ 
+  return fmix(Mur(f, Mur(e, Mur(d, Mur(c, Mur(b, Mur(a, h))))))); 
+} 
+ 
+static uint32_t Hash32Len0to4(const char *s, size_t len) { 
+  uint32_t b = 0; 
+  uint32_t c = 9; 
+  for (size_t i = 0; i < len; i++) { 
+    signed char v = s[i]; 
+    b = b * c1 + v; 
+    c ^= b; 
+  } 
+  return fmix(Mur(b, Mur(len, c))); 
+} 
+ 
+static uint32_t Hash32Len5to12(const char *s, size_t len) { 
+  uint32_t a = len, b = len * 5, c = 9, d = b; 
+  a += Fetch32(s); 
+  b += Fetch32(s + len - 4); 
+  c += Fetch32(s + ((len >> 1) & 4)); 
+  return fmix(Mur(c, Mur(b, Mur(a, d)))); 
+} 
+ 
+uint32_t CityHash32(const char *s, size_t len) { 
+  if (len <= 24) { 
+    return len <= 12 
+               ? (len <= 4 ? Hash32Len0to4(s, len) : Hash32Len5to12(s, len)) 
+               : Hash32Len13to24(s, len); 
+  } 
+ 
+  // len > 24 
+  uint32_t h = len, g = c1 * len, f = g; 
+ 
+  uint32_t a0 = Rotate32(Fetch32(s + len - 4) * c1, 17) * c2; 
+  uint32_t a1 = Rotate32(Fetch32(s + len - 8) * c1, 17) * c2; 
+  uint32_t a2 = Rotate32(Fetch32(s + len - 16) * c1, 17) * c2; 
+  uint32_t a3 = Rotate32(Fetch32(s + len - 12) * c1, 17) * c2; 
+  uint32_t a4 = Rotate32(Fetch32(s + len - 20) * c1, 17) * c2; 
+  h ^= a0; 
+  h = Rotate32(h, 19); 
+  h = h * 5 + 0xe6546b64; 
+  h ^= a2; 
+  h = Rotate32(h, 19); 
+  h = h * 5 + 0xe6546b64; 
+  g ^= a1; 
+  g = Rotate32(g, 19); 
+  g = g * 5 + 0xe6546b64; 
+  g ^= a3; 
+  g = Rotate32(g, 19); 
+  g = g * 5 + 0xe6546b64; 
+  f += a4; 
+  f = Rotate32(f, 19); 
+  f = f * 5 + 0xe6546b64; 
+  size_t iters = (len - 1) / 20; 
+  do { 
+    uint32_t b0 = Rotate32(Fetch32(s) * c1, 17) * c2; 
+    uint32_t b1 = Fetch32(s + 4); 
+    uint32_t b2 = Rotate32(Fetch32(s + 8) * c1, 17) * c2; 
+    uint32_t b3 = Rotate32(Fetch32(s + 12) * c1, 17) * c2; 
+    uint32_t b4 = Fetch32(s + 16); 
+    h ^= b0; 
+    h = Rotate32(h, 18); 
+    h = h * 5 + 0xe6546b64; 
+    f += b1; 
+    f = Rotate32(f, 19); 
+    f = f * c1; 
+    g += b2; 
+    g = Rotate32(g, 18); 
+    g = g * 5 + 0xe6546b64; 
+    h ^= b3 + b1; 
+    h = Rotate32(h, 19); 
+    h = h * 5 + 0xe6546b64; 
+    g ^= b4; 
     g = y_absl::gbswap_32(g) * 5;
-    h += b4 * 5;
+    h += b4 * 5; 
     h = y_absl::gbswap_32(h);
-    f += b0;
-    PERMUTE3(f, h, g);
-    s += 20;
-  } while (--iters != 0);
-  g = Rotate32(g, 11) * c1;
-  g = Rotate32(g, 17) * c1;
-  f = Rotate32(f, 11) * c1;
-  f = Rotate32(f, 17) * c1;
-  h = Rotate32(h + g, 19);
-  h = h * 5 + 0xe6546b64;
-  h = Rotate32(h, 17) * c1;
-  h = Rotate32(h + f, 19);
-  h = h * 5 + 0xe6546b64;
-  h = Rotate32(h, 17) * c1;
-  return h;
-}
-
-// Bitwise right rotate.  Normally this will compile to a single
-// instruction, especially if the shift is a manifest constant.
-static uint64_t Rotate(uint64_t val, int shift) {
-  // Avoid shifting by 64: doing so yields an undefined result.
-  return shift == 0 ? val : ((val >> shift) | (val << (64 - shift)));
-}
-
-static uint64_t ShiftMix(uint64_t val) { return val ^ (val >> 47); }
-
-static uint64_t HashLen16(uint64_t u, uint64_t v, uint64_t mul) {
-  // Murmur-inspired hashing.
-  uint64_t a = (u ^ v) * mul;
-  a ^= (a >> 47);
-  uint64_t b = (v ^ a) * mul;
-  b ^= (b >> 47);
-  b *= mul;
-  return b;
-}
-
+    f += b0; 
+    PERMUTE3(f, h, g); 
+    s += 20; 
+  } while (--iters != 0); 
+  g = Rotate32(g, 11) * c1; 
+  g = Rotate32(g, 17) * c1; 
+  f = Rotate32(f, 11) * c1; 
+  f = Rotate32(f, 17) * c1; 
+  h = Rotate32(h + g, 19); 
+  h = h * 5 + 0xe6546b64; 
+  h = Rotate32(h, 17) * c1; 
+  h = Rotate32(h + f, 19); 
+  h = h * 5 + 0xe6546b64; 
+  h = Rotate32(h, 17) * c1; 
+  return h; 
+} 
+ 
+// Bitwise right rotate.  Normally this will compile to a single 
+// instruction, especially if the shift is a manifest constant. 
+static uint64_t Rotate(uint64_t val, int shift) { 
+  // Avoid shifting by 64: doing so yields an undefined result. 
+  return shift == 0 ? val : ((val >> shift) | (val << (64 - shift))); 
+} 
+ 
+static uint64_t ShiftMix(uint64_t val) { return val ^ (val >> 47); } 
+ 
+static uint64_t HashLen16(uint64_t u, uint64_t v, uint64_t mul) { 
+  // Murmur-inspired hashing. 
+  uint64_t a = (u ^ v) * mul; 
+  a ^= (a >> 47); 
+  uint64_t b = (v ^ a) * mul; 
+  b ^= (b >> 47); 
+  b *= mul; 
+  return b; 
+} 
+ 
 static uint64_t HashLen16(uint64_t u, uint64_t v) {
   const uint64_t kMul = 0x9ddfea08eb382d69ULL;
   return HashLen16(u, v, kMul);
 }
 
-static uint64_t HashLen0to16(const char *s, size_t len) {
-  if (len >= 8) {
-    uint64_t mul = k2 + len * 2;
-    uint64_t a = Fetch64(s) + k2;
-    uint64_t b = Fetch64(s + len - 8);
-    uint64_t c = Rotate(b, 37) * mul + a;
-    uint64_t d = (Rotate(a, 25) + b) * mul;
-    return HashLen16(c, d, mul);
-  }
-  if (len >= 4) {
-    uint64_t mul = k2 + len * 2;
-    uint64_t a = Fetch32(s);
-    return HashLen16(len + (a << 3), Fetch32(s + len - 4), mul);
-  }
-  if (len > 0) {
-    uint8_t a = s[0];
-    uint8_t b = s[len >> 1];
-    uint8_t c = s[len - 1];
-    uint32_t y = static_cast<uint32_t>(a) + (static_cast<uint32_t>(b) << 8);
-    uint32_t z = len + (static_cast<uint32_t>(c) << 2);
-    return ShiftMix(y * k2 ^ z * k0) * k2;
-  }
-  return k2;
-}
-
-// This probably works well for 16-byte strings as well, but it may be overkill
-// in that case.
-static uint64_t HashLen17to32(const char *s, size_t len) {
-  uint64_t mul = k2 + len * 2;
-  uint64_t a = Fetch64(s) * k1;
-  uint64_t b = Fetch64(s + 8);
-  uint64_t c = Fetch64(s + len - 8) * mul;
-  uint64_t d = Fetch64(s + len - 16) * k2;
-  return HashLen16(Rotate(a + b, 43) + Rotate(c, 30) + d,
-                   a + Rotate(b + k2, 18) + c, mul);
-}
-
-// Return a 16-byte hash for 48 bytes.  Quick and dirty.
-// Callers do best to use "random-looking" values for a and b.
+static uint64_t HashLen0to16(const char *s, size_t len) { 
+  if (len >= 8) { 
+    uint64_t mul = k2 + len * 2; 
+    uint64_t a = Fetch64(s) + k2; 
+    uint64_t b = Fetch64(s + len - 8); 
+    uint64_t c = Rotate(b, 37) * mul + a; 
+    uint64_t d = (Rotate(a, 25) + b) * mul; 
+    return HashLen16(c, d, mul); 
+  } 
+  if (len >= 4) { 
+    uint64_t mul = k2 + len * 2; 
+    uint64_t a = Fetch32(s); 
+    return HashLen16(len + (a << 3), Fetch32(s + len - 4), mul); 
+  } 
+  if (len > 0) { 
+    uint8_t a = s[0]; 
+    uint8_t b = s[len >> 1]; 
+    uint8_t c = s[len - 1]; 
+    uint32_t y = static_cast<uint32_t>(a) + (static_cast<uint32_t>(b) << 8); 
+    uint32_t z = len + (static_cast<uint32_t>(c) << 2); 
+    return ShiftMix(y * k2 ^ z * k0) * k2; 
+  } 
+  return k2; 
+} 
+ 
+// This probably works well for 16-byte strings as well, but it may be overkill 
+// in that case. 
+static uint64_t HashLen17to32(const char *s, size_t len) { 
+  uint64_t mul = k2 + len * 2; 
+  uint64_t a = Fetch64(s) * k1; 
+  uint64_t b = Fetch64(s + 8); 
+  uint64_t c = Fetch64(s + len - 8) * mul; 
+  uint64_t d = Fetch64(s + len - 16) * k2; 
+  return HashLen16(Rotate(a + b, 43) + Rotate(c, 30) + d, 
+                   a + Rotate(b + k2, 18) + c, mul); 
+} 
+ 
+// Return a 16-byte hash for 48 bytes.  Quick and dirty. 
+// Callers do best to use "random-looking" values for a and b. 
 static std::pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
     uint64_t w, uint64_t x, uint64_t y, uint64_t z, uint64_t a, uint64_t b) {
-  a += w;
-  b = Rotate(b + a + z, 21);
-  uint64_t c = a;
-  a += x;
-  a += y;
-  b += Rotate(a, 44);
-  return std::make_pair(a + z, b + c);
-}
-
-// Return a 16-byte hash for s[0] ... s[31], a, and b.  Quick and dirty.
+  a += w; 
+  b = Rotate(b + a + z, 21); 
+  uint64_t c = a; 
+  a += x; 
+  a += y; 
+  b += Rotate(a, 44); 
+  return std::make_pair(a + z, b + c); 
+} 
+ 
+// Return a 16-byte hash for s[0] ... s[31], a, and b.  Quick and dirty. 
 static std::pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(const char *s,
                                                             uint64_t a,
                                                             uint64_t b) {
-  return WeakHashLen32WithSeeds(Fetch64(s), Fetch64(s + 8), Fetch64(s + 16),
-                                Fetch64(s + 24), a, b);
-}
-
-// Return an 8-byte hash for 33 to 64 bytes.
-static uint64_t HashLen33to64(const char *s, size_t len) {
-  uint64_t mul = k2 + len * 2;
-  uint64_t a = Fetch64(s) * k2;
-  uint64_t b = Fetch64(s + 8);
-  uint64_t c = Fetch64(s + len - 24);
-  uint64_t d = Fetch64(s + len - 32);
-  uint64_t e = Fetch64(s + 16) * k2;
-  uint64_t f = Fetch64(s + 24) * 9;
-  uint64_t g = Fetch64(s + len - 8);
-  uint64_t h = Fetch64(s + len - 16) * mul;
-  uint64_t u = Rotate(a + g, 43) + (Rotate(b, 30) + c) * 9;
-  uint64_t v = ((a + g) ^ d) + f + 1;
+  return WeakHashLen32WithSeeds(Fetch64(s), Fetch64(s + 8), Fetch64(s + 16), 
+                                Fetch64(s + 24), a, b); 
+} 
+ 
+// Return an 8-byte hash for 33 to 64 bytes. 
+static uint64_t HashLen33to64(const char *s, size_t len) { 
+  uint64_t mul = k2 + len * 2; 
+  uint64_t a = Fetch64(s) * k2; 
+  uint64_t b = Fetch64(s + 8); 
+  uint64_t c = Fetch64(s + len - 24); 
+  uint64_t d = Fetch64(s + len - 32); 
+  uint64_t e = Fetch64(s + 16) * k2; 
+  uint64_t f = Fetch64(s + 24) * 9; 
+  uint64_t g = Fetch64(s + len - 8); 
+  uint64_t h = Fetch64(s + len - 16) * mul; 
+  uint64_t u = Rotate(a + g, 43) + (Rotate(b, 30) + c) * 9; 
+  uint64_t v = ((a + g) ^ d) + f + 1; 
   uint64_t w = y_absl::gbswap_64((u + v) * mul) + h;
-  uint64_t x = Rotate(e + f, 42) + c;
+  uint64_t x = Rotate(e + f, 42) + c; 
   uint64_t y = (y_absl::gbswap_64((v + w) * mul) + g) * mul;
-  uint64_t z = e + f + c;
+  uint64_t z = e + f + c; 
   a = y_absl::gbswap_64((x + z) * mul + y) + b;
-  b = ShiftMix((z + a) * mul + d + h) * mul;
-  return b + x;
-}
-
-uint64_t CityHash64(const char *s, size_t len) {
-  if (len <= 32) {
-    if (len <= 16) {
-      return HashLen0to16(s, len);
-    } else {
-      return HashLen17to32(s, len);
-    }
-  } else if (len <= 64) {
-    return HashLen33to64(s, len);
-  }
-
-  // For strings over 64 bytes we hash the end first, and then as we
-  // loop we keep 56 bytes of state: v, w, x, y, and z.
-  uint64_t x = Fetch64(s + len - 40);
-  uint64_t y = Fetch64(s + len - 16) + Fetch64(s + len - 56);
-  uint64_t z = HashLen16(Fetch64(s + len - 48) + len, Fetch64(s + len - 24));
+  b = ShiftMix((z + a) * mul + d + h) * mul; 
+  return b + x; 
+} 
+ 
+uint64_t CityHash64(const char *s, size_t len) { 
+  if (len <= 32) { 
+    if (len <= 16) { 
+      return HashLen0to16(s, len); 
+    } else { 
+      return HashLen17to32(s, len); 
+    } 
+  } else if (len <= 64) { 
+    return HashLen33to64(s, len); 
+  } 
+ 
+  // For strings over 64 bytes we hash the end first, and then as we 
+  // loop we keep 56 bytes of state: v, w, x, y, and z. 
+  uint64_t x = Fetch64(s + len - 40); 
+  uint64_t y = Fetch64(s + len - 16) + Fetch64(s + len - 56); 
+  uint64_t z = HashLen16(Fetch64(s + len - 48) + len, Fetch64(s + len - 24)); 
   std::pair<uint64_t, uint64_t> v =
       WeakHashLen32WithSeeds(s + len - 64, len, z);
   std::pair<uint64_t, uint64_t> w =
       WeakHashLen32WithSeeds(s + len - 32, y + k1, x);
-  x = x * k1 + Fetch64(s);
-
-  // Decrease len to the nearest multiple of 64, and operate on 64-byte chunks.
-  len = (len - 1) & ~static_cast<size_t>(63);
-  do {
-    x = Rotate(x + y + v.first + Fetch64(s + 8), 37) * k1;
-    y = Rotate(y + v.second + Fetch64(s + 48), 42) * k1;
-    x ^= w.second;
-    y += v.first + Fetch64(s + 40);
-    z = Rotate(z + w.first, 33) * k1;
-    v = WeakHashLen32WithSeeds(s, v.second * k1, x + w.first);
-    w = WeakHashLen32WithSeeds(s + 32, z + w.second, y + Fetch64(s + 16));
-    std::swap(z, x);
-    s += 64;
-    len -= 64;
-  } while (len != 0);
-  return HashLen16(HashLen16(v.first, w.first) + ShiftMix(y) * k1 + z,
-                   HashLen16(v.second, w.second) + x);
-}
-
-uint64_t CityHash64WithSeed(const char *s, size_t len, uint64_t seed) {
-  return CityHash64WithSeeds(s, len, k2, seed);
-}
-
-uint64_t CityHash64WithSeeds(const char *s, size_t len, uint64_t seed0,
+  x = x * k1 + Fetch64(s); 
+ 
+  // Decrease len to the nearest multiple of 64, and operate on 64-byte chunks. 
+  len = (len - 1) & ~static_cast<size_t>(63); 
+  do { 
+    x = Rotate(x + y + v.first + Fetch64(s + 8), 37) * k1; 
+    y = Rotate(y + v.second + Fetch64(s + 48), 42) * k1; 
+    x ^= w.second; 
+    y += v.first + Fetch64(s + 40); 
+    z = Rotate(z + w.first, 33) * k1; 
+    v = WeakHashLen32WithSeeds(s, v.second * k1, x + w.first); 
+    w = WeakHashLen32WithSeeds(s + 32, z + w.second, y + Fetch64(s + 16)); 
+    std::swap(z, x); 
+    s += 64; 
+    len -= 64; 
+  } while (len != 0); 
+  return HashLen16(HashLen16(v.first, w.first) + ShiftMix(y) * k1 + z, 
+                   HashLen16(v.second, w.second) + x); 
+} 
+ 
+uint64_t CityHash64WithSeed(const char *s, size_t len, uint64_t seed) { 
+  return CityHash64WithSeeds(s, len, k2, seed); 
+} 
+ 
+uint64_t CityHash64WithSeeds(const char *s, size_t len, uint64_t seed0, 
                              uint64_t seed1) {
-  return HashLen16(CityHash64(s, len) - seed0, seed1);
-}
-
-}  // namespace hash_internal
+  return HashLen16(CityHash64(s, len) - seed0, seed1); 
+} 
+ 
+}  // namespace hash_internal 
 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..6a229db1a5 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
@@ -1,78 +1,78 @@
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// https://code.google.com/p/cityhash/
-//
-// This file provides a few functions for hashing strings.  All of them are
-// high-quality functions in the sense that they pass standard tests such
-// as Austin Appleby's SMHasher.  They are also fast.
-//
-// For 64-bit x86 code, on short strings, we don't know of anything faster than
-// CityHash64 that is of comparable quality.  We believe our nearest competitor
-// is Murmur3.  For 64-bit x86 code, CityHash64 is an excellent choice for hash
-// tables and most other hashing (excluding cryptography).
-//
-// For 32-bit x86 code, we don't know of anything faster than CityHash32 that
-// is of comparable quality.  We believe our nearest competitor is Murmur3A.
-// (On 64-bit CPUs, it is typically faster to use the other CityHash variants.)
-//
-// Functions in the CityHash family are not suitable for cryptography.
-//
-// Please see CityHash's README file for more details on our performance
-// measurements and so on.
-//
-// WARNING: This code has been only lightly tested on big-endian platforms!
-// It is known to work well on little-endian platforms that have a small penalty
-// for unaligned reads, such as current Intel and AMD moderate-to-high-end CPUs.
-// It should work on all 32-bit and 64-bit platforms that allow unaligned reads;
-// bug reports are welcome.
-//
-// By the way, for some hash functions, given strings a and b, the hash
-// 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_
-
-#include <stdint.h>
-#include <stdlib.h>  // for size_t.
-
-#include <utility>
+// Copyright 2018 The Abseil Authors. 
+// 
+// Licensed under the Apache License, Version 2.0 (the "License"); 
+// you may not use this file except in compliance with the License. 
+// You may obtain a copy of the License at 
+// 
+//      https://www.apache.org/licenses/LICENSE-2.0 
+// 
+// Unless required by applicable law or agreed to in writing, software 
+// distributed under the License is distributed on an "AS IS" BASIS, 
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+// See the License for the specific language governing permissions and 
+// limitations under the License. 
+// 
+// https://code.google.com/p/cityhash/ 
+// 
+// This file provides a few functions for hashing strings.  All of them are 
+// high-quality functions in the sense that they pass standard tests such 
+// as Austin Appleby's SMHasher.  They are also fast. 
+// 
+// For 64-bit x86 code, on short strings, we don't know of anything faster than 
+// CityHash64 that is of comparable quality.  We believe our nearest competitor 
+// is Murmur3.  For 64-bit x86 code, CityHash64 is an excellent choice for hash 
+// tables and most other hashing (excluding cryptography). 
+// 
+// For 32-bit x86 code, we don't know of anything faster than CityHash32 that 
+// is of comparable quality.  We believe our nearest competitor is Murmur3A. 
+// (On 64-bit CPUs, it is typically faster to use the other CityHash variants.) 
+// 
+// Functions in the CityHash family are not suitable for cryptography. 
+// 
+// Please see CityHash's README file for more details on our performance 
+// measurements and so on. 
+// 
+// WARNING: This code has been only lightly tested on big-endian platforms! 
+// It is known to work well on little-endian platforms that have a small penalty 
+// for unaligned reads, such as current Intel and AMD moderate-to-high-end CPUs. 
+// It should work on all 32-bit and 64-bit platforms that allow unaligned reads; 
+// bug reports are welcome. 
+// 
+// By the way, for some hash functions, given strings a and b, the hash 
+// 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_ 
+ 
+#include <stdint.h> 
+#include <stdlib.h>  // for size_t. 
 
+#include <utility> 
+ 
 #include "y_absl/base/config.h"
 
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-namespace hash_internal {
-
-// Hash function for a byte array.
-uint64_t CityHash64(const char *s, size_t len);
-
-// Hash function for a byte array.  For convenience, a 64-bit seed is also
-// hashed into the result.
-uint64_t CityHash64WithSeed(const char *s, size_t len, uint64_t seed);
-
-// Hash function for a byte array.  For convenience, two seeds are also
-// hashed into the result.
-uint64_t CityHash64WithSeeds(const char *s, size_t len, uint64_t seed0,
+namespace hash_internal { 
+ 
+// Hash function for a byte array. 
+uint64_t CityHash64(const char *s, size_t len); 
+ 
+// Hash function for a byte array.  For convenience, a 64-bit seed is also 
+// hashed into the result. 
+uint64_t CityHash64WithSeed(const char *s, size_t len, uint64_t seed); 
+ 
+// Hash function for a byte array.  For convenience, two seeds are also 
+// hashed into the result. 
+uint64_t CityHash64WithSeeds(const char *s, size_t len, uint64_t seed0, 
                              uint64_t seed1);
-
-// Hash function for a byte array.  Most useful in 32-bit binaries.
-uint32_t CityHash32(const char *s, size_t len);
-
-}  // namespace hash_internal
+ 
+// Hash function for a byte array.  Most useful in 32-bit binaries. 
+uint32_t CityHash32(const char *s, size_t len); 
+ 
+}  // namespace hash_internal 
 ABSL_NAMESPACE_END
 }  // namespace y_absl
-
-#endif  // ABSL_HASH_INTERNAL_CITY_H_
+ 
+#endif  // 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..a8a6252323 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
@@ -1,51 +1,51 @@
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
+// Copyright 2018 The Abseil Authors. 
+// 
+// Licensed under the Apache License, Version 2.0 (the "License"); 
+// you may not use this file except in compliance with the License. 
+// You may obtain a copy of the License at 
+// 
+//      https://www.apache.org/licenses/LICENSE-2.0 
+// 
+// Unless required by applicable law or agreed to in writing, software 
+// distributed under the License is distributed on an "AS IS" BASIS, 
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+// See the License for the specific language governing permissions and 
+// limitations under the License. 
+ 
 #include "y_absl/hash/internal/hash.h"
-
+ 
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-namespace hash_internal {
-
+namespace hash_internal { 
+ 
 uint64_t MixingHashState::CombineLargeContiguousImpl32(
     uint64_t state, const unsigned char* first, size_t len) {
-  while (len >= PiecewiseChunkSize()) {
+  while (len >= PiecewiseChunkSize()) { 
     state = Mix(state,
                 hash_internal::CityHash32(reinterpret_cast<const char*>(first),
                                           PiecewiseChunkSize()));
-    len -= PiecewiseChunkSize();
-    first += PiecewiseChunkSize();
-  }
-  // Handle the remainder.
-  return CombineContiguousImpl(state, first, len,
-                               std::integral_constant<int, 4>{});
-}
-
+    len -= PiecewiseChunkSize(); 
+    first += PiecewiseChunkSize(); 
+  } 
+  // Handle the remainder. 
+  return CombineContiguousImpl(state, first, len, 
+                               std::integral_constant<int, 4>{}); 
+} 
+ 
 uint64_t MixingHashState::CombineLargeContiguousImpl64(
     uint64_t state, const unsigned char* first, size_t len) {
-  while (len >= PiecewiseChunkSize()) {
+  while (len >= PiecewiseChunkSize()) { 
     state = Mix(state, Hash64(first, PiecewiseChunkSize()));
-    len -= PiecewiseChunkSize();
-    first += PiecewiseChunkSize();
-  }
-  // Handle the remainder.
-  return CombineContiguousImpl(state, first, len,
-                               std::integral_constant<int, 8>{});
-}
-
+    len -= PiecewiseChunkSize(); 
+    first += PiecewiseChunkSize(); 
+  } 
+  // Handle the remainder. 
+  return CombineContiguousImpl(state, first, len, 
+                               std::integral_constant<int, 8>{}); 
+} 
+ 
 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()`
 // for that mechanism.
@@ -64,6 +64,6 @@ uint64_t MixingHashState::LowLevelHashImpl(const unsigned char* data,
   return LowLevelHash(data, len, Seed(), kHashSalt);
 }
 
-}  // namespace hash_internal
+}  // namespace hash_internal 
 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..d44d650c21 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
@@ -1,44 +1,44 @@
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: hash.h
-// -----------------------------------------------------------------------------
-//
-#ifndef ABSL_HASH_INTERNAL_HASH_H_
-#define ABSL_HASH_INTERNAL_HASH_H_
-
-#include <algorithm>
-#include <array>
+// Copyright 2018 The Abseil Authors. 
+// 
+// Licensed under the Apache License, Version 2.0 (the "License"); 
+// you may not use this file except in compliance with the License. 
+// You may obtain a copy of the License at 
+// 
+//      https://www.apache.org/licenses/LICENSE-2.0 
+// 
+// Unless required by applicable law or agreed to in writing, software 
+// distributed under the License is distributed on an "AS IS" BASIS, 
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+// See the License for the specific language governing permissions and 
+// limitations under the License. 
+// 
+// ----------------------------------------------------------------------------- 
+// File: hash.h 
+// ----------------------------------------------------------------------------- 
+// 
+#ifndef ABSL_HASH_INTERNAL_HASH_H_ 
+#define ABSL_HASH_INTERNAL_HASH_H_ 
+ 
+#include <algorithm> 
+#include <array> 
 #include <bitset>
-#include <cmath>
-#include <cstring>
-#include <deque>
-#include <forward_list>
-#include <functional>
-#include <iterator>
-#include <limits>
-#include <list>
-#include <map>
-#include <memory>
-#include <set>
+#include <cmath> 
+#include <cstring> 
+#include <deque> 
+#include <forward_list> 
+#include <functional> 
+#include <iterator> 
+#include <limits> 
+#include <list> 
+#include <map> 
+#include <memory> 
+#include <set> 
 #include <util/generic/string.h>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include <vector>
-
+#include <tuple> 
+#include <type_traits> 
+#include <utility> 
+#include <vector> 
+ 
 #include "y_absl/base/config.h"
 #include "y_absl/base/internal/unaligned_access.h"
 #include "y_absl/base/port.h"
@@ -51,15 +51,15 @@
 #include "y_absl/types/optional.h"
 #include "y_absl/types/variant.h"
 #include "y_absl/utility/utility.h"
-
+ 
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-namespace hash_internal {
-
-// Internal detail: Large buffers are hashed in smaller chunks.  This function
-// returns the size of these chunks.
+namespace hash_internal { 
+ 
+// Internal detail: Large buffers are hashed in smaller chunks.  This function 
+// returns the size of these chunks. 
 constexpr size_t PiecewiseChunkSize() { return 1024; }
-
+ 
 // PiecewiseCombiner
 //
 // PiecewiseCombiner is an internal-only helper class for hashing a piecewise
@@ -115,393 +115,393 @@ class PiecewiseCombiner {
   size_t position_;
 };
 
-// HashStateBase
-//
-// A hash state object represents an intermediate state in the computation
-// of an unspecified hash algorithm. `HashStateBase` provides a CRTP style
-// base class for hash state implementations. Developers adding type support
+// HashStateBase 
+// 
+// A hash state object represents an intermediate state in the computation 
+// of an unspecified hash algorithm. `HashStateBase` provides a CRTP style 
+// base class for hash state implementations. Developers adding type support 
 // for `y_absl::Hash` should not rely on any parts of the state object other than
-// the following member functions:
-//
-//   * HashStateBase::combine()
-//   * HashStateBase::combine_contiguous()
-//
-// A derived hash state class of type `H` must provide a static member function
-// with a signature similar to the following:
-//
-//    `static H combine_contiguous(H state, const unsigned char*, size_t)`.
-//
-// `HashStateBase` will provide a complete implementation for a hash state
-// object in terms of this method.
-//
-// Example:
-//
-//   // Use CRTP to define your derived class.
-//   struct MyHashState : HashStateBase<MyHashState> {
-//       static H combine_contiguous(H state, const unsigned char*, size_t);
-//       using MyHashState::HashStateBase::combine;
-//       using MyHashState::HashStateBase::combine_contiguous;
-//   };
-template <typename H>
-class HashStateBase {
- public:
-  // HashStateBase::combine()
-  //
-  // Combines an arbitrary number of values into a hash state, returning the
-  // updated state.
-  //
-  // Each of the value types `T` must be separately hashable by the Abseil
-  // hashing framework.
-  //
-  // NOTE:
-  //
-  //   state = H::combine(std::move(state), value1, value2, value3);
-  //
-  // is guaranteed to produce the same hash expansion as:
-  //
-  //   state = H::combine(std::move(state), value1);
-  //   state = H::combine(std::move(state), value2);
-  //   state = H::combine(std::move(state), value3);
-  template <typename T, typename... Ts>
-  static H combine(H state, const T& value, const Ts&... values);
-  static H combine(H state) { return state; }
-
-  // HashStateBase::combine_contiguous()
-  //
-  // Combines a contiguous array of `size` elements into a hash state, returning
-  // the updated state.
-  //
-  // NOTE:
-  //
-  //   state = H::combine_contiguous(std::move(state), data, size);
-  //
-  // is NOT guaranteed to produce the same hash expansion as a for-loop (it may
-  // perform internal optimizations).  If you need this guarantee, use the
-  // for-loop instead.
-  template <typename T>
-  static H combine_contiguous(H state, const T* data, size_t size);
-
+// the following member functions: 
+// 
+//   * HashStateBase::combine() 
+//   * HashStateBase::combine_contiguous() 
+// 
+// A derived hash state class of type `H` must provide a static member function 
+// with a signature similar to the following: 
+// 
+//    `static H combine_contiguous(H state, const unsigned char*, size_t)`. 
+// 
+// `HashStateBase` will provide a complete implementation for a hash state 
+// object in terms of this method. 
+// 
+// Example: 
+// 
+//   // Use CRTP to define your derived class. 
+//   struct MyHashState : HashStateBase<MyHashState> { 
+//       static H combine_contiguous(H state, const unsigned char*, size_t); 
+//       using MyHashState::HashStateBase::combine; 
+//       using MyHashState::HashStateBase::combine_contiguous; 
+//   }; 
+template <typename H> 
+class HashStateBase { 
+ public: 
+  // HashStateBase::combine() 
+  // 
+  // Combines an arbitrary number of values into a hash state, returning the 
+  // updated state. 
+  // 
+  // Each of the value types `T` must be separately hashable by the Abseil 
+  // hashing framework. 
+  // 
+  // NOTE: 
+  // 
+  //   state = H::combine(std::move(state), value1, value2, value3); 
+  // 
+  // is guaranteed to produce the same hash expansion as: 
+  // 
+  //   state = H::combine(std::move(state), value1); 
+  //   state = H::combine(std::move(state), value2); 
+  //   state = H::combine(std::move(state), value3); 
+  template <typename T, typename... Ts> 
+  static H combine(H state, const T& value, const Ts&... values); 
+  static H combine(H state) { return state; } 
+ 
+  // HashStateBase::combine_contiguous() 
+  // 
+  // Combines a contiguous array of `size` elements into a hash state, returning 
+  // the updated state. 
+  // 
+  // NOTE: 
+  // 
+  //   state = H::combine_contiguous(std::move(state), data, size); 
+  // 
+  // is NOT guaranteed to produce the same hash expansion as a for-loop (it may 
+  // perform internal optimizations).  If you need this guarantee, use the 
+  // for-loop instead. 
+  template <typename T> 
+  static H combine_contiguous(H state, const T* data, size_t size); 
+ 
   using AbslInternalPiecewiseCombiner = PiecewiseCombiner;
-};
-
-// is_uniquely_represented
-//
-// `is_uniquely_represented<T>` is a trait class that indicates whether `T`
-// is uniquely represented.
-//
-// A type is "uniquely represented" if two equal values of that type are
-// guaranteed to have the same bytes in their underlying storage. In other
-// words, if `a == b`, then `memcmp(&a, &b, sizeof(T))` is guaranteed to be
-// zero. This property cannot be detected automatically, so this trait is false
-// by default, but can be specialized by types that wish to assert that they are
-// uniquely represented. This makes them eligible for certain optimizations.
-//
-// If you have any doubt whatsoever, do not specialize this template.
-// The default is completely safe, and merely disables some optimizations
-// that will not matter for most types. Specializing this template,
-// on the other hand, can be very hazardous.
-//
-// To be uniquely represented, a type must not have multiple ways of
-// representing the same value; for example, float and double are not
-// uniquely represented, because they have distinct representations for
-// +0 and -0. Furthermore, the type's byte representation must consist
-// solely of user-controlled data, with no padding bits and no compiler-
-// controlled data such as vptrs or sanitizer metadata. This is usually
-// very difficult to guarantee, because in most cases the compiler can
-// insert data and padding bits at its own discretion.
-//
-// If you specialize this template for a type `T`, you must do so in the file
-// that defines that type (or in this file). If you define that specialization
-// anywhere else, `is_uniquely_represented<T>` could have different meanings
-// in different places.
-//
-// The Enable parameter is meaningless; it is provided as a convenience,
-// to support certain SFINAE techniques when defining specializations.
-template <typename T, typename Enable = void>
-struct is_uniquely_represented : std::false_type {};
-
-// is_uniquely_represented<unsigned char>
-//
-// unsigned char is a synonym for "byte", so it is guaranteed to be
-// uniquely represented.
-template <>
-struct is_uniquely_represented<unsigned char> : std::true_type {};
-
-// is_uniquely_represented for non-standard integral types
-//
-// Integral types other than bool should be uniquely represented on any
-// platform that this will plausibly be ported to.
-template <typename Integral>
-struct is_uniquely_represented<
-    Integral, typename std::enable_if<std::is_integral<Integral>::value>::type>
-    : std::true_type {};
-
-// is_uniquely_represented<bool>
-//
-//
-template <>
-struct is_uniquely_represented<bool> : std::false_type {};
-
-// hash_bytes()
-//
-// Convenience function that combines `hash_state` with the byte representation
-// of `value`.
-template <typename H, typename T>
-H hash_bytes(H hash_state, const T& value) {
-  const unsigned char* start = reinterpret_cast<const unsigned char*>(&value);
-  return H::combine_contiguous(std::move(hash_state), start, sizeof(value));
-}
-
-// -----------------------------------------------------------------------------
-// AbslHashValue for Basic Types
-// -----------------------------------------------------------------------------
-
-// Note: Default `AbslHashValue` implementations live in `hash_internal`. This
-// allows us to block lexical scope lookup when doing an unqualified call to
-// `AbslHashValue` below. User-defined implementations of `AbslHashValue` can
-// only be found via ADL.
-
-// AbslHashValue() for hashing bool values
-//
-// We use SFINAE to ensure that this overload only accepts bool, not types that
-// are convertible to bool.
-template <typename H, typename B>
-typename std::enable_if<std::is_same<B, bool>::value, H>::type AbslHashValue(
-    H hash_state, B value) {
-  return H::combine(std::move(hash_state),
-                    static_cast<unsigned char>(value ? 1 : 0));
-}
-
-// AbslHashValue() for hashing enum values
-template <typename H, typename Enum>
-typename std::enable_if<std::is_enum<Enum>::value, H>::type AbslHashValue(
-    H hash_state, Enum e) {
-  // In practice, we could almost certainly just invoke hash_bytes directly,
-  // but it's possible that a sanitizer might one day want to
-  // store data in the unused bits of an enum. To avoid that risk, we
-  // convert to the underlying type before hashing. Hopefully this will get
-  // optimized away; if not, we can reopen discussion with c-toolchain-team.
-  return H::combine(std::move(hash_state),
-                    static_cast<typename std::underlying_type<Enum>::type>(e));
-}
-// AbslHashValue() for hashing floating-point values
-template <typename H, typename Float>
-typename std::enable_if<std::is_same<Float, float>::value ||
-                            std::is_same<Float, double>::value,
-                        H>::type
-AbslHashValue(H hash_state, Float value) {
-  return hash_internal::hash_bytes(std::move(hash_state),
-                                   value == 0 ? 0 : value);
-}
-
-// Long double has the property that it might have extra unused bytes in it.
-// For example, in x86 sizeof(long double)==16 but it only really uses 80-bits
-// of it. This means we can't use hash_bytes on a long double and have to
-// convert it to something else first.
-template <typename H, typename LongDouble>
-typename std::enable_if<std::is_same<LongDouble, long double>::value, H>::type
-AbslHashValue(H hash_state, LongDouble value) {
-  const int category = std::fpclassify(value);
-  switch (category) {
-    case FP_INFINITE:
-      // Add the sign bit to differentiate between +Inf and -Inf
-      hash_state = H::combine(std::move(hash_state), std::signbit(value));
-      break;
-
-    case FP_NAN:
-    case FP_ZERO:
-    default:
-      // Category is enough for these.
-      break;
-
-    case FP_NORMAL:
-    case FP_SUBNORMAL:
-      // We can't convert `value` directly to double because this would have
-      // undefined behavior if the value is out of range.
-      // std::frexp gives us a value in the range (-1, -.5] or [.5, 1) that is
-      // guaranteed to be in range for `double`. The truncation is
-      // implementation defined, but that works as long as it is deterministic.
-      int exp;
-      auto mantissa = static_cast<double>(std::frexp(value, &exp));
-      hash_state = H::combine(std::move(hash_state), mantissa, exp);
-  }
-
-  return H::combine(std::move(hash_state), category);
-}
-
-// AbslHashValue() for hashing pointers
-template <typename H, typename T>
-H AbslHashValue(H hash_state, T* ptr) {
-  auto v = reinterpret_cast<uintptr_t>(ptr);
-  // Due to alignment, pointers tend to have low bits as zero, and the next few
-  // bits follow a pattern since they are also multiples of some base value.
-  // Mixing the pointer twice helps prevent stuck low bits for certain alignment
-  // values.
-  return H::combine(std::move(hash_state), v, v);
-}
-
-// AbslHashValue() for hashing nullptr_t
-template <typename H>
-H AbslHashValue(H hash_state, std::nullptr_t) {
-  return H::combine(std::move(hash_state), static_cast<void*>(nullptr));
-}
-
-// -----------------------------------------------------------------------------
-// AbslHashValue for Composite Types
-// -----------------------------------------------------------------------------
-
-// is_hashable()
-//
+}; 
+ 
+// is_uniquely_represented 
+// 
+// `is_uniquely_represented<T>` is a trait class that indicates whether `T` 
+// is uniquely represented. 
+// 
+// A type is "uniquely represented" if two equal values of that type are 
+// guaranteed to have the same bytes in their underlying storage. In other 
+// words, if `a == b`, then `memcmp(&a, &b, sizeof(T))` is guaranteed to be 
+// zero. This property cannot be detected automatically, so this trait is false 
+// by default, but can be specialized by types that wish to assert that they are 
+// uniquely represented. This makes them eligible for certain optimizations. 
+// 
+// If you have any doubt whatsoever, do not specialize this template. 
+// The default is completely safe, and merely disables some optimizations 
+// that will not matter for most types. Specializing this template, 
+// on the other hand, can be very hazardous. 
+// 
+// To be uniquely represented, a type must not have multiple ways of 
+// representing the same value; for example, float and double are not 
+// uniquely represented, because they have distinct representations for 
+// +0 and -0. Furthermore, the type's byte representation must consist 
+// solely of user-controlled data, with no padding bits and no compiler- 
+// controlled data such as vptrs or sanitizer metadata. This is usually 
+// very difficult to guarantee, because in most cases the compiler can 
+// insert data and padding bits at its own discretion. 
+// 
+// If you specialize this template for a type `T`, you must do so in the file 
+// that defines that type (or in this file). If you define that specialization 
+// anywhere else, `is_uniquely_represented<T>` could have different meanings 
+// in different places. 
+// 
+// The Enable parameter is meaningless; it is provided as a convenience, 
+// to support certain SFINAE techniques when defining specializations. 
+template <typename T, typename Enable = void> 
+struct is_uniquely_represented : std::false_type {}; 
+ 
+// is_uniquely_represented<unsigned char> 
+// 
+// unsigned char is a synonym for "byte", so it is guaranteed to be 
+// uniquely represented. 
+template <> 
+struct is_uniquely_represented<unsigned char> : std::true_type {}; 
+ 
+// is_uniquely_represented for non-standard integral types 
+// 
+// Integral types other than bool should be uniquely represented on any 
+// platform that this will plausibly be ported to. 
+template <typename Integral> 
+struct is_uniquely_represented< 
+    Integral, typename std::enable_if<std::is_integral<Integral>::value>::type> 
+    : std::true_type {}; 
+ 
+// is_uniquely_represented<bool> 
+// 
+// 
+template <> 
+struct is_uniquely_represented<bool> : std::false_type {}; 
+ 
+// hash_bytes() 
+// 
+// Convenience function that combines `hash_state` with the byte representation 
+// of `value`. 
+template <typename H, typename T> 
+H hash_bytes(H hash_state, const T& value) { 
+  const unsigned char* start = reinterpret_cast<const unsigned char*>(&value); 
+  return H::combine_contiguous(std::move(hash_state), start, sizeof(value)); 
+} 
+ 
+// ----------------------------------------------------------------------------- 
+// AbslHashValue for Basic Types 
+// ----------------------------------------------------------------------------- 
+ 
+// Note: Default `AbslHashValue` implementations live in `hash_internal`. This 
+// allows us to block lexical scope lookup when doing an unqualified call to 
+// `AbslHashValue` below. User-defined implementations of `AbslHashValue` can 
+// only be found via ADL. 
+ 
+// AbslHashValue() for hashing bool values 
+// 
+// We use SFINAE to ensure that this overload only accepts bool, not types that 
+// are convertible to bool. 
+template <typename H, typename B> 
+typename std::enable_if<std::is_same<B, bool>::value, H>::type AbslHashValue( 
+    H hash_state, B value) { 
+  return H::combine(std::move(hash_state), 
+                    static_cast<unsigned char>(value ? 1 : 0)); 
+} 
+ 
+// AbslHashValue() for hashing enum values 
+template <typename H, typename Enum> 
+typename std::enable_if<std::is_enum<Enum>::value, H>::type AbslHashValue( 
+    H hash_state, Enum e) { 
+  // In practice, we could almost certainly just invoke hash_bytes directly, 
+  // but it's possible that a sanitizer might one day want to 
+  // store data in the unused bits of an enum. To avoid that risk, we 
+  // convert to the underlying type before hashing. Hopefully this will get 
+  // optimized away; if not, we can reopen discussion with c-toolchain-team. 
+  return H::combine(std::move(hash_state), 
+                    static_cast<typename std::underlying_type<Enum>::type>(e)); 
+} 
+// AbslHashValue() for hashing floating-point values 
+template <typename H, typename Float> 
+typename std::enable_if<std::is_same<Float, float>::value || 
+                            std::is_same<Float, double>::value, 
+                        H>::type 
+AbslHashValue(H hash_state, Float value) { 
+  return hash_internal::hash_bytes(std::move(hash_state), 
+                                   value == 0 ? 0 : value); 
+} 
+ 
+// Long double has the property that it might have extra unused bytes in it. 
+// For example, in x86 sizeof(long double)==16 but it only really uses 80-bits 
+// of it. This means we can't use hash_bytes on a long double and have to 
+// convert it to something else first. 
+template <typename H, typename LongDouble> 
+typename std::enable_if<std::is_same<LongDouble, long double>::value, H>::type 
+AbslHashValue(H hash_state, LongDouble value) { 
+  const int category = std::fpclassify(value); 
+  switch (category) { 
+    case FP_INFINITE: 
+      // Add the sign bit to differentiate between +Inf and -Inf 
+      hash_state = H::combine(std::move(hash_state), std::signbit(value)); 
+      break; 
+ 
+    case FP_NAN: 
+    case FP_ZERO: 
+    default: 
+      // Category is enough for these. 
+      break; 
+ 
+    case FP_NORMAL: 
+    case FP_SUBNORMAL: 
+      // We can't convert `value` directly to double because this would have 
+      // undefined behavior if the value is out of range. 
+      // std::frexp gives us a value in the range (-1, -.5] or [.5, 1) that is 
+      // guaranteed to be in range for `double`. The truncation is 
+      // implementation defined, but that works as long as it is deterministic. 
+      int exp; 
+      auto mantissa = static_cast<double>(std::frexp(value, &exp)); 
+      hash_state = H::combine(std::move(hash_state), mantissa, exp); 
+  } 
+ 
+  return H::combine(std::move(hash_state), category); 
+} 
+ 
+// AbslHashValue() for hashing pointers 
+template <typename H, typename T> 
+H AbslHashValue(H hash_state, T* ptr) { 
+  auto v = reinterpret_cast<uintptr_t>(ptr); 
+  // Due to alignment, pointers tend to have low bits as zero, and the next few 
+  // bits follow a pattern since they are also multiples of some base value. 
+  // Mixing the pointer twice helps prevent stuck low bits for certain alignment 
+  // values. 
+  return H::combine(std::move(hash_state), v, v); 
+} 
+ 
+// AbslHashValue() for hashing nullptr_t 
+template <typename H> 
+H AbslHashValue(H hash_state, std::nullptr_t) { 
+  return H::combine(std::move(hash_state), static_cast<void*>(nullptr)); 
+} 
+ 
+// ----------------------------------------------------------------------------- 
+// AbslHashValue for Composite Types 
+// ----------------------------------------------------------------------------- 
+ 
+// is_hashable() 
+// 
 // Trait class which returns true if T is hashable by the y_absl::Hash framework.
-// Used for the AbslHashValue implementations for composite types below.
-template <typename T>
-struct is_hashable;
-
-// AbslHashValue() for hashing pairs
-template <typename H, typename T1, typename T2>
-typename std::enable_if<is_hashable<T1>::value && is_hashable<T2>::value,
-                        H>::type
-AbslHashValue(H hash_state, const std::pair<T1, T2>& p) {
-  return H::combine(std::move(hash_state), p.first, p.second);
-}
-
-// hash_tuple()
-//
-// Helper function for hashing a tuple. The third argument should
-// be an index_sequence running from 0 to tuple_size<Tuple> - 1.
-template <typename H, typename Tuple, size_t... Is>
+// Used for the AbslHashValue implementations for composite types below. 
+template <typename T> 
+struct is_hashable; 
+ 
+// AbslHashValue() for hashing pairs 
+template <typename H, typename T1, typename T2> 
+typename std::enable_if<is_hashable<T1>::value && is_hashable<T2>::value, 
+                        H>::type 
+AbslHashValue(H hash_state, const std::pair<T1, T2>& p) { 
+  return H::combine(std::move(hash_state), p.first, p.second); 
+} 
+ 
+// hash_tuple() 
+// 
+// Helper function for hashing a tuple. The third argument should 
+// be an index_sequence running from 0 to tuple_size<Tuple> - 1. 
+template <typename H, typename Tuple, size_t... Is> 
 H hash_tuple(H hash_state, const Tuple& t, y_absl::index_sequence<Is...>) {
-  return H::combine(std::move(hash_state), std::get<Is>(t)...);
-}
-
-// AbslHashValue for hashing tuples
-template <typename H, typename... Ts>
-#if defined(_MSC_VER)
-// This SFINAE gets MSVC confused under some conditions. Let's just disable it
-// for now.
-H
+  return H::combine(std::move(hash_state), std::get<Is>(t)...); 
+} 
+ 
+// AbslHashValue for hashing tuples 
+template <typename H, typename... Ts> 
+#if defined(_MSC_VER) 
+// This SFINAE gets MSVC confused under some conditions. Let's just disable it 
+// for now. 
+H 
 #else   // _MSC_VER
 typename std::enable_if<y_absl::conjunction<is_hashable<Ts>...>::value, H>::type
-#endif  // _MSC_VER
-AbslHashValue(H hash_state, const std::tuple<Ts...>& t) {
-  return hash_internal::hash_tuple(std::move(hash_state), t,
+#endif  // _MSC_VER 
+AbslHashValue(H hash_state, const std::tuple<Ts...>& t) { 
+  return hash_internal::hash_tuple(std::move(hash_state), t, 
                                    y_absl::make_index_sequence<sizeof...(Ts)>());
-}
-
-// -----------------------------------------------------------------------------
-// AbslHashValue for Pointers
-// -----------------------------------------------------------------------------
-
-// AbslHashValue for hashing unique_ptr
-template <typename H, typename T, typename D>
-H AbslHashValue(H hash_state, const std::unique_ptr<T, D>& ptr) {
-  return H::combine(std::move(hash_state), ptr.get());
-}
-
-// AbslHashValue for hashing shared_ptr
-template <typename H, typename T>
-H AbslHashValue(H hash_state, const std::shared_ptr<T>& ptr) {
-  return H::combine(std::move(hash_state), ptr.get());
-}
-
-// -----------------------------------------------------------------------------
-// AbslHashValue for String-Like Types
-// -----------------------------------------------------------------------------
-
-// AbslHashValue for hashing strings
-//
-// All the string-like types supported here provide the same hash expansion for
-// the same character sequence. These types are:
-//
+} 
+ 
+// ----------------------------------------------------------------------------- 
+// AbslHashValue for Pointers 
+// ----------------------------------------------------------------------------- 
+ 
+// AbslHashValue for hashing unique_ptr 
+template <typename H, typename T, typename D> 
+H AbslHashValue(H hash_state, const std::unique_ptr<T, D>& ptr) { 
+  return H::combine(std::move(hash_state), ptr.get()); 
+} 
+ 
+// AbslHashValue for hashing shared_ptr 
+template <typename H, typename T> 
+H AbslHashValue(H hash_state, const std::shared_ptr<T>& ptr) { 
+  return H::combine(std::move(hash_state), ptr.get()); 
+} 
+ 
+// ----------------------------------------------------------------------------- 
+// AbslHashValue for String-Like Types 
+// ----------------------------------------------------------------------------- 
+ 
+// AbslHashValue for hashing strings 
+// 
+// All the string-like types supported here provide the same hash expansion for 
+// the same character sequence. These types are: 
+// 
 //  - `y_absl::Cord`
 //  - `TString` (and std::basic_string<char, std::char_traits<char>, A> for
-//      any allocator A)
+//      any allocator A) 
 //  - `y_absl::string_view` and `std::string_view`
-//
-// For simplicity, we currently support only `char` strings. This support may
-// be broadened, if necessary, but with some caution - this overload would
-// misbehave in cases where the traits' `eq()` member isn't equivalent to `==`
-// on the underlying character type.
-template <typename H>
+// 
+// For simplicity, we currently support only `char` strings. This support may 
+// be broadened, if necessary, but with some caution - this overload would 
+// misbehave in cases where the traits' `eq()` member isn't equivalent to `==` 
+// on the underlying character type. 
+template <typename H> 
 H AbslHashValue(H hash_state, y_absl::string_view str) {
-  return H::combine(
-      H::combine_contiguous(std::move(hash_state), str.data(), str.size()),
-      str.size());
-}
-
-// Support std::wstring, std::u16string and std::u32string.
-template <typename Char, typename Alloc, typename H,
+  return H::combine( 
+      H::combine_contiguous(std::move(hash_state), str.data(), str.size()), 
+      str.size()); 
+} 
+ 
+// Support std::wstring, std::u16string and std::u32string. 
+template <typename Char, typename Alloc, typename H, 
           typename = y_absl::enable_if_t<std::is_same<Char, wchar_t>::value ||
-                                       std::is_same<Char, char16_t>::value ||
-                                       std::is_same<Char, char32_t>::value>>
-H AbslHashValue(
-    H hash_state,
-    const std::basic_string<Char, std::char_traits<Char>, Alloc>& str) {
-  return H::combine(
-      H::combine_contiguous(std::move(hash_state), str.data(), str.size()),
-      str.size());
-}
-
-// -----------------------------------------------------------------------------
-// AbslHashValue for Sequence Containers
-// -----------------------------------------------------------------------------
-
-// AbslHashValue for hashing std::array
-template <typename H, typename T, size_t N>
-typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
-    H hash_state, const std::array<T, N>& array) {
-  return H::combine_contiguous(std::move(hash_state), array.data(),
-                               array.size());
-}
-
-// AbslHashValue for hashing std::deque
-template <typename H, typename T, typename Allocator>
-typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
-    H hash_state, const std::deque<T, Allocator>& deque) {
-  // TODO(gromer): investigate a more efficient implementation taking
-  // advantage of the chunk structure.
-  for (const auto& t : deque) {
-    hash_state = H::combine(std::move(hash_state), t);
-  }
-  return H::combine(std::move(hash_state), deque.size());
-}
-
-// AbslHashValue for hashing std::forward_list
-template <typename H, typename T, typename Allocator>
-typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
-    H hash_state, const std::forward_list<T, Allocator>& list) {
-  size_t size = 0;
-  for (const T& t : list) {
-    hash_state = H::combine(std::move(hash_state), t);
-    ++size;
-  }
-  return H::combine(std::move(hash_state), size);
-}
-
-// AbslHashValue for hashing std::list
-template <typename H, typename T, typename Allocator>
-typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
-    H hash_state, const std::list<T, Allocator>& list) {
-  for (const auto& t : list) {
-    hash_state = H::combine(std::move(hash_state), t);
-  }
-  return H::combine(std::move(hash_state), list.size());
-}
-
-// AbslHashValue for hashing std::vector
-//
+                                       std::is_same<Char, char16_t>::value || 
+                                       std::is_same<Char, char32_t>::value>> 
+H AbslHashValue( 
+    H hash_state, 
+    const std::basic_string<Char, std::char_traits<Char>, Alloc>& str) { 
+  return H::combine( 
+      H::combine_contiguous(std::move(hash_state), str.data(), str.size()), 
+      str.size()); 
+} 
+ 
+// ----------------------------------------------------------------------------- 
+// AbslHashValue for Sequence Containers 
+// ----------------------------------------------------------------------------- 
+ 
+// AbslHashValue for hashing std::array 
+template <typename H, typename T, size_t N> 
+typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue( 
+    H hash_state, const std::array<T, N>& array) { 
+  return H::combine_contiguous(std::move(hash_state), array.data(), 
+                               array.size()); 
+} 
+ 
+// AbslHashValue for hashing std::deque 
+template <typename H, typename T, typename Allocator> 
+typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue( 
+    H hash_state, const std::deque<T, Allocator>& deque) { 
+  // TODO(gromer): investigate a more efficient implementation taking 
+  // advantage of the chunk structure. 
+  for (const auto& t : deque) { 
+    hash_state = H::combine(std::move(hash_state), t); 
+  } 
+  return H::combine(std::move(hash_state), deque.size()); 
+} 
+ 
+// AbslHashValue for hashing std::forward_list 
+template <typename H, typename T, typename Allocator> 
+typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue( 
+    H hash_state, const std::forward_list<T, Allocator>& list) { 
+  size_t size = 0; 
+  for (const T& t : list) { 
+    hash_state = H::combine(std::move(hash_state), t); 
+    ++size; 
+  } 
+  return H::combine(std::move(hash_state), size); 
+} 
+ 
+// AbslHashValue for hashing std::list 
+template <typename H, typename T, typename Allocator> 
+typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue( 
+    H hash_state, const std::list<T, Allocator>& list) { 
+  for (const auto& t : list) { 
+    hash_state = H::combine(std::move(hash_state), t); 
+  } 
+  return H::combine(std::move(hash_state), list.size()); 
+} 
+ 
+// AbslHashValue for hashing std::vector 
+// 
 // Do not use this for vector<bool> on platforms that have a working
 // implementation of std::hash. It does not have a .data(), and a fallback for
 // std::hash<> is most likely faster.
-template <typename H, typename T, typename Allocator>
-typename std::enable_if<is_hashable<T>::value && !std::is_same<T, bool>::value,
-                        H>::type
-AbslHashValue(H hash_state, const std::vector<T, Allocator>& vector) {
-  return H::combine(H::combine_contiguous(std::move(hash_state), vector.data(),
-                                          vector.size()),
-                    vector.size());
-}
-
+template <typename H, typename T, typename Allocator> 
+typename std::enable_if<is_hashable<T>::value && !std::is_same<T, bool>::value, 
+                        H>::type 
+AbslHashValue(H hash_state, const std::vector<T, Allocator>& vector) { 
+  return H::combine(H::combine_contiguous(std::move(hash_state), vector.data(), 
+                                          vector.size()), 
+                    vector.size()); 
+} 
+ 
 #if defined(ABSL_IS_BIG_ENDIAN) && \
     (defined(__GLIBCXX__) || defined(__GLIBCPP__))
 // AbslHashValue for hashing std::vector<bool>
@@ -523,59 +523,59 @@ AbslHashValue(H hash_state, const std::vector<T, Allocator>& vector) {
 }
 #endif
 
-// -----------------------------------------------------------------------------
-// AbslHashValue for Ordered Associative Containers
-// -----------------------------------------------------------------------------
-
-// AbslHashValue for hashing std::map
-template <typename H, typename Key, typename T, typename Compare,
-          typename Allocator>
-typename std::enable_if<is_hashable<Key>::value && is_hashable<T>::value,
-                        H>::type
-AbslHashValue(H hash_state, const std::map<Key, T, Compare, Allocator>& map) {
-  for (const auto& t : map) {
-    hash_state = H::combine(std::move(hash_state), t);
-  }
-  return H::combine(std::move(hash_state), map.size());
-}
-
-// AbslHashValue for hashing std::multimap
-template <typename H, typename Key, typename T, typename Compare,
-          typename Allocator>
-typename std::enable_if<is_hashable<Key>::value && is_hashable<T>::value,
-                        H>::type
-AbslHashValue(H hash_state,
-              const std::multimap<Key, T, Compare, Allocator>& map) {
-  for (const auto& t : map) {
-    hash_state = H::combine(std::move(hash_state), t);
-  }
-  return H::combine(std::move(hash_state), map.size());
-}
-
-// AbslHashValue for hashing std::set
-template <typename H, typename Key, typename Compare, typename Allocator>
-typename std::enable_if<is_hashable<Key>::value, H>::type AbslHashValue(
-    H hash_state, const std::set<Key, Compare, Allocator>& set) {
-  for (const auto& t : set) {
-    hash_state = H::combine(std::move(hash_state), t);
-  }
-  return H::combine(std::move(hash_state), set.size());
-}
-
-// AbslHashValue for hashing std::multiset
-template <typename H, typename Key, typename Compare, typename Allocator>
-typename std::enable_if<is_hashable<Key>::value, H>::type AbslHashValue(
-    H hash_state, const std::multiset<Key, Compare, Allocator>& set) {
-  for (const auto& t : set) {
-    hash_state = H::combine(std::move(hash_state), t);
-  }
-  return H::combine(std::move(hash_state), set.size());
-}
-
-// -----------------------------------------------------------------------------
-// AbslHashValue for Wrapper Types
-// -----------------------------------------------------------------------------
-
+// ----------------------------------------------------------------------------- 
+// AbslHashValue for Ordered Associative Containers 
+// ----------------------------------------------------------------------------- 
+ 
+// AbslHashValue for hashing std::map 
+template <typename H, typename Key, typename T, typename Compare, 
+          typename Allocator> 
+typename std::enable_if<is_hashable<Key>::value && is_hashable<T>::value, 
+                        H>::type 
+AbslHashValue(H hash_state, const std::map<Key, T, Compare, Allocator>& map) { 
+  for (const auto& t : map) { 
+    hash_state = H::combine(std::move(hash_state), t); 
+  } 
+  return H::combine(std::move(hash_state), map.size()); 
+} 
+ 
+// AbslHashValue for hashing std::multimap 
+template <typename H, typename Key, typename T, typename Compare, 
+          typename Allocator> 
+typename std::enable_if<is_hashable<Key>::value && is_hashable<T>::value, 
+                        H>::type 
+AbslHashValue(H hash_state, 
+              const std::multimap<Key, T, Compare, Allocator>& map) { 
+  for (const auto& t : map) { 
+    hash_state = H::combine(std::move(hash_state), t); 
+  } 
+  return H::combine(std::move(hash_state), map.size()); 
+} 
+ 
+// AbslHashValue for hashing std::set 
+template <typename H, typename Key, typename Compare, typename Allocator> 
+typename std::enable_if<is_hashable<Key>::value, H>::type AbslHashValue( 
+    H hash_state, const std::set<Key, Compare, Allocator>& set) { 
+  for (const auto& t : set) { 
+    hash_state = H::combine(std::move(hash_state), t); 
+  } 
+  return H::combine(std::move(hash_state), set.size()); 
+} 
+ 
+// AbslHashValue for hashing std::multiset 
+template <typename H, typename Key, typename Compare, typename Allocator> 
+typename std::enable_if<is_hashable<Key>::value, H>::type AbslHashValue( 
+    H hash_state, const std::multiset<Key, Compare, Allocator>& set) { 
+  for (const auto& t : set) { 
+    hash_state = H::combine(std::move(hash_state), t); 
+  } 
+  return H::combine(std::move(hash_state), set.size()); 
+} 
+ 
+// ----------------------------------------------------------------------------- 
+// AbslHashValue for Wrapper Types 
+// ----------------------------------------------------------------------------- 
+ 
 // AbslHashValue for hashing std::reference_wrapper
 template <typename H, typename T>
 typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
@@ -584,42 +584,42 @@ typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
 }
 
 // AbslHashValue for hashing y_absl::optional
-template <typename H, typename T>
-typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
+template <typename H, typename T> 
+typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue( 
     H hash_state, const y_absl::optional<T>& opt) {
-  if (opt) hash_state = H::combine(std::move(hash_state), *opt);
-  return H::combine(std::move(hash_state), opt.has_value());
-}
-
-// VariantVisitor
-template <typename H>
-struct VariantVisitor {
-  H&& hash_state;
-  template <typename T>
-  H operator()(const T& t) const {
-    return H::combine(std::move(hash_state), t);
-  }
-};
-
+  if (opt) hash_state = H::combine(std::move(hash_state), *opt); 
+  return H::combine(std::move(hash_state), opt.has_value()); 
+} 
+ 
+// VariantVisitor 
+template <typename H> 
+struct VariantVisitor { 
+  H&& hash_state; 
+  template <typename T> 
+  H operator()(const T& t) const { 
+    return H::combine(std::move(hash_state), t); 
+  } 
+}; 
+ 
 // AbslHashValue for hashing y_absl::variant
-template <typename H, typename... T>
-typename std::enable_if<conjunction<is_hashable<T>...>::value, H>::type
+template <typename H, typename... T> 
+typename std::enable_if<conjunction<is_hashable<T>...>::value, H>::type 
 AbslHashValue(H hash_state, const y_absl::variant<T...>& v) {
-  if (!v.valueless_by_exception()) {
+  if (!v.valueless_by_exception()) { 
     hash_state = y_absl::visit(VariantVisitor<H>{std::move(hash_state)}, v);
-  }
-  return H::combine(std::move(hash_state), v.index());
-}
-
-// -----------------------------------------------------------------------------
-// AbslHashValue for Other Types
-// -----------------------------------------------------------------------------
-
+  } 
+  return H::combine(std::move(hash_state), v.index()); 
+} 
+ 
+// ----------------------------------------------------------------------------- 
+// AbslHashValue for Other Types 
+// ----------------------------------------------------------------------------- 
+ 
 // AbslHashValue for hashing std::bitset is not defined on Little Endian
 // platforms, for the same reason as for vector<bool> (see std::vector above):
 // It does not expose the raw bytes, and a fallback to std::hash<> is most
 // likely faster.
-
+ 
 #if defined(ABSL_IS_BIG_ENDIAN) && \
     (defined(__GLIBCXX__) || defined(__GLIBCPP__))
 // AbslHashValue for hashing std::bitset
@@ -638,219 +638,219 @@ H AbslHashValue(H hash_state, const std::bitset<N>& set) {
 }
 #endif
 
-// -----------------------------------------------------------------------------
-
-// hash_range_or_bytes()
-//
-// Mixes all values in the range [data, data+size) into the hash state.
-// This overload accepts only uniquely-represented types, and hashes them by
-// hashing the entire range of bytes.
-template <typename H, typename T>
-typename std::enable_if<is_uniquely_represented<T>::value, H>::type
-hash_range_or_bytes(H hash_state, const T* data, size_t size) {
-  const auto* bytes = reinterpret_cast<const unsigned char*>(data);
-  return H::combine_contiguous(std::move(hash_state), bytes, sizeof(T) * size);
-}
-
-// hash_range_or_bytes()
-template <typename H, typename T>
-typename std::enable_if<!is_uniquely_represented<T>::value, H>::type
-hash_range_or_bytes(H hash_state, const T* data, size_t size) {
-  for (const auto end = data + size; data < end; ++data) {
-    hash_state = H::combine(std::move(hash_state), *data);
-  }
-  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
-#else
-#define ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_ 0
-#endif
-
-// HashSelect
-//
-// Type trait to select the appropriate hash implementation to use.
-// HashSelect::type<T> will give the proper hash implementation, to be invoked
-// as:
-//   HashSelect::type<T>::Invoke(state, value)
-// Also, HashSelect::type<T>::value is a boolean equal to `true` if there is a
-// valid `Invoke` function. Types that are not hashable will have a ::value of
-// `false`.
-struct HashSelect {
- private:
-  struct State : HashStateBase<State> {
-    static State combine_contiguous(State hash_state, const unsigned char*,
-                                    size_t);
-    using State::HashStateBase::combine_contiguous;
-  };
-
-  struct UniquelyRepresentedProbe {
-    template <typename H, typename T>
-    static auto Invoke(H state, const T& value)
+// ----------------------------------------------------------------------------- 
+ 
+// hash_range_or_bytes() 
+// 
+// Mixes all values in the range [data, data+size) into the hash state. 
+// This overload accepts only uniquely-represented types, and hashes them by 
+// hashing the entire range of bytes. 
+template <typename H, typename T> 
+typename std::enable_if<is_uniquely_represented<T>::value, H>::type 
+hash_range_or_bytes(H hash_state, const T* data, size_t size) { 
+  const auto* bytes = reinterpret_cast<const unsigned char*>(data); 
+  return H::combine_contiguous(std::move(hash_state), bytes, sizeof(T) * size); 
+} 
+ 
+// hash_range_or_bytes() 
+template <typename H, typename T> 
+typename std::enable_if<!is_uniquely_represented<T>::value, H>::type 
+hash_range_or_bytes(H hash_state, const T* data, size_t size) { 
+  for (const auto end = data + size; data < end; ++data) { 
+    hash_state = H::combine(std::move(hash_state), *data); 
+  } 
+  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 
+#else 
+#define ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_ 0 
+#endif 
+ 
+// HashSelect 
+// 
+// Type trait to select the appropriate hash implementation to use. 
+// HashSelect::type<T> will give the proper hash implementation, to be invoked 
+// as: 
+//   HashSelect::type<T>::Invoke(state, value) 
+// Also, HashSelect::type<T>::value is a boolean equal to `true` if there is a 
+// valid `Invoke` function. Types that are not hashable will have a ::value of 
+// `false`. 
+struct HashSelect { 
+ private: 
+  struct State : HashStateBase<State> { 
+    static State combine_contiguous(State hash_state, const unsigned char*, 
+                                    size_t); 
+    using State::HashStateBase::combine_contiguous; 
+  }; 
+ 
+  struct UniquelyRepresentedProbe { 
+    template <typename H, typename T> 
+    static auto Invoke(H state, const T& value) 
         -> y_absl::enable_if_t<is_uniquely_represented<T>::value, H> {
-      return hash_internal::hash_bytes(std::move(state), value);
-    }
-  };
-
-  struct HashValueProbe {
-    template <typename H, typename T>
+      return hash_internal::hash_bytes(std::move(state), value); 
+    } 
+  }; 
+ 
+  struct HashValueProbe { 
+    template <typename H, typename T> 
     static auto Invoke(H state, const T& value) -> y_absl::enable_if_t<
-        std::is_same<H,
-                     decltype(AbslHashValue(std::move(state), value))>::value,
-        H> {
-      return AbslHashValue(std::move(state), value);
-    }
-  };
-
-  struct LegacyHashProbe {
-#if ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_
-    template <typename H, typename T>
+        std::is_same<H, 
+                     decltype(AbslHashValue(std::move(state), value))>::value, 
+        H> { 
+      return AbslHashValue(std::move(state), value); 
+    } 
+  }; 
+ 
+  struct LegacyHashProbe { 
+#if 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)),
-            size_t>::value,
-        H> {
-      return hash_internal::hash_bytes(
-          std::move(state),
-          ABSL_INTERNAL_LEGACY_HASH_NAMESPACE::hash<T>{}(value));
-    }
-#endif  // ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_
-  };
-
-  struct StdHashProbe {
-    template <typename H, typename T>
-    static auto Invoke(H state, const T& value)
+        std::is_convertible< 
+            decltype(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)); 
+    } 
+#endif  // ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_ 
+  }; 
+ 
+  struct StdHashProbe { 
+    template <typename H, typename T> 
+    static auto Invoke(H state, const T& value) 
         -> y_absl::enable_if_t<type_traits_internal::IsHashable<T>::value, H> {
-      return hash_internal::hash_bytes(std::move(state), std::hash<T>{}(value));
-    }
-  };
-
-  template <typename Hash, typename T>
-  struct Probe : Hash {
-   private:
-    template <typename H, typename = decltype(H::Invoke(
-                              std::declval<State>(), std::declval<const T&>()))>
-    static std::true_type Test(int);
-    template <typename U>
-    static std::false_type Test(char);
-
-   public:
-    static constexpr bool value = decltype(Test<Hash>(0))::value;
-  };
-
- public:
-  // Probe each implementation in order.
-  // disjunction provides short circuiting wrt instantiation.
-  template <typename T>
+      return hash_internal::hash_bytes(std::move(state), std::hash<T>{}(value)); 
+    } 
+  }; 
+ 
+  template <typename Hash, typename T> 
+  struct Probe : Hash { 
+   private: 
+    template <typename H, typename = decltype(H::Invoke( 
+                              std::declval<State>(), std::declval<const T&>()))> 
+    static std::true_type Test(int); 
+    template <typename U> 
+    static std::false_type Test(char); 
+ 
+   public: 
+    static constexpr bool value = decltype(Test<Hash>(0))::value; 
+  }; 
+ 
+ public: 
+  // Probe each implementation in order. 
+  // disjunction provides short circuiting wrt instantiation. 
+  template <typename T> 
   using Apply = y_absl::disjunction<         //
-      Probe<UniquelyRepresentedProbe, T>,  //
-      Probe<HashValueProbe, T>,            //
-      Probe<LegacyHashProbe, T>,           //
-      Probe<StdHashProbe, T>,              //
-      std::false_type>;
-};
-
-template <typename T>
-struct is_hashable
-    : std::integral_constant<bool, HashSelect::template Apply<T>::value> {};
-
+      Probe<UniquelyRepresentedProbe, T>,  // 
+      Probe<HashValueProbe, T>,            // 
+      Probe<LegacyHashProbe, T>,           // 
+      Probe<StdHashProbe, T>,              // 
+      std::false_type>; 
+}; 
+ 
+template <typename T> 
+struct is_hashable 
+    : std::integral_constant<bool, HashSelect::template Apply<T>::value> {}; 
+ 
 // MixingHashState
 class 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
-  using uint128 = __uint128_t;
-#else   // ABSL_HAVE_INTRINSIC_INT128
+  // We use the intrinsic when available to improve performance. 
+#ifdef ABSL_HAVE_INTRINSIC_INT128 
+  using uint128 = __uint128_t; 
+#else   // ABSL_HAVE_INTRINSIC_INT128 
   using uint128 = y_absl::uint128;
-#endif  // ABSL_HAVE_INTRINSIC_INT128
-
-  static constexpr uint64_t kMul =
-      sizeof(size_t) == 4 ? uint64_t{0xcc9e2d51}
-                          : uint64_t{0x9ddfea08eb382d69};
-
-  template <typename T>
-  using IntegralFastPath =
-      conjunction<std::is_integral<T>, is_uniquely_represented<T>>;
-
- public:
-  // Move only
+#endif  // ABSL_HAVE_INTRINSIC_INT128 
+ 
+  static constexpr uint64_t kMul = 
+      sizeof(size_t) == 4 ? uint64_t{0xcc9e2d51} 
+                          : uint64_t{0x9ddfea08eb382d69}; 
+ 
+  template <typename T> 
+  using IntegralFastPath = 
+      conjunction<std::is_integral<T>, is_uniquely_represented<T>>; 
+ 
+ public: 
+  // Move only 
   MixingHashState(MixingHashState&&) = default;
   MixingHashState& operator=(MixingHashState&&) = default;
-
+ 
   // MixingHashState::combine_contiguous()
-  //
-  // Fundamental base case for hash recursion: mixes the given range of bytes
-  // into the hash state.
+  // 
+  // Fundamental base case for hash recursion: mixes the given range of bytes 
+  // into the hash state. 
   static MixingHashState combine_contiguous(MixingHashState hash_state,
                                             const unsigned char* first,
                                             size_t size) {
     return MixingHashState(
-        CombineContiguousImpl(hash_state.state_, first, size,
-                              std::integral_constant<int, sizeof(size_t)>{}));
-  }
+        CombineContiguousImpl(hash_state.state_, first, size, 
+                              std::integral_constant<int, sizeof(size_t)>{})); 
+  } 
   using MixingHashState::HashStateBase::combine_contiguous;
-
+ 
   // MixingHashState::hash()
-  //
-  // For performance reasons in non-opt mode, we specialize this for
-  // integral types.
-  // Otherwise we would be instantiating and calling dozens of functions for
-  // something that is just one multiplication and a couple xor's.
-  // The result should be the same as running the whole algorithm, but faster.
+  // 
+  // For performance reasons in non-opt mode, we specialize this for 
+  // integral types. 
+  // Otherwise we would be instantiating and calling dozens of functions for 
+  // something that is just one multiplication and a couple xor's. 
+  // The result should be the same as running the whole algorithm, but faster. 
   template <typename T, y_absl::enable_if_t<IntegralFastPath<T>::value, int> = 0>
-  static size_t hash(T value) {
-    return static_cast<size_t>(Mix(Seed(), static_cast<uint64_t>(value)));
-  }
-
+  static size_t hash(T value) { 
+    return static_cast<size_t>(Mix(Seed(), static_cast<uint64_t>(value))); 
+  } 
+ 
   // Overload of MixingHashState::hash()
   template <typename T, y_absl::enable_if_t<!IntegralFastPath<T>::value, int> = 0>
-  static size_t hash(const T& value) {
+  static size_t hash(const T& value) { 
     return static_cast<size_t>(combine(MixingHashState{}, value).state_);
-  }
-
- private:
-  // Invoked only once for a given argument; that plus the fact that this is
-  // move-only ensures that there is only one non-moved-from object.
+  } 
+ 
+ private: 
+  // Invoked only once for a given argument; that plus the fact that this is 
+  // move-only ensures that there is only one non-moved-from object. 
   MixingHashState() : state_(Seed()) {}
-
-  // Workaround for MSVC bug.
-  // We make the type copyable to fix the calling convention, even though we
-  // never actually copy it. Keep it private to not affect the public API of the
-  // type.
+ 
+  // Workaround for MSVC bug. 
+  // We make the type copyable to fix the calling convention, even though we 
+  // never actually copy it. Keep it private to not affect the public API of the 
+  // type. 
   MixingHashState(const MixingHashState&) = default;
-
+ 
   explicit MixingHashState(uint64_t state) : state_(state) {}
-
-  // Implementation of the base case for combine_contiguous where we actually
-  // mix the bytes into the state.
-  // Dispatch to different implementations of the combine_contiguous depending
-  // on the value of `sizeof(size_t)`.
-  static uint64_t CombineContiguousImpl(uint64_t state,
-                                        const unsigned char* first, size_t len,
-                                        std::integral_constant<int, 4>
+ 
+  // Implementation of the base case for combine_contiguous where we actually 
+  // mix the bytes into the state. 
+  // Dispatch to different implementations of the combine_contiguous depending 
+  // on the value of `sizeof(size_t)`. 
+  static uint64_t CombineContiguousImpl(uint64_t state, 
+                                        const unsigned char* first, size_t len, 
+                                        std::integral_constant<int, 4> 
+                                        /* sizeof_size_t */); 
+  static uint64_t CombineContiguousImpl(uint64_t state, 
+                                        const unsigned char* first, size_t len, 
+                                        std::integral_constant<int, 8> 
                                         /* sizeof_size_t */);
-  static uint64_t CombineContiguousImpl(uint64_t state,
-                                        const unsigned char* first, size_t len,
-                                        std::integral_constant<int, 8>
-                                        /* sizeof_size_t */);
-
-  // Slow dispatch path for calls to CombineContiguousImpl with a size argument
-  // larger than PiecewiseChunkSize().  Has the same effect as calling
-  // CombineContiguousImpl() repeatedly with the chunk stride size.
-  static uint64_t CombineLargeContiguousImpl32(uint64_t state,
-                                               const unsigned char* first,
-                                               size_t len);
-  static uint64_t CombineLargeContiguousImpl64(uint64_t state,
-                                               const unsigned char* first,
-                                               size_t len);
-
-  // Reads 9 to 16 bytes from p.
+ 
+  // Slow dispatch path for calls to CombineContiguousImpl with a size argument 
+  // larger than PiecewiseChunkSize().  Has the same effect as calling 
+  // CombineContiguousImpl() repeatedly with the chunk stride size. 
+  static uint64_t CombineLargeContiguousImpl32(uint64_t state, 
+                                               const unsigned char* first, 
+                                               size_t len); 
+  static uint64_t CombineLargeContiguousImpl64(uint64_t state, 
+                                               const unsigned char* first, 
+                                               size_t len); 
+ 
+  // Reads 9 to 16 bytes from p. 
   // The least significant 8 bytes are in .first, the rest (zero padded) bytes
   // are in .second.
-  static std::pair<uint64_t, uint64_t> Read9To16(const unsigned char* p,
-                                                 size_t len) {
+  static std::pair<uint64_t, uint64_t> Read9To16(const unsigned char* p, 
+                                                 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
@@ -861,10 +861,10 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
     uint64_t least_significant = high_mem;
 #endif
     return {least_significant, most_significant >> (128 - len * 8)};
-  }
-
-  // Reads 4 to 8 bytes from p. Zero pads to fill uint64_t.
-  static uint64_t Read4To8(const unsigned char* p, size_t len) {
+  } 
+ 
+  // Reads 4 to 8 bytes from p. Zero pads to fill uint64_t. 
+  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
@@ -876,10 +876,10 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
 #endif
     return (static_cast<uint64_t>(most_significant) << (len - 4) * 8) |
            least_significant;
-  }
-
-  // Reads 1 to 3 bytes from p. Zero pads to fill uint32_t.
-  static uint32_t Read1To3(const unsigned char* p, size_t len) {
+  } 
+ 
+  // Reads 1 to 3 bytes from p. Zero pads to fill uint32_t. 
+  static uint32_t Read1To3(const unsigned char* p, size_t len) { 
     unsigned char mem0 = p[0];
     unsigned char mem1 = p[len / 2];
     unsigned char mem2 = p[len - 1];
@@ -895,27 +895,27 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
     return static_cast<uint32_t>(significant0 |                     //
                                  (significant1 << (len / 2 * 8)) |  //
                                  (significant2 << ((len - 1) * 8)));
-  }
-
-  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Mix(uint64_t state, uint64_t v) {
+  } 
+ 
+  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
     // halves of the result.
     using MultType = uint64_t;
 #else
-    using MultType =
+    using MultType = 
         y_absl::conditional_t<sizeof(size_t) == 4, uint64_t, uint128>;
 #endif
-    // We do the addition in 64-bit space to make sure the 128-bit
-    // multiplication is fast. If we were to do it as MultType the compiler has
-    // to assume that the high word is non-zero and needs to perform 2
-    // multiplications instead of one.
-    MultType m = state + v;
-    m *= kMul;
-    return static_cast<uint64_t>(m ^ (m >> (sizeof(m) * 8 / 2)));
-  }
-
+    // We do the addition in 64-bit space to make sure the 128-bit 
+    // multiplication is fast. If we were to do it as MultType the compiler has 
+    // to assume that the high word is non-zero and needs to perform 2 
+    // multiplications instead of one. 
+    MultType m = state + v; 
+    m *= kMul; 
+    return static_cast<uint64_t>(m ^ (m >> (sizeof(m) * 8 / 2))); 
+  } 
+ 
   // An extern to avoid bloat on a direct call to LowLevelHash() with fixed
   // values for both the seed and salt parameters.
   static uint64_t LowLevelHashImpl(const unsigned char* data, size_t len);
@@ -929,137 +929,137 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
 #endif
   }
 
-  // Seed()
-  //
-  // A non-deterministic seed.
-  //
-  // The current purpose of this seed is to generate non-deterministic results
-  // and prevent having users depend on the particular hash values.
-  // It is not meant as a security feature right now, but it leaves the door
-  // open to upgrade it to a true per-process random seed. A true random seed
-  // costs more and we don't need to pay for that right now.
-  //
-  // On platforms with ASLR, we take advantage of it to make a per-process
-  // random value.
-  // See https://en.wikipedia.org/wiki/Address_space_layout_randomization
-  //
-  // 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() {
+  // Seed() 
+  // 
+  // A non-deterministic seed. 
+  // 
+  // The current purpose of this seed is to generate non-deterministic results 
+  // and prevent having users depend on the particular hash values. 
+  // It is not meant as a security feature right now, but it leaves the door 
+  // open to upgrade it to a true per-process random seed. A true random seed 
+  // costs more and we don't need to pay for that right now. 
+  // 
+  // On platforms with ASLR, we take advantage of it to make a per-process 
+  // random value. 
+  // See https://en.wikipedia.org/wiki/Address_space_layout_randomization 
+  // 
+  // 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() { 
 #if (!defined(__clang__) || __clang_major__ > 11) && \
     !defined(__apple_build_version__)
     return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(&kSeed));
 #else
     // Workaround the absence of
     // https://github.com/llvm/llvm-project/commit/bc15bf66dcca76cc06fe71fca35b74dc4d521021.
-    return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(kSeed));
+    return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(kSeed)); 
 #endif
-  }
-  static const void* const kSeed;
-
-  uint64_t state_;
-};
-
+  } 
+  static const void* const kSeed; 
+ 
+  uint64_t state_; 
+}; 
+ 
 // MixingHashState::CombineContiguousImpl()
 inline uint64_t MixingHashState::CombineContiguousImpl(
-    uint64_t state, const unsigned char* first, size_t len,
-    std::integral_constant<int, 4> /* sizeof_size_t */) {
-  // For large values we use CityHash, for small ones we just use a
-  // multiplicative hash.
-  uint64_t v;
-  if (len > 8) {
-    if (ABSL_PREDICT_FALSE(len > PiecewiseChunkSize())) {
-      return CombineLargeContiguousImpl32(state, first, len);
-    }
+    uint64_t state, const unsigned char* first, size_t len, 
+    std::integral_constant<int, 4> /* sizeof_size_t */) { 
+  // For large values we use CityHash, for small ones we just use a 
+  // multiplicative hash. 
+  uint64_t v; 
+  if (len > 8) { 
+    if (ABSL_PREDICT_FALSE(len > PiecewiseChunkSize())) { 
+      return CombineLargeContiguousImpl32(state, first, len); 
+    } 
     v = hash_internal::CityHash32(reinterpret_cast<const char*>(first), len);
-  } else if (len >= 4) {
-    v = Read4To8(first, len);
-  } else if (len > 0) {
-    v = Read1To3(first, len);
-  } else {
-    // Empty ranges have no effect.
-    return state;
-  }
-  return Mix(state, v);
-}
-
+  } else if (len >= 4) { 
+    v = Read4To8(first, len); 
+  } else if (len > 0) { 
+    v = Read1To3(first, len); 
+  } else { 
+    // Empty ranges have no effect. 
+    return state; 
+  } 
+  return Mix(state, v); 
+} 
+ 
 // Overload of MixingHashState::CombineContiguousImpl()
 inline uint64_t MixingHashState::CombineContiguousImpl(
-    uint64_t state, const unsigned char* first, size_t len,
-    std::integral_constant<int, 8> /* sizeof_size_t */) {
+    uint64_t state, const unsigned char* first, size_t len, 
+    std::integral_constant<int, 8> /* sizeof_size_t */) { 
   // For large values we use LowLevelHash or CityHash depending on the platform,
   // for small ones we just use a multiplicative hash.
-  uint64_t v;
-  if (len > 16) {
-    if (ABSL_PREDICT_FALSE(len > PiecewiseChunkSize())) {
-      return CombineLargeContiguousImpl64(state, first, len);
-    }
+  uint64_t v; 
+  if (len > 16) { 
+    if (ABSL_PREDICT_FALSE(len > PiecewiseChunkSize())) { 
+      return CombineLargeContiguousImpl64(state, first, len); 
+    } 
     v = Hash64(first, len);
-  } else if (len > 8) {
-    auto p = Read9To16(first, len);
-    state = Mix(state, p.first);
-    v = p.second;
-  } else if (len >= 4) {
-    v = Read4To8(first, len);
-  } else if (len > 0) {
-    v = Read1To3(first, len);
-  } else {
-    // Empty ranges have no effect.
-    return state;
-  }
-  return Mix(state, v);
-}
-
-struct AggregateBarrier {};
-
-// HashImpl
-
-// Add a private base class to make sure this type is not an aggregate.
-// Aggregates can be aggregate initialized even if the default constructor is
-// deleted.
-struct PoisonedHash : private AggregateBarrier {
-  PoisonedHash() = delete;
-  PoisonedHash(const PoisonedHash&) = delete;
-  PoisonedHash& operator=(const PoisonedHash&) = delete;
-};
-
-template <typename T>
-struct HashImpl {
+  } else if (len > 8) { 
+    auto p = Read9To16(first, len); 
+    state = Mix(state, p.first); 
+    v = p.second; 
+  } else if (len >= 4) { 
+    v = Read4To8(first, len); 
+  } else if (len > 0) { 
+    v = Read1To3(first, len); 
+  } else { 
+    // Empty ranges have no effect. 
+    return state; 
+  } 
+  return Mix(state, v); 
+} 
+ 
+struct AggregateBarrier {}; 
+ 
+// HashImpl 
+ 
+// Add a private base class to make sure this type is not an aggregate. 
+// Aggregates can be aggregate initialized even if the default constructor is 
+// deleted. 
+struct PoisonedHash : private AggregateBarrier { 
+  PoisonedHash() = delete; 
+  PoisonedHash(const PoisonedHash&) = delete; 
+  PoisonedHash& operator=(const PoisonedHash&) = delete; 
+}; 
+ 
+template <typename T> 
+struct HashImpl { 
   size_t operator()(const T& value) const {
     return MixingHashState::hash(value);
   }
-};
-
-template <typename T>
-struct Hash
+}; 
+ 
+template <typename T> 
+struct Hash 
     : y_absl::conditional_t<is_hashable<T>::value, HashImpl<T>, PoisonedHash> {};
-
-template <typename H>
-template <typename T, typename... Ts>
-H HashStateBase<H>::combine(H state, const T& value, const Ts&... values) {
-  return H::combine(hash_internal::HashSelect::template Apply<T>::Invoke(
-                        std::move(state), value),
-                    values...);
-}
-
-// HashStateBase::combine_contiguous()
-template <typename H>
-template <typename T>
-H HashStateBase<H>::combine_contiguous(H state, const T* data, size_t size) {
-  return hash_internal::hash_range_or_bytes(std::move(state), data, size);
-}
-
-// HashStateBase::PiecewiseCombiner::add_buffer()
-template <typename H>
-H PiecewiseCombiner::add_buffer(H state, const unsigned char* data,
-                                size_t size) {
-  if (position_ + size < PiecewiseChunkSize()) {
-    // This partial chunk does not fill our existing buffer
-    memcpy(buf_ + position_, data, size);
-    position_ += size;
+ 
+template <typename H> 
+template <typename T, typename... Ts> 
+H HashStateBase<H>::combine(H state, const T& value, const Ts&... values) { 
+  return H::combine(hash_internal::HashSelect::template Apply<T>::Invoke( 
+                        std::move(state), value), 
+                    values...); 
+} 
+ 
+// HashStateBase::combine_contiguous() 
+template <typename H> 
+template <typename T> 
+H HashStateBase<H>::combine_contiguous(H state, const T* data, size_t size) { 
+  return hash_internal::hash_range_or_bytes(std::move(state), data, size); 
+} 
+ 
+// HashStateBase::PiecewiseCombiner::add_buffer() 
+template <typename H> 
+H PiecewiseCombiner::add_buffer(H state, const unsigned char* data, 
+                                size_t size) { 
+  if (position_ + size < PiecewiseChunkSize()) { 
+    // This partial chunk does not fill our existing buffer 
+    memcpy(buf_ + position_, data, size); 
+    position_ += size; 
     return state;
-  }
-
+  } 
+ 
   // If the buffer is partially filled we need to complete the buffer
   // and hash it.
   if (position_ != 0) {
@@ -1069,28 +1069,28 @@ H PiecewiseCombiner::add_buffer(H state, const unsigned char* data,
     data += bytes_needed;
     size -= bytes_needed;
   }
-
-  // Hash whatever chunks we can without copying
-  while (size >= PiecewiseChunkSize()) {
-    state = H::combine_contiguous(std::move(state), data, PiecewiseChunkSize());
-    data += PiecewiseChunkSize();
-    size -= PiecewiseChunkSize();
-  }
-  // Fill the buffer with the remainder
-  memcpy(buf_, data, size);
-  position_ = size;
+ 
+  // Hash whatever chunks we can without copying 
+  while (size >= PiecewiseChunkSize()) { 
+    state = H::combine_contiguous(std::move(state), data, PiecewiseChunkSize()); 
+    data += PiecewiseChunkSize(); 
+    size -= PiecewiseChunkSize(); 
+  } 
+  // Fill the buffer with the remainder 
+  memcpy(buf_, data, size); 
+  position_ = size; 
   return state;
-}
-
-// HashStateBase::PiecewiseCombiner::finalize()
-template <typename H>
-H PiecewiseCombiner::finalize(H state) {
-  // Hash the remainder left in the buffer, which may be empty
-  return H::combine_contiguous(std::move(state), buf_, position_);
-}
-
-}  // namespace hash_internal
+} 
+ 
+// HashStateBase::PiecewiseCombiner::finalize() 
+template <typename H> 
+H PiecewiseCombiner::finalize(H state) { 
+  // Hash the remainder left in the buffer, which may be empty 
+  return H::combine_contiguous(std::move(state), buf_, position_); 
+} 
+ 
+}  // namespace hash_internal 
 ABSL_NAMESPACE_END
 }  // namespace y_absl
-
-#endif  // ABSL_HASH_INTERNAL_HASH_H_
+ 
+#endif  // ABSL_HASH_INTERNAL_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..a3e09aba2e 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
@@ -1,231 +1,231 @@
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_HASH_INTERNAL_SPY_HASH_STATE_H_
-#define ABSL_HASH_INTERNAL_SPY_HASH_STATE_H_
-
-#include <ostream>
+// Copyright 2018 The Abseil Authors. 
+// 
+// Licensed under the Apache License, Version 2.0 (the "License"); 
+// you may not use this file except in compliance with the License. 
+// You may obtain a copy of the License at 
+// 
+//      https://www.apache.org/licenses/LICENSE-2.0 
+// 
+// Unless required by applicable law or agreed to in writing, software 
+// distributed under the License is distributed on an "AS IS" BASIS, 
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+// See the License for the specific language governing permissions and 
+// limitations under the License. 
+ 
+#ifndef ABSL_HASH_INTERNAL_SPY_HASH_STATE_H_ 
+#define ABSL_HASH_INTERNAL_SPY_HASH_STATE_H_ 
+ 
+#include <ostream> 
 #include <util/generic/string.h>
-#include <vector>
-
+#include <vector> 
+ 
 #include "y_absl/hash/hash.h"
 #include "y_absl/strings/match.h"
 #include "y_absl/strings/str_format.h"
 #include "y_absl/strings/str_join.h"
-
+ 
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-namespace hash_internal {
-
-// SpyHashState is an implementation of the HashState API that simply
-// accumulates all input bytes in an internal buffer. This makes it useful
-// for testing AbslHashValue overloads (so long as they are templated on the
-// HashState parameter), since it can report the exact hash representation
-// that the AbslHashValue overload produces.
-//
-// Sample usage:
-// EXPECT_EQ(SpyHashState::combine(SpyHashState(), foo),
-//           SpyHashState::combine(SpyHashState(), bar));
-template <typename T>
-class SpyHashStateImpl : public HashStateBase<SpyHashStateImpl<T>> {
- public:
+namespace hash_internal { 
+ 
+// SpyHashState is an implementation of the HashState API that simply 
+// accumulates all input bytes in an internal buffer. This makes it useful 
+// for testing AbslHashValue overloads (so long as they are templated on the 
+// HashState parameter), since it can report the exact hash representation 
+// that the AbslHashValue overload produces. 
+// 
+// Sample usage: 
+// EXPECT_EQ(SpyHashState::combine(SpyHashState(), foo), 
+//           SpyHashState::combine(SpyHashState(), bar)); 
+template <typename T> 
+class SpyHashStateImpl : public HashStateBase<SpyHashStateImpl<T>> { 
+ public: 
   SpyHashStateImpl() : error_(std::make_shared<y_absl::optional<TString>>()) {
-    static_assert(std::is_void<T>::value, "");
-  }
-
-  // Move-only
-  SpyHashStateImpl(const SpyHashStateImpl&) = delete;
-  SpyHashStateImpl& operator=(const SpyHashStateImpl&) = delete;
-
-  SpyHashStateImpl(SpyHashStateImpl&& other) noexcept {
-    *this = std::move(other);
-  }
-
-  SpyHashStateImpl& operator=(SpyHashStateImpl&& other) noexcept {
-    hash_representation_ = std::move(other.hash_representation_);
-    error_ = other.error_;
-    moved_from_ = other.moved_from_;
-    other.moved_from_ = true;
-    return *this;
-  }
-
-  template <typename U>
-  SpyHashStateImpl(SpyHashStateImpl<U>&& other) {  // NOLINT
-    hash_representation_ = std::move(other.hash_representation_);
-    error_ = other.error_;
-    moved_from_ = other.moved_from_;
-    other.moved_from_ = true;
-  }
-
-  template <typename A, typename... Args>
-  static SpyHashStateImpl combine(SpyHashStateImpl s, const A& a,
-                                  const Args&... args) {
-    // Pass an instance of SpyHashStateImpl<A> when trying to combine `A`. This
-    // allows us to test that the user only uses this instance for combine calls
-    // and does not call AbslHashValue directly.
-    // See AbslHashValue implementation at the bottom.
-    s = SpyHashStateImpl<A>::HashStateBase::combine(std::move(s), a);
-    return SpyHashStateImpl::combine(std::move(s), args...);
-  }
-  static SpyHashStateImpl combine(SpyHashStateImpl s) {
-    if (direct_absl_hash_value_error_) {
-      *s.error_ = "AbslHashValue should not be invoked directly.";
-    } else if (s.moved_from_) {
-      *s.error_ = "Used moved-from instance of the hash state object.";
-    }
-    return s;
-  }
-
-  static void SetDirectAbslHashValueError() {
-    direct_absl_hash_value_error_ = true;
-  }
-
-  // Two SpyHashStateImpl objects are equal if they hold equal hash
-  // representations.
-  friend bool operator==(const SpyHashStateImpl& lhs,
-                         const SpyHashStateImpl& rhs) {
-    return lhs.hash_representation_ == rhs.hash_representation_;
-  }
-
-  friend bool operator!=(const SpyHashStateImpl& lhs,
-                         const SpyHashStateImpl& rhs) {
-    return !(lhs == rhs);
-  }
-
-  enum class CompareResult {
-    kEqual,
-    kASuffixB,
-    kBSuffixA,
-    kUnequal,
-  };
-
-  static CompareResult Compare(const SpyHashStateImpl& a,
-                               const SpyHashStateImpl& b) {
+    static_assert(std::is_void<T>::value, ""); 
+  } 
+ 
+  // Move-only 
+  SpyHashStateImpl(const SpyHashStateImpl&) = delete; 
+  SpyHashStateImpl& operator=(const SpyHashStateImpl&) = delete; 
+ 
+  SpyHashStateImpl(SpyHashStateImpl&& other) noexcept { 
+    *this = std::move(other); 
+  } 
+ 
+  SpyHashStateImpl& operator=(SpyHashStateImpl&& other) noexcept { 
+    hash_representation_ = std::move(other.hash_representation_); 
+    error_ = other.error_; 
+    moved_from_ = other.moved_from_; 
+    other.moved_from_ = true; 
+    return *this; 
+  } 
+ 
+  template <typename U> 
+  SpyHashStateImpl(SpyHashStateImpl<U>&& other) {  // NOLINT 
+    hash_representation_ = std::move(other.hash_representation_); 
+    error_ = other.error_; 
+    moved_from_ = other.moved_from_; 
+    other.moved_from_ = true; 
+  } 
+ 
+  template <typename A, typename... Args> 
+  static SpyHashStateImpl combine(SpyHashStateImpl s, const A& a, 
+                                  const Args&... args) { 
+    // Pass an instance of SpyHashStateImpl<A> when trying to combine `A`. This 
+    // allows us to test that the user only uses this instance for combine calls 
+    // and does not call AbslHashValue directly. 
+    // See AbslHashValue implementation at the bottom. 
+    s = SpyHashStateImpl<A>::HashStateBase::combine(std::move(s), a); 
+    return SpyHashStateImpl::combine(std::move(s), args...); 
+  } 
+  static SpyHashStateImpl combine(SpyHashStateImpl s) { 
+    if (direct_absl_hash_value_error_) { 
+      *s.error_ = "AbslHashValue should not be invoked directly."; 
+    } else if (s.moved_from_) { 
+      *s.error_ = "Used moved-from instance of the hash state object."; 
+    } 
+    return s; 
+  } 
+ 
+  static void SetDirectAbslHashValueError() { 
+    direct_absl_hash_value_error_ = true; 
+  } 
+ 
+  // Two SpyHashStateImpl objects are equal if they hold equal hash 
+  // representations. 
+  friend bool operator==(const SpyHashStateImpl& lhs, 
+                         const SpyHashStateImpl& rhs) { 
+    return lhs.hash_representation_ == rhs.hash_representation_; 
+  } 
+ 
+  friend bool operator!=(const SpyHashStateImpl& lhs, 
+                         const SpyHashStateImpl& rhs) { 
+    return !(lhs == rhs); 
+  } 
+ 
+  enum class CompareResult { 
+    kEqual, 
+    kASuffixB, 
+    kBSuffixA, 
+    kUnequal, 
+  }; 
+ 
+  static CompareResult Compare(const SpyHashStateImpl& a, 
+                               const SpyHashStateImpl& b) { 
     const TString a_flat = y_absl::StrJoin(a.hash_representation_, "");
     const TString b_flat = y_absl::StrJoin(b.hash_representation_, "");
-    if (a_flat == b_flat) return CompareResult::kEqual;
+    if (a_flat == b_flat) return CompareResult::kEqual; 
     if (y_absl::EndsWith(a_flat, b_flat)) return CompareResult::kBSuffixA;
     if (y_absl::EndsWith(b_flat, a_flat)) return CompareResult::kASuffixB;
-    return CompareResult::kUnequal;
-  }
-
-  // operator<< prints the hash representation as a hex and ASCII dump, to
-  // facilitate debugging.
-  friend std::ostream& operator<<(std::ostream& out,
-                                  const SpyHashStateImpl& hash_state) {
-    out << "[\n";
-    for (auto& s : hash_state.hash_representation_) {
-      size_t offset = 0;
-      for (char c : s) {
-        if (offset % 16 == 0) {
+    return CompareResult::kUnequal; 
+  } 
+ 
+  // operator<< prints the hash representation as a hex and ASCII dump, to 
+  // facilitate debugging. 
+  friend std::ostream& operator<<(std::ostream& out, 
+                                  const SpyHashStateImpl& hash_state) { 
+    out << "[\n"; 
+    for (auto& s : hash_state.hash_representation_) { 
+      size_t offset = 0; 
+      for (char c : s) { 
+        if (offset % 16 == 0) { 
           out << y_absl::StreamFormat("\n0x%04x: ", offset);
-        }
-        if (offset % 2 == 0) {
-          out << " ";
-        }
+        } 
+        if (offset % 2 == 0) { 
+          out << " "; 
+        } 
         out << y_absl::StreamFormat("%02x", c);
-        ++offset;
-      }
-      out << "\n";
-    }
-    return out << "]";
-  }
-
-  // The base case of the combine recursion, which writes raw bytes into the
-  // internal buffer.
-  static SpyHashStateImpl combine_contiguous(SpyHashStateImpl hash_state,
-                                             const unsigned char* begin,
-                                             size_t size) {
-    const size_t large_chunk_stride = PiecewiseChunkSize();
-    if (size > large_chunk_stride) {
-      // Combining a large contiguous buffer must have the same effect as
-      // doing it piecewise by the stride length, followed by the (possibly
-      // empty) remainder.
-      while (size >= large_chunk_stride) {
-        hash_state = SpyHashStateImpl::combine_contiguous(
-            std::move(hash_state), begin, large_chunk_stride);
-        begin += large_chunk_stride;
-        size -= large_chunk_stride;
-      }
-    }
-
-    hash_state.hash_representation_.emplace_back(
-        reinterpret_cast<const char*>(begin), size);
-    return hash_state;
-  }
-
-  using SpyHashStateImpl::HashStateBase::combine_contiguous;
-
+        ++offset; 
+      } 
+      out << "\n"; 
+    } 
+    return out << "]"; 
+  } 
+ 
+  // The base case of the combine recursion, which writes raw bytes into the 
+  // internal buffer. 
+  static SpyHashStateImpl combine_contiguous(SpyHashStateImpl hash_state, 
+                                             const unsigned char* begin, 
+                                             size_t size) { 
+    const size_t large_chunk_stride = PiecewiseChunkSize(); 
+    if (size > large_chunk_stride) { 
+      // Combining a large contiguous buffer must have the same effect as 
+      // doing it piecewise by the stride length, followed by the (possibly 
+      // empty) remainder. 
+      while (size >= large_chunk_stride) { 
+        hash_state = SpyHashStateImpl::combine_contiguous( 
+            std::move(hash_state), begin, large_chunk_stride); 
+        begin += large_chunk_stride; 
+        size -= large_chunk_stride; 
+      } 
+    } 
+ 
+    hash_state.hash_representation_.emplace_back( 
+        reinterpret_cast<const char*>(begin), size); 
+    return hash_state; 
+  } 
+ 
+  using SpyHashStateImpl::HashStateBase::combine_contiguous; 
+ 
   y_absl::optional<TString> error() const {
-    if (moved_from_) {
-      return "Returned a moved-from instance of the hash state object.";
-    }
-    return *error_;
-  }
-
- private:
-  template <typename U>
-  friend class SpyHashStateImpl;
-
-  // This is true if SpyHashStateImpl<T> has been passed to a call of
-  // AbslHashValue with the wrong type. This detects that the user called
-  // AbslHashValue directly (because the hash state type does not match).
-  static bool direct_absl_hash_value_error_;
-
+    if (moved_from_) { 
+      return "Returned a moved-from instance of the hash state object."; 
+    } 
+    return *error_; 
+  } 
+ 
+ private: 
+  template <typename U> 
+  friend class SpyHashStateImpl; 
+ 
+  // This is true if SpyHashStateImpl<T> has been passed to a call of 
+  // AbslHashValue with the wrong type. This detects that the user called 
+  // AbslHashValue directly (because the hash state type does not match). 
+  static bool direct_absl_hash_value_error_; 
+ 
   std::vector<TString> hash_representation_;
-  // This is a shared_ptr because we want all instances of the particular
-  // SpyHashState run to share the field. This way we can set the error for
-  // use-after-move and all the copies will see it.
+  // This is a shared_ptr because we want all instances of the particular 
+  // SpyHashState run to share the field. This way we can set the error for 
+  // use-after-move and all the copies will see it. 
   std::shared_ptr<y_absl::optional<TString>> error_;
-  bool moved_from_ = false;
-};
-
-template <typename T>
-bool SpyHashStateImpl<T>::direct_absl_hash_value_error_;
-
-template <bool& B>
-struct OdrUse {
-  constexpr OdrUse() {}
-  bool& b = B;
-};
-
-template <void (*)()>
-struct RunOnStartup {
-  static bool run;
-  static constexpr OdrUse<run> kOdrUse{};
-};
-
-template <void (*f)()>
-bool RunOnStartup<f>::run = (f(), true);
-
-template <
-    typename T, typename U,
-    // Only trigger for when (T != U),
+  bool moved_from_ = false; 
+}; 
+ 
+template <typename T> 
+bool SpyHashStateImpl<T>::direct_absl_hash_value_error_; 
+ 
+template <bool& B> 
+struct OdrUse { 
+  constexpr OdrUse() {} 
+  bool& b = B; 
+}; 
+ 
+template <void (*)()> 
+struct RunOnStartup { 
+  static bool run; 
+  static constexpr OdrUse<run> kOdrUse{}; 
+}; 
+ 
+template <void (*f)()> 
+bool RunOnStartup<f>::run = (f(), true); 
+ 
+template < 
+    typename T, typename U, 
+    // Only trigger for when (T != U), 
     typename = y_absl::enable_if_t<!std::is_same<T, U>::value>,
-    // This statement works in two ways:
-    //  - First, it instantiates RunOnStartup and forces the initialization of
-    //    `run`, which set the global variable.
-    //  - Second, it triggers a SFINAE error disabling the overload to prevent
-    //    compile time errors. If we didn't disable the overload we would get
-    //    ambiguous overload errors, which we don't want.
-    int = RunOnStartup<SpyHashStateImpl<T>::SetDirectAbslHashValueError>::run>
-void AbslHashValue(SpyHashStateImpl<T>, const U&);
-
-using SpyHashState = SpyHashStateImpl<void>;
-
-}  // namespace hash_internal
+    // This statement works in two ways: 
+    //  - First, it instantiates RunOnStartup and forces the initialization of 
+    //    `run`, which set the global variable. 
+    //  - Second, it triggers a SFINAE error disabling the overload to prevent 
+    //    compile time errors. If we didn't disable the overload we would get 
+    //    ambiguous overload errors, which we don't want. 
+    int = RunOnStartup<SpyHashStateImpl<T>::SetDirectAbslHashValueError>::run> 
+void AbslHashValue(SpyHashStateImpl<T>, const U&); 
+ 
+using SpyHashState = SpyHashStateImpl<void>; 
+ 
+}  // namespace hash_internal 
 ABSL_NAMESPACE_END
 }  // namespace y_absl
-
-#endif  // ABSL_HASH_INTERNAL_SPY_HASH_STATE_H_
+ 
+#endif  // ABSL_HASH_INTERNAL_SPY_HASH_STATE_H_