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

37 files changed, 572 insertions, 572 deletions

diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_strings_internal/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_strings_internal/ya.make
index 6b12ede171..4e57fc75f6 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_strings_internal/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_strings_internal/ya.make
@@ -11,23 +11,23 @@ OWNER(
 
 LICENSE(Apache-2.0)
 
-PEERDIR( 
+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/raw_logging
     contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity 
-) 
- 
-ADDINCL( 
-    GLOBAL contrib/restricted/abseil-cpp-tstring 
-) 
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity
+)
+
+ADDINCL(
+    GLOBAL contrib/restricted/abseil-cpp-tstring
+)
 
 NO_COMPILER_WARNINGS()
 
 SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal)
 
 SRCS(
-    escaping.cc 
+    escaping.cc
     ostringstream.cc
     utf8.cc
 )
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/char_map.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/char_map.h
index 9d19d6b721..25428e304c 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/char_map.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/char_map.h
@@ -28,7 +28,7 @@
 #include "y_absl/base/port.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN 
+ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 class Charmap {
@@ -150,7 +150,7 @@ constexpr Charmap GraphCharmap() { return PrintCharmap() & ~SpaceCharmap(); }
 constexpr Charmap PunctCharmap() { return GraphCharmap() & ~AlnumCharmap(); }
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END 
+ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 #endif  // ABSL_STRINGS_INTERNAL_CHAR_MAP_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.cc
index c14e28c0c5..72a4fa188b 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.cc
@@ -16,10 +16,10 @@
 
 #include <algorithm>
 #include <cassert>
-#include <util/generic/string.h> 
+#include <util/generic/string.h>
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN 
+ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 namespace {
@@ -158,12 +158,12 @@ const uint32_t* LargePowerOfFiveData(int i) {
 int LargePowerOfFiveSize(int i) { return 2 * i; }
 }  // namespace
 
-ABSL_DLL const uint32_t kFiveToNth[14] = { 
+ABSL_DLL const uint32_t kFiveToNth[14] = {
     1,     5,      25,      125,     625,      3125,      15625,
     78125, 390625, 1953125, 9765625, 48828125, 244140625, 1220703125,
 };
 
-ABSL_DLL const uint32_t kTenToNth[10] = { 
+ABSL_DLL const uint32_t kTenToNth[10] = {
     1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000,
 };
 
@@ -355,5 +355,5 @@ template class BigUnsigned<4>;
 template class BigUnsigned<84>;
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END 
+ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.h
index 11c5581bad..a77aab14dd 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_bigint.h
@@ -18,15 +18,15 @@
 #include <algorithm>
 #include <cstdint>
 #include <iostream>
-#include <util/generic/string.h> 
+#include <util/generic/string.h>
 
-#include "y_absl/base/config.h" 
+#include "y_absl/base/config.h"
 #include "y_absl/strings/ascii.h"
 #include "y_absl/strings/internal/charconv_parse.h"
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN 
+ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 // The largest power that 5 that can be raised to, and still fit in a uint32_t.
@@ -34,9 +34,9 @@ constexpr int kMaxSmallPowerOfFive = 13;
 // The largest power that 10 that can be raised to, and still fit in a uint32_t.
 constexpr int kMaxSmallPowerOfTen = 9;
 
-ABSL_DLL extern const uint32_t 
-    kFiveToNth[kMaxSmallPowerOfFive + 1]; 
-ABSL_DLL extern const uint32_t kTenToNth[kMaxSmallPowerOfTen + 1]; 
+ABSL_DLL extern const uint32_t
+    kFiveToNth[kMaxSmallPowerOfFive + 1];
+ABSL_DLL extern const uint32_t kTenToNth[kMaxSmallPowerOfTen + 1];
 
 // Large, fixed-width unsigned integer.
 //
@@ -417,7 +417,7 @@ extern template class BigUnsigned<4>;
 extern template class BigUnsigned<84>;
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END 
+ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 #endif  // ABSL_STRINGS_INTERNAL_CHARCONV_BIGINT_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_parse.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_parse.cc
index 050f1cf0af..f0f78eb68c 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_parse.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_parse.cc
@@ -22,7 +22,7 @@
 #include "y_absl/strings/internal/memutil.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN 
+ABSL_NAMESPACE_BEGIN
 namespace {
 
 // ParseFloat<10> will read the first 19 significant digits of the mantissa.
@@ -500,5 +500,5 @@ template ParsedFloat ParseFloat<16>(const char* begin, const char* end,
                                     chars_format format_flags);
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END 
+ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_parse.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_parse.h
index 83b74723af..3f942cd4cb 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_parse.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/charconv_parse.h
@@ -17,11 +17,11 @@
 
 #include <cstdint>
 
-#include "y_absl/base/config.h" 
+#include "y_absl/base/config.h"
 #include "y_absl/strings/charconv.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN 
+ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 // Enum indicating whether a parsed float is a number or special value.
@@ -94,6 +94,6 @@ extern template ParsedFloat ParseFloat<16>(const char* begin, const char* end,
                                            y_absl::chars_format format_flags);
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END 
+ABSL_NAMESPACE_END
 }  // namespace y_absl
 #endif  // ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_internal.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_internal.h
index f9986faf33..82f5ac7b81 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_internal.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cord_internal.h
@@ -1,38 +1,38 @@
 // Copyright 2021 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_STRINGS_INTERNAL_CORD_INTERNAL_H_ 
-#define ABSL_STRINGS_INTERNAL_CORD_INTERNAL_H_ 
- 
-#include <atomic> 
-#include <cassert> 
-#include <cstddef> 
-#include <cstdint> 
-#include <type_traits> 
- 
+//
+// 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_STRINGS_INTERNAL_CORD_INTERNAL_H_
+#define ABSL_STRINGS_INTERNAL_CORD_INTERNAL_H_
+
+#include <atomic>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <type_traits>
+
 #include "y_absl/base/config.h"
 #include "y_absl/base/internal/endian.h"
 #include "y_absl/base/internal/invoke.h"
 #include "y_absl/base/optimization.h"
 #include "y_absl/container/internal/compressed_tuple.h"
-#include "y_absl/meta/type_traits.h" 
-#include "y_absl/strings/string_view.h" 
- 
-namespace y_absl { 
-ABSL_NAMESPACE_BEGIN 
-namespace cord_internal { 
- 
+#include "y_absl/meta/type_traits.h"
+#include "y_absl/strings/string_view.h"
+
+namespace y_absl {
+ABSL_NAMESPACE_BEGIN
+namespace cord_internal {
+
 class CordzInfo;
 
 // Default feature enable states for cord ring buffers
@@ -83,48 +83,48 @@ enum Constants {
 // Compact class for tracking the reference count and state flags for CordRep
 // instances.  Data is stored in an atomic int32_t for compactness and speed.
 class RefcountAndFlags {
- public: 
+ public:
   constexpr RefcountAndFlags() : count_{kRefIncrement} {}
   struct Immortal {};
   explicit constexpr RefcountAndFlags(Immortal) : count_(kImmortalFlag) {}
   struct WithCrc {};
   explicit constexpr RefcountAndFlags(WithCrc)
       : count_(kCrcFlag | kRefIncrement) {}
- 
+
   // Increments the reference count. Imposes no memory ordering.
   inline void Increment() {
     count_.fetch_add(kRefIncrement, std::memory_order_relaxed);
   }
- 
-  // Asserts that the current refcount is greater than 0. If the refcount is 
+
+  // Asserts that the current refcount is greater than 0. If the refcount is
   // greater than 1, decrements the reference count.
-  // 
-  // Returns false if there are no references outstanding; true otherwise. 
-  // Inserts barriers to ensure that state written before this method returns 
-  // false will be visible to a thread that just observed this method returning 
+  //
+  // Returns false if there are no references outstanding; true otherwise.
+  // Inserts barriers to ensure that state written before this method returns
+  // false will be visible to a thread that just observed this method returning
   // false.  Always returns false when the immortal bit is set.
-  inline bool Decrement() { 
+  inline bool Decrement() {
     int32_t refcount = count_.load(std::memory_order_acquire) & kRefcountMask;
     assert(refcount > 0 || refcount & kImmortalFlag);
     return refcount != kRefIncrement &&
            (count_.fetch_sub(kRefIncrement, std::memory_order_acq_rel) &
             kRefcountMask) != kRefIncrement;
-  } 
- 
-  // Same as Decrement but expect that refcount is greater than 1. 
-  inline bool DecrementExpectHighRefcount() { 
+  }
+
+  // Same as Decrement but expect that refcount is greater than 1.
+  inline bool DecrementExpectHighRefcount() {
     int32_t refcount =
         count_.fetch_sub(kRefIncrement, std::memory_order_acq_rel) &
         kRefcountMask;
     assert(refcount > 0 || refcount & kImmortalFlag);
     return refcount != kRefIncrement;
-  } 
- 
-  // Returns the current reference count using acquire semantics. 
+  }
+
+  // Returns the current reference count using acquire semantics.
   inline int32_t Get() const {
     return count_.load(std::memory_order_acquire) >> kNumFlags;
   }
- 
+
   // Returns true if the referenced object carries a CRC value.
   bool HasCrc() const {
     return (count_.load(std::memory_order_relaxed) & kCrcFlag) != 0;
@@ -155,12 +155,12 @@ class RefcountAndFlags {
     return (count_.load(std::memory_order_acquire) & kRefcountMask) ==
            kRefIncrement;
   }
- 
+
   bool IsImmortal() const {
     return (count_.load(std::memory_order_relaxed) & kImmortalFlag) != 0;
   }
 
- private: 
+ private:
   // We reserve the bottom bits for flags.
   // kImmortalBit indicates that this entity should never be collected; it is
   // used for the StringConstant constructor to avoid collecting immutable
@@ -180,21 +180,21 @@ class RefcountAndFlags {
     kRefcountMask = ~kCrcFlag,
   };
 
-  std::atomic<int32_t> count_; 
-}; 
- 
-// The overhead of a vtable is too much for Cord, so we roll our own subclasses 
-// using only a single byte to differentiate classes from each other - the "tag" 
-// byte.  Define the subclasses first so we can provide downcasting helper 
-// functions in the base class. 
- 
-struct CordRepConcat; 
+  std::atomic<int32_t> count_;
+};
+
+// The overhead of a vtable is too much for Cord, so we roll our own subclasses
+// using only a single byte to differentiate classes from each other - the "tag"
+// byte.  Define the subclasses first so we can provide downcasting helper
+// functions in the base class.
+
+struct CordRepConcat;
 struct CordRepExternal;
 struct CordRepFlat;
-struct CordRepSubstring; 
+struct CordRepSubstring;
 class CordRepRing;
 class CordRepBtree;
- 
+
 // Various representations that we allow
 enum CordRepKind {
   CONCAT = 0,
@@ -224,19 +224,19 @@ static_assert(RING == BTREE + 1, "BTREE and RING not consecutive");
 static_assert(EXTERNAL == RING + 1, "BTREE and EXTERNAL not consecutive");
 static_assert(FLAT == EXTERNAL + 1, "EXTERNAL and FLAT not consecutive");
 
-struct CordRep { 
+struct CordRep {
   CordRep() = default;
   constexpr CordRep(RefcountAndFlags::Immortal immortal, size_t l)
       : length(l), refcount(immortal), tag(EXTERNAL), storage{} {}
 
-  // The following three fields have to be less than 32 bytes since 
-  // that is the smallest supported flat node size. 
+  // The following three fields have to be less than 32 bytes since
+  // that is the smallest supported flat node size.
   size_t length;
   RefcountAndFlags refcount;
-  // If tag < FLAT, it represents CordRepKind and indicates the type of node. 
-  // Otherwise, the node type is CordRepFlat and the tag is the encoded size. 
-  uint8_t tag; 
- 
+  // If tag < FLAT, it represents CordRepKind and indicates the type of node.
+  // Otherwise, the node type is CordRepFlat and the tag is the encoded size.
+  uint8_t tag;
+
   // `storage` provides two main purposes:
   // - the starting point for FlatCordRep.Data() [flexible-array-member]
   // - 3 bytes of additional storage for use by derived classes.
@@ -257,12 +257,12 @@ struct CordRep {
 
   inline CordRepRing* ring();
   inline const CordRepRing* ring() const;
-  inline CordRepConcat* concat(); 
-  inline const CordRepConcat* concat() const; 
-  inline CordRepSubstring* substring(); 
-  inline const CordRepSubstring* substring() const; 
-  inline CordRepExternal* external(); 
-  inline const CordRepExternal* external() const; 
+  inline CordRepConcat* concat();
+  inline const CordRepConcat* concat() const;
+  inline CordRepSubstring* substring();
+  inline const CordRepSubstring* substring() const;
+  inline CordRepExternal* external();
+  inline const CordRepExternal* external() const;
   inline CordRepFlat* flat();
   inline const CordRepFlat* flat() const;
   inline CordRepBtree* btree();
@@ -281,28 +281,28 @@ struct CordRep {
   // Decrements the reference count of `rep`. Destroys rep if count reaches
   // zero. Requires `rep` to be a non-null pointer value.
   static inline void Unref(CordRep* rep);
-}; 
- 
-struct CordRepConcat : public CordRep { 
-  CordRep* left; 
-  CordRep* right; 
- 
+};
+
+struct CordRepConcat : public CordRep {
+  CordRep* left;
+  CordRep* right;
+
   uint8_t depth() const { return storage[0]; }
   void set_depth(uint8_t depth) { storage[0] = depth; }
-}; 
- 
-struct CordRepSubstring : public CordRep { 
-  size_t start;  // Starting offset of substring in child 
-  CordRep* child; 
-}; 
- 
+};
+
+struct CordRepSubstring : public CordRep {
+  size_t start;  // Starting offset of substring in child
+  CordRep* child;
+};
+
 // Type for function pointer that will invoke the releaser function and also
 // delete the `CordRepExternalImpl` corresponding to the passed in
 // `CordRepExternal`.
 using ExternalReleaserInvoker = void (*)(CordRepExternal*);
- 
-// External CordReps are allocated together with a type erased releaser. The 
-// releaser is stored in the memory directly following the CordRepExternal. 
+
+// External CordReps are allocated together with a type erased releaser. The
+// releaser is stored in the memory directly following the CordRepExternal.
 struct CordRepExternal : public CordRep {
   CordRepExternal() = default;
   explicit constexpr CordRepExternal(y_absl::string_view str)
@@ -310,18 +310,18 @@ struct CordRepExternal : public CordRep {
         base(str.data()),
         releaser_invoker(nullptr) {}
 
-  const char* base; 
-  // Pointer to function that knows how to call and destroy the releaser. 
-  ExternalReleaserInvoker releaser_invoker; 
+  const char* base;
+  // Pointer to function that knows how to call and destroy the releaser.
+  ExternalReleaserInvoker releaser_invoker;
 
   // Deletes (releases) the external rep.
   // Requires rep != nullptr and rep->IsExternal()
   static void Delete(CordRep* rep);
-}; 
- 
+};
+
 struct Rank1 {};
 struct Rank0 : Rank1 {};
- 
+
 template <typename Releaser, typename = ::y_absl::base_internal::invoke_result_t<
                                  Releaser, y_absl::string_view>>
 void InvokeReleaser(Rank0, Releaser&& releaser, y_absl::string_view data) {
@@ -613,8 +613,8 @@ inline void CordRep::Unref(CordRep* rep) {
   }
 }
 
-}  // namespace cord_internal 
+}  // namespace cord_internal
 
-ABSL_NAMESPACE_END 
-}  // namespace y_absl 
-#endif  // ABSL_STRINGS_INTERNAL_CORD_INTERNAL_H_ 
+ABSL_NAMESPACE_END
+}  // namespace y_absl
+#endif  // ABSL_STRINGS_INTERNAL_CORD_INTERNAL_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_functions/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_functions/ya.make
index 613da918ff..06e99346da 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_functions/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/cordz_functions/ya.make
@@ -17,9 +17,9 @@ PEERDIR(
     contrib/restricted/abseil-cpp-tstring/y_absl/profiling/internal/exponential_biased
 )
 
-ADDINCL( 
-    GLOBAL contrib/restricted/abseil-cpp-tstring 
-) 
+ADDINCL(
+    GLOBAL contrib/restricted/abseil-cpp-tstring
+)
 
 NO_COMPILER_WARNINGS()
 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/escaping.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/escaping.cc
index 36218c2bbd..01b8974983 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/escaping.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/escaping.cc
@@ -1,180 +1,180 @@
-// Copyright 2020 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/strings/internal/escaping.h" 
- 
-#include "y_absl/base/internal/endian.h" 
-#include "y_absl/base/internal/raw_logging.h" 
- 
-namespace y_absl { 
-ABSL_NAMESPACE_BEGIN 
-namespace strings_internal { 
- 
-const char kBase64Chars[] = 
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; 
- 
-size_t CalculateBase64EscapedLenInternal(size_t input_len, bool do_padding) { 
-  // Base64 encodes three bytes of input at a time. If the input is not 
-  // divisible by three, we pad as appropriate. 
-  // 
-  // (from https://tools.ietf.org/html/rfc3548) 
-  // Special processing is performed if fewer than 24 bits are available 
-  // at the end of the data being encoded.  A full encoding quantum is 
-  // always completed at the end of a quantity.  When fewer than 24 input 
-  // bits are available in an input group, zero bits are added (on the 
-  // right) to form an integral number of 6-bit groups.  Padding at the 
-  // end of the data is performed using the '=' character.  Since all base 
-  // 64 input is an integral number of octets, only the following cases 
-  // can arise: 
- 
-  // Base64 encodes each three bytes of input into four bytes of output. 
-  size_t len = (input_len / 3) * 4; 
- 
-  if (input_len % 3 == 0) { 
-    // (from https://tools.ietf.org/html/rfc3548) 
-    // (1) the final quantum of encoding input is an integral multiple of 24 
-    // bits; here, the final unit of encoded output will be an integral 
-    // multiple of 4 characters with no "=" padding, 
-  } else if (input_len % 3 == 1) { 
-    // (from https://tools.ietf.org/html/rfc3548) 
-    // (2) the final quantum of encoding input is exactly 8 bits; here, the 
-    // final unit of encoded output will be two characters followed by two 
-    // "=" padding characters, or 
-    len += 2; 
-    if (do_padding) { 
-      len += 2; 
-    } 
-  } else {  // (input_len % 3 == 2) 
-    // (from https://tools.ietf.org/html/rfc3548) 
-    // (3) the final quantum of encoding input is exactly 16 bits; here, the 
-    // final unit of encoded output will be three characters followed by one 
-    // "=" padding character. 
-    len += 3; 
-    if (do_padding) { 
-      len += 1; 
-    } 
-  } 
- 
-  assert(len >= input_len);  // make sure we didn't overflow 
-  return len; 
-} 
- 
-size_t Base64EscapeInternal(const unsigned char* src, size_t szsrc, char* dest, 
-                            size_t szdest, const char* base64, 
-                            bool do_padding) { 
-  static const char kPad64 = '='; 
- 
-  if (szsrc * 4 > szdest * 3) return 0; 
- 
-  char* cur_dest = dest; 
-  const unsigned char* cur_src = src; 
- 
-  char* const limit_dest = dest + szdest; 
-  const unsigned char* const limit_src = src + szsrc; 
- 
-  // Three bytes of data encodes to four characters of cyphertext. 
-  // So we can pump through three-byte chunks atomically. 
-  if (szsrc >= 3) {                    // "limit_src - 3" is UB if szsrc < 3. 
-    while (cur_src < limit_src - 3) {  // While we have >= 32 bits. 
-      uint32_t in = y_absl::big_endian::Load32(cur_src) >> 8; 
- 
-      cur_dest[0] = base64[in >> 18]; 
-      in &= 0x3FFFF; 
-      cur_dest[1] = base64[in >> 12]; 
-      in &= 0xFFF; 
-      cur_dest[2] = base64[in >> 6]; 
-      in &= 0x3F; 
-      cur_dest[3] = base64[in]; 
- 
-      cur_dest += 4; 
-      cur_src += 3; 
-    } 
-  } 
-  // To save time, we didn't update szdest or szsrc in the loop.  So do it now. 
-  szdest = limit_dest - cur_dest; 
-  szsrc = limit_src - cur_src; 
- 
-  /* now deal with the tail (<=3 bytes) */ 
-  switch (szsrc) { 
-    case 0: 
-      // Nothing left; nothing more to do. 
-      break; 
-    case 1: { 
-      // One byte left: this encodes to two characters, and (optionally) 
-      // two pad characters to round out the four-character cypherblock. 
-      if (szdest < 2) return 0; 
-      uint32_t in = cur_src[0]; 
-      cur_dest[0] = base64[in >> 2]; 
-      in &= 0x3; 
-      cur_dest[1] = base64[in << 4]; 
-      cur_dest += 2; 
-      szdest -= 2; 
-      if (do_padding) { 
-        if (szdest < 2) return 0; 
-        cur_dest[0] = kPad64; 
-        cur_dest[1] = kPad64; 
-        cur_dest += 2; 
-        szdest -= 2; 
-      } 
-      break; 
-    } 
-    case 2: { 
-      // Two bytes left: this encodes to three characters, and (optionally) 
-      // one pad character to round out the four-character cypherblock. 
-      if (szdest < 3) return 0; 
-      uint32_t in = y_absl::big_endian::Load16(cur_src); 
-      cur_dest[0] = base64[in >> 10]; 
-      in &= 0x3FF; 
-      cur_dest[1] = base64[in >> 4]; 
-      in &= 0x00F; 
-      cur_dest[2] = base64[in << 2]; 
-      cur_dest += 3; 
-      szdest -= 3; 
-      if (do_padding) { 
-        if (szdest < 1) return 0; 
-        cur_dest[0] = kPad64; 
-        cur_dest += 1; 
-        szdest -= 1; 
-      } 
-      break; 
-    } 
-    case 3: { 
-      // Three bytes left: same as in the big loop above.  We can't do this in 
-      // the loop because the loop above always reads 4 bytes, and the fourth 
-      // byte is past the end of the input. 
-      if (szdest < 4) return 0; 
-      uint32_t in = (cur_src[0] << 16) + y_absl::big_endian::Load16(cur_src + 1); 
-      cur_dest[0] = base64[in >> 18]; 
-      in &= 0x3FFFF; 
-      cur_dest[1] = base64[in >> 12]; 
-      in &= 0xFFF; 
-      cur_dest[2] = base64[in >> 6]; 
-      in &= 0x3F; 
-      cur_dest[3] = base64[in]; 
-      cur_dest += 4; 
-      szdest -= 4; 
-      break; 
-    } 
-    default: 
-      // Should not be reached: blocks of 4 bytes are handled 
-      // in the while loop before this switch statement. 
-      ABSL_RAW_LOG(FATAL, "Logic problem? szsrc = %zu", szsrc); 
-      break; 
-  } 
-  return (cur_dest - dest); 
-} 
- 
-}  // namespace strings_internal 
-ABSL_NAMESPACE_END 
-}  // namespace y_absl 
+// Copyright 2020 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/strings/internal/escaping.h"
+
+#include "y_absl/base/internal/endian.h"
+#include "y_absl/base/internal/raw_logging.h"
+
+namespace y_absl {
+ABSL_NAMESPACE_BEGIN
+namespace strings_internal {
+
+const char kBase64Chars[] =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+size_t CalculateBase64EscapedLenInternal(size_t input_len, bool do_padding) {
+  // Base64 encodes three bytes of input at a time. If the input is not
+  // divisible by three, we pad as appropriate.
+  //
+  // (from https://tools.ietf.org/html/rfc3548)
+  // Special processing is performed if fewer than 24 bits are available
+  // at the end of the data being encoded.  A full encoding quantum is
+  // always completed at the end of a quantity.  When fewer than 24 input
+  // bits are available in an input group, zero bits are added (on the
+  // right) to form an integral number of 6-bit groups.  Padding at the
+  // end of the data is performed using the '=' character.  Since all base
+  // 64 input is an integral number of octets, only the following cases
+  // can arise:
+
+  // Base64 encodes each three bytes of input into four bytes of output.
+  size_t len = (input_len / 3) * 4;
+
+  if (input_len % 3 == 0) {
+    // (from https://tools.ietf.org/html/rfc3548)
+    // (1) the final quantum of encoding input is an integral multiple of 24
+    // bits; here, the final unit of encoded output will be an integral
+    // multiple of 4 characters with no "=" padding,
+  } else if (input_len % 3 == 1) {
+    // (from https://tools.ietf.org/html/rfc3548)
+    // (2) the final quantum of encoding input is exactly 8 bits; here, the
+    // final unit of encoded output will be two characters followed by two
+    // "=" padding characters, or
+    len += 2;
+    if (do_padding) {
+      len += 2;
+    }
+  } else {  // (input_len % 3 == 2)
+    // (from https://tools.ietf.org/html/rfc3548)
+    // (3) the final quantum of encoding input is exactly 16 bits; here, the
+    // final unit of encoded output will be three characters followed by one
+    // "=" padding character.
+    len += 3;
+    if (do_padding) {
+      len += 1;
+    }
+  }
+
+  assert(len >= input_len);  // make sure we didn't overflow
+  return len;
+}
+
+size_t Base64EscapeInternal(const unsigned char* src, size_t szsrc, char* dest,
+                            size_t szdest, const char* base64,
+                            bool do_padding) {
+  static const char kPad64 = '=';
+
+  if (szsrc * 4 > szdest * 3) return 0;
+
+  char* cur_dest = dest;
+  const unsigned char* cur_src = src;
+
+  char* const limit_dest = dest + szdest;
+  const unsigned char* const limit_src = src + szsrc;
+
+  // Three bytes of data encodes to four characters of cyphertext.
+  // So we can pump through three-byte chunks atomically.
+  if (szsrc >= 3) {                    // "limit_src - 3" is UB if szsrc < 3.
+    while (cur_src < limit_src - 3) {  // While we have >= 32 bits.
+      uint32_t in = y_absl::big_endian::Load32(cur_src) >> 8;
+
+      cur_dest[0] = base64[in >> 18];
+      in &= 0x3FFFF;
+      cur_dest[1] = base64[in >> 12];
+      in &= 0xFFF;
+      cur_dest[2] = base64[in >> 6];
+      in &= 0x3F;
+      cur_dest[3] = base64[in];
+
+      cur_dest += 4;
+      cur_src += 3;
+    }
+  }
+  // To save time, we didn't update szdest or szsrc in the loop.  So do it now.
+  szdest = limit_dest - cur_dest;
+  szsrc = limit_src - cur_src;
+
+  /* now deal with the tail (<=3 bytes) */
+  switch (szsrc) {
+    case 0:
+      // Nothing left; nothing more to do.
+      break;
+    case 1: {
+      // One byte left: this encodes to two characters, and (optionally)
+      // two pad characters to round out the four-character cypherblock.
+      if (szdest < 2) return 0;
+      uint32_t in = cur_src[0];
+      cur_dest[0] = base64[in >> 2];
+      in &= 0x3;
+      cur_dest[1] = base64[in << 4];
+      cur_dest += 2;
+      szdest -= 2;
+      if (do_padding) {
+        if (szdest < 2) return 0;
+        cur_dest[0] = kPad64;
+        cur_dest[1] = kPad64;
+        cur_dest += 2;
+        szdest -= 2;
+      }
+      break;
+    }
+    case 2: {
+      // Two bytes left: this encodes to three characters, and (optionally)
+      // one pad character to round out the four-character cypherblock.
+      if (szdest < 3) return 0;
+      uint32_t in = y_absl::big_endian::Load16(cur_src);
+      cur_dest[0] = base64[in >> 10];
+      in &= 0x3FF;
+      cur_dest[1] = base64[in >> 4];
+      in &= 0x00F;
+      cur_dest[2] = base64[in << 2];
+      cur_dest += 3;
+      szdest -= 3;
+      if (do_padding) {
+        if (szdest < 1) return 0;
+        cur_dest[0] = kPad64;
+        cur_dest += 1;
+        szdest -= 1;
+      }
+      break;
+    }
+    case 3: {
+      // Three bytes left: same as in the big loop above.  We can't do this in
+      // the loop because the loop above always reads 4 bytes, and the fourth
+      // byte is past the end of the input.
+      if (szdest < 4) return 0;
+      uint32_t in = (cur_src[0] << 16) + y_absl::big_endian::Load16(cur_src + 1);
+      cur_dest[0] = base64[in >> 18];
+      in &= 0x3FFFF;
+      cur_dest[1] = base64[in >> 12];
+      in &= 0xFFF;
+      cur_dest[2] = base64[in >> 6];
+      in &= 0x3F;
+      cur_dest[3] = base64[in];
+      cur_dest += 4;
+      szdest -= 4;
+      break;
+    }
+    default:
+      // Should not be reached: blocks of 4 bytes are handled
+      // in the while loop before this switch statement.
+      ABSL_RAW_LOG(FATAL, "Logic problem? szsrc = %zu", szsrc);
+      break;
+  }
+  return (cur_dest - dest);
+}
+
+}  // namespace strings_internal
+ABSL_NAMESPACE_END
+}  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/escaping.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/escaping.h
index be8dc4460e..d62fc0fbcb 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/escaping.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/escaping.h
@@ -1,58 +1,58 @@
-// Copyright 2020 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_STRINGS_INTERNAL_ESCAPING_H_ 
-#define ABSL_STRINGS_INTERNAL_ESCAPING_H_ 
- 
-#include <cassert> 
- 
-#include "y_absl/strings/internal/resize_uninitialized.h" 
- 
-namespace y_absl { 
-ABSL_NAMESPACE_BEGIN 
-namespace strings_internal { 
- 
-ABSL_CONST_INIT extern const char kBase64Chars[]; 
- 
-// Calculates how long a string will be when it is base64 encoded given its 
-// length and whether or not the result should be padded. 
-size_t CalculateBase64EscapedLenInternal(size_t input_len, bool do_padding); 
- 
-// Base64-encodes `src` using the alphabet provided in `base64` and writes the 
-// result to `dest`. If `do_padding` is true, `dest` is padded with '=' chars 
-// until its length is a multiple of 3. Returns the length of `dest`. 
-size_t Base64EscapeInternal(const unsigned char* src, size_t szsrc, char* dest, 
-                            size_t szdest, const char* base64, bool do_padding); 
- 
-// Base64-encodes `src` using the alphabet provided in `base64` and writes the 
-// result to `dest`. If `do_padding` is true, `dest` is padded with '=' chars 
-// until its length is a multiple of 3. 
-template <typename String> 
-void Base64EscapeInternal(const unsigned char* src, size_t szsrc, String* dest, 
-                          bool do_padding, const char* base64_chars) { 
-  const size_t calc_escaped_size = 
-      CalculateBase64EscapedLenInternal(szsrc, do_padding); 
-  STLStringResizeUninitialized(dest, calc_escaped_size); 
- 
-  const size_t escaped_len = Base64EscapeInternal( 
-      src, szsrc, &(*dest)[0], dest->size(), base64_chars, do_padding); 
-  assert(calc_escaped_size == escaped_len); 
-  dest->erase(escaped_len); 
-} 
- 
-}  // namespace strings_internal 
-ABSL_NAMESPACE_END 
-}  // namespace y_absl 
- 
-#endif  // ABSL_STRINGS_INTERNAL_ESCAPING_H_ 
+// Copyright 2020 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_STRINGS_INTERNAL_ESCAPING_H_
+#define ABSL_STRINGS_INTERNAL_ESCAPING_H_
+
+#include <cassert>
+
+#include "y_absl/strings/internal/resize_uninitialized.h"
+
+namespace y_absl {
+ABSL_NAMESPACE_BEGIN
+namespace strings_internal {
+
+ABSL_CONST_INIT extern const char kBase64Chars[];
+
+// Calculates how long a string will be when it is base64 encoded given its
+// length and whether or not the result should be padded.
+size_t CalculateBase64EscapedLenInternal(size_t input_len, bool do_padding);
+
+// Base64-encodes `src` using the alphabet provided in `base64` and writes the
+// result to `dest`. If `do_padding` is true, `dest` is padded with '=' chars
+// until its length is a multiple of 3. Returns the length of `dest`.
+size_t Base64EscapeInternal(const unsigned char* src, size_t szsrc, char* dest,
+                            size_t szdest, const char* base64, bool do_padding);
+
+// Base64-encodes `src` using the alphabet provided in `base64` and writes the
+// result to `dest`. If `do_padding` is true, `dest` is padded with '=' chars
+// until its length is a multiple of 3.
+template <typename String>
+void Base64EscapeInternal(const unsigned char* src, size_t szsrc, String* dest,
+                          bool do_padding, const char* base64_chars) {
+  const size_t calc_escaped_size =
+      CalculateBase64EscapedLenInternal(szsrc, do_padding);
+  STLStringResizeUninitialized(dest, calc_escaped_size);
+
+  const size_t escaped_len = Base64EscapeInternal(
+      src, szsrc, &(*dest)[0], dest->size(), base64_chars, do_padding);
+  assert(calc_escaped_size == escaped_len);
+  dest->erase(escaped_len);
+}
+
+}  // namespace strings_internal
+ABSL_NAMESPACE_END
+}  // namespace y_absl
+
+#endif  // ABSL_STRINGS_INTERNAL_ESCAPING_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/escaping_test_common.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/escaping_test_common.h
index 20f98e27b0..f145127225 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/escaping_test_common.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/escaping_test_common.h
@@ -22,7 +22,7 @@
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN 
+ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 struct base64_testcase {
@@ -127,7 +127,7 @@ inline const std::array<base64_testcase, 5>& base64_strings() {
 }
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END 
+ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 #endif  // ABSL_STRINGS_INTERNAL_ESCAPING_TEST_COMMON_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/memutil.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/memutil.cc
index fcd0fd6ace..0ba6574fdb 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/memutil.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/memutil.cc
@@ -17,7 +17,7 @@
 #include <cstdlib>
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN 
+ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 int memcasecmp(const char* s1, const char* s2, size_t len) {
@@ -108,5 +108,5 @@ const char* memmatch(const char* phaystack, size_t haylen, const char* pneedle,
 }
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END 
+ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/memutil.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/memutil.h
index 050af2c345..ee442fe25f 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/memutil.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/memutil.h
@@ -69,7 +69,7 @@
 #include "y_absl/strings/ascii.h"  // for y_absl::ascii_tolower
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN 
+ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 inline char* memcat(char* dest, size_t destlen, const char* src,
@@ -142,7 +142,7 @@ const char* memmatch(const char* phaystack, size_t haylen, const char* pneedle,
                      size_t neelen);
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END 
+ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 #endif  // ABSL_STRINGS_INTERNAL_MEMUTIL_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/numbers_test_common.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/numbers_test_common.h
index 496cc1889a..12aec3ac11 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/numbers_test_common.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/numbers_test_common.h
@@ -21,12 +21,12 @@
 #include <array>
 #include <cstdint>
 #include <limits>
-#include <util/generic/string.h> 
+#include <util/generic/string.h>
+
+#include "y_absl/base/config.h"
 
-#include "y_absl/base/config.h" 
- 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN 
+ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 template <typename IntType>
@@ -178,7 +178,7 @@ inline const std::array<uint64_test_case, 34>& strtouint64_test_cases() {
 }
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END 
+ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 #endif  // ABSL_STRINGS_INTERNAL_NUMBERS_TEST_COMMON_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/ostringstream.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/ostringstream.cc
index 4427d66e27..ba18857d83 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/ostringstream.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/ostringstream.cc
@@ -15,7 +15,7 @@
 #include "y_absl/strings/internal/ostringstream.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN 
+ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 OStringStream::Buf::int_type OStringStream::overflow(int c) {
@@ -32,5 +32,5 @@ std::streamsize OStringStream::xsputn(const char* s, std::streamsize n) {
 }
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END 
+ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/ostringstream.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/ostringstream.h
index 9dbcf09f57..d00cef9c23 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/ostringstream.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/ostringstream.h
@@ -18,12 +18,12 @@
 #include <cassert>
 #include <ostream>
 #include <streambuf>
-#include <util/generic/string.h> 
+#include <util/generic/string.h>
 
 #include "y_absl/base/port.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN 
+ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 // The same as std::ostringstream but appends to a user-specified TString,
@@ -83,7 +83,7 @@ class OStringStream : private std::basic_streambuf<char>, public std::ostream {
 };
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END 
+ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 #endif  // ABSL_STRINGS_INTERNAL_OSTRINGSTREAM_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/pow10_helper.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/pow10_helper.h
index 7b529e72a4..e4d41d7e4e 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/pow10_helper.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/pow10_helper.h
@@ -22,10 +22,10 @@
 
 #include <vector>
 
-#include "y_absl/base/config.h" 
- 
+#include "y_absl/base/config.h"
+
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN 
+ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 // Computes the precise value of 10^exp. (I.e. the nearest representable
@@ -34,7 +34,7 @@ namespace strings_internal {
 double Pow10(int exp);
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END 
+ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 #endif  // ABSL_STRINGS_INTERNAL_POW10_HELPER_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/resize_uninitialized.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/resize_uninitialized.h
index 68063a1922..14860bb237 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/resize_uninitialized.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/resize_uninitialized.h
@@ -18,7 +18,7 @@
 #define ABSL_STRINGS_INTERNAL_RESIZE_UNINITIALIZED_H_
 
 #include <algorithm>
-#include <util/generic/string.h> 
+#include <util/generic/string.h>
 #include <type_traits>
 #include <utility>
 
@@ -26,7 +26,7 @@
 #include "y_absl/meta/type_traits.h"  //  for void_t
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN 
+ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 // In this type trait, we look for a __resize_default_init member function, and
@@ -113,7 +113,7 @@ void STLStringResizeUninitializedAmortized(string_type* s, size_t new_size) {
 }
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END 
+ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 #endif  // ABSL_STRINGS_INTERNAL_RESIZE_UNINITIALIZED_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/stl_type_traits.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/stl_type_traits.h
index a8a79a0e7d..db8d4635d0 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/stl_type_traits.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/stl_type_traits.h
@@ -40,7 +40,7 @@
 #include "y_absl/meta/type_traits.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN 
+ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 template <typename C, template <typename...> class T>
@@ -243,6 +243,6 @@ struct IsStrictlyBaseOfAndConvertibleToSTLContainer
                         IsConvertibleToSTLContainer<C>> {};
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END 
+ABSL_NAMESPACE_END
 }  // namespace y_absl
 #endif  // ABSL_STRINGS_INTERNAL_STL_TYPE_TRAITS_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.cc
index ebe05ae232..8d5c3b61ac 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.cc
@@ -21,7 +21,7 @@
 #include <cassert>
 #include <cerrno>
 #include <cstdlib>
-#include <util/generic/string.h> 
+#include <util/generic/string.h>
 #include <type_traits>
 
 #include "y_absl/base/port.h"
@@ -29,7 +29,7 @@
 #include "y_absl/strings/numbers.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN 
+ABSL_NAMESPACE_BEGIN
 namespace str_format_internal {
 namespace {
 
@@ -334,7 +334,7 @@ template <typename T>
 bool ConvertFloatArg(T v, const FormatConversionSpecImpl conv,
                      FormatSinkImpl *sink) {
   return FormatConversionCharIsFloat(conv.conversion_char()) &&
-         ConvertFloatImpl(v, conv, sink); 
+         ConvertFloatImpl(v, conv, sink);
 }
 
 inline bool ConvertStringArg(string_view v, const FormatConversionSpecImpl conv,
@@ -374,7 +374,7 @@ FormatConvertImpl(const char *v, const FormatConversionSpecImpl conv,
   } else if (conv.precision() < 0) {
     len = std::strlen(v);
   } else {
-    // If precision is set, we look for the NUL-terminator on the valid range. 
+    // If precision is set, we look for the NUL-terminator on the valid range.
     len = std::find(v, v + conv.precision(), '\0') - v;
   }
   return {ConvertStringArg(string_view(v, len), conv, sink)};
@@ -484,5 +484,5 @@ ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_();
 
 }  // namespace str_format_internal
 
-ABSL_NAMESPACE_END 
+ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.h
index 1413fc721f..59b7bcc727 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/arg.h
@@ -23,7 +23,7 @@
 #include <limits>
 #include <memory>
 #include <sstream>
-#include <util/generic/string.h> 
+#include <util/generic/string.h>
 #include <util/stream/str.h>
 #include <type_traits>
 
@@ -34,9 +34,9 @@
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN 
+ABSL_NAMESPACE_BEGIN
 
-class Cord; 
+class Cord;
 class FormatCountCapture;
 class FormatSink;
 
@@ -157,17 +157,17 @@ StringConvertResult FormatConvertImpl(const AbslCord& value,
 
   if (space_remaining > 0 && !is_left) sink->Append(space_remaining, ' ');
 
-  for (string_view piece : value.Chunks()) { 
-    if (piece.size() > to_write) { 
-      piece.remove_suffix(piece.size() - to_write); 
-      to_write = 0; 
-    } else { 
-      to_write -= piece.size(); 
-    } 
+  for (string_view piece : value.Chunks()) {
+    if (piece.size() > to_write) {
+      piece.remove_suffix(piece.size() - to_write);
+      to_write = 0;
+    } else {
+      to_write -= piece.size();
+    }
     sink->Append(piece);
-    if (to_write == 0) { 
-      break; 
-    } 
+    if (to_write == 0) {
+      break;
+    }
   }
 
   if (space_remaining > 0 && is_left) sink->Append(space_remaining, ' ');
@@ -522,7 +522,7 @@ ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_(extern);
 
 
 }  // namespace str_format_internal
-ABSL_NAMESPACE_END 
+ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 #endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_ARG_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/bind.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/bind.cc
index aff5aad744..211ce25dea 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/bind.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/bind.cc
@@ -17,10 +17,10 @@
 #include <cerrno>
 #include <limits>
 #include <sstream>
-#include <util/generic/string.h> 
+#include <util/generic/string.h>
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN 
+ABSL_NAMESPACE_BEGIN
 namespace str_format_internal {
 
 namespace {
@@ -80,21 +80,21 @@ inline bool ArgContext::Bind(const UnboundConversion* unbound,
         return false;
     }
 
-    FormatConversionSpecImplFriend::SetWidth(width, bound); 
-    FormatConversionSpecImplFriend::SetPrecision(precision, bound); 
- 
-    if (force_left) { 
+    FormatConversionSpecImplFriend::SetWidth(width, bound);
+    FormatConversionSpecImplFriend::SetPrecision(precision, bound);
+
+    if (force_left) {
       FormatConversionSpecImplFriend::SetFlags(unbound->flags | Flags::kLeft,
                                                bound);
-    } else { 
-      FormatConversionSpecImplFriend::SetFlags(unbound->flags, bound); 
-    } 
+    } else {
+      FormatConversionSpecImplFriend::SetFlags(unbound->flags, bound);
+    }
   } else {
-    FormatConversionSpecImplFriend::SetFlags(unbound->flags, bound); 
-    FormatConversionSpecImplFriend::SetWidth(-1, bound); 
-    FormatConversionSpecImplFriend::SetPrecision(-1, bound); 
+    FormatConversionSpecImplFriend::SetFlags(unbound->flags, bound);
+    FormatConversionSpecImplFriend::SetWidth(-1, bound);
+    FormatConversionSpecImplFriend::SetPrecision(-1, bound);
   }
-  FormatConversionSpecImplFriend::SetConversionChar(unbound->conv, bound); 
+  FormatConversionSpecImplFriend::SetConversionChar(unbound->conv, bound);
   bound->set_arg(arg);
   return true;
 }
@@ -156,8 +156,8 @@ class SummarizingConverter {
     UntypedFormatSpecImpl spec("%d");
 
     std::ostringstream ss;
-    ss << "{" << Streamable(spec, {*bound.arg()}) << ":" 
-       << FormatConversionSpecImplFriend::FlagsToString(bound); 
+    ss << "{" << Streamable(spec, {*bound.arg()}) << ":"
+       << FormatConversionSpecImplFriend::FlagsToString(bound);
     if (bound.width() >= 0) ss << bound.width();
     if (bound.precision() >= 0) ss << "." << bound.precision();
     ss << bound.conversion_char() << "}";
@@ -254,5 +254,5 @@ int SnprintF(char* output, size_t size, const UntypedFormatSpecImpl format,
 }
 
 }  // namespace str_format_internal
-ABSL_NAMESPACE_END 
+ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/bind.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/bind.h
index a2ab6ff6ff..3966610710 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/bind.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/bind.h
@@ -18,7 +18,7 @@
 #include <array>
 #include <cstdio>
 #include <sstream>
-#include <util/generic/string.h> 
+#include <util/generic/string.h>
 
 #include "y_absl/base/port.h"
 #include "y_absl/strings/internal/str_format/arg.h"
@@ -27,7 +27,7 @@
 #include "y_absl/types/span.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN 
+ABSL_NAMESPACE_BEGIN
 
 class UntypedFormatSpec;
 
@@ -88,7 +88,7 @@ class FormatSpecTemplate
   using Base = typename MakeDependent<UntypedFormatSpec, Args...>::type;
 
  public:
-#ifdef ABSL_INTERNAL_ENABLE_FORMAT_CHECKER 
+#ifdef ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
 
   // Honeypot overload for when the string is not constexpr.
   // We use the 'unavailable' attribute to give a better compiler error than
@@ -211,7 +211,7 @@ class StreamedWrapper {
 };
 
 }  // namespace str_format_internal
-ABSL_NAMESPACE_END 
+ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 #endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_BIND_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/checker.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/checker.h
index 78a137029f..7c530d2507 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/checker.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/checker.h
@@ -15,20 +15,20 @@
 #ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_CHECKER_H_
 #define ABSL_STRINGS_INTERNAL_STR_FORMAT_CHECKER_H_
 
-#include "y_absl/base/attributes.h" 
+#include "y_absl/base/attributes.h"
 #include "y_absl/strings/internal/str_format/arg.h"
 #include "y_absl/strings/internal/str_format/extension.h"
 
 // Compile time check support for entry points.
 
 #ifndef ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
-#if ABSL_HAVE_ATTRIBUTE(enable_if) && !defined(__native_client__) 
+#if ABSL_HAVE_ATTRIBUTE(enable_if) && !defined(__native_client__)
 #define ABSL_INTERNAL_ENABLE_FORMAT_CHECKER 1
-#endif  // ABSL_HAVE_ATTRIBUTE(enable_if) && !defined(__native_client__) 
+#endif  // ABSL_HAVE_ATTRIBUTE(enable_if) && !defined(__native_client__)
 #endif  // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN 
+ABSL_NAMESPACE_BEGIN
 namespace str_format_internal {
 
 constexpr bool AllOf() { return true; }
@@ -38,7 +38,7 @@ constexpr bool AllOf(bool b, T... t) {
   return b && AllOf(t...);
 }
 
-#ifdef ABSL_INTERNAL_ENABLE_FORMAT_CHECKER 
+#ifdef ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
 
 constexpr bool ContainsChar(const char* chars, char c) {
   return *chars == c || (*chars && ContainsChar(chars + 1, c));
@@ -327,7 +327,7 @@ constexpr bool ValidFormatImpl(string_view format) {
 #endif  // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
 
 }  // namespace str_format_internal
-ABSL_NAMESPACE_END 
+ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 #endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_CHECKER_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.cc
index 2eafe4721d..f2a4169ae7 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.cc
@@ -17,10 +17,10 @@
 
 #include <errno.h>
 #include <algorithm>
-#include <util/generic/string.h> 
+#include <util/generic/string.h>
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN 
+ABSL_NAMESPACE_BEGIN
 namespace str_format_internal {
 
 TString FlagsToString(Flags v) {
@@ -71,5 +71,5 @@ bool FormatSinkImpl::PutPaddedString(string_view value, int width,
 }
 
 }  // namespace str_format_internal
-ABSL_NAMESPACE_END 
+ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.h
index b4cd3d61f3..e5de5cb6a1 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/extension.h
@@ -17,19 +17,19 @@
 #define ABSL_STRINGS_INTERNAL_STR_FORMAT_EXTENSION_H_
 
 #include <limits.h>
- 
+
 #include <cstddef>
 #include <cstring>
 #include <ostream>
 
-#include "y_absl/base/config.h" 
+#include "y_absl/base/config.h"
 #include "y_absl/base/port.h"
 #include "y_absl/meta/type_traits.h"
 #include "y_absl/strings/internal/str_format/output.h"
 #include "y_absl/strings/string_view.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN 
+ABSL_NAMESPACE_BEGIN
 
 enum class FormatConversionChar : uint8_t;
 enum class FormatConversionCharSet : uint64_t;
@@ -156,7 +156,7 @@ inline std::ostream& operator<<(std::ostream& os, Flags v) {
 }
 
 // clang-format off
-#define ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(X_VAL, X_SEP) \ 
+#define ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(X_VAL, X_SEP) \
   /* text */ \
   X_VAL(c) X_SEP X_VAL(s) X_SEP \
   /* ints */ \
@@ -200,21 +200,21 @@ struct FormatConversionCharInternal {
 #undef ABSL_INTERNAL_X_VAL
   static constexpr FormatConversionChar kNone =
       static_cast<FormatConversionChar>(Enum::kNone);
-}; 
-// clang-format on 
+};
+// clang-format on
 
-inline FormatConversionChar FormatConversionCharFromChar(char c) { 
-  switch (c) { 
-#define ABSL_INTERNAL_X_VAL(id) \ 
-  case #id[0]:                  \ 
+inline FormatConversionChar FormatConversionCharFromChar(char c) {
+  switch (c) {
+#define ABSL_INTERNAL_X_VAL(id) \
+  case #id[0]:                  \
     return FormatConversionCharInternal::id;
-    ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL, ) 
-#undef ABSL_INTERNAL_X_VAL 
+    ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL, )
+#undef ABSL_INTERNAL_X_VAL
   }
   return FormatConversionCharInternal::kNone;
-} 
+}
 
-inline bool FormatConversionCharIsUpper(FormatConversionChar c) { 
+inline bool FormatConversionCharIsUpper(FormatConversionChar c) {
   if (c == FormatConversionCharInternal::X ||
       c == FormatConversionCharInternal::F ||
       c == FormatConversionCharInternal::E ||
@@ -224,9 +224,9 @@ inline bool FormatConversionCharIsUpper(FormatConversionChar c) {
   } else {
     return false;
   }
-} 
+}
 
-inline bool FormatConversionCharIsFloat(FormatConversionChar c) { 
+inline bool FormatConversionCharIsFloat(FormatConversionChar c) {
   if (c == FormatConversionCharInternal::a ||
       c == FormatConversionCharInternal::e ||
       c == FormatConversionCharInternal::f ||
@@ -239,38 +239,38 @@ inline bool FormatConversionCharIsFloat(FormatConversionChar c) {
   } else {
     return false;
   }
-} 
+}
 
-inline char FormatConversionCharToChar(FormatConversionChar c) { 
+inline char FormatConversionCharToChar(FormatConversionChar c) {
   if (c == FormatConversionCharInternal::kNone) {
     return '\0';
 
 #define ABSL_INTERNAL_X_VAL(e)                       \
   } else if (c == FormatConversionCharInternal::e) { \
-    return #e[0]; 
-#define ABSL_INTERNAL_X_SEP 
+    return #e[0];
+#define ABSL_INTERNAL_X_SEP
   ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL,
                                          ABSL_INTERNAL_X_SEP)
   } else {
     return '\0';
   }
 
-#undef ABSL_INTERNAL_X_VAL 
-#undef ABSL_INTERNAL_X_SEP 
-} 
+#undef ABSL_INTERNAL_X_VAL
+#undef ABSL_INTERNAL_X_SEP
+}
 
-// The associated char. 
-inline std::ostream& operator<<(std::ostream& os, FormatConversionChar v) { 
-  char c = FormatConversionCharToChar(v); 
-  if (!c) c = '?'; 
-  return os << c; 
-} 
+// The associated char.
+inline std::ostream& operator<<(std::ostream& os, FormatConversionChar v) {
+  char c = FormatConversionCharToChar(v);
+  if (!c) c = '?';
+  return os << c;
+}
 
-struct FormatConversionSpecImplFriend; 
+struct FormatConversionSpecImplFriend;
 
 class FormatConversionSpecImpl {
- public: 
-  // Width and precison are not specified, no flags are set. 
+ public:
+  // Width and precison are not specified, no flags are set.
   bool is_basic() const { return flags_ == Flags::kBasic; }
   bool has_left_flag() const { return FlagsContains(flags_, Flags::kLeft); }
   bool has_show_pos_flag() const {
@@ -282,7 +282,7 @@ class FormatConversionSpecImpl {
   bool has_alt_flag() const { return FlagsContains(flags_, Flags::kAlt); }
   bool has_zero_flag() const { return FlagsContains(flags_, Flags::kZero); }
 
-  FormatConversionChar conversion_char() const { 
+  FormatConversionChar conversion_char() const {
     // Keep this field first in the struct . It generates better code when
     // accessing it when ConversionSpec is passed by value in registers.
     static_assert(offsetof(FormatConversionSpecImpl, conv_) == 0, "");
@@ -302,32 +302,32 @@ class FormatConversionSpecImpl {
   }
 
  private:
-  friend struct str_format_internal::FormatConversionSpecImplFriend; 
+  friend struct str_format_internal::FormatConversionSpecImplFriend;
   FormatConversionChar conv_ = FormatConversionCharInternal::kNone;
   Flags flags_;
   int width_;
   int precision_;
 };
 
-struct FormatConversionSpecImplFriend final { 
+struct FormatConversionSpecImplFriend final {
   static void SetFlags(Flags f, FormatConversionSpecImpl* conv) {
-    conv->flags_ = f; 
-  } 
-  static void SetConversionChar(FormatConversionChar c, 
+    conv->flags_ = f;
+  }
+  static void SetConversionChar(FormatConversionChar c,
                                 FormatConversionSpecImpl* conv) {
-    conv->conv_ = c; 
-  } 
+    conv->conv_ = c;
+  }
   static void SetWidth(int w, FormatConversionSpecImpl* conv) {
     conv->width_ = w;
   }
   static void SetPrecision(int p, FormatConversionSpecImpl* conv) {
-    conv->precision_ = p; 
-  } 
+    conv->precision_ = p;
+  }
   static TString FlagsToString(const FormatConversionSpecImpl& spec) {
     return str_format_internal::FlagsToString(spec.flags_);
-  } 
-}; 
- 
+  }
+};
+
 // Type safe OR operator.
 // We need this for two reasons:
 //  1. operator| on enums makes them decay to integers and the result is an
@@ -355,9 +355,9 @@ constexpr uint64_t FormatConversionCharToConvInt(char conv) {
 #define ABSL_INTERNAL_CHAR_SET_CASE(c)                                 \
   conv == #c[0]                                                        \
       ? FormatConversionCharToConvInt(FormatConversionCharInternal::c) \
-      : 
-      ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_CHAR_SET_CASE, ) 
-#undef ABSL_INTERNAL_CHAR_SET_CASE 
+      :
+      ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_CHAR_SET_CASE, )
+#undef ABSL_INTERNAL_CHAR_SET_CASE
                   conv == '*'
           ? 1
           : 0;
@@ -372,8 +372,8 @@ struct FormatConversionCharSetInternal {
 #define ABSL_INTERNAL_CHAR_SET_CASE(c)         \
   static constexpr FormatConversionCharSet c = \
       FormatConversionCharToConvValue(#c[0]);
-  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_CHAR_SET_CASE, ) 
-#undef ABSL_INTERNAL_CHAR_SET_CASE 
+  ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_CHAR_SET_CASE, )
+#undef ABSL_INTERNAL_CHAR_SET_CASE
 
   // Used for width/precision '*' specification.
   static constexpr FormatConversionCharSet kStar =
@@ -393,8 +393,8 @@ struct FormatConversionCharSetInternal {
 //  1. operator| on enums makes them decay to integers and the result is an
 //     integer. We need the result to stay as an enum.
 //  2. We use "enum class" which would not work even if we accepted the decay.
-constexpr FormatConversionCharSet operator|(FormatConversionCharSet a, 
-                                            FormatConversionCharSet b) { 
+constexpr FormatConversionCharSet operator|(FormatConversionCharSet a,
+                                            FormatConversionCharSet b) {
   return FormatConversionCharSetUnion(a, b);
 }
 
@@ -415,14 +415,14 @@ template <typename T>
 void ToFormatConversionCharSet(T) = delete;
 
 // Checks whether `c` exists in `set`.
-constexpr bool Contains(FormatConversionCharSet set, char c) { 
+constexpr bool Contains(FormatConversionCharSet set, char c) {
   return (static_cast<uint64_t>(set) &
           static_cast<uint64_t>(FormatConversionCharToConvValue(c))) != 0;
 }
 
 // Checks whether all the characters in `c` are contained in `set`
-constexpr bool Contains(FormatConversionCharSet set, 
-                        FormatConversionCharSet c) { 
+constexpr bool Contains(FormatConversionCharSet set,
+                        FormatConversionCharSet c) {
   return (static_cast<uint64_t>(set) & static_cast<uint64_t>(c)) ==
          static_cast<uint64_t>(c);
 }
@@ -439,7 +439,7 @@ inline size_t Excess(size_t used, size_t capacity) {
 
 }  // namespace str_format_internal
 
-ABSL_NAMESPACE_END 
+ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 #endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_EXTENSION_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.cc
index 7a5f1d23a2..c49062538d 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.cc
@@ -20,7 +20,7 @@
 #include <cassert>
 #include <cmath>
 #include <limits>
-#include <util/generic/string.h> 
+#include <util/generic/string.h>
 
 #include "y_absl/base/attributes.h"
 #include "y_absl/base/config.h"
@@ -35,7 +35,7 @@
 #include "y_absl/types/span.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN 
+ABSL_NAMESPACE_BEGIN
 namespace str_format_internal {
 
 namespace {
@@ -946,7 +946,7 @@ bool FallbackToSnprintf(const Float v, const FormatConversionSpecImpl &conv,
   {
     char *fp = fmt;
     *fp++ = '%';
-    fp = CopyStringTo(FormatConversionSpecImplFriend::FlagsToString(conv), fp); 
+    fp = CopyStringTo(FormatConversionSpecImplFriend::FlagsToString(conv), fp);
     fp = CopyStringTo("*.*", fp);
     if (std::is_same<long double, Float>()) {
       *fp++ = 'L';
@@ -1419,5 +1419,5 @@ bool ConvertFloatImpl(double v, const FormatConversionSpecImpl &conv,
 }
 
 }  // namespace str_format_internal
-ABSL_NAMESPACE_END 
+ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.h
index c586eb4e49..d93a415756 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/float_conversion.h
@@ -18,7 +18,7 @@
 #include "y_absl/strings/internal/str_format/extension.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN 
+ABSL_NAMESPACE_BEGIN
 namespace str_format_internal {
 
 bool ConvertFloatImpl(float v, const FormatConversionSpecImpl &conv,
@@ -31,7 +31,7 @@ bool ConvertFloatImpl(long double v, const FormatConversionSpecImpl &conv,
                       FormatSinkImpl *sink);
 
 }  // namespace str_format_internal
-ABSL_NAMESPACE_END 
+ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 #endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_FLOAT_CONVERSION_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/output.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/output.cc
index f80aeb1214..ade3f67ef2 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/output.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/output.cc
@@ -18,7 +18,7 @@
 #include <cstring>
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN 
+ABSL_NAMESPACE_BEGIN
 namespace str_format_internal {
 
 namespace {
@@ -68,5 +68,5 @@ void FILERawSink::Write(string_view v) {
 }
 
 }  // namespace str_format_internal
-ABSL_NAMESPACE_END 
+ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/output.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/output.h
index 2a2fa34abb..8fc46fbafa 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/output.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/output.h
@@ -23,13 +23,13 @@
 
 #include <cstdio>
 #include <ostream>
-#include <util/generic/string.h> 
+#include <util/generic/string.h>
 
 #include "y_absl/base/port.h"
 #include "y_absl/strings/string_view.h"
 
-namespace y_absl { 
-ABSL_NAMESPACE_BEGIN 
+namespace y_absl {
+ABSL_NAMESPACE_BEGIN
 namespace str_format_internal {
 
 // RawSink implementation that writes into a char* buffer.
@@ -90,7 +90,7 @@ auto InvokeFlush(T* out, string_view s) -> decltype(AbslFormatFlush(out, s)) {
 }
 
 }  // namespace str_format_internal
-ABSL_NAMESPACE_END 
+ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 #endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_OUTPUT_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.cc
index f8b7c04931..af07e32fe5 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.cc
@@ -24,16 +24,16 @@
 #include <initializer_list>
 #include <limits>
 #include <ostream>
-#include <util/generic/string.h> 
+#include <util/generic/string.h>
 #include <unordered_set>
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN 
+ABSL_NAMESPACE_BEGIN
 namespace str_format_internal {
 
 using CC = FormatConversionCharInternal;
-using LM = LengthMod; 
- 
+using LM = LengthMod;
+
 // Abbreviations to fit in the table below.
 constexpr auto f_sign = Flags::kSignCol;
 constexpr auto f_alt = Flags::kAlt;
@@ -209,11 +209,11 @@ const char *ConsumeConversion(const char *pos, const char *const end,
     using str_format_internal::LengthMod;
     LengthMod length_mod = tag.as_length();
     ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
-    if (c == 'h' && length_mod == LengthMod::h) { 
-      conv->length_mod = LengthMod::hh; 
+    if (c == 'h' && length_mod == LengthMod::h) {
+      conv->length_mod = LengthMod::hh;
       ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
-    } else if (c == 'l' && length_mod == LengthMod::l) { 
-      conv->length_mod = LengthMod::ll; 
+    } else if (c == 'l' && length_mod == LengthMod::l) {
+      conv->length_mod = LengthMod::ll;
       ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
     } else {
       conv->length_mod = length_mod;
@@ -232,32 +232,32 @@ const char *ConsumeConversion(const char *pos, const char *const end,
 
 }  // namespace
 
-TString LengthModToString(LengthMod v) { 
-  switch (v) { 
-    case LengthMod::h: 
-      return "h"; 
-    case LengthMod::hh: 
-      return "hh"; 
-    case LengthMod::l: 
-      return "l"; 
-    case LengthMod::ll: 
-      return "ll"; 
-    case LengthMod::L: 
-      return "L"; 
-    case LengthMod::j: 
-      return "j"; 
-    case LengthMod::z: 
-      return "z"; 
-    case LengthMod::t: 
-      return "t"; 
-    case LengthMod::q: 
-      return "q"; 
-    case LengthMod::none: 
-      return ""; 
-  } 
-  return ""; 
-} 
- 
+TString LengthModToString(LengthMod v) {
+  switch (v) {
+    case LengthMod::h:
+      return "h";
+    case LengthMod::hh:
+      return "hh";
+    case LengthMod::l:
+      return "l";
+    case LengthMod::ll:
+      return "ll";
+    case LengthMod::L:
+      return "L";
+    case LengthMod::j:
+      return "j";
+    case LengthMod::z:
+      return "z";
+    case LengthMod::t:
+      return "t";
+    case LengthMod::q:
+      return "q";
+    case LengthMod::none:
+      return "";
+  }
+  return "";
+}
+
 const char *ConsumeUnboundConversion(const char *p, const char *end,
                                      UnboundConversion *conv, int *next_arg) {
   if (*next_arg < 0) return ConsumeConversion<true>(p, end, conv, next_arg);
@@ -327,13 +327,13 @@ bool ParsedFormatBase::MatchesConversions(
     if (conv.width.is_from_arg() &&
         !add_if_valid_conv(conv.width.get_from_arg(), '*'))
       return false;
-    if (!add_if_valid_conv(conv.arg_position, 
-                           FormatConversionCharToChar(conv.conv))) 
-      return false; 
+    if (!add_if_valid_conv(conv.arg_position,
+                           FormatConversionCharToChar(conv.conv)))
+      return false;
   }
   return used.size() == convs.size() || allow_ignored;
 }
 
 }  // namespace str_format_internal
-ABSL_NAMESPACE_END 
+ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.h
index 64a4a7ce59..ba614bb8b4 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/parser.h
@@ -20,25 +20,25 @@
 #include <stdlib.h>
 
 #include <cassert>
-#include <cstdint> 
+#include <cstdint>
 #include <initializer_list>
 #include <iosfwd>
 #include <iterator>
 #include <memory>
-#include <util/generic/string.h> 
+#include <util/generic/string.h>
 #include <vector>
 
 #include "y_absl/strings/internal/str_format/checker.h"
 #include "y_absl/strings/internal/str_format/extension.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN 
+ABSL_NAMESPACE_BEGIN
 namespace str_format_internal {
 
-enum class LengthMod : std::uint8_t { h, hh, l, ll, L, j, z, t, q, none }; 
- 
-TString LengthModToString(LengthMod v); 
- 
+enum class LengthMod : std::uint8_t { h, hh, l, ll, L, j, z, t, q, none };
+
+TString LengthModToString(LengthMod v);
+
 // The analyzed properties of a single specified conversion.
 struct UnboundConversion {
   UnboundConversion() {}
@@ -77,7 +77,7 @@ struct UnboundConversion {
   InputValue precision;
 
   Flags flags = Flags::kBasic;
-  LengthMod length_mod = LengthMod::none; 
+  LengthMod length_mod = LengthMod::none;
   FormatConversionChar conv = FormatConversionCharInternal::kNone;
 };
 
@@ -91,12 +91,12 @@ const char* ConsumeUnboundConversion(const char* p, const char* end,
 
 // Helper tag class for the table below.
 // It allows fast `char -> ConversionChar/LengthMod/Flags` checking and
-// conversions. 
+// conversions.
 class ConvTag {
  public:
   constexpr ConvTag(FormatConversionChar conversion_char)  // NOLINT
       : tag_(static_cast<uint8_t>(conversion_char)) {}
-  constexpr ConvTag(LengthMod length_mod)  // NOLINT 
+  constexpr ConvTag(LengthMod length_mod)  // NOLINT
       : tag_(0x80 | static_cast<uint8_t>(length_mod)) {}
   constexpr ConvTag(Flags flags)  // NOLINT
       : tag_(0xc0 | static_cast<uint8_t>(flags)) {}
@@ -308,7 +308,7 @@ template <FormatConversionCharSet... C>
 class ExtendedParsedFormat : public str_format_internal::ParsedFormatBase {
  public:
   explicit ExtendedParsedFormat(string_view format)
-#ifdef ABSL_INTERNAL_ENABLE_FORMAT_CHECKER 
+#ifdef ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
       __attribute__((
           enable_if(str_format_internal::EnsureConstexpr(format),
                     "Format string is not constexpr."),
@@ -351,7 +351,7 @@ class ExtendedParsedFormat : public str_format_internal::ParsedFormatBase {
       : ParsedFormatBase(s, allow_ignored, {C...}) {}
 };
 }  // namespace str_format_internal
-ABSL_NAMESPACE_END 
+ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 #endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_PARSER_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/ya.make b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/ya.make
index 63aaefb0c3..ff8069cd0f 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/ya.make
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format/ya.make
@@ -22,9 +22,9 @@ PEERDIR(
     contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/absl_strings_internal
 )
 
-ADDINCL( 
-    GLOBAL contrib/restricted/abseil-cpp-tstring 
-) 
+ADDINCL(
+    GLOBAL contrib/restricted/abseil-cpp-tstring
+)
 
 NO_COMPILER_WARNINGS()
 
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_join_internal.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_join_internal.h
index 3e9bc53cf6..0a220fa33d 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_join_internal.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_join_internal.h
@@ -34,7 +34,7 @@
 #include <cstring>
 #include <iterator>
 #include <memory>
-#include <util/generic/string.h> 
+#include <util/generic/string.h>
 #include <type_traits>
 #include <utility>
 
@@ -43,7 +43,7 @@
 #include "y_absl/strings/str_cat.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN 
+ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 //
@@ -308,7 +308,7 @@ TString JoinRange(const Range& range, y_absl::string_view separator) {
 }
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END 
+ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 #endif  // ABSL_STRINGS_INTERNAL_STR_JOIN_INTERNAL_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_split_internal.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_split_internal.h
index 158c1ea8ab..237864c0ed 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_split_internal.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_split_internal.h
@@ -47,7 +47,7 @@
 #endif  // _GLIBCXX_DEBUG
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN 
+ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 // This class is implicitly constructible from everything that y_absl::string_view
@@ -424,7 +424,7 @@ class Splitter {
 };
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END 
+ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 #endif  // ABSL_STRINGS_INTERNAL_STR_SPLIT_INTERNAL_H_
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/utf8.cc b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/utf8.cc
index f1c2c15528..06b1cae79d 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/utf8.cc
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/utf8.cc
@@ -17,7 +17,7 @@
 #include "y_absl/strings/internal/utf8.h"
 
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN 
+ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 size_t EncodeUTF8Char(char *buffer, char32_t utf8_char) {
@@ -49,5 +49,5 @@ size_t EncodeUTF8Char(char *buffer, char32_t utf8_char) {
 }
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END 
+ABSL_NAMESPACE_END
 }  // namespace y_absl
diff --git a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/utf8.h b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/utf8.h
index 53ef10c972..1b2d6abd51 100644
--- a/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/utf8.h
+++ b/contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/utf8.h
@@ -20,10 +20,10 @@
 #include <cstddef>
 #include <cstdint>
 
-#include "y_absl/base/config.h" 
- 
+#include "y_absl/base/config.h"
+
 namespace y_absl {
-ABSL_NAMESPACE_BEGIN 
+ABSL_NAMESPACE_BEGIN
 namespace strings_internal {
 
 // For Unicode code points 0 through 0x10FFFF, EncodeUTF8Char writes
@@ -44,7 +44,7 @@ enum { kMaxEncodedUTF8Size = 4 };
 size_t EncodeUTF8Char(char *buffer, char32_t utf8_char);
 
 }  // namespace strings_internal
-ABSL_NAMESPACE_END 
+ABSL_NAMESPACE_END
 }  // namespace y_absl
 
 #endif  // ABSL_STRINGS_INTERNAL_UTF8_H_