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

7 files changed, 172 insertions, 172 deletions

diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/hash.h b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/hash.h
index 1e93ee96d9..80e6efd0e6 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/hash.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/hash.h
@@ -73,8 +73,8 @@
 #ifndef ABSL_HASH_HASH_H_
 #define ABSL_HASH_HASH_H_
 
-#include <tuple>
-
+#include <tuple> 
+ 
 #include "y_absl/hash/internal/hash.h"
 
 namespace y_absl {
@@ -216,26 +216,26 @@ ABSL_NAMESPACE_BEGIN
 template <typename T>
 using Hash = y_absl::hash_internal::Hash<T>;
 
-// HashOf
-//
-// y_absl::HashOf() is a helper that generates a hash from the values of its
-// arguments.  It dispatches to y_absl::Hash directly, as follows:
-//  * HashOf(t) == y_absl::Hash<T>{}(t)
-//  * HashOf(a, b, c) == HashOf(std::make_tuple(a, b, c))
-//
-// HashOf(a1, a2, ...) == HashOf(b1, b2, ...) is guaranteed when
-//  * The argument lists have pairwise identical C++ types
-//  * a1 == b1 && a2 == b2 && ...
-//
-// The requirement that the arguments match in both type and value is critical.
-// It means that `a == b` does not necessarily imply `HashOf(a) == HashOf(b)` if
-// `a` and `b` have different types. For example, `HashOf(2) != HashOf(2.0)`.
-template <int&... ExplicitArgumentBarrier, typename... Types>
-size_t HashOf(const Types&... values) {
-  auto tuple = std::tie(values...);
-  return y_absl::Hash<decltype(tuple)>{}(tuple);
-}
-
+// HashOf 
+// 
+// y_absl::HashOf() is a helper that generates a hash from the values of its 
+// arguments.  It dispatches to y_absl::Hash directly, as follows: 
+//  * HashOf(t) == y_absl::Hash<T>{}(t) 
+//  * HashOf(a, b, c) == HashOf(std::make_tuple(a, b, c)) 
+// 
+// HashOf(a1, a2, ...) == HashOf(b1, b2, ...) is guaranteed when 
+//  * The argument lists have pairwise identical C++ types 
+//  * a1 == b1 && a2 == b2 && ... 
+// 
+// The requirement that the arguments match in both type and value is critical. 
+// It means that `a == b` does not necessarily imply `HashOf(a) == HashOf(b)` if 
+// `a` and `b` have different types. For example, `HashOf(2) != HashOf(2.0)`. 
+template <int&... ExplicitArgumentBarrier, typename... Types> 
+size_t HashOf(const Types&... values) { 
+  auto tuple = std::tie(values...); 
+  return y_absl::Hash<decltype(tuple)>{}(tuple); 
+} 
+ 
 // HashState
 //
 // A type erased version of the hash state concept, for use in user-defined
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..0c9894f54d 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
@@ -18,12 +18,12 @@ namespace y_absl {
 ABSL_NAMESPACE_BEGIN
 namespace hash_internal {
 
-uint64_t MixingHashState::CombineLargeContiguousImpl32(
-    uint64_t state, const unsigned char* first, size_t len) {
+uint64_t MixingHashState::CombineLargeContiguousImpl32( 
+    uint64_t state, const unsigned char* first, size_t len) { 
   while (len >= PiecewiseChunkSize()) {
-    state = Mix(state,
-                hash_internal::CityHash32(reinterpret_cast<const char*>(first),
-                                          PiecewiseChunkSize()));
+    state = Mix(state, 
+                hash_internal::CityHash32(reinterpret_cast<const char*>(first), 
+                                          PiecewiseChunkSize())); 
     len -= PiecewiseChunkSize();
     first += PiecewiseChunkSize();
   }
@@ -32,8 +32,8 @@ uint64_t MixingHashState::CombineLargeContiguousImpl32(
                                std::integral_constant<int, 4>{});
 }
 
-uint64_t MixingHashState::CombineLargeContiguousImpl64(
-    uint64_t state, const unsigned char* first, size_t len) {
+uint64_t MixingHashState::CombineLargeContiguousImpl64( 
+    uint64_t state, const unsigned char* first, size_t len) { 
   while (len >= PiecewiseChunkSize()) {
     state = Mix(state, Hash64(first, PiecewiseChunkSize()));
     len -= PiecewiseChunkSize();
@@ -44,24 +44,24 @@ uint64_t MixingHashState::CombineLargeContiguousImpl64(
                                std::integral_constant<int, 8>{});
 }
 
-ABSL_CONST_INIT const void* const MixingHashState::kSeed = &kSeed;
+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.
+// 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. 
 //
 // Any random values are fine. These values are just digits from the decimal
 // part of pi.
 // https://en.wikipedia.org/wiki/Nothing-up-my-sleeve_number
-constexpr uint64_t kHashSalt[5] = {
+constexpr uint64_t kHashSalt[5] = { 
     uint64_t{0x243F6A8885A308D3}, uint64_t{0x13198A2E03707344},
     uint64_t{0xA4093822299F31D0}, uint64_t{0x082EFA98EC4E6C89},
     uint64_t{0x452821E638D01377},
 };
 
-uint64_t MixingHashState::LowLevelHashImpl(const unsigned char* data,
-                                           size_t len) {
-  return LowLevelHash(data, len, Seed(), kHashSalt);
+uint64_t MixingHashState::LowLevelHashImpl(const unsigned char* data, 
+                                           size_t len) { 
+  return LowLevelHash(data, len, Seed(), kHashSalt); 
 }
 
 }  // namespace hash_internal
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..32cbbbb27a 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
@@ -21,7 +21,7 @@
 
 #include <algorithm>
 #include <array>
-#include <bitset>
+#include <bitset> 
 #include <cmath>
 #include <cstring>
 #include <deque>
@@ -43,8 +43,8 @@
 #include "y_absl/base/internal/unaligned_access.h"
 #include "y_absl/base/port.h"
 #include "y_absl/container/fixed_array.h"
-#include "y_absl/hash/internal/city.h"
-#include "y_absl/hash/internal/low_level_hash.h"
+#include "y_absl/hash/internal/city.h" 
+#include "y_absl/hash/internal/low_level_hash.h" 
 #include "y_absl/meta/type_traits.h"
 #include "y_absl/numeric/int128.h"
 #include "y_absl/strings/string_view.h"
@@ -380,7 +380,7 @@ template <typename H, typename... Ts>
 // This SFINAE gets MSVC confused under some conditions. Let's just disable it
 // for now.
 H
-#else   // _MSC_VER
+#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) {
@@ -490,9 +490,9 @@ typename std::enable_if<is_hashable<T>::value, H>::type AbslHashValue(
 
 // 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.
+// 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
@@ -502,27 +502,27 @@ AbslHashValue(H hash_state, const std::vector<T, Allocator>& vector) {
                     vector.size());
 }
 
-#if defined(ABSL_IS_BIG_ENDIAN) && \
-    (defined(__GLIBCXX__) || defined(__GLIBCPP__))
-// AbslHashValue for hashing std::vector<bool>
-//
-// std::hash in libstdc++ does not work correctly with vector<bool> on Big
-// Endian platforms therefore we need to implement a custom AbslHashValue for
-// it. More details on the bug:
-// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102531
-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) {
-  typename H::AbslInternalPiecewiseCombiner combiner;
-  for (const auto& i : vector) {
-    unsigned char c = static_cast<unsigned char>(i);
-    hash_state = combiner.add_buffer(std::move(hash_state), &c, sizeof(c));
-  }
-  return H::combine(combiner.finalize(std::move(hash_state)), vector.size());
-}
-#endif
-
+#if defined(ABSL_IS_BIG_ENDIAN) && \ 
+    (defined(__GLIBCXX__) || defined(__GLIBCPP__)) 
+// AbslHashValue for hashing std::vector<bool> 
+// 
+// std::hash in libstdc++ does not work correctly with vector<bool> on Big 
+// Endian platforms therefore we need to implement a custom AbslHashValue for 
+// it. More details on the bug: 
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102531 
+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) { 
+  typename H::AbslInternalPiecewiseCombiner combiner; 
+  for (const auto& i : vector) { 
+    unsigned char c = static_cast<unsigned char>(i); 
+    hash_state = combiner.add_buffer(std::move(hash_state), &c, sizeof(c)); 
+  } 
+  return H::combine(combiner.finalize(std::move(hash_state)), vector.size()); 
+} 
+#endif 
+ 
 // -----------------------------------------------------------------------------
 // AbslHashValue for Ordered Associative Containers
 // -----------------------------------------------------------------------------
@@ -615,29 +615,29 @@ AbslHashValue(H hash_state, const y_absl::variant<T...>& v) {
 // 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
-//
-// std::hash in libstdc++ does not work correctly with std::bitset on Big Endian
-// platforms therefore we need to implement a custom AbslHashValue for it. More
-// details on the bug: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102531
-template <typename H, size_t N>
-H AbslHashValue(H hash_state, const std::bitset<N>& set) {
-  typename H::AbslInternalPiecewiseCombiner combiner;
-  for (int i = 0; i < N; i++) {
-    unsigned char c = static_cast<unsigned char>(set[i]);
-    hash_state = combiner.add_buffer(std::move(hash_state), &c, sizeof(c));
-  }
-  return H::combine(combiner.finalize(std::move(hash_state)), N);
-}
-#endif
-
+// 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 
+// 
+// std::hash in libstdc++ does not work correctly with std::bitset on Big Endian 
+// platforms therefore we need to implement a custom AbslHashValue for it. More 
+// details on the bug: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102531 
+template <typename H, size_t N> 
+H AbslHashValue(H hash_state, const std::bitset<N>& set) { 
+  typename H::AbslInternalPiecewiseCombiner combiner; 
+  for (int i = 0; i < N; i++) { 
+    unsigned char c = static_cast<unsigned char>(set[i]); 
+    hash_state = combiner.add_buffer(std::move(hash_state), &c, sizeof(c)); 
+  } 
+  return H::combine(combiner.finalize(std::move(hash_state)), N); 
+} 
+#endif 
+ 
 // -----------------------------------------------------------------------------
 
 // hash_range_or_bytes()
@@ -756,8 +756,8 @@ template <typename T>
 struct is_hashable
     : std::integral_constant<bool, HashSelect::template Apply<T>::value> {};
 
-// MixingHashState
-class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
+// 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
@@ -776,23 +776,23 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
 
  public:
   // Move only
-  MixingHashState(MixingHashState&&) = default;
-  MixingHashState& operator=(MixingHashState&&) = default;
+  MixingHashState(MixingHashState&&) = default; 
+  MixingHashState& operator=(MixingHashState&&) = default; 
 
-  // MixingHashState::combine_contiguous()
+  // MixingHashState::combine_contiguous() 
   //
   // 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(
+  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)>{}));
   }
-  using MixingHashState::HashStateBase::combine_contiguous;
+  using MixingHashState::HashStateBase::combine_contiguous; 
 
-  // MixingHashState::hash()
+  // MixingHashState::hash() 
   //
   // For performance reasons in non-opt mode, we specialize this for
   // integral types.
@@ -804,24 +804,24 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
     return static_cast<size_t>(Mix(Seed(), static_cast<uint64_t>(value)));
   }
 
-  // Overload of MixingHashState::hash()
+  // Overload of MixingHashState::hash() 
   template <typename T, y_absl::enable_if_t<!IntegralFastPath<T>::value, int> = 0>
   static size_t hash(const T& value) {
-    return static_cast<size_t>(combine(MixingHashState{}, value).state_);
+    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.
-  MixingHashState() : state_(Seed()) {}
+  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.
-  MixingHashState(const MixingHashState&) = default;
+  MixingHashState(const MixingHashState&) = default; 
 
-  explicit MixingHashState(uint64_t state) : state_(state) {}
+  explicit MixingHashState(uint64_t state) : state_(state) {} 
 
   // Implementation of the base case for combine_contiguous where we actually
   // mix the bytes into the state.
@@ -898,15 +898,15 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
   }
 
   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
+#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 =
         y_absl::conditional_t<sizeof(size_t) == 4, uint64_t, uint128>;
-#endif
+#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
@@ -916,16 +916,16 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
     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);
+  // 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); 
 
   ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Hash64(const unsigned char* data,
                                                       size_t len) {
 #ifdef ABSL_HAVE_INTRINSIC_INT128
-    return LowLevelHashImpl(data, len);
+    return LowLevelHashImpl(data, len); 
 #else
-    return hash_internal::CityHash64(reinterpret_cast<const char*>(data), len);
+    return hash_internal::CityHash64(reinterpret_cast<const char*>(data), len); 
 #endif
   }
 
@@ -960,8 +960,8 @@ class ABSL_DLL MixingHashState : public HashStateBase<MixingHashState> {
   uint64_t state_;
 };
 
-// MixingHashState::CombineContiguousImpl()
-inline uint64_t MixingHashState::CombineContiguousImpl(
+// 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
@@ -971,7 +971,7 @@ inline uint64_t MixingHashState::CombineContiguousImpl(
     if (ABSL_PREDICT_FALSE(len > PiecewiseChunkSize())) {
       return CombineLargeContiguousImpl32(state, first, len);
     }
-    v = hash_internal::CityHash32(reinterpret_cast<const char*>(first), len);
+    v = hash_internal::CityHash32(reinterpret_cast<const char*>(first), len); 
   } else if (len >= 4) {
     v = Read4To8(first, len);
   } else if (len > 0) {
@@ -983,12 +983,12 @@ inline uint64_t MixingHashState::CombineContiguousImpl(
   return Mix(state, v);
 }
 
-// Overload of MixingHashState::CombineContiguousImpl()
-inline uint64_t MixingHashState::CombineContiguousImpl(
+// 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 */) {
-  // For large values we use LowLevelHash or CityHash depending on the platform,
-  // for small ones we just use a multiplicative hash.
+  // 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())) {
@@ -1025,9 +1025,9 @@ struct PoisonedHash : private AggregateBarrier {
 
 template <typename T>
 struct HashImpl {
-  size_t operator()(const T& value) const {
-    return MixingHashState::hash(value);
-  }
+  size_t operator()(const T& value) const { 
+    return MixingHashState::hash(value); 
+  } 
 };
 
 template <typename T>
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/low_level_hash.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/low_level_hash.cc
index 08b6dd85d4..e1f309d045 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/low_level_hash.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/low_level_hash.cc
@@ -12,35 +12,35 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "y_absl/hash/internal/low_level_hash.h"
+#include "y_absl/hash/internal/low_level_hash.h" 
 
 #include "y_absl/base/internal/unaligned_access.h"
-#include "y_absl/numeric/bits.h"
+#include "y_absl/numeric/bits.h" 
 #include "y_absl/numeric/int128.h"
 
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
 namespace hash_internal {
 
-static uint64_t Mix(uint64_t v0, uint64_t v1) {
-#if !defined(__aarch64__)
-  // The default bit-mixer uses 64x64->128-bit multiplication.
+static uint64_t Mix(uint64_t v0, uint64_t v1) { 
+#if !defined(__aarch64__) 
+  // The default bit-mixer uses 64x64->128-bit multiplication. 
   y_absl::uint128 p = v0;
   p *= v1;
   return y_absl::Uint128Low64(p) ^ y_absl::Uint128High64(p);
-#else
-  // The default bit-mixer above would perform poorly on some ARM microarchs,
-  // where calculating a 128-bit product requires a sequence of two
-  // instructions with a high combined latency and poor throughput.
-  // Instead, we mix bits using only 64-bit arithmetic, which is faster.
-  uint64_t p = v0 ^ y_absl::rotl(v1, 40);
-  p *= v1 ^ y_absl::rotl(v0, 39);
-  return p ^ (p >> 11);
-#endif
+#else 
+  // The default bit-mixer above would perform poorly on some ARM microarchs, 
+  // where calculating a 128-bit product requires a sequence of two 
+  // instructions with a high combined latency and poor throughput. 
+  // Instead, we mix bits using only 64-bit arithmetic, which is faster. 
+  uint64_t p = v0 ^ y_absl::rotl(v1, 40); 
+  p *= v1 ^ y_absl::rotl(v0, 39); 
+  return p ^ (p >> 11); 
+#endif 
 }
 
-uint64_t LowLevelHash(const void* data, size_t len, uint64_t seed,
-                      const uint64_t salt[]) {
+uint64_t LowLevelHash(const void* data, size_t len, uint64_t seed, 
+                      const uint64_t salt[]) { 
   const uint8_t* ptr = static_cast<const uint8_t*>(data);
   uint64_t starting_length = static_cast<uint64_t>(len);
   uint64_t current_state = seed ^ salt[0];
@@ -61,12 +61,12 @@ uint64_t LowLevelHash(const void* data, size_t len, uint64_t seed,
       uint64_t g = y_absl::base_internal::UnalignedLoad64(ptr + 48);
       uint64_t h = y_absl::base_internal::UnalignedLoad64(ptr + 56);
 
-      uint64_t cs0 = Mix(a ^ salt[1], b ^ current_state);
-      uint64_t cs1 = Mix(c ^ salt[2], d ^ current_state);
+      uint64_t cs0 = Mix(a ^ salt[1], b ^ current_state); 
+      uint64_t cs1 = Mix(c ^ salt[2], d ^ current_state); 
       current_state = (cs0 ^ cs1);
 
-      uint64_t ds0 = Mix(e ^ salt[3], f ^ duplicated_state);
-      uint64_t ds1 = Mix(g ^ salt[4], h ^ duplicated_state);
+      uint64_t ds0 = Mix(e ^ salt[3], f ^ duplicated_state); 
+      uint64_t ds1 = Mix(g ^ salt[4], h ^ duplicated_state); 
       duplicated_state = (ds0 ^ ds1);
 
       ptr += 64;
@@ -82,7 +82,7 @@ uint64_t LowLevelHash(const void* data, size_t len, uint64_t seed,
     uint64_t a = y_absl::base_internal::UnalignedLoad64(ptr);
     uint64_t b = y_absl::base_internal::UnalignedLoad64(ptr + 8);
 
-    current_state = Mix(a ^ salt[1], b ^ current_state);
+    current_state = Mix(a ^ salt[1], b ^ current_state); 
 
     ptr += 16;
     len -= 16;
@@ -113,9 +113,9 @@ uint64_t LowLevelHash(const void* data, size_t len, uint64_t seed,
     b = 0;
   }
 
-  uint64_t w = Mix(a ^ salt[1], b ^ current_state);
+  uint64_t w = Mix(a ^ salt[1], b ^ current_state); 
   uint64_t z = salt[1] ^ starting_length;
-  return Mix(w, z);
+  return Mix(w, z); 
 }
 
 }  // namespace hash_internal
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/low_level_hash.h b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/low_level_hash.h
index 4a71ab9418..ce25edf5d0 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/low_level_hash.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/low_level_hash.h
@@ -12,18 +12,18 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
-// This file provides the Google-internal implementation of LowLevelHash.
+// This file provides the Google-internal implementation of LowLevelHash. 
 //
-// LowLevelHash is a fast hash function for hash tables, the fastest we've
-// currently (late 2020) found that passes the SMHasher tests. The algorithm
-// relies on intrinsic 128-bit multiplication for speed. This is not meant to be
-// secure - just fast.
-//
-// It is closely based on a version of wyhash, but does not maintain or
-// guarantee future compatibility with it.
+// LowLevelHash is a fast hash function for hash tables, the fastest we've 
+// currently (late 2020) found that passes the SMHasher tests. The algorithm 
+// relies on intrinsic 128-bit multiplication for speed. This is not meant to be 
+// secure - just fast. 
+// 
+// It is closely based on a version of wyhash, but does not maintain or 
+// guarantee future compatibility with it. 
 
-#ifndef ABSL_HASH_INTERNAL_LOW_LEVEL_HASH_H_
-#define ABSL_HASH_INTERNAL_LOW_LEVEL_HASH_H_
+#ifndef ABSL_HASH_INTERNAL_LOW_LEVEL_HASH_H_ 
+#define ABSL_HASH_INTERNAL_LOW_LEVEL_HASH_H_ 
 
 #include <stdint.h>
 #include <stdlib.h>
@@ -38,13 +38,13 @@ namespace hash_internal {
 // integers are hashed into the result.
 //
 // To allow all hashable types (including string_view and Span) to depend on
-// this algorithm, we keep the API low-level, with as few dependencies as
+// this algorithm, we keep the API low-level, with as few dependencies as 
 // possible.
-uint64_t LowLevelHash(const void* data, size_t len, uint64_t seed,
-                      const uint64_t salt[5]);
+uint64_t LowLevelHash(const void* data, size_t len, uint64_t seed, 
+                      const uint64_t salt[5]); 
 
 }  // namespace hash_internal
 ABSL_NAMESPACE_END
 }  // namespace y_absl
 
-#endif  // ABSL_HASH_INTERNAL_LOW_LEVEL_HASH_H_
+#endif  // ABSL_HASH_INTERNAL_LOW_LEVEL_HASH_H_ 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/ya.make
index 7f3aae3751..f04389ca52 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal/ya.make
@@ -26,7 +26,7 @@ ADDINCL(
 NO_COMPILER_WARNINGS()
 
 SRCS(
-    low_level_hash.cc
+    low_level_hash.cc 
 )
 
 END()
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/ya.make
index 576811ee62..e9419e6061 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/hash/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/hash/ya.make
@@ -9,23 +9,23 @@ OWNER(
 
 LICENSE(Apache-2.0)
 
-LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
-
+LICENSE_TEXTS(.yandex_meta/licenses.list.txt) 
+ 
 PEERDIR(
     contrib/restricted/abseil-cpp-tstring/y_absl/base
     contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging
     contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait
     contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/throw_delegate
     contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity
-    contrib/restricted/abseil-cpp-tstring/y_absl/city
-    contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal
+    contrib/restricted/abseil-cpp-tstring/y_absl/city 
+    contrib/restricted/abseil-cpp-tstring/y_absl/hash/internal 
     contrib/restricted/abseil-cpp-tstring/y_absl/numeric
     contrib/restricted/abseil-cpp-tstring/y_absl/strings
-    contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_strings_internal
+    contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_strings_internal 
     contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_optional_access
-    contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_variant_access
+    contrib/restricted/abseil-cpp-tstring/y_absl/types/bad_variant_access 
     contrib/restricted/abseil-cpp-tstring/y_absl/types
-    contrib/restricted/abseil-cpp-tstring/y_absl/types/internal
+    contrib/restricted/abseil-cpp-tstring/y_absl/types/internal 
 )
 
 ADDINCL(
@@ -35,7 +35,7 @@ ADDINCL(
 NO_COMPILER_WARNINGS()
 
 SRCS(
-    internal/hash.cc
+    internal/hash.cc 
 )
 
 END()