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

34 files changed, 5738 insertions, 5738 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 e3a7b28f61..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
@@ -1,16 +1,16 @@
-# Generated by devtools/yamaker. 
- 
-LIBRARY() 
- 
+# Generated by devtools/yamaker.
+
+LIBRARY()
+
 WITHOUT_LICENSE_TEXTS()
 
 OWNER(
     somov
     g:cpp-contrib
 )
- 
-LICENSE(Apache-2.0) 
- 
+
+LICENSE(Apache-2.0)
+
 PEERDIR(
     contrib/restricted/abseil-cpp-tstring/y_absl/base
     contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging
@@ -21,15 +21,15 @@ PEERDIR(
 ADDINCL(
     GLOBAL contrib/restricted/abseil-cpp-tstring
 )
- 
-NO_COMPILER_WARNINGS() 
- 
+
+NO_COMPILER_WARNINGS()
+
 SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal)
 
-SRCS( 
+SRCS(
     escaping.cc
-    ostringstream.cc 
-    utf8.cc 
-) 
- 
-END() 
+    ostringstream.cc
+    utf8.cc
+)
+
+END()
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 ba054e4646..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
@@ -1,156 +1,156 @@
-// Copyright 2017 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. 
-// 
-// Character Map Class 
-// 
-// A fast, bit-vector map for 8-bit unsigned characters. 
-// This class is useful for non-character purposes as well. 
- 
-#ifndef ABSL_STRINGS_INTERNAL_CHAR_MAP_H_ 
-#define ABSL_STRINGS_INTERNAL_CHAR_MAP_H_ 
- 
-#include <cstddef> 
-#include <cstdint> 
-#include <cstring> 
- 
+// Copyright 2017 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.
+//
+// Character Map Class
+//
+// A fast, bit-vector map for 8-bit unsigned characters.
+// This class is useful for non-character purposes as well.
+
+#ifndef ABSL_STRINGS_INTERNAL_CHAR_MAP_H_
+#define ABSL_STRINGS_INTERNAL_CHAR_MAP_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+
 #include "y_absl/base/macros.h"
 #include "y_absl/base/port.h"
- 
+
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-namespace strings_internal { 
- 
-class Charmap { 
- public: 
-  constexpr Charmap() : m_() {} 
- 
-  // Initializes with a given char*.  Note that NUL is not treated as 
-  // a terminator, but rather a char to be flicked. 
-  Charmap(const char* str, int len) : m_() { 
-    while (len--) SetChar(*str++); 
-  } 
- 
-  // Initializes with a given char*.  NUL is treated as a terminator 
-  // and will not be in the charmap. 
-  explicit Charmap(const char* str) : m_() { 
-    while (*str) SetChar(*str++); 
-  } 
- 
-  constexpr bool contains(unsigned char c) const { 
-    return (m_[c / 64] >> (c % 64)) & 0x1; 
-  } 
- 
-  // Returns true if and only if a character exists in both maps. 
-  bool IntersectsWith(const Charmap& c) const { 
-    for (size_t i = 0; i < ABSL_ARRAYSIZE(m_); ++i) { 
-      if ((m_[i] & c.m_[i]) != 0) return true; 
-    } 
-    return false; 
-  } 
- 
-  bool IsZero() const { 
-    for (uint64_t c : m_) { 
-      if (c != 0) return false; 
-    } 
-    return true; 
-  } 
- 
-  // Containing only a single specified char. 
-  static constexpr Charmap Char(char x) { 
-    return Charmap(CharMaskForWord(x, 0), CharMaskForWord(x, 1), 
-                   CharMaskForWord(x, 2), CharMaskForWord(x, 3)); 
-  } 
- 
+namespace strings_internal {
+
+class Charmap {
+ public:
+  constexpr Charmap() : m_() {}
+
+  // Initializes with a given char*.  Note that NUL is not treated as
+  // a terminator, but rather a char to be flicked.
+  Charmap(const char* str, int len) : m_() {
+    while (len--) SetChar(*str++);
+  }
+
+  // Initializes with a given char*.  NUL is treated as a terminator
+  // and will not be in the charmap.
+  explicit Charmap(const char* str) : m_() {
+    while (*str) SetChar(*str++);
+  }
+
+  constexpr bool contains(unsigned char c) const {
+    return (m_[c / 64] >> (c % 64)) & 0x1;
+  }
+
+  // Returns true if and only if a character exists in both maps.
+  bool IntersectsWith(const Charmap& c) const {
+    for (size_t i = 0; i < ABSL_ARRAYSIZE(m_); ++i) {
+      if ((m_[i] & c.m_[i]) != 0) return true;
+    }
+    return false;
+  }
+
+  bool IsZero() const {
+    for (uint64_t c : m_) {
+      if (c != 0) return false;
+    }
+    return true;
+  }
+
+  // Containing only a single specified char.
+  static constexpr Charmap Char(char x) {
+    return Charmap(CharMaskForWord(x, 0), CharMaskForWord(x, 1),
+                   CharMaskForWord(x, 2), CharMaskForWord(x, 3));
+  }
+
   // Containing all the chars in the C-string 's'.
-  // Note that this is expensively recursive because of the C++11 constexpr 
-  // formulation. Use only in constexpr initializers. 
-  static constexpr Charmap FromString(const char* s) { 
-    return *s == 0 ? Charmap() : (Char(*s) | FromString(s + 1)); 
-  } 
- 
-  // Containing all the chars in the closed interval [lo,hi]. 
-  static constexpr Charmap Range(char lo, char hi) { 
-    return Charmap(RangeForWord(lo, hi, 0), RangeForWord(lo, hi, 1), 
-                   RangeForWord(lo, hi, 2), RangeForWord(lo, hi, 3)); 
-  } 
- 
-  friend constexpr Charmap operator&(const Charmap& a, const Charmap& b) { 
-    return Charmap(a.m_[0] & b.m_[0], a.m_[1] & b.m_[1], a.m_[2] & b.m_[2], 
-                   a.m_[3] & b.m_[3]); 
-  } 
- 
-  friend constexpr Charmap operator|(const Charmap& a, const Charmap& b) { 
-    return Charmap(a.m_[0] | b.m_[0], a.m_[1] | b.m_[1], a.m_[2] | b.m_[2], 
-                   a.m_[3] | b.m_[3]); 
-  } 
- 
-  friend constexpr Charmap operator~(const Charmap& a) { 
-    return Charmap(~a.m_[0], ~a.m_[1], ~a.m_[2], ~a.m_[3]); 
-  } 
- 
- private: 
-  constexpr Charmap(uint64_t b0, uint64_t b1, uint64_t b2, uint64_t b3) 
-      : m_{b0, b1, b2, b3} {} 
- 
-  static constexpr uint64_t RangeForWord(unsigned char lo, unsigned char hi, 
-                                         uint64_t word) { 
-    return OpenRangeFromZeroForWord(hi + 1, word) & 
-           ~OpenRangeFromZeroForWord(lo, word); 
-  } 
- 
-  // All the chars in the specified word of the range [0, upper). 
-  static constexpr uint64_t OpenRangeFromZeroForWord(uint64_t upper, 
-                                                     uint64_t word) { 
-    return (upper <= 64 * word) 
-               ? 0 
-               : (upper >= 64 * (word + 1)) 
-                     ? ~static_cast<uint64_t>(0) 
-                     : (~static_cast<uint64_t>(0) >> (64 - upper % 64)); 
-  } 
- 
-  static constexpr uint64_t CharMaskForWord(unsigned char x, uint64_t word) { 
-    return (x / 64 == word) ? (static_cast<uint64_t>(1) << (x % 64)) : 0; 
-  } 
- 
- private: 
-  void SetChar(unsigned char c) { 
-    m_[c / 64] |= static_cast<uint64_t>(1) << (c % 64); 
-  } 
- 
-  uint64_t m_[4]; 
-}; 
- 
-// Mirror the char-classifying predicates in <cctype> 
-constexpr Charmap UpperCharmap() { return Charmap::Range('A', 'Z'); } 
-constexpr Charmap LowerCharmap() { return Charmap::Range('a', 'z'); } 
-constexpr Charmap DigitCharmap() { return Charmap::Range('0', '9'); } 
-constexpr Charmap AlphaCharmap() { return LowerCharmap() | UpperCharmap(); } 
-constexpr Charmap AlnumCharmap() { return DigitCharmap() | AlphaCharmap(); } 
-constexpr Charmap XDigitCharmap() { 
-  return DigitCharmap() | Charmap::Range('A', 'F') | Charmap::Range('a', 'f'); 
-} 
-constexpr Charmap PrintCharmap() { return Charmap::Range(0x20, 0x7e); } 
-constexpr Charmap SpaceCharmap() { return Charmap::FromString("\t\n\v\f\r "); } 
-constexpr Charmap CntrlCharmap() { 
-  return Charmap::Range(0, 0x7f) & ~PrintCharmap(); 
-} 
-constexpr Charmap BlankCharmap() { return Charmap::FromString("\t "); } 
-constexpr Charmap GraphCharmap() { return PrintCharmap() & ~SpaceCharmap(); } 
-constexpr Charmap PunctCharmap() { return GraphCharmap() & ~AlnumCharmap(); } 
- 
-}  // namespace strings_internal 
+  // Note that this is expensively recursive because of the C++11 constexpr
+  // formulation. Use only in constexpr initializers.
+  static constexpr Charmap FromString(const char* s) {
+    return *s == 0 ? Charmap() : (Char(*s) | FromString(s + 1));
+  }
+
+  // Containing all the chars in the closed interval [lo,hi].
+  static constexpr Charmap Range(char lo, char hi) {
+    return Charmap(RangeForWord(lo, hi, 0), RangeForWord(lo, hi, 1),
+                   RangeForWord(lo, hi, 2), RangeForWord(lo, hi, 3));
+  }
+
+  friend constexpr Charmap operator&(const Charmap& a, const Charmap& b) {
+    return Charmap(a.m_[0] & b.m_[0], a.m_[1] & b.m_[1], a.m_[2] & b.m_[2],
+                   a.m_[3] & b.m_[3]);
+  }
+
+  friend constexpr Charmap operator|(const Charmap& a, const Charmap& b) {
+    return Charmap(a.m_[0] | b.m_[0], a.m_[1] | b.m_[1], a.m_[2] | b.m_[2],
+                   a.m_[3] | b.m_[3]);
+  }
+
+  friend constexpr Charmap operator~(const Charmap& a) {
+    return Charmap(~a.m_[0], ~a.m_[1], ~a.m_[2], ~a.m_[3]);
+  }
+
+ private:
+  constexpr Charmap(uint64_t b0, uint64_t b1, uint64_t b2, uint64_t b3)
+      : m_{b0, b1, b2, b3} {}
+
+  static constexpr uint64_t RangeForWord(unsigned char lo, unsigned char hi,
+                                         uint64_t word) {
+    return OpenRangeFromZeroForWord(hi + 1, word) &
+           ~OpenRangeFromZeroForWord(lo, word);
+  }
+
+  // All the chars in the specified word of the range [0, upper).
+  static constexpr uint64_t OpenRangeFromZeroForWord(uint64_t upper,
+                                                     uint64_t word) {
+    return (upper <= 64 * word)
+               ? 0
+               : (upper >= 64 * (word + 1))
+                     ? ~static_cast<uint64_t>(0)
+                     : (~static_cast<uint64_t>(0) >> (64 - upper % 64));
+  }
+
+  static constexpr uint64_t CharMaskForWord(unsigned char x, uint64_t word) {
+    return (x / 64 == word) ? (static_cast<uint64_t>(1) << (x % 64)) : 0;
+  }
+
+ private:
+  void SetChar(unsigned char c) {
+    m_[c / 64] |= static_cast<uint64_t>(1) << (c % 64);
+  }
+
+  uint64_t m_[4];
+};
+
+// Mirror the char-classifying predicates in <cctype>
+constexpr Charmap UpperCharmap() { return Charmap::Range('A', 'Z'); }
+constexpr Charmap LowerCharmap() { return Charmap::Range('a', 'z'); }
+constexpr Charmap DigitCharmap() { return Charmap::Range('0', '9'); }
+constexpr Charmap AlphaCharmap() { return LowerCharmap() | UpperCharmap(); }
+constexpr Charmap AlnumCharmap() { return DigitCharmap() | AlphaCharmap(); }
+constexpr Charmap XDigitCharmap() {
+  return DigitCharmap() | Charmap::Range('A', 'F') | Charmap::Range('a', 'f');
+}
+constexpr Charmap PrintCharmap() { return Charmap::Range(0x20, 0x7e); }
+constexpr Charmap SpaceCharmap() { return Charmap::FromString("\t\n\v\f\r "); }
+constexpr Charmap CntrlCharmap() {
+  return Charmap::Range(0, 0x7f) & ~PrintCharmap();
+}
+constexpr Charmap BlankCharmap() { return Charmap::FromString("\t "); }
+constexpr Charmap GraphCharmap() { return PrintCharmap() & ~SpaceCharmap(); }
+constexpr Charmap PunctCharmap() { return GraphCharmap() & ~AlnumCharmap(); }
+
+}  // namespace strings_internal
 ABSL_NAMESPACE_END
 }  // namespace y_absl
- 
-#endif  // ABSL_STRINGS_INTERNAL_CHAR_MAP_H_ 
+
+#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 b8646c3194..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
@@ -1,359 +1,359 @@
-// Copyright 2018 The Abseil Authors. 
-// 
-// Licensed under the Apache License, Version 2.0 (the "License"); 
-// you may not use this file except in compliance with the License. 
-// You may obtain a copy of the License at 
-// 
-//      https://www.apache.org/licenses/LICENSE-2.0 
-// 
-// Unless required by applicable law or agreed to in writing, software 
-// distributed under the License is distributed on an "AS IS" BASIS, 
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-// See the License for the specific language governing permissions and 
-// limitations under the License. 
- 
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 #include "y_absl/strings/internal/charconv_bigint.h"
- 
-#include <algorithm> 
-#include <cassert> 
+
+#include <algorithm>
+#include <cassert>
 #include <util/generic/string.h>
- 
+
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-namespace strings_internal { 
- 
-namespace { 
- 
-// Table containing some large powers of 5, for fast computation. 
- 
-// Constant step size for entries in the kLargePowersOfFive table.  Each entry 
-// is larger than the previous entry by a factor of 5**kLargePowerOfFiveStep 
-// (or 5**27). 
-// 
-// In other words, the Nth entry in the table is 5**(27*N). 
-// 
-// 5**27 is the largest power of 5 that fits in 64 bits. 
-constexpr int kLargePowerOfFiveStep = 27; 
- 
-// The largest legal index into the kLargePowersOfFive table. 
-// 
-// In other words, the largest precomputed power of 5 is 5**(27*20). 
-constexpr int kLargestPowerOfFiveIndex = 20; 
- 
-// Table of powers of (5**27), up to (5**27)**20 == 5**540. 
-// 
-// Used to generate large powers of 5 while limiting the number of repeated 
-// multiplications required. 
-// 
-// clang-format off 
-const uint32_t kLargePowersOfFive[] = { 
-// 5**27 (i=1), start=0, end=2 
-  0xfa10079dU, 0x6765c793U, 
-// 5**54 (i=2), start=2, end=6 
-  0x97d9f649U, 0x6664242dU, 0x29939b14U, 0x29c30f10U, 
-// 5**81 (i=3), start=6, end=12 
-  0xc4f809c5U, 0x7bf3f22aU, 0x67bdae34U, 0xad340517U, 0x369d1b5fU, 0x10de1593U, 
-// 5**108 (i=4), start=12, end=20 
-  0x92b260d1U, 0x9efff7c7U, 0x81de0ec6U, 0xaeba5d56U, 0x410664a4U, 0x4f40737aU, 
-  0x20d3846fU, 0x06d00f73U, 
-// 5**135 (i=5), start=20, end=30 
-  0xff1b172dU, 0x13a1d71cU, 0xefa07617U, 0x7f682d3dU, 0xff8c90c0U, 0x3f0131e7U, 
-  0x3fdcb9feU, 0x917b0177U, 0x16c407a7U, 0x02c06b9dU, 
-// 5**162 (i=6), start=30, end=42 
-  0x960f7199U, 0x056667ecU, 0xe07aefd8U, 0x80f2b9ccU, 0x8273f5e3U, 0xeb9a214aU, 
-  0x40b38005U, 0x0e477ad4U, 0x277d08e6U, 0xfa28b11eU, 0xd3f7d784U, 0x011c835bU, 
-// 5**189 (i=7), start=42, end=56 
-  0xf723d9d5U, 0x3282d3f3U, 0xe00857d1U, 0x69659d25U, 0x2cf117cfU, 0x24da6d07U, 
-  0x954d1417U, 0x3e5d8cedU, 0x7a8bb766U, 0xfd785ae6U, 0x645436d2U, 0x40c78b34U, 
-  0x94151217U, 0x0072e9f7U, 
-// 5**216 (i=8), start=56, end=72 
-  0x2b416aa1U, 0x7893c5a7U, 0xe37dc6d4U, 0x2bad2beaU, 0xf0fc846cU, 0x7575ae4bU, 
-  0x62587b14U, 0x83b67a34U, 0x02110cdbU, 0xf7992f55U, 0x00deb022U, 0xa4a23becU, 
-  0x8af5c5cdU, 0xb85b654fU, 0x818df38bU, 0x002e69d2U, 
-// 5**243 (i=9), start=72, end=90 
-  0x3518cbbdU, 0x20b0c15fU, 0x38756c2fU, 0xfb5dc3ddU, 0x22ad2d94U, 0xbf35a952U, 
-  0xa699192aU, 0x9a613326U, 0xad2a9cedU, 0xd7f48968U, 0xe87dfb54U, 0xc8f05db6U, 
-  0x5ef67531U, 0x31c1ab49U, 0xe202ac9fU, 0x9b2957b5U, 0xa143f6d3U, 0x0012bf07U, 
-// 5**270 (i=10), start=90, end=110 
-  0x8b971de9U, 0x21aba2e1U, 0x63944362U, 0x57172336U, 0xd9544225U, 0xfb534166U, 
-  0x08c563eeU, 0x14640ee2U, 0x24e40d31U, 0x02b06537U, 0x03887f14U, 0x0285e533U, 
-  0xb744ef26U, 0x8be3a6c4U, 0x266979b4U, 0x6761ece2U, 0xd9cb39e4U, 0xe67de319U, 
-  0x0d39e796U, 0x00079250U, 
-// 5**297 (i=11), start=110, end=132 
-  0x260eb6e5U, 0xf414a796U, 0xee1a7491U, 0xdb9368ebU, 0xf50c105bU, 0x59157750U, 
-  0x9ed2fb5cU, 0xf6e56d8bU, 0xeaee8d23U, 0x0f319f75U, 0x2aa134d6U, 0xac2908e9U, 
-  0xd4413298U, 0x02f02a55U, 0x989d5a7aU, 0x70dde184U, 0xba8040a7U, 0x03200981U, 
-  0xbe03b11cU, 0x3c1c2a18U, 0xd60427a1U, 0x00030ee0U, 
-// 5**324 (i=12), start=132, end=156 
-  0xce566d71U, 0xf1c4aa25U, 0x4e93ca53U, 0xa72283d0U, 0x551a73eaU, 0x3d0538e2U, 
-  0x8da4303fU, 0x6a58de60U, 0x0e660221U, 0x49cf61a6U, 0x8d058fc1U, 0xb9d1a14cU, 
-  0x4bab157dU, 0xc85c6932U, 0x518c8b9eU, 0x9b92b8d0U, 0x0d8a0e21U, 0xbd855df9U, 
-  0xb3ea59a1U, 0x8da29289U, 0x4584d506U, 0x3752d80fU, 0xb72569c6U, 0x00013c33U, 
-// 5**351 (i=13), start=156, end=182 
-  0x190f354dU, 0x83695cfeU, 0xe5a4d0c7U, 0xb60fb7e8U, 0xee5bbcc4U, 0xb922054cU, 
-  0xbb4f0d85U, 0x48394028U, 0x1d8957dbU, 0x0d7edb14U, 0x4ecc7587U, 0x505e9e02U, 
-  0x4c87f36bU, 0x99e66bd6U, 0x44b9ed35U, 0x753037d4U, 0xe5fe5f27U, 0x2742c203U, 
-  0x13b2ed2bU, 0xdc525d2cU, 0xe6fde59aU, 0x77ffb18fU, 0x13c5752cU, 0x08a84bccU, 
-  0x859a4940U, 0x00007fb6U, 
-// 5**378 (i=14), start=182, end=210 
-  0x4f98cb39U, 0xa60edbbcU, 0x83b5872eU, 0xa501acffU, 0x9cc76f78U, 0xbadd4c73U, 
-  0x43e989faU, 0xca7acf80U, 0x2e0c824fU, 0xb19f4ffcU, 0x092fd81cU, 0xe4eb645bU, 
-  0xa1ff84c2U, 0x8a5a83baU, 0xa8a1fae9U, 0x1db43609U, 0xb0fed50bU, 0x0dd7d2bdU, 
-  0x7d7accd8U, 0x91fa640fU, 0x37dcc6c5U, 0x1c417fd5U, 0xe4d462adU, 0xe8a43399U, 
-  0x131bf9a5U, 0x8df54d29U, 0x36547dc1U, 0x00003395U, 
-// 5**405 (i=15), start=210, end=240 
-  0x5bd330f5U, 0x77d21967U, 0x1ac481b7U, 0x6be2f7ceU, 0x7f4792a9U, 0xe84c2c52U, 
-  0x84592228U, 0x9dcaf829U, 0xdab44ce1U, 0x3d0c311bU, 0x532e297dU, 0x4704e8b4U, 
-  0x9cdc32beU, 0x41e64d9dU, 0x7717bea1U, 0xa824c00dU, 0x08f50b27U, 0x0f198d77U, 
-  0x49bbfdf0U, 0x025c6c69U, 0xd4e55cd3U, 0xf083602bU, 0xb9f0fecdU, 0xc0864aeaU, 
-  0x9cb98681U, 0xaaf620e9U, 0xacb6df30U, 0x4faafe66U, 0x8af13c3bU, 0x000014d5U, 
-// 5**432 (i=16), start=240, end=272 
-  0x682bb941U, 0x89a9f297U, 0xcba75d7bU, 0x404217b1U, 0xb4e519e9U, 0xa1bc162bU, 
-  0xf7f5910aU, 0x98715af5U, 0x2ff53e57U, 0xe3ef118cU, 0x490c4543U, 0xbc9b1734U, 
-  0x2affbe4dU, 0x4cedcb4cU, 0xfb14e99eU, 0x35e34212U, 0xece39c24U, 0x07673ab3U, 
-  0xe73115ddU, 0xd15d38e7U, 0x093eed3bU, 0xf8e7eac5U, 0x78a8cc80U, 0x25227aacU, 
-  0x3f590551U, 0x413da1cbU, 0xdf643a55U, 0xab65ad44U, 0xd70b23d7U, 0xc672cd76U, 
-  0x3364ea62U, 0x0000086aU, 
-// 5**459 (i=17), start=272, end=306 
-  0x22f163ddU, 0x23cf07acU, 0xbe2af6c2U, 0xf412f6f6U, 0xc3ff541eU, 0x6eeaf7deU, 
-  0xa47047e0U, 0x408cda92U, 0x0f0eeb08U, 0x56deba9dU, 0xcfc6b090U, 0x8bbbdf04U, 
-  0x3933cdb3U, 0x9e7bb67dU, 0x9f297035U, 0x38946244U, 0xee1d37bbU, 0xde898174U, 
-  0x63f3559dU, 0x705b72fbU, 0x138d27d9U, 0xf8603a78U, 0x735eec44U, 0xe30987d5U, 
-  0xc6d38070U, 0x9cfe548eU, 0x9ff01422U, 0x7c564aa8U, 0x91cc60baU, 0xcbc3565dU, 
-  0x7550a50bU, 0x6909aeadU, 0x13234c45U, 0x00000366U, 
-// 5**486 (i=18), start=306, end=342 
-  0x17954989U, 0x3a7d7709U, 0x98042de5U, 0xa9011443U, 0x45e723c2U, 0x269ffd6fU, 
-  0x58852a46U, 0xaaa1042aU, 0x2eee8153U, 0xb2b6c39eU, 0xaf845b65U, 0xf6c365d7U, 
-  0xe4cffb2bU, 0xc840e90cU, 0xabea8abbU, 0x5c58f8d2U, 0x5c19fa3aU, 0x4670910aU, 
-  0x4449f21cU, 0xefa645b3U, 0xcc427decU, 0x083c3d73U, 0x467cb413U, 0x6fe10ae4U, 
-  0x3caffc72U, 0x9f8da55eU, 0x5e5c8ea7U, 0x490594bbU, 0xf0871b0bU, 0xdd89816cU, 
-  0x8e931df8U, 0xe85ce1c9U, 0xcca090a5U, 0x575fa16bU, 0x6b9f106cU, 0x0000015fU, 
-// 5**513 (i=19), start=342, end=380 
-  0xee20d805U, 0x57bc3c07U, 0xcdea624eU, 0xd3f0f52dU, 0x9924b4f4U, 0xcf968640U, 
-  0x61d41962U, 0xe87fb464U, 0xeaaf51c7U, 0x564c8b60U, 0xccda4028U, 0x529428bbU, 
-  0x313a1fa8U, 0x96bd0f94U, 0x7a82ebaaU, 0xad99e7e9U, 0xf2668cd4U, 0xbe33a45eU, 
-  0xfd0db669U, 0x87ee369fU, 0xd3ec20edU, 0x9c4d7db7U, 0xdedcf0d8U, 0x7cd2ca64U, 
-  0xe25a6577U, 0x61003fd4U, 0xe56f54ccU, 0x10b7c748U, 0x40526e5eU, 0x7300ae87U, 
-  0x5c439261U, 0x2c0ff469U, 0xbf723f12U, 0xb2379b61U, 0xbf59b4f5U, 0xc91b1c3fU, 
-  0xf0046d27U, 0x0000008dU, 
-// 5**540 (i=20), start=380, end=420 
-  0x525c9e11U, 0xf4e0eb41U, 0xebb2895dU, 0x5da512f9U, 0x7d9b29d4U, 0x452f4edcU, 
-  0x0b90bc37U, 0x341777cbU, 0x63d269afU, 0x1da77929U, 0x0a5c1826U, 0x77991898U, 
-  0x5aeddf86U, 0xf853a877U, 0x538c31ccU, 0xe84896daU, 0xb7a0010bU, 0x17ef4de5U, 
-  0xa52a2adeU, 0x029fd81cU, 0x987ce701U, 0x27fefd77U, 0xdb46c66fU, 0x5d301900U, 
-  0x496998c0U, 0xbb6598b9U, 0x5eebb607U, 0xe547354aU, 0xdf4a2f7eU, 0xf06c4955U, 
-  0x96242ffaU, 0x1775fb27U, 0xbecc58ceU, 0xebf2a53bU, 0x3eaad82aU, 0xf41137baU, 
-  0x573e6fbaU, 0xfb4866b8U, 0x54002148U, 0x00000039U, 
-}; 
-// clang-format on 
- 
-// Returns a pointer to the big integer data for (5**27)**i.  i must be 
-// between 1 and 20, inclusive. 
-const uint32_t* LargePowerOfFiveData(int i) { 
-  return kLargePowersOfFive + i * (i - 1); 
-} 
- 
-// Returns the size of the big integer data for (5**27)**i, in words.  i must be 
-// between 1 and 20, inclusive. 
-int LargePowerOfFiveSize(int i) { return 2 * i; } 
-}  // namespace 
- 
+namespace strings_internal {
+
+namespace {
+
+// Table containing some large powers of 5, for fast computation.
+
+// Constant step size for entries in the kLargePowersOfFive table.  Each entry
+// is larger than the previous entry by a factor of 5**kLargePowerOfFiveStep
+// (or 5**27).
+//
+// In other words, the Nth entry in the table is 5**(27*N).
+//
+// 5**27 is the largest power of 5 that fits in 64 bits.
+constexpr int kLargePowerOfFiveStep = 27;
+
+// The largest legal index into the kLargePowersOfFive table.
+//
+// In other words, the largest precomputed power of 5 is 5**(27*20).
+constexpr int kLargestPowerOfFiveIndex = 20;
+
+// Table of powers of (5**27), up to (5**27)**20 == 5**540.
+//
+// Used to generate large powers of 5 while limiting the number of repeated
+// multiplications required.
+//
+// clang-format off
+const uint32_t kLargePowersOfFive[] = {
+// 5**27 (i=1), start=0, end=2
+  0xfa10079dU, 0x6765c793U,
+// 5**54 (i=2), start=2, end=6
+  0x97d9f649U, 0x6664242dU, 0x29939b14U, 0x29c30f10U,
+// 5**81 (i=3), start=6, end=12
+  0xc4f809c5U, 0x7bf3f22aU, 0x67bdae34U, 0xad340517U, 0x369d1b5fU, 0x10de1593U,
+// 5**108 (i=4), start=12, end=20
+  0x92b260d1U, 0x9efff7c7U, 0x81de0ec6U, 0xaeba5d56U, 0x410664a4U, 0x4f40737aU,
+  0x20d3846fU, 0x06d00f73U,
+// 5**135 (i=5), start=20, end=30
+  0xff1b172dU, 0x13a1d71cU, 0xefa07617U, 0x7f682d3dU, 0xff8c90c0U, 0x3f0131e7U,
+  0x3fdcb9feU, 0x917b0177U, 0x16c407a7U, 0x02c06b9dU,
+// 5**162 (i=6), start=30, end=42
+  0x960f7199U, 0x056667ecU, 0xe07aefd8U, 0x80f2b9ccU, 0x8273f5e3U, 0xeb9a214aU,
+  0x40b38005U, 0x0e477ad4U, 0x277d08e6U, 0xfa28b11eU, 0xd3f7d784U, 0x011c835bU,
+// 5**189 (i=7), start=42, end=56
+  0xf723d9d5U, 0x3282d3f3U, 0xe00857d1U, 0x69659d25U, 0x2cf117cfU, 0x24da6d07U,
+  0x954d1417U, 0x3e5d8cedU, 0x7a8bb766U, 0xfd785ae6U, 0x645436d2U, 0x40c78b34U,
+  0x94151217U, 0x0072e9f7U,
+// 5**216 (i=8), start=56, end=72
+  0x2b416aa1U, 0x7893c5a7U, 0xe37dc6d4U, 0x2bad2beaU, 0xf0fc846cU, 0x7575ae4bU,
+  0x62587b14U, 0x83b67a34U, 0x02110cdbU, 0xf7992f55U, 0x00deb022U, 0xa4a23becU,
+  0x8af5c5cdU, 0xb85b654fU, 0x818df38bU, 0x002e69d2U,
+// 5**243 (i=9), start=72, end=90
+  0x3518cbbdU, 0x20b0c15fU, 0x38756c2fU, 0xfb5dc3ddU, 0x22ad2d94U, 0xbf35a952U,
+  0xa699192aU, 0x9a613326U, 0xad2a9cedU, 0xd7f48968U, 0xe87dfb54U, 0xc8f05db6U,
+  0x5ef67531U, 0x31c1ab49U, 0xe202ac9fU, 0x9b2957b5U, 0xa143f6d3U, 0x0012bf07U,
+// 5**270 (i=10), start=90, end=110
+  0x8b971de9U, 0x21aba2e1U, 0x63944362U, 0x57172336U, 0xd9544225U, 0xfb534166U,
+  0x08c563eeU, 0x14640ee2U, 0x24e40d31U, 0x02b06537U, 0x03887f14U, 0x0285e533U,
+  0xb744ef26U, 0x8be3a6c4U, 0x266979b4U, 0x6761ece2U, 0xd9cb39e4U, 0xe67de319U,
+  0x0d39e796U, 0x00079250U,
+// 5**297 (i=11), start=110, end=132
+  0x260eb6e5U, 0xf414a796U, 0xee1a7491U, 0xdb9368ebU, 0xf50c105bU, 0x59157750U,
+  0x9ed2fb5cU, 0xf6e56d8bU, 0xeaee8d23U, 0x0f319f75U, 0x2aa134d6U, 0xac2908e9U,
+  0xd4413298U, 0x02f02a55U, 0x989d5a7aU, 0x70dde184U, 0xba8040a7U, 0x03200981U,
+  0xbe03b11cU, 0x3c1c2a18U, 0xd60427a1U, 0x00030ee0U,
+// 5**324 (i=12), start=132, end=156
+  0xce566d71U, 0xf1c4aa25U, 0x4e93ca53U, 0xa72283d0U, 0x551a73eaU, 0x3d0538e2U,
+  0x8da4303fU, 0x6a58de60U, 0x0e660221U, 0x49cf61a6U, 0x8d058fc1U, 0xb9d1a14cU,
+  0x4bab157dU, 0xc85c6932U, 0x518c8b9eU, 0x9b92b8d0U, 0x0d8a0e21U, 0xbd855df9U,
+  0xb3ea59a1U, 0x8da29289U, 0x4584d506U, 0x3752d80fU, 0xb72569c6U, 0x00013c33U,
+// 5**351 (i=13), start=156, end=182
+  0x190f354dU, 0x83695cfeU, 0xe5a4d0c7U, 0xb60fb7e8U, 0xee5bbcc4U, 0xb922054cU,
+  0xbb4f0d85U, 0x48394028U, 0x1d8957dbU, 0x0d7edb14U, 0x4ecc7587U, 0x505e9e02U,
+  0x4c87f36bU, 0x99e66bd6U, 0x44b9ed35U, 0x753037d4U, 0xe5fe5f27U, 0x2742c203U,
+  0x13b2ed2bU, 0xdc525d2cU, 0xe6fde59aU, 0x77ffb18fU, 0x13c5752cU, 0x08a84bccU,
+  0x859a4940U, 0x00007fb6U,
+// 5**378 (i=14), start=182, end=210
+  0x4f98cb39U, 0xa60edbbcU, 0x83b5872eU, 0xa501acffU, 0x9cc76f78U, 0xbadd4c73U,
+  0x43e989faU, 0xca7acf80U, 0x2e0c824fU, 0xb19f4ffcU, 0x092fd81cU, 0xe4eb645bU,
+  0xa1ff84c2U, 0x8a5a83baU, 0xa8a1fae9U, 0x1db43609U, 0xb0fed50bU, 0x0dd7d2bdU,
+  0x7d7accd8U, 0x91fa640fU, 0x37dcc6c5U, 0x1c417fd5U, 0xe4d462adU, 0xe8a43399U,
+  0x131bf9a5U, 0x8df54d29U, 0x36547dc1U, 0x00003395U,
+// 5**405 (i=15), start=210, end=240
+  0x5bd330f5U, 0x77d21967U, 0x1ac481b7U, 0x6be2f7ceU, 0x7f4792a9U, 0xe84c2c52U,
+  0x84592228U, 0x9dcaf829U, 0xdab44ce1U, 0x3d0c311bU, 0x532e297dU, 0x4704e8b4U,
+  0x9cdc32beU, 0x41e64d9dU, 0x7717bea1U, 0xa824c00dU, 0x08f50b27U, 0x0f198d77U,
+  0x49bbfdf0U, 0x025c6c69U, 0xd4e55cd3U, 0xf083602bU, 0xb9f0fecdU, 0xc0864aeaU,
+  0x9cb98681U, 0xaaf620e9U, 0xacb6df30U, 0x4faafe66U, 0x8af13c3bU, 0x000014d5U,
+// 5**432 (i=16), start=240, end=272
+  0x682bb941U, 0x89a9f297U, 0xcba75d7bU, 0x404217b1U, 0xb4e519e9U, 0xa1bc162bU,
+  0xf7f5910aU, 0x98715af5U, 0x2ff53e57U, 0xe3ef118cU, 0x490c4543U, 0xbc9b1734U,
+  0x2affbe4dU, 0x4cedcb4cU, 0xfb14e99eU, 0x35e34212U, 0xece39c24U, 0x07673ab3U,
+  0xe73115ddU, 0xd15d38e7U, 0x093eed3bU, 0xf8e7eac5U, 0x78a8cc80U, 0x25227aacU,
+  0x3f590551U, 0x413da1cbU, 0xdf643a55U, 0xab65ad44U, 0xd70b23d7U, 0xc672cd76U,
+  0x3364ea62U, 0x0000086aU,
+// 5**459 (i=17), start=272, end=306
+  0x22f163ddU, 0x23cf07acU, 0xbe2af6c2U, 0xf412f6f6U, 0xc3ff541eU, 0x6eeaf7deU,
+  0xa47047e0U, 0x408cda92U, 0x0f0eeb08U, 0x56deba9dU, 0xcfc6b090U, 0x8bbbdf04U,
+  0x3933cdb3U, 0x9e7bb67dU, 0x9f297035U, 0x38946244U, 0xee1d37bbU, 0xde898174U,
+  0x63f3559dU, 0x705b72fbU, 0x138d27d9U, 0xf8603a78U, 0x735eec44U, 0xe30987d5U,
+  0xc6d38070U, 0x9cfe548eU, 0x9ff01422U, 0x7c564aa8U, 0x91cc60baU, 0xcbc3565dU,
+  0x7550a50bU, 0x6909aeadU, 0x13234c45U, 0x00000366U,
+// 5**486 (i=18), start=306, end=342
+  0x17954989U, 0x3a7d7709U, 0x98042de5U, 0xa9011443U, 0x45e723c2U, 0x269ffd6fU,
+  0x58852a46U, 0xaaa1042aU, 0x2eee8153U, 0xb2b6c39eU, 0xaf845b65U, 0xf6c365d7U,
+  0xe4cffb2bU, 0xc840e90cU, 0xabea8abbU, 0x5c58f8d2U, 0x5c19fa3aU, 0x4670910aU,
+  0x4449f21cU, 0xefa645b3U, 0xcc427decU, 0x083c3d73U, 0x467cb413U, 0x6fe10ae4U,
+  0x3caffc72U, 0x9f8da55eU, 0x5e5c8ea7U, 0x490594bbU, 0xf0871b0bU, 0xdd89816cU,
+  0x8e931df8U, 0xe85ce1c9U, 0xcca090a5U, 0x575fa16bU, 0x6b9f106cU, 0x0000015fU,
+// 5**513 (i=19), start=342, end=380
+  0xee20d805U, 0x57bc3c07U, 0xcdea624eU, 0xd3f0f52dU, 0x9924b4f4U, 0xcf968640U,
+  0x61d41962U, 0xe87fb464U, 0xeaaf51c7U, 0x564c8b60U, 0xccda4028U, 0x529428bbU,
+  0x313a1fa8U, 0x96bd0f94U, 0x7a82ebaaU, 0xad99e7e9U, 0xf2668cd4U, 0xbe33a45eU,
+  0xfd0db669U, 0x87ee369fU, 0xd3ec20edU, 0x9c4d7db7U, 0xdedcf0d8U, 0x7cd2ca64U,
+  0xe25a6577U, 0x61003fd4U, 0xe56f54ccU, 0x10b7c748U, 0x40526e5eU, 0x7300ae87U,
+  0x5c439261U, 0x2c0ff469U, 0xbf723f12U, 0xb2379b61U, 0xbf59b4f5U, 0xc91b1c3fU,
+  0xf0046d27U, 0x0000008dU,
+// 5**540 (i=20), start=380, end=420
+  0x525c9e11U, 0xf4e0eb41U, 0xebb2895dU, 0x5da512f9U, 0x7d9b29d4U, 0x452f4edcU,
+  0x0b90bc37U, 0x341777cbU, 0x63d269afU, 0x1da77929U, 0x0a5c1826U, 0x77991898U,
+  0x5aeddf86U, 0xf853a877U, 0x538c31ccU, 0xe84896daU, 0xb7a0010bU, 0x17ef4de5U,
+  0xa52a2adeU, 0x029fd81cU, 0x987ce701U, 0x27fefd77U, 0xdb46c66fU, 0x5d301900U,
+  0x496998c0U, 0xbb6598b9U, 0x5eebb607U, 0xe547354aU, 0xdf4a2f7eU, 0xf06c4955U,
+  0x96242ffaU, 0x1775fb27U, 0xbecc58ceU, 0xebf2a53bU, 0x3eaad82aU, 0xf41137baU,
+  0x573e6fbaU, 0xfb4866b8U, 0x54002148U, 0x00000039U,
+};
+// clang-format on
+
+// Returns a pointer to the big integer data for (5**27)**i.  i must be
+// between 1 and 20, inclusive.
+const uint32_t* LargePowerOfFiveData(int i) {
+  return kLargePowersOfFive + i * (i - 1);
+}
+
+// Returns the size of the big integer data for (5**27)**i, in words.  i must be
+// between 1 and 20, inclusive.
+int LargePowerOfFiveSize(int i) { return 2 * i; }
+}  // namespace
+
 ABSL_DLL const uint32_t kFiveToNth[14] = {
-    1,     5,      25,      125,     625,      3125,      15625, 
-    78125, 390625, 1953125, 9765625, 48828125, 244140625, 1220703125, 
-}; 
- 
+    1,     5,      25,      125,     625,      3125,      15625,
+    78125, 390625, 1953125, 9765625, 48828125, 244140625, 1220703125,
+};
+
 ABSL_DLL const uint32_t kTenToNth[10] = {
-    1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000, 
-}; 
- 
-template <int max_words> 
-int BigUnsigned<max_words>::ReadFloatMantissa(const ParsedFloat& fp, 
-                                              int significant_digits) { 
-  SetToZero(); 
-  assert(fp.type == FloatType::kNumber); 
- 
-  if (fp.subrange_begin == nullptr) { 
-    // We already exactly parsed the mantissa, so no more work is necessary. 
-    words_[0] = fp.mantissa & 0xffffffffu; 
-    words_[1] = fp.mantissa >> 32; 
-    if (words_[1]) { 
-      size_ = 2; 
-    } else if (words_[0]) { 
-      size_ = 1; 
-    } 
-    return fp.exponent; 
-  } 
-  int exponent_adjust = 
-      ReadDigits(fp.subrange_begin, fp.subrange_end, significant_digits); 
-  return fp.literal_exponent + exponent_adjust; 
-} 
- 
-template <int max_words> 
-int BigUnsigned<max_words>::ReadDigits(const char* begin, const char* end, 
-                                       int significant_digits) { 
-  assert(significant_digits <= Digits10() + 1); 
-  SetToZero(); 
- 
-  bool after_decimal_point = false; 
-  // Discard any leading zeroes before the decimal point 
-  while (begin < end && *begin == '0') { 
-    ++begin; 
-  } 
-  int dropped_digits = 0; 
-  // Discard any trailing zeroes.  These may or may not be after the decimal 
-  // point. 
-  while (begin < end && *std::prev(end) == '0') { 
-    --end; 
-    ++dropped_digits; 
-  } 
-  if (begin < end && *std::prev(end) == '.') { 
+    1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000,
+};
+
+template <int max_words>
+int BigUnsigned<max_words>::ReadFloatMantissa(const ParsedFloat& fp,
+                                              int significant_digits) {
+  SetToZero();
+  assert(fp.type == FloatType::kNumber);
+
+  if (fp.subrange_begin == nullptr) {
+    // We already exactly parsed the mantissa, so no more work is necessary.
+    words_[0] = fp.mantissa & 0xffffffffu;
+    words_[1] = fp.mantissa >> 32;
+    if (words_[1]) {
+      size_ = 2;
+    } else if (words_[0]) {
+      size_ = 1;
+    }
+    return fp.exponent;
+  }
+  int exponent_adjust =
+      ReadDigits(fp.subrange_begin, fp.subrange_end, significant_digits);
+  return fp.literal_exponent + exponent_adjust;
+}
+
+template <int max_words>
+int BigUnsigned<max_words>::ReadDigits(const char* begin, const char* end,
+                                       int significant_digits) {
+  assert(significant_digits <= Digits10() + 1);
+  SetToZero();
+
+  bool after_decimal_point = false;
+  // Discard any leading zeroes before the decimal point
+  while (begin < end && *begin == '0') {
+    ++begin;
+  }
+  int dropped_digits = 0;
+  // Discard any trailing zeroes.  These may or may not be after the decimal
+  // point.
+  while (begin < end && *std::prev(end) == '0') {
+    --end;
+    ++dropped_digits;
+  }
+  if (begin < end && *std::prev(end) == '.') {
     // If the string ends in '.', either before or after dropping zeroes, then
-    // drop the decimal point and look for more digits to drop. 
-    dropped_digits = 0; 
-    --end; 
-    while (begin < end && *std::prev(end) == '0') { 
-      --end; 
-      ++dropped_digits; 
-    } 
-  } else if (dropped_digits) { 
-    // We dropped digits, and aren't sure if they're before or after the decimal 
-    // point.  Figure that out now. 
-    const char* dp = std::find(begin, end, '.'); 
-    if (dp != end) { 
-      // The dropped trailing digits were after the decimal point, so don't 
-      // count them. 
-      dropped_digits = 0; 
-    } 
-  } 
-  // Any non-fraction digits we dropped need to be accounted for in our exponent 
-  // adjustment. 
-  int exponent_adjust = dropped_digits; 
- 
-  uint32_t queued = 0; 
-  int digits_queued = 0; 
-  for (; begin != end && significant_digits > 0; ++begin) { 
-    if (*begin == '.') { 
-      after_decimal_point = true; 
-      continue; 
-    } 
-    if (after_decimal_point) { 
-      // For each fractional digit we emit in our parsed integer, adjust our 
-      // decimal exponent to compensate. 
-      --exponent_adjust; 
-    } 
-    int digit = (*begin - '0'); 
-    --significant_digits; 
-    if (significant_digits == 0 && std::next(begin) != end && 
-        (digit == 0 || digit == 5)) { 
-      // If this is the very last significant digit, but insignificant digits 
-      // remain, we know that the last of those remaining significant digits is 
-      // nonzero.  (If it wasn't, we would have stripped it before we got here.) 
-      // So if this final digit is a 0 or 5, adjust it upward by 1. 
-      // 
-      // This adjustment is what allows incredibly large mantissas ending in 
-      // 500000...000000000001 to correctly round up, rather than to nearest. 
-      ++digit; 
-    } 
-    queued = 10 * queued + digit; 
-    ++digits_queued; 
-    if (digits_queued == kMaxSmallPowerOfTen) { 
-      MultiplyBy(kTenToNth[kMaxSmallPowerOfTen]); 
-      AddWithCarry(0, queued); 
-      queued = digits_queued = 0; 
-    } 
-  } 
-  // Encode any remaining digits. 
-  if (digits_queued) { 
-    MultiplyBy(kTenToNth[digits_queued]); 
-    AddWithCarry(0, queued); 
-  } 
- 
-  // If any insignificant digits remain, we will drop them.  But if we have not 
-  // yet read the decimal point, then we have to adjust the exponent to account 
-  // for the dropped digits. 
-  if (begin < end && !after_decimal_point) { 
-    // This call to std::find will result in a pointer either to the decimal 
-    // point, or to the end of our buffer if there was none. 
-    // 
-    // Either way, [begin, decimal_point) will contain the set of dropped digits 
-    // that require an exponent adjustment. 
-    const char* decimal_point = std::find(begin, end, '.'); 
-    exponent_adjust += (decimal_point - begin); 
-  } 
-  return exponent_adjust; 
-} 
- 
-template <int max_words> 
-/* static */ BigUnsigned<max_words> BigUnsigned<max_words>::FiveToTheNth( 
-    int n) { 
-  BigUnsigned answer(1u); 
- 
-  // Seed from the table of large powers, if possible. 
-  bool first_pass = true; 
-  while (n >= kLargePowerOfFiveStep) { 
-    int big_power = 
-        std::min(n / kLargePowerOfFiveStep, kLargestPowerOfFiveIndex); 
-    if (first_pass) { 
-      // just copy, rather than multiplying by 1 
-      std::copy( 
-          LargePowerOfFiveData(big_power), 
-          LargePowerOfFiveData(big_power) + LargePowerOfFiveSize(big_power), 
-          answer.words_); 
-      answer.size_ = LargePowerOfFiveSize(big_power); 
-      first_pass = false; 
-    } else { 
-      answer.MultiplyBy(LargePowerOfFiveSize(big_power), 
-                        LargePowerOfFiveData(big_power)); 
-    } 
-    n -= kLargePowerOfFiveStep * big_power; 
-  } 
-  answer.MultiplyByFiveToTheNth(n); 
-  return answer; 
-} 
- 
-template <int max_words> 
-void BigUnsigned<max_words>::MultiplyStep(int original_size, 
-                                          const uint32_t* other_words, 
-                                          int other_size, int step) { 
-  int this_i = std::min(original_size - 1, step); 
-  int other_i = step - this_i; 
- 
-  uint64_t this_word = 0; 
-  uint64_t carry = 0; 
-  for (; this_i >= 0 && other_i < other_size; --this_i, ++other_i) { 
-    uint64_t product = words_[this_i]; 
-    product *= other_words[other_i]; 
-    this_word += product; 
-    carry += (this_word >> 32); 
-    this_word &= 0xffffffff; 
-  } 
-  AddWithCarry(step + 1, carry); 
-  words_[step] = this_word & 0xffffffff; 
-  if (this_word > 0 && size_ <= step) { 
-    size_ = step + 1; 
-  } 
-} 
- 
-template <int max_words> 
+    // drop the decimal point and look for more digits to drop.
+    dropped_digits = 0;
+    --end;
+    while (begin < end && *std::prev(end) == '0') {
+      --end;
+      ++dropped_digits;
+    }
+  } else if (dropped_digits) {
+    // We dropped digits, and aren't sure if they're before or after the decimal
+    // point.  Figure that out now.
+    const char* dp = std::find(begin, end, '.');
+    if (dp != end) {
+      // The dropped trailing digits were after the decimal point, so don't
+      // count them.
+      dropped_digits = 0;
+    }
+  }
+  // Any non-fraction digits we dropped need to be accounted for in our exponent
+  // adjustment.
+  int exponent_adjust = dropped_digits;
+
+  uint32_t queued = 0;
+  int digits_queued = 0;
+  for (; begin != end && significant_digits > 0; ++begin) {
+    if (*begin == '.') {
+      after_decimal_point = true;
+      continue;
+    }
+    if (after_decimal_point) {
+      // For each fractional digit we emit in our parsed integer, adjust our
+      // decimal exponent to compensate.
+      --exponent_adjust;
+    }
+    int digit = (*begin - '0');
+    --significant_digits;
+    if (significant_digits == 0 && std::next(begin) != end &&
+        (digit == 0 || digit == 5)) {
+      // If this is the very last significant digit, but insignificant digits
+      // remain, we know that the last of those remaining significant digits is
+      // nonzero.  (If it wasn't, we would have stripped it before we got here.)
+      // So if this final digit is a 0 or 5, adjust it upward by 1.
+      //
+      // This adjustment is what allows incredibly large mantissas ending in
+      // 500000...000000000001 to correctly round up, rather than to nearest.
+      ++digit;
+    }
+    queued = 10 * queued + digit;
+    ++digits_queued;
+    if (digits_queued == kMaxSmallPowerOfTen) {
+      MultiplyBy(kTenToNth[kMaxSmallPowerOfTen]);
+      AddWithCarry(0, queued);
+      queued = digits_queued = 0;
+    }
+  }
+  // Encode any remaining digits.
+  if (digits_queued) {
+    MultiplyBy(kTenToNth[digits_queued]);
+    AddWithCarry(0, queued);
+  }
+
+  // If any insignificant digits remain, we will drop them.  But if we have not
+  // yet read the decimal point, then we have to adjust the exponent to account
+  // for the dropped digits.
+  if (begin < end && !after_decimal_point) {
+    // This call to std::find will result in a pointer either to the decimal
+    // point, or to the end of our buffer if there was none.
+    //
+    // Either way, [begin, decimal_point) will contain the set of dropped digits
+    // that require an exponent adjustment.
+    const char* decimal_point = std::find(begin, end, '.');
+    exponent_adjust += (decimal_point - begin);
+  }
+  return exponent_adjust;
+}
+
+template <int max_words>
+/* static */ BigUnsigned<max_words> BigUnsigned<max_words>::FiveToTheNth(
+    int n) {
+  BigUnsigned answer(1u);
+
+  // Seed from the table of large powers, if possible.
+  bool first_pass = true;
+  while (n >= kLargePowerOfFiveStep) {
+    int big_power =
+        std::min(n / kLargePowerOfFiveStep, kLargestPowerOfFiveIndex);
+    if (first_pass) {
+      // just copy, rather than multiplying by 1
+      std::copy(
+          LargePowerOfFiveData(big_power),
+          LargePowerOfFiveData(big_power) + LargePowerOfFiveSize(big_power),
+          answer.words_);
+      answer.size_ = LargePowerOfFiveSize(big_power);
+      first_pass = false;
+    } else {
+      answer.MultiplyBy(LargePowerOfFiveSize(big_power),
+                        LargePowerOfFiveData(big_power));
+    }
+    n -= kLargePowerOfFiveStep * big_power;
+  }
+  answer.MultiplyByFiveToTheNth(n);
+  return answer;
+}
+
+template <int max_words>
+void BigUnsigned<max_words>::MultiplyStep(int original_size,
+                                          const uint32_t* other_words,
+                                          int other_size, int step) {
+  int this_i = std::min(original_size - 1, step);
+  int other_i = step - this_i;
+
+  uint64_t this_word = 0;
+  uint64_t carry = 0;
+  for (; this_i >= 0 && other_i < other_size; --this_i, ++other_i) {
+    uint64_t product = words_[this_i];
+    product *= other_words[other_i];
+    this_word += product;
+    carry += (this_word >> 32);
+    this_word &= 0xffffffff;
+  }
+  AddWithCarry(step + 1, carry);
+  words_[step] = this_word & 0xffffffff;
+  if (this_word > 0 && size_ <= step) {
+    size_ = step + 1;
+  }
+}
+
+template <int max_words>
 TString BigUnsigned<max_words>::ToString() const {
-  BigUnsigned<max_words> copy = *this; 
+  BigUnsigned<max_words> copy = *this;
   TString result;
-  // Build result in reverse order 
-  while (copy.size() > 0) { 
-    int next_digit = copy.DivMod<10>(); 
-    result.push_back('0' + next_digit); 
-  } 
-  if (result.empty()) { 
-    result.push_back('0'); 
-  } 
+  // Build result in reverse order
+  while (copy.size() > 0) {
+    int next_digit = copy.DivMod<10>();
+    result.push_back('0' + next_digit);
+  }
+  if (result.empty()) {
+    result.push_back('0');
+  }
   std::reverse(result.begin(), result.vend());
-  return result; 
-} 
- 
-template class BigUnsigned<4>; 
-template class BigUnsigned<84>; 
- 
-}  // namespace strings_internal 
+  return result;
+}
+
+template class BigUnsigned<4>;
+template class BigUnsigned<84>;
+
+}  // namespace strings_internal
 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 4508b8f24f..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
@@ -1,423 +1,423 @@
-// Copyright 2018 The Abseil Authors. 
-// 
-// Licensed under the Apache License, Version 2.0 (the "License"); 
-// you may not use this file except in compliance with the License. 
-// You may obtain a copy of the License at 
-// 
-//      https://www.apache.org/licenses/LICENSE-2.0 
-// 
-// Unless required by applicable law or agreed to in writing, software 
-// distributed under the License is distributed on an "AS IS" BASIS, 
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-// See the License for the specific language governing permissions and 
-// limitations under the License. 
- 
-#ifndef ABSL_STRINGS_INTERNAL_CHARCONV_BIGINT_H_ 
-#define ABSL_STRINGS_INTERNAL_CHARCONV_BIGINT_H_ 
- 
-#include <algorithm> 
-#include <cstdint> 
-#include <iostream> 
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_STRINGS_INTERNAL_CHARCONV_BIGINT_H_
+#define ABSL_STRINGS_INTERNAL_CHARCONV_BIGINT_H_
+
+#include <algorithm>
+#include <cstdint>
+#include <iostream>
 #include <util/generic/string.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
-namespace strings_internal { 
- 
-// The largest power that 5 that can be raised to, and still fit in a uint32_t. 
-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; 
- 
+namespace strings_internal {
+
+// The largest power that 5 that can be raised to, and still fit in a uint32_t.
+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];
- 
-// Large, fixed-width unsigned integer. 
-// 
-// Exact rounding for decimal-to-binary floating point conversion requires very 
+
+// Large, fixed-width unsigned integer.
+//
+// Exact rounding for decimal-to-binary floating point conversion requires very
 // large integer math, but a design goal of y_absl::from_chars is to avoid
-// allocating memory.  The integer precision needed for decimal-to-binary 
-// conversions is large but bounded, so a huge fixed-width integer class 
-// suffices. 
-// 
-// This is an intentionally limited big integer class.  Only needed operations 
-// are implemented.  All storage lives in an array data member, and all 
-// arithmetic is done in-place, to avoid requiring separate storage for operand 
-// and result. 
-// 
-// This is an internal class.  Some methods live in the .cc file, and are 
-// instantiated only for the values of max_words we need. 
-template <int max_words> 
-class BigUnsigned { 
- public: 
-  static_assert(max_words == 4 || max_words == 84, 
-                "unsupported max_words value"); 
- 
-  BigUnsigned() : size_(0), words_{} {} 
-  explicit constexpr BigUnsigned(uint64_t v) 
-      : size_((v >> 32) ? 2 : v ? 1 : 0), 
-        words_{static_cast<uint32_t>(v & 0xffffffffu), 
-               static_cast<uint32_t>(v >> 32)} {} 
- 
-  // Constructs a BigUnsigned from the given string_view containing a decimal 
+// allocating memory.  The integer precision needed for decimal-to-binary
+// conversions is large but bounded, so a huge fixed-width integer class
+// suffices.
+//
+// This is an intentionally limited big integer class.  Only needed operations
+// are implemented.  All storage lives in an array data member, and all
+// arithmetic is done in-place, to avoid requiring separate storage for operand
+// and result.
+//
+// This is an internal class.  Some methods live in the .cc file, and are
+// instantiated only for the values of max_words we need.
+template <int max_words>
+class BigUnsigned {
+ public:
+  static_assert(max_words == 4 || max_words == 84,
+                "unsupported max_words value");
+
+  BigUnsigned() : size_(0), words_{} {}
+  explicit constexpr BigUnsigned(uint64_t v)
+      : size_((v >> 32) ? 2 : v ? 1 : 0),
+        words_{static_cast<uint32_t>(v & 0xffffffffu),
+               static_cast<uint32_t>(v >> 32)} {}
+
+  // Constructs a BigUnsigned from the given string_view containing a decimal
   // value.  If the input string is not a decimal integer, constructs a 0
-  // instead. 
+  // instead.
   explicit BigUnsigned(y_absl::string_view sv) : size_(0), words_{} {
-    // Check for valid input, returning a 0 otherwise.  This is reasonable 
-    // behavior only because this constructor is for unit tests. 
-    if (std::find_if_not(sv.begin(), sv.end(), ascii_isdigit) != sv.end() || 
-        sv.empty()) { 
-      return; 
-    } 
-    int exponent_adjust = 
-        ReadDigits(sv.data(), sv.data() + sv.size(), Digits10() + 1); 
-    if (exponent_adjust > 0) { 
-      MultiplyByTenToTheNth(exponent_adjust); 
-    } 
-  } 
- 
-  // Loads the mantissa value of a previously-parsed float. 
-  // 
-  // Returns the associated decimal exponent.  The value of the parsed float is 
-  // exactly *this * 10**exponent. 
-  int ReadFloatMantissa(const ParsedFloat& fp, int significant_digits); 
- 
-  // Returns the number of decimal digits of precision this type provides.  All 
-  // numbers with this many decimal digits or fewer are representable by this 
-  // type. 
-  // 
-  // Analagous to std::numeric_limits<BigUnsigned>::digits10. 
-  static constexpr int Digits10() { 
-    // 9975007/1035508 is very slightly less than log10(2**32). 
-    return static_cast<uint64_t>(max_words) * 9975007 / 1035508; 
-  } 
- 
-  // Shifts left by the given number of bits. 
-  void ShiftLeft(int count) { 
-    if (count > 0) { 
-      const int word_shift = count / 32; 
-      if (word_shift >= max_words) { 
-        SetToZero(); 
-        return; 
-      } 
-      size_ = (std::min)(size_ + word_shift, max_words); 
-      count %= 32; 
-      if (count == 0) { 
-        std::copy_backward(words_, words_ + size_ - word_shift, words_ + size_); 
-      } else { 
-        for (int i = (std::min)(size_, max_words - 1); i > word_shift; --i) { 
-          words_[i] = (words_[i - word_shift] << count) | 
-                      (words_[i - word_shift - 1] >> (32 - count)); 
-        } 
-        words_[word_shift] = words_[0] << count; 
-        // Grow size_ if necessary. 
-        if (size_ < max_words && words_[size_]) { 
-          ++size_; 
-        } 
-      } 
-      std::fill(words_, words_ + word_shift, 0u); 
-    } 
-  } 
- 
- 
-  // Multiplies by v in-place. 
-  void MultiplyBy(uint32_t v) { 
-    if (size_ == 0 || v == 1) { 
-      return; 
-    } 
-    if (v == 0) { 
-      SetToZero(); 
-      return; 
-    } 
-    const uint64_t factor = v; 
-    uint64_t window = 0; 
-    for (int i = 0; i < size_; ++i) { 
-      window += factor * words_[i]; 
-      words_[i] = window & 0xffffffff; 
-      window >>= 32; 
-    } 
-    // If carry bits remain and there's space for them, grow size_. 
-    if (window && size_ < max_words) { 
-      words_[size_] = window & 0xffffffff; 
-      ++size_; 
-    } 
-  } 
- 
-  void MultiplyBy(uint64_t v) { 
-    uint32_t words[2]; 
-    words[0] = static_cast<uint32_t>(v); 
-    words[1] = static_cast<uint32_t>(v >> 32); 
-    if (words[1] == 0) { 
-      MultiplyBy(words[0]); 
-    } else { 
-      MultiplyBy(2, words); 
-    } 
-  } 
- 
-  // Multiplies in place by 5 to the power of n.  n must be non-negative. 
-  void MultiplyByFiveToTheNth(int n) { 
-    while (n >= kMaxSmallPowerOfFive) { 
-      MultiplyBy(kFiveToNth[kMaxSmallPowerOfFive]); 
-      n -= kMaxSmallPowerOfFive; 
-    } 
-    if (n > 0) { 
-      MultiplyBy(kFiveToNth[n]); 
-    } 
-  } 
- 
-  // Multiplies in place by 10 to the power of n.  n must be non-negative. 
-  void MultiplyByTenToTheNth(int n) { 
-    if (n > kMaxSmallPowerOfTen) { 
-      // For large n, raise to a power of 5, then shift left by the same amount. 
-      // (10**n == 5**n * 2**n.)  This requires fewer multiplications overall. 
-      MultiplyByFiveToTheNth(n); 
-      ShiftLeft(n); 
-    } else if (n > 0) { 
-      // We can do this more quickly for very small N by using a single 
-      // multiplication. 
-      MultiplyBy(kTenToNth[n]); 
-    } 
-  } 
- 
-  // Returns the value of 5**n, for non-negative n.  This implementation uses 
-  // a lookup table, and is faster then seeding a BigUnsigned with 1 and calling 
-  // MultiplyByFiveToTheNth(). 
-  static BigUnsigned FiveToTheNth(int n); 
- 
-  // Multiplies by another BigUnsigned, in-place. 
-  template <int M> 
-  void MultiplyBy(const BigUnsigned<M>& other) { 
-    MultiplyBy(other.size(), other.words()); 
-  } 
- 
-  void SetToZero() { 
-    std::fill(words_, words_ + size_, 0u); 
-    size_ = 0; 
-  } 
- 
-  // Returns the value of the nth word of this BigUnsigned.  This is 
-  // range-checked, and returns 0 on out-of-bounds accesses. 
-  uint32_t GetWord(int index) const { 
-    if (index < 0 || index >= size_) { 
-      return 0; 
-    } 
-    return words_[index]; 
-  } 
- 
+    // Check for valid input, returning a 0 otherwise.  This is reasonable
+    // behavior only because this constructor is for unit tests.
+    if (std::find_if_not(sv.begin(), sv.end(), ascii_isdigit) != sv.end() ||
+        sv.empty()) {
+      return;
+    }
+    int exponent_adjust =
+        ReadDigits(sv.data(), sv.data() + sv.size(), Digits10() + 1);
+    if (exponent_adjust > 0) {
+      MultiplyByTenToTheNth(exponent_adjust);
+    }
+  }
+
+  // Loads the mantissa value of a previously-parsed float.
+  //
+  // Returns the associated decimal exponent.  The value of the parsed float is
+  // exactly *this * 10**exponent.
+  int ReadFloatMantissa(const ParsedFloat& fp, int significant_digits);
+
+  // Returns the number of decimal digits of precision this type provides.  All
+  // numbers with this many decimal digits or fewer are representable by this
+  // type.
+  //
+  // Analagous to std::numeric_limits<BigUnsigned>::digits10.
+  static constexpr int Digits10() {
+    // 9975007/1035508 is very slightly less than log10(2**32).
+    return static_cast<uint64_t>(max_words) * 9975007 / 1035508;
+  }
+
+  // Shifts left by the given number of bits.
+  void ShiftLeft(int count) {
+    if (count > 0) {
+      const int word_shift = count / 32;
+      if (word_shift >= max_words) {
+        SetToZero();
+        return;
+      }
+      size_ = (std::min)(size_ + word_shift, max_words);
+      count %= 32;
+      if (count == 0) {
+        std::copy_backward(words_, words_ + size_ - word_shift, words_ + size_);
+      } else {
+        for (int i = (std::min)(size_, max_words - 1); i > word_shift; --i) {
+          words_[i] = (words_[i - word_shift] << count) |
+                      (words_[i - word_shift - 1] >> (32 - count));
+        }
+        words_[word_shift] = words_[0] << count;
+        // Grow size_ if necessary.
+        if (size_ < max_words && words_[size_]) {
+          ++size_;
+        }
+      }
+      std::fill(words_, words_ + word_shift, 0u);
+    }
+  }
+
+
+  // Multiplies by v in-place.
+  void MultiplyBy(uint32_t v) {
+    if (size_ == 0 || v == 1) {
+      return;
+    }
+    if (v == 0) {
+      SetToZero();
+      return;
+    }
+    const uint64_t factor = v;
+    uint64_t window = 0;
+    for (int i = 0; i < size_; ++i) {
+      window += factor * words_[i];
+      words_[i] = window & 0xffffffff;
+      window >>= 32;
+    }
+    // If carry bits remain and there's space for them, grow size_.
+    if (window && size_ < max_words) {
+      words_[size_] = window & 0xffffffff;
+      ++size_;
+    }
+  }
+
+  void MultiplyBy(uint64_t v) {
+    uint32_t words[2];
+    words[0] = static_cast<uint32_t>(v);
+    words[1] = static_cast<uint32_t>(v >> 32);
+    if (words[1] == 0) {
+      MultiplyBy(words[0]);
+    } else {
+      MultiplyBy(2, words);
+    }
+  }
+
+  // Multiplies in place by 5 to the power of n.  n must be non-negative.
+  void MultiplyByFiveToTheNth(int n) {
+    while (n >= kMaxSmallPowerOfFive) {
+      MultiplyBy(kFiveToNth[kMaxSmallPowerOfFive]);
+      n -= kMaxSmallPowerOfFive;
+    }
+    if (n > 0) {
+      MultiplyBy(kFiveToNth[n]);
+    }
+  }
+
+  // Multiplies in place by 10 to the power of n.  n must be non-negative.
+  void MultiplyByTenToTheNth(int n) {
+    if (n > kMaxSmallPowerOfTen) {
+      // For large n, raise to a power of 5, then shift left by the same amount.
+      // (10**n == 5**n * 2**n.)  This requires fewer multiplications overall.
+      MultiplyByFiveToTheNth(n);
+      ShiftLeft(n);
+    } else if (n > 0) {
+      // We can do this more quickly for very small N by using a single
+      // multiplication.
+      MultiplyBy(kTenToNth[n]);
+    }
+  }
+
+  // Returns the value of 5**n, for non-negative n.  This implementation uses
+  // a lookup table, and is faster then seeding a BigUnsigned with 1 and calling
+  // MultiplyByFiveToTheNth().
+  static BigUnsigned FiveToTheNth(int n);
+
+  // Multiplies by another BigUnsigned, in-place.
+  template <int M>
+  void MultiplyBy(const BigUnsigned<M>& other) {
+    MultiplyBy(other.size(), other.words());
+  }
+
+  void SetToZero() {
+    std::fill(words_, words_ + size_, 0u);
+    size_ = 0;
+  }
+
+  // Returns the value of the nth word of this BigUnsigned.  This is
+  // range-checked, and returns 0 on out-of-bounds accesses.
+  uint32_t GetWord(int index) const {
+    if (index < 0 || index >= size_) {
+      return 0;
+    }
+    return words_[index];
+  }
+
   // Returns this integer as a decimal string.  This is not used in the decimal-
-  // to-binary conversion; it is intended to aid in testing. 
+  // to-binary conversion; it is intended to aid in testing.
   TString ToString() const;
- 
-  int size() const { return size_; } 
-  const uint32_t* words() const { return words_; } 
- 
- private: 
-  // Reads the number between [begin, end), possibly containing a decimal point, 
-  // into this BigUnsigned. 
-  // 
-  // Callers are required to ensure [begin, end) contains a valid number, with 
-  // one or more decimal digits and at most one decimal point.  This routine 
-  // will behave unpredictably if these preconditions are not met. 
-  // 
-  // Only the first `significant_digits` digits are read.  Digits beyond this 
-  // limit are "sticky": If the final significant digit is 0 or 5, and if any 
-  // dropped digit is nonzero, then that final significant digit is adjusted up 
-  // to 1 or 6.  This adjustment allows for precise rounding. 
-  // 
-  // Returns `exponent_adjustment`, a power-of-ten exponent adjustment to 
-  // account for the decimal point and for dropped significant digits.  After 
-  // this function returns, 
-  //   actual_value_of_parsed_string ~= *this * 10**exponent_adjustment. 
-  int ReadDigits(const char* begin, const char* end, int significant_digits); 
- 
-  // Performs a step of big integer multiplication.  This computes the full 
-  // (64-bit-wide) values that should be added at the given index (step), and 
-  // adds to that location in-place. 
-  // 
-  // Because our math all occurs in place, we must multiply starting from the 
-  // highest word working downward.  (This is a bit more expensive due to the 
-  // extra carries involved.) 
-  // 
-  // This must be called in steps, for each word to be calculated, starting from 
-  // the high end and working down to 0.  The first value of `step` should be 
-  //   `std::min(original_size + other.size_ - 2, max_words - 1)`. 
-  // The reason for this expression is that multiplying the i'th word from one 
-  // multiplicand and the j'th word of another multiplicand creates a 
-  // two-word-wide value to be stored at the (i+j)'th element.  The highest 
-  // word indices we will access are `original_size - 1` from this object, and 
-  // `other.size_ - 1` from our operand.  Therefore, 
-  // `original_size + other.size_ - 2` is the first step we should calculate, 
-  // but limited on an upper bound by max_words. 
- 
-  // Working from high-to-low ensures that we do not overwrite the portions of 
-  // the initial value of *this which are still needed for later steps. 
-  // 
-  // Once called with step == 0, *this contains the result of the 
-  // multiplication. 
-  // 
-  // `original_size` is the size_ of *this before the first call to 
-  // MultiplyStep().  `other_words` and `other_size` are the contents of our 
-  // operand.  `step` is the step to perform, as described above. 
-  void MultiplyStep(int original_size, const uint32_t* other_words, 
-                    int other_size, int step); 
- 
-  void MultiplyBy(int other_size, const uint32_t* other_words) { 
-    const int original_size = size_; 
-    const int first_step = 
-        (std::min)(original_size + other_size - 2, max_words - 1); 
-    for (int step = first_step; step >= 0; --step) { 
-      MultiplyStep(original_size, other_words, other_size, step); 
-    } 
-  } 
- 
-  // Adds a 32-bit value to the index'th word, with carry. 
-  void AddWithCarry(int index, uint32_t value) { 
-    if (value) { 
-      while (index < max_words && value > 0) { 
-        words_[index] += value; 
-        // carry if we overflowed in this word: 
-        if (value > words_[index]) { 
-          value = 1; 
-          ++index; 
-        } else { 
-          value = 0; 
-        } 
-      } 
-      size_ = (std::min)(max_words, (std::max)(index + 1, size_)); 
-    } 
-  } 
- 
-  void AddWithCarry(int index, uint64_t value) { 
-    if (value && index < max_words) { 
-      uint32_t high = value >> 32; 
-      uint32_t low = value & 0xffffffff; 
-      words_[index] += low; 
-      if (words_[index] < low) { 
-        ++high; 
-        if (high == 0) { 
-          // Carry from the low word caused our high word to overflow. 
-          // Short circuit here to do the right thing. 
-          AddWithCarry(index + 2, static_cast<uint32_t>(1)); 
-          return; 
-        } 
-      } 
-      if (high > 0) { 
-        AddWithCarry(index + 1, high); 
-      } else { 
-        // Normally 32-bit AddWithCarry() sets size_, but since we don't call 
-        // it when `high` is 0, do it ourselves here. 
-        size_ = (std::min)(max_words, (std::max)(index + 1, size_)); 
-      } 
-    } 
-  } 
- 
-  // Divide this in place by a constant divisor.  Returns the remainder of the 
-  // division. 
-  template <uint32_t divisor> 
-  uint32_t DivMod() { 
-    uint64_t accumulator = 0; 
-    for (int i = size_ - 1; i >= 0; --i) { 
-      accumulator <<= 32; 
-      accumulator += words_[i]; 
-      // accumulator / divisor will never overflow an int32_t in this loop 
-      words_[i] = static_cast<uint32_t>(accumulator / divisor); 
-      accumulator = accumulator % divisor; 
-    } 
-    while (size_ > 0 && words_[size_ - 1] == 0) { 
-      --size_; 
-    } 
-    return static_cast<uint32_t>(accumulator); 
-  } 
- 
-  // The number of elements in words_ that may carry significant values. 
-  // All elements beyond this point are 0. 
-  // 
-  // When size_ is 0, this BigUnsigned stores the value 0. 
-  // When size_ is nonzero, is *not* guaranteed that words_[size_ - 1] is 
-  // nonzero.  This can occur due to overflow truncation. 
-  // In particular, x.size_ != y.size_ does *not* imply x != y. 
-  int size_; 
-  uint32_t words_[max_words]; 
-}; 
- 
-// Compares two big integer instances. 
-// 
-// Returns -1 if lhs < rhs, 0 if lhs == rhs, and 1 if lhs > rhs. 
-template <int N, int M> 
-int Compare(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) { 
-  int limit = (std::max)(lhs.size(), rhs.size()); 
-  for (int i = limit - 1; i >= 0; --i) { 
-    const uint32_t lhs_word = lhs.GetWord(i); 
-    const uint32_t rhs_word = rhs.GetWord(i); 
-    if (lhs_word < rhs_word) { 
-      return -1; 
-    } else if (lhs_word > rhs_word) { 
-      return 1; 
-    } 
-  } 
-  return 0; 
-} 
- 
-template <int N, int M> 
-bool operator==(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) { 
-  int limit = (std::max)(lhs.size(), rhs.size()); 
-  for (int i = 0; i < limit; ++i) { 
-    if (lhs.GetWord(i) != rhs.GetWord(i)) { 
-      return false; 
-    } 
-  } 
-  return true; 
-} 
- 
-template <int N, int M> 
-bool operator!=(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) { 
-  return !(lhs == rhs); 
-} 
- 
-template <int N, int M> 
-bool operator<(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) { 
-  return Compare(lhs, rhs) == -1; 
-} 
- 
-template <int N, int M> 
-bool operator>(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) { 
-  return rhs < lhs; 
-} 
-template <int N, int M> 
-bool operator<=(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) { 
-  return !(rhs < lhs); 
-} 
-template <int N, int M> 
-bool operator>=(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) { 
-  return !(lhs < rhs); 
-} 
- 
-// Output operator for BigUnsigned, for testing purposes only. 
-template <int N> 
-std::ostream& operator<<(std::ostream& os, const BigUnsigned<N>& num) { 
-  return os << num.ToString(); 
-} 
- 
-// Explicit instantiation declarations for the sizes of BigUnsigned that we 
-// are using. 
-// 
-// For now, the choices of 4 and 84 are arbitrary; 4 is a small value that is 
-// still bigger than an int128, and 84 is a large value we will want to use 
-// in the from_chars implementation. 
-// 
-// Comments justifying the use of 84 belong in the from_chars implementation, 
-// and will be added in a follow-up CL. 
-extern template class BigUnsigned<4>; 
-extern template class BigUnsigned<84>; 
- 
-}  // namespace strings_internal 
+
+  int size() const { return size_; }
+  const uint32_t* words() const { return words_; }
+
+ private:
+  // Reads the number between [begin, end), possibly containing a decimal point,
+  // into this BigUnsigned.
+  //
+  // Callers are required to ensure [begin, end) contains a valid number, with
+  // one or more decimal digits and at most one decimal point.  This routine
+  // will behave unpredictably if these preconditions are not met.
+  //
+  // Only the first `significant_digits` digits are read.  Digits beyond this
+  // limit are "sticky": If the final significant digit is 0 or 5, and if any
+  // dropped digit is nonzero, then that final significant digit is adjusted up
+  // to 1 or 6.  This adjustment allows for precise rounding.
+  //
+  // Returns `exponent_adjustment`, a power-of-ten exponent adjustment to
+  // account for the decimal point and for dropped significant digits.  After
+  // this function returns,
+  //   actual_value_of_parsed_string ~= *this * 10**exponent_adjustment.
+  int ReadDigits(const char* begin, const char* end, int significant_digits);
+
+  // Performs a step of big integer multiplication.  This computes the full
+  // (64-bit-wide) values that should be added at the given index (step), and
+  // adds to that location in-place.
+  //
+  // Because our math all occurs in place, we must multiply starting from the
+  // highest word working downward.  (This is a bit more expensive due to the
+  // extra carries involved.)
+  //
+  // This must be called in steps, for each word to be calculated, starting from
+  // the high end and working down to 0.  The first value of `step` should be
+  //   `std::min(original_size + other.size_ - 2, max_words - 1)`.
+  // The reason for this expression is that multiplying the i'th word from one
+  // multiplicand and the j'th word of another multiplicand creates a
+  // two-word-wide value to be stored at the (i+j)'th element.  The highest
+  // word indices we will access are `original_size - 1` from this object, and
+  // `other.size_ - 1` from our operand.  Therefore,
+  // `original_size + other.size_ - 2` is the first step we should calculate,
+  // but limited on an upper bound by max_words.
+
+  // Working from high-to-low ensures that we do not overwrite the portions of
+  // the initial value of *this which are still needed for later steps.
+  //
+  // Once called with step == 0, *this contains the result of the
+  // multiplication.
+  //
+  // `original_size` is the size_ of *this before the first call to
+  // MultiplyStep().  `other_words` and `other_size` are the contents of our
+  // operand.  `step` is the step to perform, as described above.
+  void MultiplyStep(int original_size, const uint32_t* other_words,
+                    int other_size, int step);
+
+  void MultiplyBy(int other_size, const uint32_t* other_words) {
+    const int original_size = size_;
+    const int first_step =
+        (std::min)(original_size + other_size - 2, max_words - 1);
+    for (int step = first_step; step >= 0; --step) {
+      MultiplyStep(original_size, other_words, other_size, step);
+    }
+  }
+
+  // Adds a 32-bit value to the index'th word, with carry.
+  void AddWithCarry(int index, uint32_t value) {
+    if (value) {
+      while (index < max_words && value > 0) {
+        words_[index] += value;
+        // carry if we overflowed in this word:
+        if (value > words_[index]) {
+          value = 1;
+          ++index;
+        } else {
+          value = 0;
+        }
+      }
+      size_ = (std::min)(max_words, (std::max)(index + 1, size_));
+    }
+  }
+
+  void AddWithCarry(int index, uint64_t value) {
+    if (value && index < max_words) {
+      uint32_t high = value >> 32;
+      uint32_t low = value & 0xffffffff;
+      words_[index] += low;
+      if (words_[index] < low) {
+        ++high;
+        if (high == 0) {
+          // Carry from the low word caused our high word to overflow.
+          // Short circuit here to do the right thing.
+          AddWithCarry(index + 2, static_cast<uint32_t>(1));
+          return;
+        }
+      }
+      if (high > 0) {
+        AddWithCarry(index + 1, high);
+      } else {
+        // Normally 32-bit AddWithCarry() sets size_, but since we don't call
+        // it when `high` is 0, do it ourselves here.
+        size_ = (std::min)(max_words, (std::max)(index + 1, size_));
+      }
+    }
+  }
+
+  // Divide this in place by a constant divisor.  Returns the remainder of the
+  // division.
+  template <uint32_t divisor>
+  uint32_t DivMod() {
+    uint64_t accumulator = 0;
+    for (int i = size_ - 1; i >= 0; --i) {
+      accumulator <<= 32;
+      accumulator += words_[i];
+      // accumulator / divisor will never overflow an int32_t in this loop
+      words_[i] = static_cast<uint32_t>(accumulator / divisor);
+      accumulator = accumulator % divisor;
+    }
+    while (size_ > 0 && words_[size_ - 1] == 0) {
+      --size_;
+    }
+    return static_cast<uint32_t>(accumulator);
+  }
+
+  // The number of elements in words_ that may carry significant values.
+  // All elements beyond this point are 0.
+  //
+  // When size_ is 0, this BigUnsigned stores the value 0.
+  // When size_ is nonzero, is *not* guaranteed that words_[size_ - 1] is
+  // nonzero.  This can occur due to overflow truncation.
+  // In particular, x.size_ != y.size_ does *not* imply x != y.
+  int size_;
+  uint32_t words_[max_words];
+};
+
+// Compares two big integer instances.
+//
+// Returns -1 if lhs < rhs, 0 if lhs == rhs, and 1 if lhs > rhs.
+template <int N, int M>
+int Compare(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
+  int limit = (std::max)(lhs.size(), rhs.size());
+  for (int i = limit - 1; i >= 0; --i) {
+    const uint32_t lhs_word = lhs.GetWord(i);
+    const uint32_t rhs_word = rhs.GetWord(i);
+    if (lhs_word < rhs_word) {
+      return -1;
+    } else if (lhs_word > rhs_word) {
+      return 1;
+    }
+  }
+  return 0;
+}
+
+template <int N, int M>
+bool operator==(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
+  int limit = (std::max)(lhs.size(), rhs.size());
+  for (int i = 0; i < limit; ++i) {
+    if (lhs.GetWord(i) != rhs.GetWord(i)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+template <int N, int M>
+bool operator!=(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
+  return !(lhs == rhs);
+}
+
+template <int N, int M>
+bool operator<(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
+  return Compare(lhs, rhs) == -1;
+}
+
+template <int N, int M>
+bool operator>(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
+  return rhs < lhs;
+}
+template <int N, int M>
+bool operator<=(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
+  return !(rhs < lhs);
+}
+template <int N, int M>
+bool operator>=(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
+  return !(lhs < rhs);
+}
+
+// Output operator for BigUnsigned, for testing purposes only.
+template <int N>
+std::ostream& operator<<(std::ostream& os, const BigUnsigned<N>& num) {
+  return os << num.ToString();
+}
+
+// Explicit instantiation declarations for the sizes of BigUnsigned that we
+// are using.
+//
+// For now, the choices of 4 and 84 are arbitrary; 4 is a small value that is
+// still bigger than an int128, and 84 is a large value we will want to use
+// in the from_chars implementation.
+//
+// Comments justifying the use of 84 belong in the from_chars implementation,
+// and will be added in a follow-up CL.
+extern template class BigUnsigned<4>;
+extern template class BigUnsigned<84>;
+
+}  // namespace strings_internal
 ABSL_NAMESPACE_END
 }  // namespace y_absl
- 
-#endif  // ABSL_STRINGS_INTERNAL_CHARCONV_BIGINT_H_ 
+
+#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 be60f962f5..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
@@ -1,504 +1,504 @@
-// Copyright 2018 The Abseil Authors. 
-// 
-// Licensed under the Apache License, Version 2.0 (the "License"); 
-// you may not use this file except in compliance with the License. 
-// You may obtain a copy of the License at 
-// 
-//      https://www.apache.org/licenses/LICENSE-2.0 
-// 
-// Unless required by applicable law or agreed to in writing, software 
-// distributed under the License is distributed on an "AS IS" BASIS, 
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-// See the License for the specific language governing permissions and 
-// limitations under the License. 
- 
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 #include "y_absl/strings/internal/charconv_parse.h"
 #include "y_absl/strings/charconv.h"
- 
-#include <cassert> 
-#include <cstdint> 
-#include <limits> 
- 
+
+#include <cassert>
+#include <cstdint>
+#include <limits>
+
 #include "y_absl/strings/internal/memutil.h"
- 
+
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-namespace { 
- 
-// ParseFloat<10> will read the first 19 significant digits of the mantissa. 
-// This number was chosen for multiple reasons. 
-// 
-// (a) First, for whatever integer type we choose to represent the mantissa, we 
-// want to choose the largest possible number of decimal digits for that integer 
-// type.  We are using uint64_t, which can express any 19-digit unsigned 
-// integer. 
-// 
-// (b) Second, we need to parse enough digits that the binary value of any 
-// mantissa we capture has more bits of resolution than the mantissa 
-// representation in the target float.  Our algorithm requires at least 3 bits 
-// of headway, but 19 decimal digits give a little more than that. 
-// 
-// The following static assertions verify the above comments: 
-constexpr int kDecimalMantissaDigitsMax = 19; 
- 
-static_assert(std::numeric_limits<uint64_t>::digits10 == 
-                  kDecimalMantissaDigitsMax, 
-              "(a) above"); 
- 
-// IEEE doubles, which we assume in Abseil, have 53 binary bits of mantissa. 
-static_assert(std::numeric_limits<double>::is_iec559, "IEEE double assumed"); 
-static_assert(std::numeric_limits<double>::radix == 2, "IEEE double fact"); 
-static_assert(std::numeric_limits<double>::digits == 53, "IEEE double fact"); 
- 
-// The lowest valued 19-digit decimal mantissa we can read still contains 
-// sufficient information to reconstruct a binary mantissa. 
+namespace {
+
+// ParseFloat<10> will read the first 19 significant digits of the mantissa.
+// This number was chosen for multiple reasons.
+//
+// (a) First, for whatever integer type we choose to represent the mantissa, we
+// want to choose the largest possible number of decimal digits for that integer
+// type.  We are using uint64_t, which can express any 19-digit unsigned
+// integer.
+//
+// (b) Second, we need to parse enough digits that the binary value of any
+// mantissa we capture has more bits of resolution than the mantissa
+// representation in the target float.  Our algorithm requires at least 3 bits
+// of headway, but 19 decimal digits give a little more than that.
+//
+// The following static assertions verify the above comments:
+constexpr int kDecimalMantissaDigitsMax = 19;
+
+static_assert(std::numeric_limits<uint64_t>::digits10 ==
+                  kDecimalMantissaDigitsMax,
+              "(a) above");
+
+// IEEE doubles, which we assume in Abseil, have 53 binary bits of mantissa.
+static_assert(std::numeric_limits<double>::is_iec559, "IEEE double assumed");
+static_assert(std::numeric_limits<double>::radix == 2, "IEEE double fact");
+static_assert(std::numeric_limits<double>::digits == 53, "IEEE double fact");
+
+// The lowest valued 19-digit decimal mantissa we can read still contains
+// sufficient information to reconstruct a binary mantissa.
 static_assert(1000000000000000000u > (uint64_t{1} << (53 + 3)), "(b) above");
- 
-// ParseFloat<16> will read the first 15 significant digits of the mantissa. 
-// 
-// Because a base-16-to-base-2 conversion can be done exactly, we do not need 
-// to maximize the number of scanned hex digits to improve our conversion.  What 
-// is required is to scan two more bits than the mantissa can represent, so that 
-// we always round correctly. 
-// 
-// (One extra bit does not suffice to perform correct rounding, since a number 
-// exactly halfway between two representable floats has unique rounding rules, 
-// so we need to differentiate between a "halfway between" number and a "closer 
-// to the larger value" number.) 
-constexpr int kHexadecimalMantissaDigitsMax = 15; 
- 
-// The minimum number of significant bits that will be read from 
-// kHexadecimalMantissaDigitsMax hex digits.  We must subtract by three, since 
-// the most significant digit can be a "1", which only contributes a single 
-// significant bit. 
-constexpr int kGuaranteedHexadecimalMantissaBitPrecision = 
-    4 * kHexadecimalMantissaDigitsMax - 3; 
- 
-static_assert(kGuaranteedHexadecimalMantissaBitPrecision > 
-                  std::numeric_limits<double>::digits + 2, 
-              "kHexadecimalMantissaDigitsMax too small"); 
- 
-// We also impose a limit on the number of significant digits we will read from 
-// an exponent, to avoid having to deal with integer overflow.  We use 9 for 
-// this purpose. 
-// 
-// If we read a 9 digit exponent, the end result of the conversion will 
-// necessarily be infinity or zero, depending on the sign of the exponent. 
-// Therefore we can just drop extra digits on the floor without any extra 
-// logic. 
-constexpr int kDecimalExponentDigitsMax = 9; 
-static_assert(std::numeric_limits<int>::digits10 >= kDecimalExponentDigitsMax, 
-              "int type too small"); 
- 
-// To avoid incredibly large inputs causing integer overflow for our exponent, 
-// we impose an arbitrary but very large limit on the number of significant 
-// digits we will accept.  The implementation refuses to match a string with 
-// more consecutive significant mantissa digits than this. 
-constexpr int kDecimalDigitLimit = 50000000; 
- 
-// Corresponding limit for hexadecimal digit inputs.  This is one fourth the 
-// amount of kDecimalDigitLimit, since each dropped hexadecimal digit requires 
-// a binary exponent adjustment of 4. 
-constexpr int kHexadecimalDigitLimit = kDecimalDigitLimit / 4; 
- 
-// The largest exponent we can read is 999999999 (per 
-// kDecimalExponentDigitsMax), and the largest exponent adjustment we can get 
-// from dropped mantissa digits is 2 * kDecimalDigitLimit, and the sum of these 
-// comfortably fits in an integer. 
-// 
-// We count kDecimalDigitLimit twice because there are independent limits for 
-// numbers before and after the decimal point.  (In the case where there are no 
-// significant digits before the decimal point, there are independent limits for 
-// post-decimal-point leading zeroes and for significant digits.) 
-static_assert(999999999 + 2 * kDecimalDigitLimit < 
-                  std::numeric_limits<int>::max(), 
-              "int type too small"); 
-static_assert(999999999 + 2 * (4 * kHexadecimalDigitLimit) < 
-                  std::numeric_limits<int>::max(), 
-              "int type too small"); 
- 
-// Returns true if the provided bitfield allows parsing an exponent value 
-// (e.g., "1.5e100"). 
-bool AllowExponent(chars_format flags) { 
-  bool fixed = (flags & chars_format::fixed) == chars_format::fixed; 
-  bool scientific = 
-      (flags & chars_format::scientific) == chars_format::scientific; 
-  return scientific || !fixed; 
-} 
- 
-// Returns true if the provided bitfield requires an exponent value be present. 
-bool RequireExponent(chars_format flags) { 
-  bool fixed = (flags & chars_format::fixed) == chars_format::fixed; 
-  bool scientific = 
-      (flags & chars_format::scientific) == chars_format::scientific; 
-  return scientific && !fixed; 
-} 
- 
-const int8_t kAsciiToInt[256] = { 
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0,  1,  2,  3,  4,  5,  6,  7,  8, 
-    9,  -1, -1, -1, -1, -1, -1, -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, 
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
-    -1, -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
-    -1, -1, -1, -1, -1, -1, -1, -1, -1}; 
- 
-// Returns true if `ch` is a digit in the given base 
-template <int base> 
-bool IsDigit(char ch); 
- 
-// Converts a valid `ch` to its digit value in the given base. 
-template <int base> 
-unsigned ToDigit(char ch); 
- 
-// Returns true if `ch` is the exponent delimiter for the given base. 
-template <int base> 
-bool IsExponentCharacter(char ch); 
- 
-// Returns the maximum number of significant digits we will read for a float 
-// in the given base. 
-template <int base> 
-constexpr int MantissaDigitsMax(); 
- 
-// Returns the largest consecutive run of digits we will accept when parsing a 
-// number in the given base. 
-template <int base> 
-constexpr int DigitLimit(); 
- 
-// Returns the amount the exponent must be adjusted by for each dropped digit. 
-// (For decimal this is 1, since the digits are in base 10 and the exponent base 
-// is also 10, but for hexadecimal this is 4, since the digits are base 16 but 
-// the exponent base is 2.) 
-template <int base> 
-constexpr int DigitMagnitude(); 
- 
-template <> 
-bool IsDigit<10>(char ch) { 
-  return ch >= '0' && ch <= '9'; 
-} 
-template <> 
-bool IsDigit<16>(char ch) { 
-  return kAsciiToInt[static_cast<unsigned char>(ch)] >= 0; 
-} 
- 
-template <> 
-unsigned ToDigit<10>(char ch) { 
-  return ch - '0'; 
-} 
-template <> 
-unsigned ToDigit<16>(char ch) { 
-  return kAsciiToInt[static_cast<unsigned char>(ch)]; 
-} 
- 
-template <> 
-bool IsExponentCharacter<10>(char ch) { 
-  return ch == 'e' || ch == 'E'; 
-} 
- 
-template <> 
-bool IsExponentCharacter<16>(char ch) { 
-  return ch == 'p' || ch == 'P'; 
-} 
- 
-template <> 
-constexpr int MantissaDigitsMax<10>() { 
-  return kDecimalMantissaDigitsMax; 
-} 
-template <> 
-constexpr int MantissaDigitsMax<16>() { 
-  return kHexadecimalMantissaDigitsMax; 
-} 
- 
-template <> 
-constexpr int DigitLimit<10>() { 
-  return kDecimalDigitLimit; 
-} 
-template <> 
-constexpr int DigitLimit<16>() { 
-  return kHexadecimalDigitLimit; 
-} 
- 
-template <> 
-constexpr int DigitMagnitude<10>() { 
-  return 1; 
-} 
-template <> 
-constexpr int DigitMagnitude<16>() { 
-  return 4; 
-} 
- 
-// Reads decimal digits from [begin, end) into *out.  Returns the number of 
-// digits consumed. 
-// 
-// After max_digits has been read, keeps consuming characters, but no longer 
-// adjusts *out.  If a nonzero digit is dropped this way, *dropped_nonzero_digit 
-// is set; otherwise, it is left unmodified. 
-// 
-// If no digits are matched, returns 0 and leaves *out unchanged. 
-// 
-// ConsumeDigits does not protect against overflow on *out; max_digits must 
-// be chosen with respect to type T to avoid the possibility of overflow. 
-template <int base, typename T> 
+
+// ParseFloat<16> will read the first 15 significant digits of the mantissa.
+//
+// Because a base-16-to-base-2 conversion can be done exactly, we do not need
+// to maximize the number of scanned hex digits to improve our conversion.  What
+// is required is to scan two more bits than the mantissa can represent, so that
+// we always round correctly.
+//
+// (One extra bit does not suffice to perform correct rounding, since a number
+// exactly halfway between two representable floats has unique rounding rules,
+// so we need to differentiate between a "halfway between" number and a "closer
+// to the larger value" number.)
+constexpr int kHexadecimalMantissaDigitsMax = 15;
+
+// The minimum number of significant bits that will be read from
+// kHexadecimalMantissaDigitsMax hex digits.  We must subtract by three, since
+// the most significant digit can be a "1", which only contributes a single
+// significant bit.
+constexpr int kGuaranteedHexadecimalMantissaBitPrecision =
+    4 * kHexadecimalMantissaDigitsMax - 3;
+
+static_assert(kGuaranteedHexadecimalMantissaBitPrecision >
+                  std::numeric_limits<double>::digits + 2,
+              "kHexadecimalMantissaDigitsMax too small");
+
+// We also impose a limit on the number of significant digits we will read from
+// an exponent, to avoid having to deal with integer overflow.  We use 9 for
+// this purpose.
+//
+// If we read a 9 digit exponent, the end result of the conversion will
+// necessarily be infinity or zero, depending on the sign of the exponent.
+// Therefore we can just drop extra digits on the floor without any extra
+// logic.
+constexpr int kDecimalExponentDigitsMax = 9;
+static_assert(std::numeric_limits<int>::digits10 >= kDecimalExponentDigitsMax,
+              "int type too small");
+
+// To avoid incredibly large inputs causing integer overflow for our exponent,
+// we impose an arbitrary but very large limit on the number of significant
+// digits we will accept.  The implementation refuses to match a string with
+// more consecutive significant mantissa digits than this.
+constexpr int kDecimalDigitLimit = 50000000;
+
+// Corresponding limit for hexadecimal digit inputs.  This is one fourth the
+// amount of kDecimalDigitLimit, since each dropped hexadecimal digit requires
+// a binary exponent adjustment of 4.
+constexpr int kHexadecimalDigitLimit = kDecimalDigitLimit / 4;
+
+// The largest exponent we can read is 999999999 (per
+// kDecimalExponentDigitsMax), and the largest exponent adjustment we can get
+// from dropped mantissa digits is 2 * kDecimalDigitLimit, and the sum of these
+// comfortably fits in an integer.
+//
+// We count kDecimalDigitLimit twice because there are independent limits for
+// numbers before and after the decimal point.  (In the case where there are no
+// significant digits before the decimal point, there are independent limits for
+// post-decimal-point leading zeroes and for significant digits.)
+static_assert(999999999 + 2 * kDecimalDigitLimit <
+                  std::numeric_limits<int>::max(),
+              "int type too small");
+static_assert(999999999 + 2 * (4 * kHexadecimalDigitLimit) <
+                  std::numeric_limits<int>::max(),
+              "int type too small");
+
+// Returns true if the provided bitfield allows parsing an exponent value
+// (e.g., "1.5e100").
+bool AllowExponent(chars_format flags) {
+  bool fixed = (flags & chars_format::fixed) == chars_format::fixed;
+  bool scientific =
+      (flags & chars_format::scientific) == chars_format::scientific;
+  return scientific || !fixed;
+}
+
+// Returns true if the provided bitfield requires an exponent value be present.
+bool RequireExponent(chars_format flags) {
+  bool fixed = (flags & chars_format::fixed) == chars_format::fixed;
+  bool scientific =
+      (flags & chars_format::scientific) == chars_format::scientific;
+  return scientific && !fixed;
+}
+
+const int8_t kAsciiToInt[256] = {
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0,  1,  2,  3,  4,  5,  6,  7,  8,
+    9,  -1, -1, -1, -1, -1, -1, -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1};
+
+// Returns true if `ch` is a digit in the given base
+template <int base>
+bool IsDigit(char ch);
+
+// Converts a valid `ch` to its digit value in the given base.
+template <int base>
+unsigned ToDigit(char ch);
+
+// Returns true if `ch` is the exponent delimiter for the given base.
+template <int base>
+bool IsExponentCharacter(char ch);
+
+// Returns the maximum number of significant digits we will read for a float
+// in the given base.
+template <int base>
+constexpr int MantissaDigitsMax();
+
+// Returns the largest consecutive run of digits we will accept when parsing a
+// number in the given base.
+template <int base>
+constexpr int DigitLimit();
+
+// Returns the amount the exponent must be adjusted by for each dropped digit.
+// (For decimal this is 1, since the digits are in base 10 and the exponent base
+// is also 10, but for hexadecimal this is 4, since the digits are base 16 but
+// the exponent base is 2.)
+template <int base>
+constexpr int DigitMagnitude();
+
+template <>
+bool IsDigit<10>(char ch) {
+  return ch >= '0' && ch <= '9';
+}
+template <>
+bool IsDigit<16>(char ch) {
+  return kAsciiToInt[static_cast<unsigned char>(ch)] >= 0;
+}
+
+template <>
+unsigned ToDigit<10>(char ch) {
+  return ch - '0';
+}
+template <>
+unsigned ToDigit<16>(char ch) {
+  return kAsciiToInt[static_cast<unsigned char>(ch)];
+}
+
+template <>
+bool IsExponentCharacter<10>(char ch) {
+  return ch == 'e' || ch == 'E';
+}
+
+template <>
+bool IsExponentCharacter<16>(char ch) {
+  return ch == 'p' || ch == 'P';
+}
+
+template <>
+constexpr int MantissaDigitsMax<10>() {
+  return kDecimalMantissaDigitsMax;
+}
+template <>
+constexpr int MantissaDigitsMax<16>() {
+  return kHexadecimalMantissaDigitsMax;
+}
+
+template <>
+constexpr int DigitLimit<10>() {
+  return kDecimalDigitLimit;
+}
+template <>
+constexpr int DigitLimit<16>() {
+  return kHexadecimalDigitLimit;
+}
+
+template <>
+constexpr int DigitMagnitude<10>() {
+  return 1;
+}
+template <>
+constexpr int DigitMagnitude<16>() {
+  return 4;
+}
+
+// Reads decimal digits from [begin, end) into *out.  Returns the number of
+// digits consumed.
+//
+// After max_digits has been read, keeps consuming characters, but no longer
+// adjusts *out.  If a nonzero digit is dropped this way, *dropped_nonzero_digit
+// is set; otherwise, it is left unmodified.
+//
+// If no digits are matched, returns 0 and leaves *out unchanged.
+//
+// ConsumeDigits does not protect against overflow on *out; max_digits must
+// be chosen with respect to type T to avoid the possibility of overflow.
+template <int base, typename T>
 int ConsumeDigits(const char* begin, const char* end, int max_digits, T* out,
                   bool* dropped_nonzero_digit) {
-  if (base == 10) { 
-    assert(max_digits <= std::numeric_limits<T>::digits10); 
-  } else if (base == 16) { 
-    assert(max_digits * 4 <= std::numeric_limits<T>::digits); 
-  } 
-  const char* const original_begin = begin; 
- 
-  // Skip leading zeros, but only if *out is zero. 
-  // They don't cause an overflow so we don't have to count them for 
-  // `max_digits`. 
-  while (!*out && end != begin && *begin == '0') ++begin; 
- 
-  T accumulator = *out; 
-  const char* significant_digits_end = 
-      (end - begin > max_digits) ? begin + max_digits : end; 
-  while (begin < significant_digits_end && IsDigit<base>(*begin)) { 
-    // Do not guard against *out overflow; max_digits was chosen to avoid this. 
-    // Do assert against it, to detect problems in debug builds. 
-    auto digit = static_cast<T>(ToDigit<base>(*begin)); 
-    assert(accumulator * base >= accumulator); 
-    accumulator *= base; 
-    assert(accumulator + digit >= accumulator); 
-    accumulator += digit; 
-    ++begin; 
-  } 
-  bool dropped_nonzero = false; 
-  while (begin < end && IsDigit<base>(*begin)) { 
-    dropped_nonzero = dropped_nonzero || (*begin != '0'); 
-    ++begin; 
-  } 
-  if (dropped_nonzero && dropped_nonzero_digit != nullptr) { 
-    *dropped_nonzero_digit = true; 
-  } 
-  *out = accumulator; 
+  if (base == 10) {
+    assert(max_digits <= std::numeric_limits<T>::digits10);
+  } else if (base == 16) {
+    assert(max_digits * 4 <= std::numeric_limits<T>::digits);
+  }
+  const char* const original_begin = begin;
+
+  // Skip leading zeros, but only if *out is zero.
+  // They don't cause an overflow so we don't have to count them for
+  // `max_digits`.
+  while (!*out && end != begin && *begin == '0') ++begin;
+
+  T accumulator = *out;
+  const char* significant_digits_end =
+      (end - begin > max_digits) ? begin + max_digits : end;
+  while (begin < significant_digits_end && IsDigit<base>(*begin)) {
+    // Do not guard against *out overflow; max_digits was chosen to avoid this.
+    // Do assert against it, to detect problems in debug builds.
+    auto digit = static_cast<T>(ToDigit<base>(*begin));
+    assert(accumulator * base >= accumulator);
+    accumulator *= base;
+    assert(accumulator + digit >= accumulator);
+    accumulator += digit;
+    ++begin;
+  }
+  bool dropped_nonzero = false;
+  while (begin < end && IsDigit<base>(*begin)) {
+    dropped_nonzero = dropped_nonzero || (*begin != '0');
+    ++begin;
+  }
+  if (dropped_nonzero && dropped_nonzero_digit != nullptr) {
+    *dropped_nonzero_digit = true;
+  }
+  *out = accumulator;
   return static_cast<int>(begin - original_begin);
-} 
- 
-// Returns true if `v` is one of the chars allowed inside parentheses following 
-// a NaN. 
-bool IsNanChar(char v) { 
-  return (v == '_') || (v >= '0' && v <= '9') || (v >= 'a' && v <= 'z') || 
-         (v >= 'A' && v <= 'Z'); 
-} 
- 
-// Checks the range [begin, end) for a strtod()-formatted infinity or NaN.  If 
-// one is found, sets `out` appropriately and returns true. 
-bool ParseInfinityOrNan(const char* begin, const char* end, 
-                        strings_internal::ParsedFloat* out) { 
-  if (end - begin < 3) { 
-    return false; 
-  } 
-  switch (*begin) { 
-    case 'i': 
-    case 'I': { 
+}
+
+// Returns true if `v` is one of the chars allowed inside parentheses following
+// a NaN.
+bool IsNanChar(char v) {
+  return (v == '_') || (v >= '0' && v <= '9') || (v >= 'a' && v <= 'z') ||
+         (v >= 'A' && v <= 'Z');
+}
+
+// Checks the range [begin, end) for a strtod()-formatted infinity or NaN.  If
+// one is found, sets `out` appropriately and returns true.
+bool ParseInfinityOrNan(const char* begin, const char* end,
+                        strings_internal::ParsedFloat* out) {
+  if (end - begin < 3) {
+    return false;
+  }
+  switch (*begin) {
+    case 'i':
+    case 'I': {
       // An infinity string consists of the characters "inf" or "infinity",
-      // case insensitive. 
-      if (strings_internal::memcasecmp(begin + 1, "nf", 2) != 0) { 
-        return false; 
-      } 
-      out->type = strings_internal::FloatType::kInfinity; 
-      if (end - begin >= 8 && 
-          strings_internal::memcasecmp(begin + 3, "inity", 5) == 0) { 
-        out->end = begin + 8; 
-      } else { 
-        out->end = begin + 3; 
-      } 
-      return true; 
-    } 
-    case 'n': 
-    case 'N': { 
-      // A NaN consists of the characters "nan", case insensitive, optionally 
-      // followed by a parenthesized sequence of zero or more alphanumeric 
-      // characters and/or underscores. 
-      if (strings_internal::memcasecmp(begin + 1, "an", 2) != 0) { 
-        return false; 
-      } 
-      out->type = strings_internal::FloatType::kNan; 
-      out->end = begin + 3; 
+      // case insensitive.
+      if (strings_internal::memcasecmp(begin + 1, "nf", 2) != 0) {
+        return false;
+      }
+      out->type = strings_internal::FloatType::kInfinity;
+      if (end - begin >= 8 &&
+          strings_internal::memcasecmp(begin + 3, "inity", 5) == 0) {
+        out->end = begin + 8;
+      } else {
+        out->end = begin + 3;
+      }
+      return true;
+    }
+    case 'n':
+    case 'N': {
+      // A NaN consists of the characters "nan", case insensitive, optionally
+      // followed by a parenthesized sequence of zero or more alphanumeric
+      // characters and/or underscores.
+      if (strings_internal::memcasecmp(begin + 1, "an", 2) != 0) {
+        return false;
+      }
+      out->type = strings_internal::FloatType::kNan;
+      out->end = begin + 3;
       // NaN is allowed to be followed by a parenthesized string, consisting of
-      // only the characters [a-zA-Z0-9_].  Match that if it's present. 
-      begin += 3; 
-      if (begin < end && *begin == '(') { 
-        const char* nan_begin = begin + 1; 
-        while (nan_begin < end && IsNanChar(*nan_begin)) { 
-          ++nan_begin; 
-        } 
-        if (nan_begin < end && *nan_begin == ')') { 
-          // We found an extra NaN specifier range 
-          out->subrange_begin = begin + 1; 
-          out->subrange_end = nan_begin; 
-          out->end = nan_begin + 1; 
-        } 
-      } 
-      return true; 
-    } 
-    default: 
-      return false; 
-  } 
-} 
-}  // namespace 
- 
-namespace strings_internal { 
- 
-template <int base> 
-strings_internal::ParsedFloat ParseFloat(const char* begin, const char* end, 
-                                         chars_format format_flags) { 
-  strings_internal::ParsedFloat result; 
- 
-  // Exit early if we're given an empty range. 
-  if (begin == end) return result; 
- 
-  // Handle the infinity and NaN cases. 
-  if (ParseInfinityOrNan(begin, end, &result)) { 
-    return result; 
-  } 
- 
-  const char* const mantissa_begin = begin; 
-  while (begin < end && *begin == '0') { 
-    ++begin;  // skip leading zeros 
-  } 
-  uint64_t mantissa = 0; 
- 
-  int exponent_adjustment = 0; 
-  bool mantissa_is_inexact = false; 
+      // only the characters [a-zA-Z0-9_].  Match that if it's present.
+      begin += 3;
+      if (begin < end && *begin == '(') {
+        const char* nan_begin = begin + 1;
+        while (nan_begin < end && IsNanChar(*nan_begin)) {
+          ++nan_begin;
+        }
+        if (nan_begin < end && *nan_begin == ')') {
+          // We found an extra NaN specifier range
+          out->subrange_begin = begin + 1;
+          out->subrange_end = nan_begin;
+          out->end = nan_begin + 1;
+        }
+      }
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+}  // namespace
+
+namespace strings_internal {
+
+template <int base>
+strings_internal::ParsedFloat ParseFloat(const char* begin, const char* end,
+                                         chars_format format_flags) {
+  strings_internal::ParsedFloat result;
+
+  // Exit early if we're given an empty range.
+  if (begin == end) return result;
+
+  // Handle the infinity and NaN cases.
+  if (ParseInfinityOrNan(begin, end, &result)) {
+    return result;
+  }
+
+  const char* const mantissa_begin = begin;
+  while (begin < end && *begin == '0') {
+    ++begin;  // skip leading zeros
+  }
+  uint64_t mantissa = 0;
+
+  int exponent_adjustment = 0;
+  bool mantissa_is_inexact = false;
   int pre_decimal_digits = ConsumeDigits<base>(
-      begin, end, MantissaDigitsMax<base>(), &mantissa, &mantissa_is_inexact); 
-  begin += pre_decimal_digits; 
-  int digits_left; 
-  if (pre_decimal_digits >= DigitLimit<base>()) { 
-    // refuse to parse pathological inputs 
-    return result; 
-  } else if (pre_decimal_digits > MantissaDigitsMax<base>()) { 
-    // We dropped some non-fraction digits on the floor.  Adjust our exponent 
-    // to compensate. 
-    exponent_adjustment = 
-        static_cast<int>(pre_decimal_digits - MantissaDigitsMax<base>()); 
-    digits_left = 0; 
-  } else { 
-    digits_left = 
-        static_cast<int>(MantissaDigitsMax<base>() - pre_decimal_digits); 
-  } 
-  if (begin < end && *begin == '.') { 
-    ++begin; 
-    if (mantissa == 0) { 
-      // If we haven't seen any nonzero digits yet, keep skipping zeros.  We 
-      // have to adjust the exponent to reflect the changed place value. 
-      const char* begin_zeros = begin; 
-      while (begin < end && *begin == '0') { 
-        ++begin; 
-      } 
+      begin, end, MantissaDigitsMax<base>(), &mantissa, &mantissa_is_inexact);
+  begin += pre_decimal_digits;
+  int digits_left;
+  if (pre_decimal_digits >= DigitLimit<base>()) {
+    // refuse to parse pathological inputs
+    return result;
+  } else if (pre_decimal_digits > MantissaDigitsMax<base>()) {
+    // We dropped some non-fraction digits on the floor.  Adjust our exponent
+    // to compensate.
+    exponent_adjustment =
+        static_cast<int>(pre_decimal_digits - MantissaDigitsMax<base>());
+    digits_left = 0;
+  } else {
+    digits_left =
+        static_cast<int>(MantissaDigitsMax<base>() - pre_decimal_digits);
+  }
+  if (begin < end && *begin == '.') {
+    ++begin;
+    if (mantissa == 0) {
+      // If we haven't seen any nonzero digits yet, keep skipping zeros.  We
+      // have to adjust the exponent to reflect the changed place value.
+      const char* begin_zeros = begin;
+      while (begin < end && *begin == '0') {
+        ++begin;
+      }
       int zeros_skipped = static_cast<int>(begin - begin_zeros);
-      if (zeros_skipped >= DigitLimit<base>()) { 
-        // refuse to parse pathological inputs 
-        return result; 
-      } 
-      exponent_adjustment -= static_cast<int>(zeros_skipped); 
-    } 
+      if (zeros_skipped >= DigitLimit<base>()) {
+        // refuse to parse pathological inputs
+        return result;
+      }
+      exponent_adjustment -= static_cast<int>(zeros_skipped);
+    }
     int post_decimal_digits = ConsumeDigits<base>(
-        begin, end, digits_left, &mantissa, &mantissa_is_inexact); 
-    begin += post_decimal_digits; 
- 
-    // Since `mantissa` is an integer, each significant digit we read after 
-    // the decimal point requires an adjustment to the exponent. "1.23e0" will 
-    // be stored as `mantissa` == 123 and `exponent` == -2 (that is, 
-    // "123e-2"). 
-    if (post_decimal_digits >= DigitLimit<base>()) { 
-      // refuse to parse pathological inputs 
-      return result; 
-    } else if (post_decimal_digits > digits_left) { 
-      exponent_adjustment -= digits_left; 
-    } else { 
-      exponent_adjustment -= post_decimal_digits; 
-    } 
-  } 
-  // If we've found no mantissa whatsoever, this isn't a number. 
-  if (mantissa_begin == begin) { 
-    return result; 
-  } 
-  // A bare "." doesn't count as a mantissa either. 
-  if (begin - mantissa_begin == 1 && *mantissa_begin == '.') { 
-    return result; 
-  } 
- 
-  if (mantissa_is_inexact) { 
-    // We dropped significant digits on the floor.  Handle this appropriately. 
-    if (base == 10) { 
-      // If we truncated significant decimal digits, store the full range of the 
-      // mantissa for future big integer math for exact rounding. 
-      result.subrange_begin = mantissa_begin; 
-      result.subrange_end = begin; 
-    } else if (base == 16) { 
-      // If we truncated hex digits, reflect this fact by setting the low 
-      // ("sticky") bit.  This allows for correct rounding in all cases. 
-      mantissa |= 1; 
-    } 
-  } 
-  result.mantissa = mantissa; 
- 
-  const char* const exponent_begin = begin; 
-  result.literal_exponent = 0; 
-  bool found_exponent = false; 
-  if (AllowExponent(format_flags) && begin < end && 
-      IsExponentCharacter<base>(*begin)) { 
-    bool negative_exponent = false; 
-    ++begin; 
-    if (begin < end && *begin == '-') { 
-      negative_exponent = true; 
-      ++begin; 
-    } else if (begin < end && *begin == '+') { 
-      ++begin; 
-    } 
-    const char* const exponent_digits_begin = begin; 
-    // Exponent is always expressed in decimal, even for hexadecimal floats. 
-    begin += ConsumeDigits<10>(begin, end, kDecimalExponentDigitsMax, 
-                               &result.literal_exponent, nullptr); 
-    if (begin == exponent_digits_begin) { 
-      // there were no digits where we expected an exponent.  We failed to read 
-      // an exponent and should not consume the 'e' after all.  Rewind 'begin'. 
-      found_exponent = false; 
-      begin = exponent_begin; 
-    } else { 
-      found_exponent = true; 
-      if (negative_exponent) { 
-        result.literal_exponent = -result.literal_exponent; 
-      } 
-    } 
-  } 
- 
-  if (!found_exponent && RequireExponent(format_flags)) { 
-    // Provided flags required an exponent, but none was found.  This results 
-    // in a failure to scan. 
-    return result; 
-  } 
- 
-  // Success! 
-  result.type = strings_internal::FloatType::kNumber; 
-  if (result.mantissa > 0) { 
-    result.exponent = result.literal_exponent + 
-                      (DigitMagnitude<base>() * exponent_adjustment); 
-  } else { 
-    result.exponent = 0; 
-  } 
-  result.end = begin; 
-  return result; 
-} 
- 
-template ParsedFloat ParseFloat<10>(const char* begin, const char* end, 
-                                    chars_format format_flags); 
-template ParsedFloat ParseFloat<16>(const char* begin, const char* end, 
-                                    chars_format format_flags); 
- 
-}  // namespace strings_internal 
+        begin, end, digits_left, &mantissa, &mantissa_is_inexact);
+    begin += post_decimal_digits;
+
+    // Since `mantissa` is an integer, each significant digit we read after
+    // the decimal point requires an adjustment to the exponent. "1.23e0" will
+    // be stored as `mantissa` == 123 and `exponent` == -2 (that is,
+    // "123e-2").
+    if (post_decimal_digits >= DigitLimit<base>()) {
+      // refuse to parse pathological inputs
+      return result;
+    } else if (post_decimal_digits > digits_left) {
+      exponent_adjustment -= digits_left;
+    } else {
+      exponent_adjustment -= post_decimal_digits;
+    }
+  }
+  // If we've found no mantissa whatsoever, this isn't a number.
+  if (mantissa_begin == begin) {
+    return result;
+  }
+  // A bare "." doesn't count as a mantissa either.
+  if (begin - mantissa_begin == 1 && *mantissa_begin == '.') {
+    return result;
+  }
+
+  if (mantissa_is_inexact) {
+    // We dropped significant digits on the floor.  Handle this appropriately.
+    if (base == 10) {
+      // If we truncated significant decimal digits, store the full range of the
+      // mantissa for future big integer math for exact rounding.
+      result.subrange_begin = mantissa_begin;
+      result.subrange_end = begin;
+    } else if (base == 16) {
+      // If we truncated hex digits, reflect this fact by setting the low
+      // ("sticky") bit.  This allows for correct rounding in all cases.
+      mantissa |= 1;
+    }
+  }
+  result.mantissa = mantissa;
+
+  const char* const exponent_begin = begin;
+  result.literal_exponent = 0;
+  bool found_exponent = false;
+  if (AllowExponent(format_flags) && begin < end &&
+      IsExponentCharacter<base>(*begin)) {
+    bool negative_exponent = false;
+    ++begin;
+    if (begin < end && *begin == '-') {
+      negative_exponent = true;
+      ++begin;
+    } else if (begin < end && *begin == '+') {
+      ++begin;
+    }
+    const char* const exponent_digits_begin = begin;
+    // Exponent is always expressed in decimal, even for hexadecimal floats.
+    begin += ConsumeDigits<10>(begin, end, kDecimalExponentDigitsMax,
+                               &result.literal_exponent, nullptr);
+    if (begin == exponent_digits_begin) {
+      // there were no digits where we expected an exponent.  We failed to read
+      // an exponent and should not consume the 'e' after all.  Rewind 'begin'.
+      found_exponent = false;
+      begin = exponent_begin;
+    } else {
+      found_exponent = true;
+      if (negative_exponent) {
+        result.literal_exponent = -result.literal_exponent;
+      }
+    }
+  }
+
+  if (!found_exponent && RequireExponent(format_flags)) {
+    // Provided flags required an exponent, but none was found.  This results
+    // in a failure to scan.
+    return result;
+  }
+
+  // Success!
+  result.type = strings_internal::FloatType::kNumber;
+  if (result.mantissa > 0) {
+    result.exponent = result.literal_exponent +
+                      (DigitMagnitude<base>() * exponent_adjustment);
+  } else {
+    result.exponent = 0;
+  }
+  result.end = begin;
+  return result;
+}
+
+template ParsedFloat ParseFloat<10>(const char* begin, const char* end,
+                                    chars_format format_flags);
+template ParsedFloat ParseFloat<16>(const char* begin, const char* end,
+                                    chars_format format_flags);
+
+}  // namespace strings_internal
 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 2e5a9d1f2e..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
@@ -1,99 +1,99 @@
-// Copyright 2018 The Abseil Authors. 
-// 
-// Licensed under the Apache License, Version 2.0 (the "License"); 
-// you may not use this file except in compliance with the License. 
-// You may obtain a copy of the License at 
-// 
-//      https://www.apache.org/licenses/LICENSE-2.0 
-// 
-// Unless required by applicable law or agreed to in writing, software 
-// distributed under the License is distributed on an "AS IS" BASIS, 
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-// See the License for the specific language governing permissions and 
-// limitations under the License. 
- 
-#ifndef ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_ 
-#define ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_ 
- 
-#include <cstdint> 
- 
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_
+#define ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_
+
+#include <cstdint>
+
 #include "y_absl/base/config.h"
 #include "y_absl/strings/charconv.h"
- 
+
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-namespace strings_internal { 
- 
-// Enum indicating whether a parsed float is a number or special value. 
-enum class FloatType { kNumber, kInfinity, kNan }; 
- 
-// The decomposed parts of a parsed `float` or `double`. 
-struct ParsedFloat { 
-  // Representation of the parsed mantissa, with the decimal point adjusted to 
-  // make it an integer. 
-  // 
-  // During decimal scanning, this contains 19 significant digits worth of 
-  // mantissa value.  If digits beyond this point are found, they 
-  // are truncated, and if any of these dropped digits are nonzero, then 
-  // `mantissa` is inexact, and the full mantissa is stored in [subrange_begin, 
-  // subrange_end). 
-  // 
-  // During hexadecimal scanning, this contains 15 significant hex digits worth 
-  // of mantissa value.  Digits beyond this point are sticky -- they are 
-  // truncated, but if any dropped digits are nonzero, the low bit of mantissa 
-  // will be set.  (This allows for precise rounding, and avoids the need 
-  // to store the full mantissa in [subrange_begin, subrange_end).) 
-  uint64_t mantissa = 0; 
- 
-  // Floating point expontent.  This reflects any decimal point adjustments and 
-  // any truncated digits from the mantissa.  The absolute value of the parsed 
-  // number is represented by mantissa * (base ** exponent), where base==10 for 
-  // decimal floats, and base==2 for hexadecimal floats. 
-  int exponent = 0; 
- 
-  // The literal exponent value scanned from the input, or 0 if none was 
-  // present.  This does not reflect any adjustments applied to mantissa. 
-  int literal_exponent = 0; 
- 
-  // The type of number scanned. 
-  FloatType type = FloatType::kNumber; 
- 
-  // When non-null, [subrange_begin, subrange_end) marks a range of characters 
-  // that require further processing.  The meaning is dependent on float type. 
-  // If type == kNumber and this is set, this is a "wide input": the input 
-  // mantissa contained more than 19 digits.  The range contains the full 
-  // mantissa.  It plus `literal_exponent` need to be examined to find the best 
-  // floating point match. 
-  // If type == kNan and this is set, the range marks the contents of a 
-  // matched parenthesized character region after the NaN. 
-  const char* subrange_begin = nullptr; 
-  const char* subrange_end = nullptr; 
- 
-  // One-past-the-end of the successfully parsed region, or nullptr if no 
-  // matching pattern was found. 
-  const char* end = nullptr; 
-}; 
- 
-// Read the floating point number in the provided range, and populate 
-// ParsedFloat accordingly. 
-// 
-// format_flags is a bitmask value specifying what patterns this API will match. 
-// `scientific` and `fixed`  are honored per std::from_chars rules 
-// ([utility.from.chars], C++17): if exactly one of these bits is set, then an 
-// exponent is required, or dislallowed, respectively. 
-// 
-// Template parameter `base` must be either 10 or 16.  For base 16, a "0x" is 
-// *not* consumed.  The `hex` bit from format_flags is ignored by ParseFloat. 
-template <int base> 
-ParsedFloat ParseFloat(const char* begin, const char* end, 
+namespace strings_internal {
+
+// Enum indicating whether a parsed float is a number or special value.
+enum class FloatType { kNumber, kInfinity, kNan };
+
+// The decomposed parts of a parsed `float` or `double`.
+struct ParsedFloat {
+  // Representation of the parsed mantissa, with the decimal point adjusted to
+  // make it an integer.
+  //
+  // During decimal scanning, this contains 19 significant digits worth of
+  // mantissa value.  If digits beyond this point are found, they
+  // are truncated, and if any of these dropped digits are nonzero, then
+  // `mantissa` is inexact, and the full mantissa is stored in [subrange_begin,
+  // subrange_end).
+  //
+  // During hexadecimal scanning, this contains 15 significant hex digits worth
+  // of mantissa value.  Digits beyond this point are sticky -- they are
+  // truncated, but if any dropped digits are nonzero, the low bit of mantissa
+  // will be set.  (This allows for precise rounding, and avoids the need
+  // to store the full mantissa in [subrange_begin, subrange_end).)
+  uint64_t mantissa = 0;
+
+  // Floating point expontent.  This reflects any decimal point adjustments and
+  // any truncated digits from the mantissa.  The absolute value of the parsed
+  // number is represented by mantissa * (base ** exponent), where base==10 for
+  // decimal floats, and base==2 for hexadecimal floats.
+  int exponent = 0;
+
+  // The literal exponent value scanned from the input, or 0 if none was
+  // present.  This does not reflect any adjustments applied to mantissa.
+  int literal_exponent = 0;
+
+  // The type of number scanned.
+  FloatType type = FloatType::kNumber;
+
+  // When non-null, [subrange_begin, subrange_end) marks a range of characters
+  // that require further processing.  The meaning is dependent on float type.
+  // If type == kNumber and this is set, this is a "wide input": the input
+  // mantissa contained more than 19 digits.  The range contains the full
+  // mantissa.  It plus `literal_exponent` need to be examined to find the best
+  // floating point match.
+  // If type == kNan and this is set, the range marks the contents of a
+  // matched parenthesized character region after the NaN.
+  const char* subrange_begin = nullptr;
+  const char* subrange_end = nullptr;
+
+  // One-past-the-end of the successfully parsed region, or nullptr if no
+  // matching pattern was found.
+  const char* end = nullptr;
+};
+
+// Read the floating point number in the provided range, and populate
+// ParsedFloat accordingly.
+//
+// format_flags is a bitmask value specifying what patterns this API will match.
+// `scientific` and `fixed`  are honored per std::from_chars rules
+// ([utility.from.chars], C++17): if exactly one of these bits is set, then an
+// exponent is required, or dislallowed, respectively.
+//
+// Template parameter `base` must be either 10 or 16.  For base 16, a "0x" is
+// *not* consumed.  The `hex` bit from format_flags is ignored by ParseFloat.
+template <int base>
+ParsedFloat ParseFloat(const char* begin, const char* end,
                        y_absl::chars_format format_flags);
- 
-extern template ParsedFloat ParseFloat<10>(const char* begin, const char* end, 
+
+extern template ParsedFloat ParseFloat<10>(const char* begin, const char* end,
                                            y_absl::chars_format format_flags);
-extern template ParsedFloat ParseFloat<16>(const char* begin, const char* end, 
+extern template ParsedFloat ParseFloat<16>(const char* begin, const char* end,
                                            y_absl::chars_format format_flags);
- 
-}  // namespace strings_internal 
+
+}  // namespace strings_internal
 ABSL_NAMESPACE_END
 }  // namespace y_absl
-#endif  // ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_H_ 
+#endif  // ABSL_STRINGS_INTERNAL_CHARCONV_PARSE_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 c6d435bed7..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
@@ -1,16 +1,16 @@
-# Generated by devtools/yamaker. 
- 
-LIBRARY() 
- 
+# Generated by devtools/yamaker.
+
+LIBRARY()
+
 WITHOUT_LICENSE_TEXTS()
- 
+
 OWNER(
     somov
     g:cpp-contrib
 )
 
-LICENSE(Apache-2.0) 
- 
+LICENSE(Apache-2.0)
+
 PEERDIR(
     contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/raw_logging
     contrib/restricted/abseil-cpp-tstring/y_absl/base/log_severity
@@ -20,13 +20,13 @@ PEERDIR(
 ADDINCL(
     GLOBAL contrib/restricted/abseil-cpp-tstring
 )
- 
-NO_COMPILER_WARNINGS() 
- 
+
+NO_COMPILER_WARNINGS()
+
 SRCDIR(contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal)
- 
-SRCS( 
+
+SRCS(
     cordz_functions.cc
-) 
- 
-END() 
+)
+
+END()
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 1268b3a64d..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
@@ -1,133 +1,133 @@
-// Copyright 2017 The Abseil Authors. 
-// 
-// Licensed under the Apache License, Version 2.0 (the "License"); 
-// you may not use this file except in compliance with the License. 
-// You may obtain a copy of the License at 
-// 
-//      https://www.apache.org/licenses/LICENSE-2.0 
-// 
-// Unless required by applicable law or agreed to in writing, software 
-// distributed under the License is distributed on an "AS IS" BASIS, 
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-// See the License for the specific language governing permissions and 
-// limitations under the License. 
-// 
-// This test contains common things needed by both escaping_test.cc and 
-// escaping_benchmark.cc. 
- 
-#ifndef ABSL_STRINGS_INTERNAL_ESCAPING_TEST_COMMON_H_ 
-#define ABSL_STRINGS_INTERNAL_ESCAPING_TEST_COMMON_H_ 
- 
-#include <array> 
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// This test contains common things needed by both escaping_test.cc and
+// escaping_benchmark.cc.
+
+#ifndef ABSL_STRINGS_INTERNAL_ESCAPING_TEST_COMMON_H_
+#define ABSL_STRINGS_INTERNAL_ESCAPING_TEST_COMMON_H_
+
+#include <array>
 #include "y_absl/strings/string_view.h"
- 
+
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-namespace strings_internal { 
- 
-struct base64_testcase { 
+namespace strings_internal {
+
+struct base64_testcase {
   y_absl::string_view plaintext;
   y_absl::string_view cyphertext;
-}; 
- 
-inline const std::array<base64_testcase, 5>& base64_strings() { 
-  static const std::array<base64_testcase, 5> testcase{{ 
-      // Some google quotes 
-      // Cyphertext created with "uuencode (GNU sharutils) 4.6.3" 
-      // (Note that we're testing the websafe encoding, though, so if 
-      // you add messages, be sure to run "tr -- '+/' '-_'" on the output) 
-      { "I was always good at math and science, and I never realized " 
-        "that was unusual or somehow undesirable. So one of the things " 
-        "I care a lot about is helping to remove that stigma, " 
-        "to show girls that you can be feminine, you can like the things " 
-        "that girls like, but you can also be really good at technology. " 
-        "You can be really good at building things." 
-        " - Marissa Meyer, Newsweek, 2010-12-22" "\n", 
- 
-        "SSB3YXMgYWx3YXlzIGdvb2QgYXQgbWF0aCBhbmQgc2NpZW5jZSwgYW5kIEkg" 
-        "bmV2ZXIgcmVhbGl6ZWQgdGhhdCB3YXMgdW51c3VhbCBvciBzb21laG93IHVu" 
-        "ZGVzaXJhYmxlLiBTbyBvbmUgb2YgdGhlIHRoaW5ncyBJIGNhcmUgYSBsb3Qg" 
-        "YWJvdXQgaXMgaGVscGluZyB0byByZW1vdmUgdGhhdCBzdGlnbWEsIHRvIHNo" 
-        "b3cgZ2lybHMgdGhhdCB5b3UgY2FuIGJlIGZlbWluaW5lLCB5b3UgY2FuIGxp" 
-        "a2UgdGhlIHRoaW5ncyB0aGF0IGdpcmxzIGxpa2UsIGJ1dCB5b3UgY2FuIGFs" 
-        "c28gYmUgcmVhbGx5IGdvb2QgYXQgdGVjaG5vbG9neS4gWW91IGNhbiBiZSBy" 
-        "ZWFsbHkgZ29vZCBhdCBidWlsZGluZyB0aGluZ3MuIC0gTWFyaXNzYSBNZXll" 
-        "ciwgTmV3c3dlZWssIDIwMTAtMTItMjIK" }, 
- 
-      { "Typical first year for a new cluster: " 
-        "~0.5 overheating " 
-        "~1 PDU failure " 
-        "~1 rack-move " 
-        "~1 network rewiring " 
-        "~20 rack failures " 
-        "~5 racks go wonky " 
-        "~8 network maintenances " 
-        "~12 router reloads " 
-        "~3 router failures " 
-        "~dozens of minor 30-second blips for dns " 
-        "~1000 individual machine failures " 
-        "~thousands of hard drive failures " 
-        "slow disks, bad memory, misconfigured machines, flaky machines, etc." 
-        " - Jeff Dean, The Joys of Real Hardware" "\n", 
- 
-        "VHlwaWNhbCBmaXJzdCB5ZWFyIGZvciBhIG5ldyBjbHVzdGVyOiB-MC41IG92" 
-        "ZXJoZWF0aW5nIH4xIFBEVSBmYWlsdXJlIH4xIHJhY2stbW92ZSB-MSBuZXR3" 
-        "b3JrIHJld2lyaW5nIH4yMCByYWNrIGZhaWx1cmVzIH41IHJhY2tzIGdvIHdv" 
-        "bmt5IH44IG5ldHdvcmsgbWFpbnRlbmFuY2VzIH4xMiByb3V0ZXIgcmVsb2Fk" 
-        "cyB-MyByb3V0ZXIgZmFpbHVyZXMgfmRvemVucyBvZiBtaW5vciAzMC1zZWNv" 
-        "bmQgYmxpcHMgZm9yIGRucyB-MTAwMCBpbmRpdmlkdWFsIG1hY2hpbmUgZmFp" 
-        "bHVyZXMgfnRob3VzYW5kcyBvZiBoYXJkIGRyaXZlIGZhaWx1cmVzIHNsb3cg" 
-        "ZGlza3MsIGJhZCBtZW1vcnksIG1pc2NvbmZpZ3VyZWQgbWFjaGluZXMsIGZs" 
-        "YWt5IG1hY2hpbmVzLCBldGMuIC0gSmVmZiBEZWFuLCBUaGUgSm95cyBvZiBS" 
-        "ZWFsIEhhcmR3YXJlCg" }, 
- 
-      { "I'm the head of the webspam team at Google.  " 
-        "That means that if you type your name into Google and get porn back, " 
-        "it's my fault. Unless you're a porn star, in which case porn is a " 
-        "completely reasonable response." 
-        " - Matt Cutts, Google Plus" "\n", 
- 
-        "SSdtIHRoZSBoZWFkIG9mIHRoZSB3ZWJzcGFtIHRlYW0gYXQgR29vZ2xlLiAg" 
-        "VGhhdCBtZWFucyB0aGF0IGlmIHlvdSB0eXBlIHlvdXIgbmFtZSBpbnRvIEdv" 
-        "b2dsZSBhbmQgZ2V0IHBvcm4gYmFjaywgaXQncyBteSBmYXVsdC4gVW5sZXNz" 
-        "IHlvdSdyZSBhIHBvcm4gc3RhciwgaW4gd2hpY2ggY2FzZSBwb3JuIGlzIGEg" 
-        "Y29tcGxldGVseSByZWFzb25hYmxlIHJlc3BvbnNlLiAtIE1hdHQgQ3V0dHMs" 
-        "IEdvb2dsZSBQbHVzCg" }, 
- 
-      { "It will still be a long time before machines approach human " 
-        "intelligence. " 
-        "But luckily, machines don't actually have to be intelligent; " 
-        "they just have to fake it. Access to a wealth of information, " 
-        "combined with a rudimentary decision-making capacity, " 
-        "can often be almost as useful. Of course, the results are better yet " 
-        "when coupled with intelligence. A reference librarian with access to " 
-        "a good search engine is a formidable tool." 
-        " - Craig Silverstein, Siemens Pictures of the Future, Spring 2004" 
-        "\n", 
- 
-        "SXQgd2lsbCBzdGlsbCBiZSBhIGxvbmcgdGltZSBiZWZvcmUgbWFjaGluZXMg" 
-        "YXBwcm9hY2ggaHVtYW4gaW50ZWxsaWdlbmNlLiBCdXQgbHVja2lseSwgbWFj" 
-        "aGluZXMgZG9uJ3QgYWN0dWFsbHkgaGF2ZSB0byBiZSBpbnRlbGxpZ2VudDsg" 
-        "dGhleSBqdXN0IGhhdmUgdG8gZmFrZSBpdC4gQWNjZXNzIHRvIGEgd2VhbHRo" 
-        "IG9mIGluZm9ybWF0aW9uLCBjb21iaW5lZCB3aXRoIGEgcnVkaW1lbnRhcnkg" 
-        "ZGVjaXNpb24tbWFraW5nIGNhcGFjaXR5LCBjYW4gb2Z0ZW4gYmUgYWxtb3N0" 
-        "IGFzIHVzZWZ1bC4gT2YgY291cnNlLCB0aGUgcmVzdWx0cyBhcmUgYmV0dGVy" 
-        "IHlldCB3aGVuIGNvdXBsZWQgd2l0aCBpbnRlbGxpZ2VuY2UuIEEgcmVmZXJl" 
-        "bmNlIGxpYnJhcmlhbiB3aXRoIGFjY2VzcyB0byBhIGdvb2Qgc2VhcmNoIGVu" 
-        "Z2luZSBpcyBhIGZvcm1pZGFibGUgdG9vbC4gLSBDcmFpZyBTaWx2ZXJzdGVp" 
-        "biwgU2llbWVucyBQaWN0dXJlcyBvZiB0aGUgRnV0dXJlLCBTcHJpbmcgMjAw" 
-        "NAo" }, 
- 
-      // Degenerate edge case 
-      { "", 
-        "" }, 
-  }}; 
- 
-  return testcase; 
-} 
- 
-}  // namespace strings_internal 
+};
+
+inline const std::array<base64_testcase, 5>& base64_strings() {
+  static const std::array<base64_testcase, 5> testcase{{
+      // Some google quotes
+      // Cyphertext created with "uuencode (GNU sharutils) 4.6.3"
+      // (Note that we're testing the websafe encoding, though, so if
+      // you add messages, be sure to run "tr -- '+/' '-_'" on the output)
+      { "I was always good at math and science, and I never realized "
+        "that was unusual or somehow undesirable. So one of the things "
+        "I care a lot about is helping to remove that stigma, "
+        "to show girls that you can be feminine, you can like the things "
+        "that girls like, but you can also be really good at technology. "
+        "You can be really good at building things."
+        " - Marissa Meyer, Newsweek, 2010-12-22" "\n",
+
+        "SSB3YXMgYWx3YXlzIGdvb2QgYXQgbWF0aCBhbmQgc2NpZW5jZSwgYW5kIEkg"
+        "bmV2ZXIgcmVhbGl6ZWQgdGhhdCB3YXMgdW51c3VhbCBvciBzb21laG93IHVu"
+        "ZGVzaXJhYmxlLiBTbyBvbmUgb2YgdGhlIHRoaW5ncyBJIGNhcmUgYSBsb3Qg"
+        "YWJvdXQgaXMgaGVscGluZyB0byByZW1vdmUgdGhhdCBzdGlnbWEsIHRvIHNo"
+        "b3cgZ2lybHMgdGhhdCB5b3UgY2FuIGJlIGZlbWluaW5lLCB5b3UgY2FuIGxp"
+        "a2UgdGhlIHRoaW5ncyB0aGF0IGdpcmxzIGxpa2UsIGJ1dCB5b3UgY2FuIGFs"
+        "c28gYmUgcmVhbGx5IGdvb2QgYXQgdGVjaG5vbG9neS4gWW91IGNhbiBiZSBy"
+        "ZWFsbHkgZ29vZCBhdCBidWlsZGluZyB0aGluZ3MuIC0gTWFyaXNzYSBNZXll"
+        "ciwgTmV3c3dlZWssIDIwMTAtMTItMjIK" },
+
+      { "Typical first year for a new cluster: "
+        "~0.5 overheating "
+        "~1 PDU failure "
+        "~1 rack-move "
+        "~1 network rewiring "
+        "~20 rack failures "
+        "~5 racks go wonky "
+        "~8 network maintenances "
+        "~12 router reloads "
+        "~3 router failures "
+        "~dozens of minor 30-second blips for dns "
+        "~1000 individual machine failures "
+        "~thousands of hard drive failures "
+        "slow disks, bad memory, misconfigured machines, flaky machines, etc."
+        " - Jeff Dean, The Joys of Real Hardware" "\n",
+
+        "VHlwaWNhbCBmaXJzdCB5ZWFyIGZvciBhIG5ldyBjbHVzdGVyOiB-MC41IG92"
+        "ZXJoZWF0aW5nIH4xIFBEVSBmYWlsdXJlIH4xIHJhY2stbW92ZSB-MSBuZXR3"
+        "b3JrIHJld2lyaW5nIH4yMCByYWNrIGZhaWx1cmVzIH41IHJhY2tzIGdvIHdv"
+        "bmt5IH44IG5ldHdvcmsgbWFpbnRlbmFuY2VzIH4xMiByb3V0ZXIgcmVsb2Fk"
+        "cyB-MyByb3V0ZXIgZmFpbHVyZXMgfmRvemVucyBvZiBtaW5vciAzMC1zZWNv"
+        "bmQgYmxpcHMgZm9yIGRucyB-MTAwMCBpbmRpdmlkdWFsIG1hY2hpbmUgZmFp"
+        "bHVyZXMgfnRob3VzYW5kcyBvZiBoYXJkIGRyaXZlIGZhaWx1cmVzIHNsb3cg"
+        "ZGlza3MsIGJhZCBtZW1vcnksIG1pc2NvbmZpZ3VyZWQgbWFjaGluZXMsIGZs"
+        "YWt5IG1hY2hpbmVzLCBldGMuIC0gSmVmZiBEZWFuLCBUaGUgSm95cyBvZiBS"
+        "ZWFsIEhhcmR3YXJlCg" },
+
+      { "I'm the head of the webspam team at Google.  "
+        "That means that if you type your name into Google and get porn back, "
+        "it's my fault. Unless you're a porn star, in which case porn is a "
+        "completely reasonable response."
+        " - Matt Cutts, Google Plus" "\n",
+
+        "SSdtIHRoZSBoZWFkIG9mIHRoZSB3ZWJzcGFtIHRlYW0gYXQgR29vZ2xlLiAg"
+        "VGhhdCBtZWFucyB0aGF0IGlmIHlvdSB0eXBlIHlvdXIgbmFtZSBpbnRvIEdv"
+        "b2dsZSBhbmQgZ2V0IHBvcm4gYmFjaywgaXQncyBteSBmYXVsdC4gVW5sZXNz"
+        "IHlvdSdyZSBhIHBvcm4gc3RhciwgaW4gd2hpY2ggY2FzZSBwb3JuIGlzIGEg"
+        "Y29tcGxldGVseSByZWFzb25hYmxlIHJlc3BvbnNlLiAtIE1hdHQgQ3V0dHMs"
+        "IEdvb2dsZSBQbHVzCg" },
+
+      { "It will still be a long time before machines approach human "
+        "intelligence. "
+        "But luckily, machines don't actually have to be intelligent; "
+        "they just have to fake it. Access to a wealth of information, "
+        "combined with a rudimentary decision-making capacity, "
+        "can often be almost as useful. Of course, the results are better yet "
+        "when coupled with intelligence. A reference librarian with access to "
+        "a good search engine is a formidable tool."
+        " - Craig Silverstein, Siemens Pictures of the Future, Spring 2004"
+        "\n",
+
+        "SXQgd2lsbCBzdGlsbCBiZSBhIGxvbmcgdGltZSBiZWZvcmUgbWFjaGluZXMg"
+        "YXBwcm9hY2ggaHVtYW4gaW50ZWxsaWdlbmNlLiBCdXQgbHVja2lseSwgbWFj"
+        "aGluZXMgZG9uJ3QgYWN0dWFsbHkgaGF2ZSB0byBiZSBpbnRlbGxpZ2VudDsg"
+        "dGhleSBqdXN0IGhhdmUgdG8gZmFrZSBpdC4gQWNjZXNzIHRvIGEgd2VhbHRo"
+        "IG9mIGluZm9ybWF0aW9uLCBjb21iaW5lZCB3aXRoIGEgcnVkaW1lbnRhcnkg"
+        "ZGVjaXNpb24tbWFraW5nIGNhcGFjaXR5LCBjYW4gb2Z0ZW4gYmUgYWxtb3N0"
+        "IGFzIHVzZWZ1bC4gT2YgY291cnNlLCB0aGUgcmVzdWx0cyBhcmUgYmV0dGVy"
+        "IHlldCB3aGVuIGNvdXBsZWQgd2l0aCBpbnRlbGxpZ2VuY2UuIEEgcmVmZXJl"
+        "bmNlIGxpYnJhcmlhbiB3aXRoIGFjY2VzcyB0byBhIGdvb2Qgc2VhcmNoIGVu"
+        "Z2luZSBpcyBhIGZvcm1pZGFibGUgdG9vbC4gLSBDcmFpZyBTaWx2ZXJzdGVp"
+        "biwgU2llbWVucyBQaWN0dXJlcyBvZiB0aGUgRnV0dXJlLCBTcHJpbmcgMjAw"
+        "NAo" },
+
+      // Degenerate edge case
+      { "",
+        "" },
+  }};
+
+  return testcase;
+}
+
+}  // namespace strings_internal
 ABSL_NAMESPACE_END
 }  // namespace y_absl
- 
-#endif  // ABSL_STRINGS_INTERNAL_ESCAPING_TEST_COMMON_H_ 
+
+#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 759222d19a..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
@@ -1,112 +1,112 @@
-// Copyright 2017 The Abseil Authors. 
-// 
-// Licensed under the Apache License, Version 2.0 (the "License"); 
-// you may not use this file except in compliance with the License. 
-// You may obtain a copy of the License at 
-// 
-//      https://www.apache.org/licenses/LICENSE-2.0 
-// 
-// Unless required by applicable law or agreed to in writing, software 
-// distributed under the License is distributed on an "AS IS" BASIS, 
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-// See the License for the specific language governing permissions and 
-// limitations under the License. 
- 
+// Copyright 2017 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/memutil.h"
- 
-#include <cstdlib> 
- 
+
+#include <cstdlib>
+
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-namespace strings_internal { 
- 
-int memcasecmp(const char* s1, const char* s2, size_t len) { 
-  const unsigned char* us1 = reinterpret_cast<const unsigned char*>(s1); 
-  const unsigned char* us2 = reinterpret_cast<const unsigned char*>(s2); 
- 
-  for (size_t i = 0; i < len; i++) { 
-    const int diff = 
+namespace strings_internal {
+
+int memcasecmp(const char* s1, const char* s2, size_t len) {
+  const unsigned char* us1 = reinterpret_cast<const unsigned char*>(s1);
+  const unsigned char* us2 = reinterpret_cast<const unsigned char*>(s2);
+
+  for (size_t i = 0; i < len; i++) {
+    const int diff =
         int{static_cast<unsigned char>(y_absl::ascii_tolower(us1[i]))} -
         int{static_cast<unsigned char>(y_absl::ascii_tolower(us2[i]))};
-    if (diff != 0) return diff; 
-  } 
-  return 0; 
-} 
- 
-char* memdup(const char* s, size_t slen) { 
-  void* copy; 
-  if ((copy = malloc(slen)) == nullptr) return nullptr; 
-  memcpy(copy, s, slen); 
-  return reinterpret_cast<char*>(copy); 
-} 
- 
-char* memrchr(const char* s, int c, size_t slen) { 
-  for (const char* e = s + slen - 1; e >= s; e--) { 
-    if (*e == c) return const_cast<char*>(e); 
-  } 
-  return nullptr; 
-} 
- 
-size_t memspn(const char* s, size_t slen, const char* accept) { 
-  const char* p = s; 
-  const char* spanp; 
-  char c, sc; 
- 
-cont: 
-  c = *p++; 
-  if (slen-- == 0) return p - 1 - s; 
-  for (spanp = accept; (sc = *spanp++) != '\0';) 
-    if (sc == c) goto cont; 
-  return p - 1 - s; 
-} 
- 
-size_t memcspn(const char* s, size_t slen, const char* reject) { 
-  const char* p = s; 
-  const char* spanp; 
-  char c, sc; 
- 
-  while (slen-- != 0) { 
-    c = *p++; 
-    for (spanp = reject; (sc = *spanp++) != '\0';) 
-      if (sc == c) return p - 1 - s; 
-  } 
-  return p - s; 
-} 
- 
-char* mempbrk(const char* s, size_t slen, const char* accept) { 
-  const char* scanp; 
-  int sc; 
- 
-  for (; slen; ++s, --slen) { 
-    for (scanp = accept; (sc = *scanp++) != '\0';) 
-      if (sc == *s) return const_cast<char*>(s); 
-  } 
-  return nullptr; 
-} 
- 
-// This is significantly faster for case-sensitive matches with very 
-// few possible matches.  See unit test for benchmarks. 
-const char* memmatch(const char* phaystack, size_t haylen, const char* pneedle, 
-                     size_t neelen) { 
-  if (0 == neelen) { 
-    return phaystack;  // even if haylen is 0 
-  } 
-  if (haylen < neelen) return nullptr; 
- 
-  const char* match; 
-  const char* hayend = phaystack + haylen - neelen + 1; 
-  // A static cast is used here to work around the fact that memchr returns 
-  // a void* on Posix-compliant systems and const void* on Windows. 
-  while ((match = static_cast<const char*>( 
-              memchr(phaystack, pneedle[0], hayend - phaystack)))) { 
-    if (memcmp(match, pneedle, neelen) == 0) 
-      return match; 
-    else 
-      phaystack = match + 1; 
-  } 
-  return nullptr; 
-} 
- 
-}  // namespace strings_internal 
+    if (diff != 0) return diff;
+  }
+  return 0;
+}
+
+char* memdup(const char* s, size_t slen) {
+  void* copy;
+  if ((copy = malloc(slen)) == nullptr) return nullptr;
+  memcpy(copy, s, slen);
+  return reinterpret_cast<char*>(copy);
+}
+
+char* memrchr(const char* s, int c, size_t slen) {
+  for (const char* e = s + slen - 1; e >= s; e--) {
+    if (*e == c) return const_cast<char*>(e);
+  }
+  return nullptr;
+}
+
+size_t memspn(const char* s, size_t slen, const char* accept) {
+  const char* p = s;
+  const char* spanp;
+  char c, sc;
+
+cont:
+  c = *p++;
+  if (slen-- == 0) return p - 1 - s;
+  for (spanp = accept; (sc = *spanp++) != '\0';)
+    if (sc == c) goto cont;
+  return p - 1 - s;
+}
+
+size_t memcspn(const char* s, size_t slen, const char* reject) {
+  const char* p = s;
+  const char* spanp;
+  char c, sc;
+
+  while (slen-- != 0) {
+    c = *p++;
+    for (spanp = reject; (sc = *spanp++) != '\0';)
+      if (sc == c) return p - 1 - s;
+  }
+  return p - s;
+}
+
+char* mempbrk(const char* s, size_t slen, const char* accept) {
+  const char* scanp;
+  int sc;
+
+  for (; slen; ++s, --slen) {
+    for (scanp = accept; (sc = *scanp++) != '\0';)
+      if (sc == *s) return const_cast<char*>(s);
+  }
+  return nullptr;
+}
+
+// This is significantly faster for case-sensitive matches with very
+// few possible matches.  See unit test for benchmarks.
+const char* memmatch(const char* phaystack, size_t haylen, const char* pneedle,
+                     size_t neelen) {
+  if (0 == neelen) {
+    return phaystack;  // even if haylen is 0
+  }
+  if (haylen < neelen) return nullptr;
+
+  const char* match;
+  const char* hayend = phaystack + haylen - neelen + 1;
+  // A static cast is used here to work around the fact that memchr returns
+  // a void* on Posix-compliant systems and const void* on Windows.
+  while ((match = static_cast<const char*>(
+              memchr(phaystack, pneedle[0], hayend - phaystack)))) {
+    if (memcmp(match, pneedle, neelen) == 0)
+      return match;
+    else
+      phaystack = match + 1;
+  }
+  return nullptr;
+}
+
+}  // namespace strings_internal
 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 e4fbbdfac6..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
@@ -1,148 +1,148 @@
-// 
-// Copyright 2017 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. 
-// 
- 
-// These routines provide mem versions of standard C string routines, 
-// such as strpbrk.  They function exactly the same as the str versions, 
-// so if you wonder what they are, replace the word "mem" by 
-// "str" and check out the man page.  I could return void*, as the 
-// strutil.h mem*() routines tend to do, but I return char* instead 
-// since this is by far the most common way these functions are called. 
-// 
-// The difference between the mem and str versions is the mem version 
-// takes a pointer and a length, rather than a '\0'-terminated string. 
-// The memcase* routines defined here assume the locale is "C" 
+//
+// Copyright 2017 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.
+//
+
+// These routines provide mem versions of standard C string routines,
+// such as strpbrk.  They function exactly the same as the str versions,
+// so if you wonder what they are, replace the word "mem" by
+// "str" and check out the man page.  I could return void*, as the
+// strutil.h mem*() routines tend to do, but I return char* instead
+// since this is by far the most common way these functions are called.
+//
+// The difference between the mem and str versions is the mem version
+// takes a pointer and a length, rather than a '\0'-terminated string.
+// The memcase* routines defined here assume the locale is "C"
 // (they use y_absl::ascii_tolower instead of tolower).
-// 
-// These routines are based on the BSD library. 
-// 
-// Here's a list of routines from string.h, and their mem analogues. 
-// Functions in lowercase are defined in string.h; those in UPPERCASE 
-// are defined here: 
-// 
-// strlen                  -- 
-// strcat strncat          MEMCAT 
-// strcpy strncpy          memcpy 
-// --                      memccpy   (very cool function, btw) 
-// --                      memmove 
-// --                      memset 
-// strcmp strncmp          memcmp 
-// strcasecmp strncasecmp  MEMCASECMP 
-// strchr                  memchr 
-// strcoll                 -- 
-// strxfrm                 -- 
-// strdup strndup          MEMDUP 
-// strrchr                 MEMRCHR 
-// strspn                  MEMSPN 
-// strcspn                 MEMCSPN 
-// strpbrk                 MEMPBRK 
-// strstr                  MEMSTR MEMMEM 
-// (g)strcasestr           MEMCASESTR MEMCASEMEM 
-// strtok                  -- 
-// strprefix               MEMPREFIX      (strprefix is from strutil.h) 
-// strcaseprefix           MEMCASEPREFIX  (strcaseprefix is from strutil.h) 
-// strsuffix               MEMSUFFIX      (strsuffix is from strutil.h) 
-// strcasesuffix           MEMCASESUFFIX  (strcasesuffix is from strutil.h) 
-// --                      MEMIS 
-// --                      MEMCASEIS 
-// strcount                MEMCOUNT       (strcount is from strutil.h) 
- 
-#ifndef ABSL_STRINGS_INTERNAL_MEMUTIL_H_ 
-#define ABSL_STRINGS_INTERNAL_MEMUTIL_H_ 
- 
-#include <cstddef> 
-#include <cstring> 
- 
+//
+// These routines are based on the BSD library.
+//
+// Here's a list of routines from string.h, and their mem analogues.
+// Functions in lowercase are defined in string.h; those in UPPERCASE
+// are defined here:
+//
+// strlen                  --
+// strcat strncat          MEMCAT
+// strcpy strncpy          memcpy
+// --                      memccpy   (very cool function, btw)
+// --                      memmove
+// --                      memset
+// strcmp strncmp          memcmp
+// strcasecmp strncasecmp  MEMCASECMP
+// strchr                  memchr
+// strcoll                 --
+// strxfrm                 --
+// strdup strndup          MEMDUP
+// strrchr                 MEMRCHR
+// strspn                  MEMSPN
+// strcspn                 MEMCSPN
+// strpbrk                 MEMPBRK
+// strstr                  MEMSTR MEMMEM
+// (g)strcasestr           MEMCASESTR MEMCASEMEM
+// strtok                  --
+// strprefix               MEMPREFIX      (strprefix is from strutil.h)
+// strcaseprefix           MEMCASEPREFIX  (strcaseprefix is from strutil.h)
+// strsuffix               MEMSUFFIX      (strsuffix is from strutil.h)
+// strcasesuffix           MEMCASESUFFIX  (strcasesuffix is from strutil.h)
+// --                      MEMIS
+// --                      MEMCASEIS
+// strcount                MEMCOUNT       (strcount is from strutil.h)
+
+#ifndef ABSL_STRINGS_INTERNAL_MEMUTIL_H_
+#define ABSL_STRINGS_INTERNAL_MEMUTIL_H_
+
+#include <cstddef>
+#include <cstring>
+
 #include "y_absl/base/port.h"  // disable some warnings on Windows
 #include "y_absl/strings/ascii.h"  // for y_absl::ascii_tolower
- 
+
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-namespace strings_internal { 
- 
-inline char* memcat(char* dest, size_t destlen, const char* src, 
-                    size_t srclen) { 
-  return reinterpret_cast<char*>(memcpy(dest + destlen, src, srclen)); 
-} 
- 
-int memcasecmp(const char* s1, const char* s2, size_t len); 
-char* memdup(const char* s, size_t slen); 
-char* memrchr(const char* s, int c, size_t slen); 
-size_t memspn(const char* s, size_t slen, const char* accept); 
-size_t memcspn(const char* s, size_t slen, const char* reject); 
-char* mempbrk(const char* s, size_t slen, const char* accept); 
- 
-// This is for internal use only.  Don't call this directly 
-template <bool case_sensitive> 
-const char* int_memmatch(const char* haystack, size_t haylen, 
-                         const char* needle, size_t neelen) { 
-  if (0 == neelen) { 
-    return haystack;  // even if haylen is 0 
-  } 
-  const char* hayend = haystack + haylen; 
-  const char* needlestart = needle; 
-  const char* needleend = needlestart + neelen; 
- 
-  for (; haystack < hayend; ++haystack) { 
-    char hay = case_sensitive 
-                   ? *haystack 
+namespace strings_internal {
+
+inline char* memcat(char* dest, size_t destlen, const char* src,
+                    size_t srclen) {
+  return reinterpret_cast<char*>(memcpy(dest + destlen, src, srclen));
+}
+
+int memcasecmp(const char* s1, const char* s2, size_t len);
+char* memdup(const char* s, size_t slen);
+char* memrchr(const char* s, int c, size_t slen);
+size_t memspn(const char* s, size_t slen, const char* accept);
+size_t memcspn(const char* s, size_t slen, const char* reject);
+char* mempbrk(const char* s, size_t slen, const char* accept);
+
+// This is for internal use only.  Don't call this directly
+template <bool case_sensitive>
+const char* int_memmatch(const char* haystack, size_t haylen,
+                         const char* needle, size_t neelen) {
+  if (0 == neelen) {
+    return haystack;  // even if haylen is 0
+  }
+  const char* hayend = haystack + haylen;
+  const char* needlestart = needle;
+  const char* needleend = needlestart + neelen;
+
+  for (; haystack < hayend; ++haystack) {
+    char hay = case_sensitive
+                   ? *haystack
                    : y_absl::ascii_tolower(static_cast<unsigned char>(*haystack));
-    char nee = case_sensitive 
-                   ? *needle 
+    char nee = case_sensitive
+                   ? *needle
                    : y_absl::ascii_tolower(static_cast<unsigned char>(*needle));
-    if (hay == nee) { 
-      if (++needle == needleend) { 
-        return haystack + 1 - neelen; 
-      } 
-    } else if (needle != needlestart) { 
-      // must back up haystack in case a prefix matched (find "aab" in "aaab") 
-      haystack -= needle - needlestart;  // for loop will advance one more 
-      needle = needlestart; 
-    } 
-  } 
-  return nullptr; 
-} 
- 
-// These are the guys you can call directly 
-inline const char* memstr(const char* phaystack, size_t haylen, 
-                          const char* pneedle) { 
-  return int_memmatch<true>(phaystack, haylen, pneedle, strlen(pneedle)); 
-} 
- 
-inline const char* memcasestr(const char* phaystack, size_t haylen, 
-                              const char* pneedle) { 
-  return int_memmatch<false>(phaystack, haylen, pneedle, strlen(pneedle)); 
-} 
- 
-inline const char* memmem(const char* phaystack, size_t haylen, 
-                          const char* pneedle, size_t needlelen) { 
-  return int_memmatch<true>(phaystack, haylen, pneedle, needlelen); 
-} 
- 
-inline const char* memcasemem(const char* phaystack, size_t haylen, 
-                              const char* pneedle, size_t needlelen) { 
-  return int_memmatch<false>(phaystack, haylen, pneedle, needlelen); 
-} 
- 
-// This is significantly faster for case-sensitive matches with very 
-// few possible matches.  See unit test for benchmarks. 
-const char* memmatch(const char* phaystack, size_t haylen, const char* pneedle, 
-                     size_t neelen); 
- 
-}  // namespace strings_internal 
+    if (hay == nee) {
+      if (++needle == needleend) {
+        return haystack + 1 - neelen;
+      }
+    } else if (needle != needlestart) {
+      // must back up haystack in case a prefix matched (find "aab" in "aaab")
+      haystack -= needle - needlestart;  // for loop will advance one more
+      needle = needlestart;
+    }
+  }
+  return nullptr;
+}
+
+// These are the guys you can call directly
+inline const char* memstr(const char* phaystack, size_t haylen,
+                          const char* pneedle) {
+  return int_memmatch<true>(phaystack, haylen, pneedle, strlen(pneedle));
+}
+
+inline const char* memcasestr(const char* phaystack, size_t haylen,
+                              const char* pneedle) {
+  return int_memmatch<false>(phaystack, haylen, pneedle, strlen(pneedle));
+}
+
+inline const char* memmem(const char* phaystack, size_t haylen,
+                          const char* pneedle, size_t needlelen) {
+  return int_memmatch<true>(phaystack, haylen, pneedle, needlelen);
+}
+
+inline const char* memcasemem(const char* phaystack, size_t haylen,
+                              const char* pneedle, size_t needlelen) {
+  return int_memmatch<false>(phaystack, haylen, pneedle, needlelen);
+}
+
+// This is significantly faster for case-sensitive matches with very
+// few possible matches.  See unit test for benchmarks.
+const char* memmatch(const char* phaystack, size_t haylen, const char* pneedle,
+                     size_t neelen);
+
+}  // namespace strings_internal
 ABSL_NAMESPACE_END
 }  // namespace y_absl
- 
-#endif  // ABSL_STRINGS_INTERNAL_MEMUTIL_H_ 
+
+#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 bfae683bf6..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
@@ -1,184 +1,184 @@
-// Copyright 2017 The Abseil Authors. 
-// 
-// Licensed under the Apache License, Version 2.0 (the "License"); 
-// you may not use this file except in compliance with the License. 
-// You may obtain a copy of the License at 
-// 
-//      https://www.apache.org/licenses/LICENSE-2.0 
-// 
-// Unless required by applicable law or agreed to in writing, software 
-// distributed under the License is distributed on an "AS IS" BASIS, 
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-// See the License for the specific language governing permissions and 
-// limitations under the License. 
-// 
-// This file contains common things needed by numbers_test.cc, 
-// numbers_legacy_test.cc and numbers_benchmark.cc. 
- 
-#ifndef ABSL_STRINGS_INTERNAL_NUMBERS_TEST_COMMON_H_ 
-#define ABSL_STRINGS_INTERNAL_NUMBERS_TEST_COMMON_H_ 
- 
-#include <array> 
-#include <cstdint> 
-#include <limits> 
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// This file contains common things needed by numbers_test.cc,
+// numbers_legacy_test.cc and numbers_benchmark.cc.
+
+#ifndef ABSL_STRINGS_INTERNAL_NUMBERS_TEST_COMMON_H_
+#define ABSL_STRINGS_INTERNAL_NUMBERS_TEST_COMMON_H_
+
+#include <array>
+#include <cstdint>
+#include <limits>
 #include <util/generic/string.h>
- 
+
 #include "y_absl/base/config.h"
 
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-namespace strings_internal { 
- 
-template <typename IntType> 
+namespace strings_internal {
+
+template <typename IntType>
 inline bool Itoa(IntType value, int base, TString* destination) {
-  destination->clear(); 
-  if (base <= 1 || base > 36) { 
-    return false; 
-  } 
- 
-  if (value == 0) { 
-    destination->push_back('0'); 
-    return true; 
-  } 
- 
-  bool negative = value < 0; 
-  while (value != 0) { 
-    const IntType next_value = value / base; 
-    // Can't use std::abs here because of problems when IntType is unsigned. 
-    int remainder = 
-        static_cast<int>(value > next_value * base ? value - next_value * base 
-                                                   : next_value * base - value); 
-    char c = remainder < 10 ? '0' + remainder : 'A' + remainder - 10; 
-    destination->insert(0, 1, c); 
-    value = next_value; 
-  } 
- 
-  if (negative) { 
-    destination->insert(0, 1, '-'); 
-  } 
-  return true; 
-} 
- 
-struct uint32_test_case { 
-  const char* str; 
-  bool expect_ok; 
-  int base;  // base to pass to the conversion function 
-  uint32_t expected; 
-}; 
- 
-inline const std::array<uint32_test_case, 27>& strtouint32_test_cases() { 
-  static const std::array<uint32_test_case, 27> test_cases{{ 
-      {"0xffffffff", true, 16, (std::numeric_limits<uint32_t>::max)()}, 
-      {"0x34234324", true, 16, 0x34234324}, 
-      {"34234324", true, 16, 0x34234324}, 
-      {"0", true, 16, 0}, 
-      {" \t\n 0xffffffff", true, 16, (std::numeric_limits<uint32_t>::max)()}, 
-      {" \f\v 46", true, 10, 46},  // must accept weird whitespace 
-      {" \t\n 72717222", true, 8, 072717222}, 
-      {" \t\n 072717222", true, 8, 072717222}, 
-      {" \t\n 072717228", false, 8, 07271722}, 
-      {"0", true, 0, 0}, 
- 
-      // Base-10 version. 
-      {"34234324", true, 0, 34234324}, 
-      {"4294967295", true, 0, (std::numeric_limits<uint32_t>::max)()}, 
-      {"34234324 \n\t", true, 10, 34234324}, 
- 
-      // Unusual base 
-      {"0", true, 3, 0}, 
-      {"2", true, 3, 2}, 
-      {"11", true, 3, 4}, 
- 
-      // Invalid uints. 
-      {"", false, 0, 0}, 
-      {"  ", false, 0, 0}, 
-      {"abc", false, 0, 0},  // would be valid hex, but prefix is missing 
-      {"34234324a", false, 0, 34234324}, 
-      {"34234.3", false, 0, 34234}, 
-      {"-1", false, 0, 0}, 
-      {"   -123", false, 0, 0}, 
-      {" \t\n -123", false, 0, 0}, 
- 
-      // Out of bounds. 
-      {"4294967296", false, 0, (std::numeric_limits<uint32_t>::max)()}, 
-      {"0x100000000", false, 0, (std::numeric_limits<uint32_t>::max)()}, 
-      {nullptr, false, 0, 0}, 
-  }}; 
-  return test_cases; 
-} 
- 
-struct uint64_test_case { 
-  const char* str; 
-  bool expect_ok; 
-  int base; 
-  uint64_t expected; 
-}; 
- 
-inline const std::array<uint64_test_case, 34>& strtouint64_test_cases() { 
-  static const std::array<uint64_test_case, 34> test_cases{{ 
-      {"0x3423432448783446", true, 16, int64_t{0x3423432448783446}}, 
-      {"3423432448783446", true, 16, int64_t{0x3423432448783446}}, 
- 
-      {"0", true, 16, 0}, 
-      {"000", true, 0, 0}, 
-      {"0", true, 0, 0}, 
-      {" \t\n 0xffffffffffffffff", true, 16, 
-       (std::numeric_limits<uint64_t>::max)()}, 
- 
-      {"012345670123456701234", true, 8, int64_t{012345670123456701234}}, 
-      {"12345670123456701234", true, 8, int64_t{012345670123456701234}}, 
- 
-      {"12845670123456701234", false, 8, 0}, 
- 
-      // Base-10 version. 
-      {"34234324487834466", true, 0, int64_t{34234324487834466}}, 
- 
-      {" \t\n 18446744073709551615", true, 0, 
-       (std::numeric_limits<uint64_t>::max)()}, 
- 
-      {"34234324487834466 \n\t ", true, 0, int64_t{34234324487834466}}, 
- 
-      {" \f\v 46", true, 10, 46},  // must accept weird whitespace 
- 
-      // Unusual base 
-      {"0", true, 3, 0}, 
-      {"2", true, 3, 2}, 
-      {"11", true, 3, 4}, 
- 
-      {"0", true, 0, 0}, 
- 
-      // Invalid uints. 
-      {"", false, 0, 0}, 
-      {"  ", false, 0, 0}, 
-      {"abc", false, 0, 0}, 
-      {"34234324487834466a", false, 0, 0}, 
-      {"34234487834466.3", false, 0, 0}, 
-      {"-1", false, 0, 0}, 
-      {"   -123", false, 0, 0}, 
-      {" \t\n -123", false, 0, 0}, 
- 
-      // Out of bounds. 
-      {"18446744073709551616", false, 10, 0}, 
-      {"18446744073709551616", false, 0, 0}, 
-      {"0x10000000000000000", false, 16, 
-       (std::numeric_limits<uint64_t>::max)()}, 
-      {"0X10000000000000000", false, 16, 
-       (std::numeric_limits<uint64_t>::max)()},  // 0X versus 0x. 
-      {"0x10000000000000000", false, 0, (std::numeric_limits<uint64_t>::max)()}, 
-      {"0X10000000000000000", false, 0, 
-       (std::numeric_limits<uint64_t>::max)()},  // 0X versus 0x. 
- 
-      {"0x1234", true, 16, 0x1234}, 
- 
+  destination->clear();
+  if (base <= 1 || base > 36) {
+    return false;
+  }
+
+  if (value == 0) {
+    destination->push_back('0');
+    return true;
+  }
+
+  bool negative = value < 0;
+  while (value != 0) {
+    const IntType next_value = value / base;
+    // Can't use std::abs here because of problems when IntType is unsigned.
+    int remainder =
+        static_cast<int>(value > next_value * base ? value - next_value * base
+                                                   : next_value * base - value);
+    char c = remainder < 10 ? '0' + remainder : 'A' + remainder - 10;
+    destination->insert(0, 1, c);
+    value = next_value;
+  }
+
+  if (negative) {
+    destination->insert(0, 1, '-');
+  }
+  return true;
+}
+
+struct uint32_test_case {
+  const char* str;
+  bool expect_ok;
+  int base;  // base to pass to the conversion function
+  uint32_t expected;
+};
+
+inline const std::array<uint32_test_case, 27>& strtouint32_test_cases() {
+  static const std::array<uint32_test_case, 27> test_cases{{
+      {"0xffffffff", true, 16, (std::numeric_limits<uint32_t>::max)()},
+      {"0x34234324", true, 16, 0x34234324},
+      {"34234324", true, 16, 0x34234324},
+      {"0", true, 16, 0},
+      {" \t\n 0xffffffff", true, 16, (std::numeric_limits<uint32_t>::max)()},
+      {" \f\v 46", true, 10, 46},  // must accept weird whitespace
+      {" \t\n 72717222", true, 8, 072717222},
+      {" \t\n 072717222", true, 8, 072717222},
+      {" \t\n 072717228", false, 8, 07271722},
+      {"0", true, 0, 0},
+
+      // Base-10 version.
+      {"34234324", true, 0, 34234324},
+      {"4294967295", true, 0, (std::numeric_limits<uint32_t>::max)()},
+      {"34234324 \n\t", true, 10, 34234324},
+
+      // Unusual base
+      {"0", true, 3, 0},
+      {"2", true, 3, 2},
+      {"11", true, 3, 4},
+
+      // Invalid uints.
+      {"", false, 0, 0},
+      {"  ", false, 0, 0},
+      {"abc", false, 0, 0},  // would be valid hex, but prefix is missing
+      {"34234324a", false, 0, 34234324},
+      {"34234.3", false, 0, 34234},
+      {"-1", false, 0, 0},
+      {"   -123", false, 0, 0},
+      {" \t\n -123", false, 0, 0},
+
+      // Out of bounds.
+      {"4294967296", false, 0, (std::numeric_limits<uint32_t>::max)()},
+      {"0x100000000", false, 0, (std::numeric_limits<uint32_t>::max)()},
+      {nullptr, false, 0, 0},
+  }};
+  return test_cases;
+}
+
+struct uint64_test_case {
+  const char* str;
+  bool expect_ok;
+  int base;
+  uint64_t expected;
+};
+
+inline const std::array<uint64_test_case, 34>& strtouint64_test_cases() {
+  static const std::array<uint64_test_case, 34> test_cases{{
+      {"0x3423432448783446", true, 16, int64_t{0x3423432448783446}},
+      {"3423432448783446", true, 16, int64_t{0x3423432448783446}},
+
+      {"0", true, 16, 0},
+      {"000", true, 0, 0},
+      {"0", true, 0, 0},
+      {" \t\n 0xffffffffffffffff", true, 16,
+       (std::numeric_limits<uint64_t>::max)()},
+
+      {"012345670123456701234", true, 8, int64_t{012345670123456701234}},
+      {"12345670123456701234", true, 8, int64_t{012345670123456701234}},
+
+      {"12845670123456701234", false, 8, 0},
+
+      // Base-10 version.
+      {"34234324487834466", true, 0, int64_t{34234324487834466}},
+
+      {" \t\n 18446744073709551615", true, 0,
+       (std::numeric_limits<uint64_t>::max)()},
+
+      {"34234324487834466 \n\t ", true, 0, int64_t{34234324487834466}},
+
+      {" \f\v 46", true, 10, 46},  // must accept weird whitespace
+
+      // Unusual base
+      {"0", true, 3, 0},
+      {"2", true, 3, 2},
+      {"11", true, 3, 4},
+
+      {"0", true, 0, 0},
+
+      // Invalid uints.
+      {"", false, 0, 0},
+      {"  ", false, 0, 0},
+      {"abc", false, 0, 0},
+      {"34234324487834466a", false, 0, 0},
+      {"34234487834466.3", false, 0, 0},
+      {"-1", false, 0, 0},
+      {"   -123", false, 0, 0},
+      {" \t\n -123", false, 0, 0},
+
+      // Out of bounds.
+      {"18446744073709551616", false, 10, 0},
+      {"18446744073709551616", false, 0, 0},
+      {"0x10000000000000000", false, 16,
+       (std::numeric_limits<uint64_t>::max)()},
+      {"0X10000000000000000", false, 16,
+       (std::numeric_limits<uint64_t>::max)()},  // 0X versus 0x.
+      {"0x10000000000000000", false, 0, (std::numeric_limits<uint64_t>::max)()},
+      {"0X10000000000000000", false, 0,
+       (std::numeric_limits<uint64_t>::max)()},  // 0X versus 0x.
+
+      {"0x1234", true, 16, 0x1234},
+
       // Base-10 string version.
-      {"1234", true, 0, 1234}, 
-      {nullptr, false, 0, 0}, 
-  }}; 
-  return test_cases; 
-} 
- 
-}  // namespace strings_internal 
+      {"1234", true, 0, 1234},
+      {nullptr, false, 0, 0},
+  }};
+  return test_cases;
+}
+
+}  // namespace strings_internal
 ABSL_NAMESPACE_END
 }  // namespace y_absl
- 
-#endif  // ABSL_STRINGS_INTERNAL_NUMBERS_TEST_COMMON_H_ 
+
+#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 318cfc1f05..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
@@ -1,36 +1,36 @@
-// Copyright 2017 The Abseil Authors. 
-// 
-// Licensed under the Apache License, Version 2.0 (the "License"); 
-// you may not use this file except in compliance with the License. 
-// You may obtain a copy of the License at 
-// 
-//      https://www.apache.org/licenses/LICENSE-2.0 
-// 
-// Unless required by applicable law or agreed to in writing, software 
-// distributed under the License is distributed on an "AS IS" BASIS, 
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-// See the License for the specific language governing permissions and 
-// limitations under the License. 
- 
+// Copyright 2017 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/ostringstream.h"
- 
+
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-namespace strings_internal { 
- 
-OStringStream::Buf::int_type OStringStream::overflow(int c) { 
-  assert(s_); 
-  if (!Buf::traits_type::eq_int_type(c, Buf::traits_type::eof())) 
-    s_->push_back(static_cast<char>(c)); 
-  return 1; 
-} 
- 
-std::streamsize OStringStream::xsputn(const char* s, std::streamsize n) { 
-  assert(s_); 
-  s_->append(s, n); 
-  return n; 
-} 
- 
-}  // namespace strings_internal 
+namespace strings_internal {
+
+OStringStream::Buf::int_type OStringStream::overflow(int c) {
+  assert(s_);
+  if (!Buf::traits_type::eq_int_type(c, Buf::traits_type::eof()))
+    s_->push_back(static_cast<char>(c));
+  return 1;
+}
+
+std::streamsize OStringStream::xsputn(const char* s, std::streamsize n) {
+  assert(s_);
+  s_->append(s, n);
+  return n;
+}
+
+}  // namespace strings_internal
 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 3a8886405a..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
@@ -1,89 +1,89 @@
-// Copyright 2017 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_OSTRINGSTREAM_H_ 
-#define ABSL_STRINGS_INTERNAL_OSTRINGSTREAM_H_ 
- 
-#include <cassert> 
-#include <ostream> 
-#include <streambuf> 
+// Copyright 2017 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_OSTRINGSTREAM_H_
+#define ABSL_STRINGS_INTERNAL_OSTRINGSTREAM_H_
+
+#include <cassert>
+#include <ostream>
+#include <streambuf>
 #include <util/generic/string.h>
- 
+
 #include "y_absl/base/port.h"
- 
+
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-namespace strings_internal { 
- 
+namespace strings_internal {
+
 // The same as std::ostringstream but appends to a user-specified TString,
-// and is faster. It is ~70% faster to create, ~50% faster to write to, and 
+// and is faster. It is ~70% faster to create, ~50% faster to write to, and
 // completely free to extract the result TString.
-// 
+//
 //   TString s;
-//   OStringStream strm(&s); 
-//   strm << 42 << ' ' << 3.14;  // appends to `s` 
-// 
-// The stream object doesn't have to be named. Starting from C++11 operator<< 
-// works with rvalues of std::ostream. 
-// 
+//   OStringStream strm(&s);
+//   strm << 42 << ' ' << 3.14;  // appends to `s`
+//
+// The stream object doesn't have to be named. Starting from C++11 operator<<
+// works with rvalues of std::ostream.
+//
 //   TString s;
-//   OStringStream(&s) << 42 << ' ' << 3.14;  // appends to `s` 
-// 
-// OStringStream is faster to create than std::ostringstream but it's still 
-// relatively slow. Avoid creating multiple streams where a single stream will 
-// do. 
-// 
-// Creates unnecessary instances of OStringStream: slow. 
-// 
+//   OStringStream(&s) << 42 << ' ' << 3.14;  // appends to `s`
+//
+// OStringStream is faster to create than std::ostringstream but it's still
+// relatively slow. Avoid creating multiple streams where a single stream will
+// do.
+//
+// Creates unnecessary instances of OStringStream: slow.
+//
 //   TString s;
-//   OStringStream(&s) << 42; 
-//   OStringStream(&s) << ' '; 
-//   OStringStream(&s) << 3.14; 
-// 
-// Creates a single instance of OStringStream and reuses it: fast. 
-// 
+//   OStringStream(&s) << 42;
+//   OStringStream(&s) << ' ';
+//   OStringStream(&s) << 3.14;
+//
+// Creates a single instance of OStringStream and reuses it: fast.
+//
 //   TString s;
-//   OStringStream strm(&s); 
-//   strm << 42; 
-//   strm << ' '; 
-//   strm << 3.14; 
-// 
-// Note: flush() has no effect. No reason to call it. 
-class OStringStream : private std::basic_streambuf<char>, public std::ostream { 
- public: 
-  // The argument can be null, in which case you'll need to call str(p) with a 
-  // non-null argument before you can write to the stream. 
-  // 
+//   OStringStream strm(&s);
+//   strm << 42;
+//   strm << ' ';
+//   strm << 3.14;
+//
+// Note: flush() has no effect. No reason to call it.
+class OStringStream : private std::basic_streambuf<char>, public std::ostream {
+ public:
+  // The argument can be null, in which case you'll need to call str(p) with a
+  // non-null argument before you can write to the stream.
+  //
   // The destructor of OStringStream doesn't use the TString. It's OK to
   // destroy the TString before the stream.
   explicit OStringStream(TString* s) : std::ostream(this), s_(s) {}
- 
+
   TString* str() { return s_; }
   const TString* str() const { return s_; }
   void str(TString* s) { s_ = s; }
- 
- private: 
-  using Buf = std::basic_streambuf<char>; 
- 
-  Buf::int_type overflow(int c) override; 
-  std::streamsize xsputn(const char* s, std::streamsize n) override; 
- 
+
+ private:
+  using Buf = std::basic_streambuf<char>;
+
+  Buf::int_type overflow(int c) override;
+  std::streamsize xsputn(const char* s, std::streamsize n) override;
+
   TString* s_;
-}; 
- 
-}  // namespace strings_internal 
+};
+
+}  // namespace strings_internal
 ABSL_NAMESPACE_END
 }  // namespace y_absl
- 
-#endif  // ABSL_STRINGS_INTERNAL_OSTRINGSTREAM_H_ 
+
+#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 7cebbdaeeb..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
@@ -1,40 +1,40 @@
-// 
-// Copyright 2018 The Abseil Authors. 
-// 
-// Licensed under the Apache License, Version 2.0 (the "License"); 
-// you may not use this file except in compliance with the License. 
-// You may obtain a copy of the License at 
-// 
-//      https://www.apache.org/licenses/LICENSE-2.0 
-// 
-// Unless required by applicable law or agreed to in writing, software 
-// distributed under the License is distributed on an "AS IS" BASIS, 
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-// See the License for the specific language governing permissions and 
-// limitations under the License. 
-// 
-// This test helper library contains a table of powers of 10, to guarantee 
-// precise values are computed across the full range of doubles. We can't rely 
-// on the pow() function, because not all standard libraries ship a version 
-// that is precise. 
-#ifndef ABSL_STRINGS_INTERNAL_POW10_HELPER_H_ 
-#define ABSL_STRINGS_INTERNAL_POW10_HELPER_H_ 
- 
-#include <vector> 
- 
+//
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// This test helper library contains a table of powers of 10, to guarantee
+// precise values are computed across the full range of doubles. We can't rely
+// on the pow() function, because not all standard libraries ship a version
+// that is precise.
+#ifndef ABSL_STRINGS_INTERNAL_POW10_HELPER_H_
+#define ABSL_STRINGS_INTERNAL_POW10_HELPER_H_
+
+#include <vector>
+
 #include "y_absl/base/config.h"
 
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-namespace strings_internal { 
- 
-// Computes the precise value of 10^exp. (I.e. the nearest representable 
-// double to the exact value, rounding to nearest-even in the (single) case of 
-// being exactly halfway between.) 
-double Pow10(int exp); 
- 
-}  // namespace strings_internal 
+namespace strings_internal {
+
+// Computes the precise value of 10^exp. (I.e. the nearest representable
+// double to the exact value, rounding to nearest-even in the (single) case of
+// being exactly halfway between.)
+double Pow10(int exp);
+
+}  // namespace strings_internal
 ABSL_NAMESPACE_END
 }  // namespace y_absl
- 
-#endif  // ABSL_STRINGS_INTERNAL_POW10_HELPER_H_ 
+
+#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 0c3af713f8..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
@@ -1,73 +1,73 @@
-// 
-// Copyright 2017 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_RESIZE_UNINITIALIZED_H_ 
-#define ABSL_STRINGS_INTERNAL_RESIZE_UNINITIALIZED_H_ 
- 
+//
+// Copyright 2017 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_RESIZE_UNINITIALIZED_H_
+#define ABSL_STRINGS_INTERNAL_RESIZE_UNINITIALIZED_H_
+
 #include <algorithm>
 #include <util/generic/string.h>
-#include <type_traits> 
-#include <utility> 
- 
+#include <type_traits>
+#include <utility>
+
 #include "y_absl/base/port.h"
 #include "y_absl/meta/type_traits.h"  //  for void_t
- 
+
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-namespace strings_internal { 
- 
+namespace strings_internal {
+
 // In this type trait, we look for a __resize_default_init member function, and
 // we use it if available, otherwise, we use resize. We provide HasMember to
 // indicate whether __resize_default_init is present.
-template <typename string_type, typename = void> 
-struct ResizeUninitializedTraits { 
-  using HasMember = std::false_type; 
-  static void Resize(string_type* s, size_t new_size) { s->resize(new_size); } 
-}; 
- 
-// __resize_default_init is provided by libc++ >= 8.0 
-template <typename string_type> 
-struct ResizeUninitializedTraits< 
+template <typename string_type, typename = void>
+struct ResizeUninitializedTraits {
+  using HasMember = std::false_type;
+  static void Resize(string_type* s, size_t new_size) { s->resize(new_size); }
+};
+
+// __resize_default_init is provided by libc++ >= 8.0
+template <typename string_type>
+struct ResizeUninitializedTraits<
     string_type, y_absl::void_t<decltype(std::declval<string_type&>()
-                                           .__resize_default_init(237))> > { 
-  using HasMember = std::true_type; 
-  static void Resize(string_type* s, size_t new_size) { 
-    s->__resize_default_init(new_size); 
-  } 
-}; 
- 
+                                           .__resize_default_init(237))> > {
+  using HasMember = std::true_type;
+  static void Resize(string_type* s, size_t new_size) {
+    s->__resize_default_init(new_size);
+  }
+};
+
 // Returns true if the TString implementation supports a resize where
 // the new characters added to the TString are left untouched.
-// 
-// (A better name might be "STLStringSupportsUninitializedResize", alluding to 
-// the previous function.) 
-template <typename string_type> 
-inline constexpr bool STLStringSupportsNontrashingResize(string_type*) { 
-  return ResizeUninitializedTraits<string_type>::HasMember::value; 
-} 
- 
-// Like str->resize(new_size), except any new characters added to "*str" as a 
-// result of resizing may be left uninitialized, rather than being filled with 
-// '0' bytes. Typically used when code is then going to overwrite the backing 
+//
+// (A better name might be "STLStringSupportsUninitializedResize", alluding to
+// the previous function.)
+template <typename string_type>
+inline constexpr bool STLStringSupportsNontrashingResize(string_type*) {
+  return ResizeUninitializedTraits<string_type>::HasMember::value;
+}
+
+// Like str->resize(new_size), except any new characters added to "*str" as a
+// result of resizing may be left uninitialized, rather than being filled with
+// '0' bytes. Typically used when code is then going to overwrite the backing
 // store of the TString with known data.
-template <typename string_type, typename = void> 
-inline void STLStringResizeUninitialized(string_type* s, size_t new_size) { 
-  ResizeUninitializedTraits<string_type>::Resize(s, new_size); 
-} 
- 
+template <typename string_type, typename = void>
+inline void STLStringResizeUninitialized(string_type* s, size_t new_size) {
+  ResizeUninitializedTraits<string_type>::Resize(s, new_size);
+}
+
 // Used to ensure exponential growth so that the amortized complexity of
 // increasing the string size by a small amount is O(1), in contrast to
 // O(str->size()) in the case of precise growth.
@@ -112,8 +112,8 @@ void STLStringResizeUninitializedAmortized(string_type* s, size_t new_size) {
   }
 }
 
-}  // namespace strings_internal 
+}  // namespace strings_internal
 ABSL_NAMESPACE_END
 }  // namespace y_absl
- 
-#endif  // ABSL_STRINGS_INTERNAL_RESIZE_UNINITIALIZED_H_ 
+
+#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 ed7a191fc0..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
@@ -1,248 +1,248 @@
-// Copyright 2017 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. 
-// 
- 
-// Thie file provides the IsStrictlyBaseOfAndConvertibleToSTLContainer type 
-// trait metafunction to assist in working with the _GLIBCXX_DEBUG debug 
-// wrappers of STL containers. 
-// 
-// DO NOT INCLUDE THIS FILE DIRECTLY. Use this file by including 
+// Copyright 2017 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.
+//
+
+// Thie file provides the IsStrictlyBaseOfAndConvertibleToSTLContainer type
+// trait metafunction to assist in working with the _GLIBCXX_DEBUG debug
+// wrappers of STL containers.
+//
+// DO NOT INCLUDE THIS FILE DIRECTLY. Use this file by including
 // y_absl/strings/str_split.h.
-// 
+//
 // IWYU pragma: private, include "y_absl/strings/str_split.h"
- 
-#ifndef ABSL_STRINGS_INTERNAL_STL_TYPE_TRAITS_H_ 
-#define ABSL_STRINGS_INTERNAL_STL_TYPE_TRAITS_H_ 
- 
-#include <array> 
-#include <bitset> 
-#include <deque> 
-#include <forward_list> 
-#include <list> 
-#include <map> 
-#include <set> 
-#include <type_traits> 
-#include <unordered_map> 
-#include <unordered_set> 
-#include <vector> 
- 
+
+#ifndef ABSL_STRINGS_INTERNAL_STL_TYPE_TRAITS_H_
+#define ABSL_STRINGS_INTERNAL_STL_TYPE_TRAITS_H_
+
+#include <array>
+#include <bitset>
+#include <deque>
+#include <forward_list>
+#include <list>
+#include <map>
+#include <set>
+#include <type_traits>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
 #include "y_absl/meta/type_traits.h"
- 
+
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-namespace strings_internal { 
- 
-template <typename C, template <typename...> class T> 
-struct IsSpecializationImpl : std::false_type {}; 
-template <template <typename...> class T, typename... Args> 
-struct IsSpecializationImpl<T<Args...>, T> : std::true_type {}; 
-template <typename C, template <typename...> class T> 
+namespace strings_internal {
+
+template <typename C, template <typename...> class T>
+struct IsSpecializationImpl : std::false_type {};
+template <template <typename...> class T, typename... Args>
+struct IsSpecializationImpl<T<Args...>, T> : std::true_type {};
+template <typename C, template <typename...> class T>
 using IsSpecialization = IsSpecializationImpl<y_absl::decay_t<C>, T>;
- 
-template <typename C> 
-struct IsArrayImpl : std::false_type {}; 
-template <template <typename, size_t> class A, typename T, size_t N> 
-struct IsArrayImpl<A<T, N>> : std::is_same<A<T, N>, std::array<T, N>> {}; 
-template <typename C> 
+
+template <typename C>
+struct IsArrayImpl : std::false_type {};
+template <template <typename, size_t> class A, typename T, size_t N>
+struct IsArrayImpl<A<T, N>> : std::is_same<A<T, N>, std::array<T, N>> {};
+template <typename C>
 using IsArray = IsArrayImpl<y_absl::decay_t<C>>;
- 
-template <typename C> 
-struct IsBitsetImpl : std::false_type {}; 
-template <template <size_t> class B, size_t N> 
-struct IsBitsetImpl<B<N>> : std::is_same<B<N>, std::bitset<N>> {}; 
-template <typename C> 
+
+template <typename C>
+struct IsBitsetImpl : std::false_type {};
+template <template <size_t> class B, size_t N>
+struct IsBitsetImpl<B<N>> : std::is_same<B<N>, std::bitset<N>> {};
+template <typename C>
 using IsBitset = IsBitsetImpl<y_absl::decay_t<C>>;
- 
-template <typename C> 
-struct IsSTLContainer 
+
+template <typename C>
+struct IsSTLContainer
     : y_absl::disjunction<
-          IsArray<C>, IsBitset<C>, IsSpecialization<C, std::deque>, 
-          IsSpecialization<C, std::forward_list>, 
-          IsSpecialization<C, std::list>, IsSpecialization<C, std::map>, 
-          IsSpecialization<C, std::multimap>, IsSpecialization<C, std::set>, 
-          IsSpecialization<C, std::multiset>, 
-          IsSpecialization<C, std::unordered_map>, 
-          IsSpecialization<C, std::unordered_multimap>, 
-          IsSpecialization<C, std::unordered_set>, 
-          IsSpecialization<C, std::unordered_multiset>, 
-          IsSpecialization<C, std::vector>> {}; 
- 
-template <typename C, template <typename...> class T, typename = void> 
-struct IsBaseOfSpecializationImpl : std::false_type {}; 
-// IsBaseOfSpecializationImpl needs multiple partial specializations to SFINAE 
-// on the existence of container dependent types and plug them into the STL 
-// template. 
-template <typename C, template <typename, typename> class T> 
-struct IsBaseOfSpecializationImpl< 
+          IsArray<C>, IsBitset<C>, IsSpecialization<C, std::deque>,
+          IsSpecialization<C, std::forward_list>,
+          IsSpecialization<C, std::list>, IsSpecialization<C, std::map>,
+          IsSpecialization<C, std::multimap>, IsSpecialization<C, std::set>,
+          IsSpecialization<C, std::multiset>,
+          IsSpecialization<C, std::unordered_map>,
+          IsSpecialization<C, std::unordered_multimap>,
+          IsSpecialization<C, std::unordered_set>,
+          IsSpecialization<C, std::unordered_multiset>,
+          IsSpecialization<C, std::vector>> {};
+
+template <typename C, template <typename...> class T, typename = void>
+struct IsBaseOfSpecializationImpl : std::false_type {};
+// IsBaseOfSpecializationImpl needs multiple partial specializations to SFINAE
+// on the existence of container dependent types and plug them into the STL
+// template.
+template <typename C, template <typename, typename> class T>
+struct IsBaseOfSpecializationImpl<
     C, T, y_absl::void_t<typename C::value_type, typename C::allocator_type>>
-    : std::is_base_of<C, 
-                      T<typename C::value_type, typename C::allocator_type>> {}; 
-template <typename C, template <typename, typename, typename> class T> 
-struct IsBaseOfSpecializationImpl< 
-    C, T, 
+    : std::is_base_of<C,
+                      T<typename C::value_type, typename C::allocator_type>> {};
+template <typename C, template <typename, typename, typename> class T>
+struct IsBaseOfSpecializationImpl<
+    C, T,
     y_absl::void_t<typename C::key_type, typename C::key_compare,
-                 typename C::allocator_type>> 
-    : std::is_base_of<C, T<typename C::key_type, typename C::key_compare, 
-                           typename C::allocator_type>> {}; 
-template <typename C, template <typename, typename, typename, typename> class T> 
-struct IsBaseOfSpecializationImpl< 
-    C, T, 
+                 typename C::allocator_type>>
+    : std::is_base_of<C, T<typename C::key_type, typename C::key_compare,
+                           typename C::allocator_type>> {};
+template <typename C, template <typename, typename, typename, typename> class T>
+struct IsBaseOfSpecializationImpl<
+    C, T,
     y_absl::void_t<typename C::key_type, typename C::mapped_type,
-                 typename C::key_compare, typename C::allocator_type>> 
-    : std::is_base_of<C, 
-                      T<typename C::key_type, typename C::mapped_type, 
-                        typename C::key_compare, typename C::allocator_type>> { 
-}; 
-template <typename C, template <typename, typename, typename, typename> class T> 
-struct IsBaseOfSpecializationImpl< 
-    C, T, 
+                 typename C::key_compare, typename C::allocator_type>>
+    : std::is_base_of<C,
+                      T<typename C::key_type, typename C::mapped_type,
+                        typename C::key_compare, typename C::allocator_type>> {
+};
+template <typename C, template <typename, typename, typename, typename> class T>
+struct IsBaseOfSpecializationImpl<
+    C, T,
     y_absl::void_t<typename C::key_type, typename C::hasher,
-                 typename C::key_equal, typename C::allocator_type>> 
-    : std::is_base_of<C, T<typename C::key_type, typename C::hasher, 
-                           typename C::key_equal, typename C::allocator_type>> { 
-}; 
-template <typename C, 
-          template <typename, typename, typename, typename, typename> class T> 
-struct IsBaseOfSpecializationImpl< 
-    C, T, 
+                 typename C::key_equal, typename C::allocator_type>>
+    : std::is_base_of<C, T<typename C::key_type, typename C::hasher,
+                           typename C::key_equal, typename C::allocator_type>> {
+};
+template <typename C,
+          template <typename, typename, typename, typename, typename> class T>
+struct IsBaseOfSpecializationImpl<
+    C, T,
     y_absl::void_t<typename C::key_type, typename C::mapped_type,
-                 typename C::hasher, typename C::key_equal, 
-                 typename C::allocator_type>> 
-    : std::is_base_of<C, T<typename C::key_type, typename C::mapped_type, 
-                           typename C::hasher, typename C::key_equal, 
-                           typename C::allocator_type>> {}; 
-template <typename C, template <typename...> class T> 
+                 typename C::hasher, typename C::key_equal,
+                 typename C::allocator_type>>
+    : std::is_base_of<C, T<typename C::key_type, typename C::mapped_type,
+                           typename C::hasher, typename C::key_equal,
+                           typename C::allocator_type>> {};
+template <typename C, template <typename...> class T>
 using IsBaseOfSpecialization = IsBaseOfSpecializationImpl<y_absl::decay_t<C>, T>;
- 
-template <typename C> 
-struct IsBaseOfArrayImpl : std::false_type {}; 
-template <template <typename, size_t> class A, typename T, size_t N> 
-struct IsBaseOfArrayImpl<A<T, N>> : std::is_base_of<A<T, N>, std::array<T, N>> { 
-}; 
-template <typename C> 
+
+template <typename C>
+struct IsBaseOfArrayImpl : std::false_type {};
+template <template <typename, size_t> class A, typename T, size_t N>
+struct IsBaseOfArrayImpl<A<T, N>> : std::is_base_of<A<T, N>, std::array<T, N>> {
+};
+template <typename C>
 using IsBaseOfArray = IsBaseOfArrayImpl<y_absl::decay_t<C>>;
- 
-template <typename C> 
-struct IsBaseOfBitsetImpl : std::false_type {}; 
-template <template <size_t> class B, size_t N> 
-struct IsBaseOfBitsetImpl<B<N>> : std::is_base_of<B<N>, std::bitset<N>> {}; 
-template <typename C> 
+
+template <typename C>
+struct IsBaseOfBitsetImpl : std::false_type {};
+template <template <size_t> class B, size_t N>
+struct IsBaseOfBitsetImpl<B<N>> : std::is_base_of<B<N>, std::bitset<N>> {};
+template <typename C>
 using IsBaseOfBitset = IsBaseOfBitsetImpl<y_absl::decay_t<C>>;
- 
-template <typename C> 
-struct IsBaseOfSTLContainer 
+
+template <typename C>
+struct IsBaseOfSTLContainer
     : y_absl::disjunction<IsBaseOfArray<C>, IsBaseOfBitset<C>,
-                        IsBaseOfSpecialization<C, std::deque>, 
-                        IsBaseOfSpecialization<C, std::forward_list>, 
-                        IsBaseOfSpecialization<C, std::list>, 
-                        IsBaseOfSpecialization<C, std::map>, 
-                        IsBaseOfSpecialization<C, std::multimap>, 
-                        IsBaseOfSpecialization<C, std::set>, 
-                        IsBaseOfSpecialization<C, std::multiset>, 
-                        IsBaseOfSpecialization<C, std::unordered_map>, 
-                        IsBaseOfSpecialization<C, std::unordered_multimap>, 
-                        IsBaseOfSpecialization<C, std::unordered_set>, 
-                        IsBaseOfSpecialization<C, std::unordered_multiset>, 
-                        IsBaseOfSpecialization<C, std::vector>> {}; 
- 
-template <typename C, template <typename...> class T, typename = void> 
-struct IsConvertibleToSpecializationImpl : std::false_type {}; 
-// IsConvertibleToSpecializationImpl needs multiple partial specializations to 
-// SFINAE on the existence of container dependent types and plug them into the 
-// STL template. 
-template <typename C, template <typename, typename> class T> 
-struct IsConvertibleToSpecializationImpl< 
+                        IsBaseOfSpecialization<C, std::deque>,
+                        IsBaseOfSpecialization<C, std::forward_list>,
+                        IsBaseOfSpecialization<C, std::list>,
+                        IsBaseOfSpecialization<C, std::map>,
+                        IsBaseOfSpecialization<C, std::multimap>,
+                        IsBaseOfSpecialization<C, std::set>,
+                        IsBaseOfSpecialization<C, std::multiset>,
+                        IsBaseOfSpecialization<C, std::unordered_map>,
+                        IsBaseOfSpecialization<C, std::unordered_multimap>,
+                        IsBaseOfSpecialization<C, std::unordered_set>,
+                        IsBaseOfSpecialization<C, std::unordered_multiset>,
+                        IsBaseOfSpecialization<C, std::vector>> {};
+
+template <typename C, template <typename...> class T, typename = void>
+struct IsConvertibleToSpecializationImpl : std::false_type {};
+// IsConvertibleToSpecializationImpl needs multiple partial specializations to
+// SFINAE on the existence of container dependent types and plug them into the
+// STL template.
+template <typename C, template <typename, typename> class T>
+struct IsConvertibleToSpecializationImpl<
     C, T, y_absl::void_t<typename C::value_type, typename C::allocator_type>>
-    : std::is_convertible< 
-          C, T<typename C::value_type, typename C::allocator_type>> {}; 
-template <typename C, template <typename, typename, typename> class T> 
-struct IsConvertibleToSpecializationImpl< 
-    C, T, 
+    : std::is_convertible<
+          C, T<typename C::value_type, typename C::allocator_type>> {};
+template <typename C, template <typename, typename, typename> class T>
+struct IsConvertibleToSpecializationImpl<
+    C, T,
     y_absl::void_t<typename C::key_type, typename C::key_compare,
-                 typename C::allocator_type>> 
-    : std::is_convertible<C, T<typename C::key_type, typename C::key_compare, 
-                               typename C::allocator_type>> {}; 
-template <typename C, template <typename, typename, typename, typename> class T> 
-struct IsConvertibleToSpecializationImpl< 
-    C, T, 
+                 typename C::allocator_type>>
+    : std::is_convertible<C, T<typename C::key_type, typename C::key_compare,
+                               typename C::allocator_type>> {};
+template <typename C, template <typename, typename, typename, typename> class T>
+struct IsConvertibleToSpecializationImpl<
+    C, T,
     y_absl::void_t<typename C::key_type, typename C::mapped_type,
-                 typename C::key_compare, typename C::allocator_type>> 
-    : std::is_convertible< 
-          C, T<typename C::key_type, typename C::mapped_type, 
-               typename C::key_compare, typename C::allocator_type>> {}; 
-template <typename C, template <typename, typename, typename, typename> class T> 
-struct IsConvertibleToSpecializationImpl< 
-    C, T, 
+                 typename C::key_compare, typename C::allocator_type>>
+    : std::is_convertible<
+          C, T<typename C::key_type, typename C::mapped_type,
+               typename C::key_compare, typename C::allocator_type>> {};
+template <typename C, template <typename, typename, typename, typename> class T>
+struct IsConvertibleToSpecializationImpl<
+    C, T,
     y_absl::void_t<typename C::key_type, typename C::hasher,
-                 typename C::key_equal, typename C::allocator_type>> 
-    : std::is_convertible< 
-          C, T<typename C::key_type, typename C::hasher, typename C::key_equal, 
-               typename C::allocator_type>> {}; 
-template <typename C, 
-          template <typename, typename, typename, typename, typename> class T> 
-struct IsConvertibleToSpecializationImpl< 
-    C, T, 
+                 typename C::key_equal, typename C::allocator_type>>
+    : std::is_convertible<
+          C, T<typename C::key_type, typename C::hasher, typename C::key_equal,
+               typename C::allocator_type>> {};
+template <typename C,
+          template <typename, typename, typename, typename, typename> class T>
+struct IsConvertibleToSpecializationImpl<
+    C, T,
     y_absl::void_t<typename C::key_type, typename C::mapped_type,
-                 typename C::hasher, typename C::key_equal, 
-                 typename C::allocator_type>> 
-    : std::is_convertible<C, T<typename C::key_type, typename C::mapped_type, 
-                               typename C::hasher, typename C::key_equal, 
-                               typename C::allocator_type>> {}; 
-template <typename C, template <typename...> class T> 
-using IsConvertibleToSpecialization = 
+                 typename C::hasher, typename C::key_equal,
+                 typename C::allocator_type>>
+    : std::is_convertible<C, T<typename C::key_type, typename C::mapped_type,
+                               typename C::hasher, typename C::key_equal,
+                               typename C::allocator_type>> {};
+template <typename C, template <typename...> class T>
+using IsConvertibleToSpecialization =
     IsConvertibleToSpecializationImpl<y_absl::decay_t<C>, T>;
- 
-template <typename C> 
-struct IsConvertibleToArrayImpl : std::false_type {}; 
-template <template <typename, size_t> class A, typename T, size_t N> 
-struct IsConvertibleToArrayImpl<A<T, N>> 
-    : std::is_convertible<A<T, N>, std::array<T, N>> {}; 
-template <typename C> 
+
+template <typename C>
+struct IsConvertibleToArrayImpl : std::false_type {};
+template <template <typename, size_t> class A, typename T, size_t N>
+struct IsConvertibleToArrayImpl<A<T, N>>
+    : std::is_convertible<A<T, N>, std::array<T, N>> {};
+template <typename C>
 using IsConvertibleToArray = IsConvertibleToArrayImpl<y_absl::decay_t<C>>;
- 
-template <typename C> 
-struct IsConvertibleToBitsetImpl : std::false_type {}; 
-template <template <size_t> class B, size_t N> 
-struct IsConvertibleToBitsetImpl<B<N>> 
-    : std::is_convertible<B<N>, std::bitset<N>> {}; 
-template <typename C> 
+
+template <typename C>
+struct IsConvertibleToBitsetImpl : std::false_type {};
+template <template <size_t> class B, size_t N>
+struct IsConvertibleToBitsetImpl<B<N>>
+    : std::is_convertible<B<N>, std::bitset<N>> {};
+template <typename C>
 using IsConvertibleToBitset = IsConvertibleToBitsetImpl<y_absl::decay_t<C>>;
- 
-template <typename C> 
-struct IsConvertibleToSTLContainer 
+
+template <typename C>
+struct IsConvertibleToSTLContainer
     : y_absl::disjunction<
-          IsConvertibleToArray<C>, IsConvertibleToBitset<C>, 
-          IsConvertibleToSpecialization<C, std::deque>, 
-          IsConvertibleToSpecialization<C, std::forward_list>, 
-          IsConvertibleToSpecialization<C, std::list>, 
-          IsConvertibleToSpecialization<C, std::map>, 
-          IsConvertibleToSpecialization<C, std::multimap>, 
-          IsConvertibleToSpecialization<C, std::set>, 
-          IsConvertibleToSpecialization<C, std::multiset>, 
-          IsConvertibleToSpecialization<C, std::unordered_map>, 
-          IsConvertibleToSpecialization<C, std::unordered_multimap>, 
-          IsConvertibleToSpecialization<C, std::unordered_set>, 
-          IsConvertibleToSpecialization<C, std::unordered_multiset>, 
-          IsConvertibleToSpecialization<C, std::vector>> {}; 
- 
-template <typename C> 
-struct IsStrictlyBaseOfAndConvertibleToSTLContainer 
+          IsConvertibleToArray<C>, IsConvertibleToBitset<C>,
+          IsConvertibleToSpecialization<C, std::deque>,
+          IsConvertibleToSpecialization<C, std::forward_list>,
+          IsConvertibleToSpecialization<C, std::list>,
+          IsConvertibleToSpecialization<C, std::map>,
+          IsConvertibleToSpecialization<C, std::multimap>,
+          IsConvertibleToSpecialization<C, std::set>,
+          IsConvertibleToSpecialization<C, std::multiset>,
+          IsConvertibleToSpecialization<C, std::unordered_map>,
+          IsConvertibleToSpecialization<C, std::unordered_multimap>,
+          IsConvertibleToSpecialization<C, std::unordered_set>,
+          IsConvertibleToSpecialization<C, std::unordered_multiset>,
+          IsConvertibleToSpecialization<C, std::vector>> {};
+
+template <typename C>
+struct IsStrictlyBaseOfAndConvertibleToSTLContainer
     : y_absl::conjunction<y_absl::negation<IsSTLContainer<C>>,
-                        IsBaseOfSTLContainer<C>, 
-                        IsConvertibleToSTLContainer<C>> {}; 
- 
-}  // namespace strings_internal 
+                        IsBaseOfSTLContainer<C>,
+                        IsConvertibleToSTLContainer<C>> {};
+
+}  // namespace strings_internal
 ABSL_NAMESPACE_END
 }  // namespace y_absl
-#endif  // ABSL_STRINGS_INTERNAL_STL_TYPE_TRAITS_H_ 
+#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 a421ea6cbb..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
@@ -1,5 +1,5 @@
 // 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
@@ -13,62 +13,62 @@
 // limitations under the License.
 
 //
-// POSIX spec: 
-//   http://pubs.opengroup.org/onlinepubs/009695399/functions/fprintf.html 
-// 
+// POSIX spec:
+//   http://pubs.opengroup.org/onlinepubs/009695399/functions/fprintf.html
+//
 #include "y_absl/strings/internal/str_format/arg.h"
- 
-#include <cassert> 
-#include <cerrno> 
-#include <cstdlib> 
+
+#include <cassert>
+#include <cerrno>
+#include <cstdlib>
 #include <util/generic/string.h>
-#include <type_traits> 
- 
+#include <type_traits>
+
 #include "y_absl/base/port.h"
 #include "y_absl/strings/internal/str_format/float_conversion.h"
 #include "y_absl/strings/numbers.h"
- 
+
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-namespace str_format_internal { 
-namespace { 
- 
-// Reduce *capacity by s.size(), clipped to a 0 minimum. 
-void ReducePadding(string_view s, size_t *capacity) { 
-  *capacity = Excess(s.size(), *capacity); 
-} 
- 
-// Reduce *capacity by n, clipped to a 0 minimum. 
-void ReducePadding(size_t n, size_t *capacity) { 
-  *capacity = Excess(n, *capacity); 
-} 
- 
-template <typename T> 
-struct MakeUnsigned : std::make_unsigned<T> {}; 
-template <> 
+namespace str_format_internal {
+namespace {
+
+// Reduce *capacity by s.size(), clipped to a 0 minimum.
+void ReducePadding(string_view s, size_t *capacity) {
+  *capacity = Excess(s.size(), *capacity);
+}
+
+// Reduce *capacity by n, clipped to a 0 minimum.
+void ReducePadding(size_t n, size_t *capacity) {
+  *capacity = Excess(n, *capacity);
+}
+
+template <typename T>
+struct MakeUnsigned : std::make_unsigned<T> {};
+template <>
 struct MakeUnsigned<y_absl::int128> {
   using type = y_absl::uint128;
-}; 
-template <> 
+};
+template <>
 struct MakeUnsigned<y_absl::uint128> {
   using type = y_absl::uint128;
-}; 
- 
-template <typename T> 
-struct IsSigned : std::is_signed<T> {}; 
-template <> 
+};
+
+template <typename T>
+struct IsSigned : std::is_signed<T> {};
+template <>
 struct IsSigned<y_absl::int128> : std::true_type {};
-template <> 
+template <>
 struct IsSigned<y_absl::uint128> : std::false_type {};
- 
+
 // Integral digit printer.
 // Call one of the PrintAs* routines after construction once.
 // Use with_neg_and_zero/without_neg_or_zero/is_negative to access the results.
 class IntDigits {
- public: 
+ public:
   // Print the unsigned integer as octal.
   // Supports unsigned integral types and uint128.
-  template <typename T> 
+  template <typename T>
   void PrintAsOct(T v) {
     static_assert(!IsSigned<T>::value, "");
     char *p = storage_ + sizeof(storage_);
@@ -95,10 +95,10 @@ class IntDigits {
     if (v < 0) {
       add_neg = true;
       u = uint128{} - u;
-    } 
+    }
     PrintAsDec(u, add_neg);
-  } 
- 
+  }
+
   void PrintAsDec(uint128 v, bool add_neg = false) {
     // This function can be sped up if needed. We can call FastIntToBuffer
     // twice, or fix FastIntToBuffer to support uint128.
@@ -117,11 +117,11 @@ class IntDigits {
     }
     size_ = storage_ + sizeof(storage_) - p;
     start_ = p;
-  } 
- 
+  }
+
   // Print the unsigned integer as hex using lowercase.
   // Supports unsigned integral types and uint128.
-  template <typename T> 
+  template <typename T>
   void PrintAsHexLower(T v) {
     static_assert(!IsSigned<T>::value, "");
     char *p = storage_ + sizeof(storage_);
@@ -136,14 +136,14 @@ class IntDigits {
     if (p[0] == '0') {
       // We printed one too many digits.
       ++p;
-    } 
+    }
     start_ = p;
     size_ = storage_ + sizeof(storage_) - p;
   }
- 
+
   // Print the unsigned integer as hex using uppercase.
   // Supports unsigned integral types and uint128.
-  template <typename T> 
+  template <typename T>
   void PrintAsHexUpper(T v) {
     static_assert(!IsSigned<T>::value, "");
     char *p = storage_ + sizeof(storage_);
@@ -155,8 +155,8 @@ class IntDigits {
     } while (v);
     start_ = p;
     size_ = storage_ + sizeof(storage_) - p;
-  } 
- 
+  }
+
   // The printed value including the '-' sign if available.
   // For inputs of value `0`, this will return "0"
   string_view with_neg_and_zero() const { return {start_, size_}; }
@@ -167,19 +167,19 @@ class IntDigits {
     static_assert('-' < '0', "The check below verifies both.");
     size_t advance = start_[0] <= '0' ? 1 : 0;
     return {start_ + advance, size_ - advance};
-  } 
- 
+  }
+
   bool is_negative() const { return start_[0] == '-'; }
- 
+
  private:
   const char *start_;
   size_t size_;
   // Max size: 128 bit value as octal -> 43 digits, plus sign char
   char storage_[128 / 3 + 1 + 1];
-}; 
- 
-// Note: 'o' conversions do not have a base indicator, it's just that 
-// the '#' flag is specified to modify the precision for 'o' conversions. 
+};
+
+// Note: 'o' conversions do not have a base indicator, it's just that
+// the '#' flag is specified to modify the precision for 'o' conversions.
 string_view BaseIndicator(const IntDigits &as_digits,
                           const FormatConversionSpecImpl conv) {
   // always show 0x for %p.
@@ -188,94 +188,94 @@ string_view BaseIndicator(const IntDigits &as_digits,
   bool hex = (conv.conversion_char() == FormatConversionCharInternal::x ||
               conv.conversion_char() == FormatConversionCharInternal::X ||
               conv.conversion_char() == FormatConversionCharInternal::p);
-  // From the POSIX description of '#' flag: 
-  //   "For x or X conversion specifiers, a non-zero result shall have 
-  //   0x (or 0X) prefixed to it." 
+  // From the POSIX description of '#' flag:
+  //   "For x or X conversion specifiers, a non-zero result shall have
+  //   0x (or 0X) prefixed to it."
   if (alt && hex && !as_digits.without_neg_or_zero().empty()) {
     return conv.conversion_char() == FormatConversionCharInternal::X ? "0X"
                                                                      : "0x";
-  } 
-  return {}; 
-} 
- 
+  }
+  return {};
+}
+
 string_view SignColumn(bool neg, const FormatConversionSpecImpl conv) {
   if (conv.conversion_char() == FormatConversionCharInternal::d ||
       conv.conversion_char() == FormatConversionCharInternal::i) {
-    if (neg) return "-"; 
+    if (neg) return "-";
     if (conv.has_show_pos_flag()) return "+";
     if (conv.has_sign_col_flag()) return " ";
-  } 
-  return {}; 
-} 
- 
+  }
+  return {};
+}
+
 bool ConvertCharImpl(unsigned char v, const FormatConversionSpecImpl conv,
-                     FormatSinkImpl *sink) { 
-  size_t fill = 0; 
-  if (conv.width() >= 0) fill = conv.width(); 
-  ReducePadding(1, &fill); 
+                     FormatSinkImpl *sink) {
+  size_t fill = 0;
+  if (conv.width() >= 0) fill = conv.width();
+  ReducePadding(1, &fill);
   if (!conv.has_left_flag()) sink->Append(fill, ' ');
-  sink->Append(1, v); 
+  sink->Append(1, v);
   if (conv.has_left_flag()) sink->Append(fill, ' ');
-  return true; 
-} 
- 
+  return true;
+}
+
 bool ConvertIntImplInnerSlow(const IntDigits &as_digits,
                              const FormatConversionSpecImpl conv,
                              FormatSinkImpl *sink) {
-  // Print as a sequence of Substrings: 
-  //   [left_spaces][sign][base_indicator][zeroes][formatted][right_spaces] 
-  size_t fill = 0; 
-  if (conv.width() >= 0) fill = conv.width(); 
- 
+  // Print as a sequence of Substrings:
+  //   [left_spaces][sign][base_indicator][zeroes][formatted][right_spaces]
+  size_t fill = 0;
+  if (conv.width() >= 0) fill = conv.width();
+
   string_view formatted = as_digits.without_neg_or_zero();
-  ReducePadding(formatted, &fill); 
- 
+  ReducePadding(formatted, &fill);
+
   string_view sign = SignColumn(as_digits.is_negative(), conv);
-  ReducePadding(sign, &fill); 
- 
+  ReducePadding(sign, &fill);
+
   string_view base_indicator = BaseIndicator(as_digits, conv);
-  ReducePadding(base_indicator, &fill); 
- 
-  int precision = conv.precision(); 
-  bool precision_specified = precision >= 0; 
-  if (!precision_specified) 
-    precision = 1; 
- 
+  ReducePadding(base_indicator, &fill);
+
+  int precision = conv.precision();
+  bool precision_specified = precision >= 0;
+  if (!precision_specified)
+    precision = 1;
+
   if (conv.has_alt_flag() &&
       conv.conversion_char() == FormatConversionCharInternal::o) {
-    // From POSIX description of the '#' (alt) flag: 
-    //   "For o conversion, it increases the precision (if necessary) to 
-    //   force the first digit of the result to be zero." 
-    if (formatted.empty() || *formatted.begin() != '0') { 
-      int needed = static_cast<int>(formatted.size()) + 1; 
-      precision = std::max(precision, needed); 
-    } 
-  } 
- 
-  size_t num_zeroes = Excess(formatted.size(), precision); 
-  ReducePadding(num_zeroes, &fill); 
- 
+    // From POSIX description of the '#' (alt) flag:
+    //   "For o conversion, it increases the precision (if necessary) to
+    //   force the first digit of the result to be zero."
+    if (formatted.empty() || *formatted.begin() != '0') {
+      int needed = static_cast<int>(formatted.size()) + 1;
+      precision = std::max(precision, needed);
+    }
+  }
+
+  size_t num_zeroes = Excess(formatted.size(), precision);
+  ReducePadding(num_zeroes, &fill);
+
   size_t num_left_spaces = !conv.has_left_flag() ? fill : 0;
   size_t num_right_spaces = conv.has_left_flag() ? fill : 0;
- 
-  // From POSIX description of the '0' (zero) flag: 
-  //   "For d, i, o, u, x, and X conversion specifiers, if a precision 
-  //   is specified, the '0' flag is ignored." 
+
+  // From POSIX description of the '0' (zero) flag:
+  //   "For d, i, o, u, x, and X conversion specifiers, if a precision
+  //   is specified, the '0' flag is ignored."
   if (!precision_specified && conv.has_zero_flag()) {
-    num_zeroes += num_left_spaces; 
-    num_left_spaces = 0; 
-  } 
- 
-  sink->Append(num_left_spaces, ' '); 
-  sink->Append(sign); 
-  sink->Append(base_indicator); 
-  sink->Append(num_zeroes, '0'); 
-  sink->Append(formatted); 
-  sink->Append(num_right_spaces, ' '); 
-  return true; 
-} 
- 
-template <typename T> 
+    num_zeroes += num_left_spaces;
+    num_left_spaces = 0;
+  }
+
+  sink->Append(num_left_spaces, ' ');
+  sink->Append(sign);
+  sink->Append(base_indicator);
+  sink->Append(num_zeroes, '0');
+  sink->Append(formatted);
+  sink->Append(num_right_spaces, ' ');
+  return true;
+}
+
+template <typename T>
 bool ConvertIntArg(T v, const FormatConversionSpecImpl conv,
                    FormatSinkImpl *sink) {
   using U = typename MakeUnsigned<T>::type;
@@ -321,168 +321,168 @@ bool ConvertIntArg(T v, const FormatConversionSpecImpl conv,
 
     default:
        ABSL_INTERNAL_ASSUME(false);
-  } 
- 
+  }
+
   if (conv.is_basic()) {
     sink->Append(as_digits.with_neg_and_zero());
     return true;
-  } 
+  }
   return ConvertIntImplInnerSlow(as_digits, conv, sink);
-} 
- 
-template <typename T> 
+}
+
+template <typename T>
 bool ConvertFloatArg(T v, const FormatConversionSpecImpl conv,
                      FormatSinkImpl *sink) {
   return FormatConversionCharIsFloat(conv.conversion_char()) &&
          ConvertFloatImpl(v, conv, sink);
-} 
- 
+}
+
 inline bool ConvertStringArg(string_view v, const FormatConversionSpecImpl conv,
-                             FormatSinkImpl *sink) { 
+                             FormatSinkImpl *sink) {
   if (conv.is_basic()) {
-    sink->Append(v); 
-    return true; 
-  } 
-  return sink->PutPaddedString(v, conv.width(), conv.precision(), 
+    sink->Append(v);
+    return true;
+  }
+  return sink->PutPaddedString(v, conv.width(), conv.precision(),
                                conv.has_left_flag());
-} 
- 
-}  // namespace 
- 
-// ==================== Strings ==================== 
+}
+
+}  // namespace
+
+// ==================== Strings ====================
 StringConvertResult FormatConvertImpl(const TString &v,
                                       const FormatConversionSpecImpl conv,
                                       FormatSinkImpl *sink) {
-  return {ConvertStringArg(v, conv, sink)}; 
-} 
- 
+  return {ConvertStringArg(v, conv, sink)};
+}
+
 StringConvertResult FormatConvertImpl(string_view v,
                                       const FormatConversionSpecImpl conv,
                                       FormatSinkImpl *sink) {
-  return {ConvertStringArg(v, conv, sink)}; 
-} 
- 
+  return {ConvertStringArg(v, conv, sink)};
+}
+
 ArgConvertResult<FormatConversionCharSetUnion(
     FormatConversionCharSetInternal::s, FormatConversionCharSetInternal::p)>
 FormatConvertImpl(const char *v, const FormatConversionSpecImpl conv,
                   FormatSinkImpl *sink) {
   if (conv.conversion_char() == FormatConversionCharInternal::p)
-    return {FormatConvertImpl(VoidPtr(v), conv, sink).value}; 
-  size_t len; 
-  if (v == nullptr) { 
-    len = 0; 
-  } else if (conv.precision() < 0) { 
-    len = std::strlen(v); 
-  } else { 
+    return {FormatConvertImpl(VoidPtr(v), conv, sink).value};
+  size_t len;
+  if (v == nullptr) {
+    len = 0;
+  } else if (conv.precision() < 0) {
+    len = std::strlen(v);
+  } else {
     // 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)}; 
-} 
- 
-// ==================== Raw pointers ==================== 
+    len = std::find(v, v + conv.precision(), '\0') - v;
+  }
+  return {ConvertStringArg(string_view(v, len), conv, sink)};
+}
+
+// ==================== Raw pointers ====================
 ArgConvertResult<FormatConversionCharSetInternal::p> FormatConvertImpl(
     VoidPtr v, const FormatConversionSpecImpl conv, FormatSinkImpl *sink) {
-  if (!v.value) { 
-    sink->Append("(nil)"); 
-    return {true}; 
-  } 
+  if (!v.value) {
+    sink->Append("(nil)");
+    return {true};
+  }
   IntDigits as_digits;
   as_digits.PrintAsHexLower(v.value);
   return {ConvertIntImplInnerSlow(as_digits, conv, sink)};
-} 
- 
-// ==================== Floats ==================== 
+}
+
+// ==================== Floats ====================
 FloatingConvertResult FormatConvertImpl(float v,
                                         const FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink) { 
-  return {ConvertFloatArg(v, conv, sink)}; 
-} 
+                                        FormatSinkImpl *sink) {
+  return {ConvertFloatArg(v, conv, sink)};
+}
 FloatingConvertResult FormatConvertImpl(double v,
                                         const FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink) { 
-  return {ConvertFloatArg(v, conv, sink)}; 
-} 
-FloatingConvertResult FormatConvertImpl(long double v, 
+                                        FormatSinkImpl *sink) {
+  return {ConvertFloatArg(v, conv, sink)};
+}
+FloatingConvertResult FormatConvertImpl(long double v,
                                         const FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink) { 
-  return {ConvertFloatArg(v, conv, sink)}; 
-} 
- 
-// ==================== Chars ==================== 
+                                        FormatSinkImpl *sink) {
+  return {ConvertFloatArg(v, conv, sink)};
+}
+
+// ==================== Chars ====================
 IntegralConvertResult FormatConvertImpl(char v,
                                         const FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink) { 
-  return {ConvertIntArg(v, conv, sink)}; 
-} 
-IntegralConvertResult FormatConvertImpl(signed char v, 
+                                        FormatSinkImpl *sink) {
+  return {ConvertIntArg(v, conv, sink)};
+}
+IntegralConvertResult FormatConvertImpl(signed char v,
                                         const FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink) { 
-  return {ConvertIntArg(v, conv, sink)}; 
-} 
-IntegralConvertResult FormatConvertImpl(unsigned char v, 
+                                        FormatSinkImpl *sink) {
+  return {ConvertIntArg(v, conv, sink)};
+}
+IntegralConvertResult FormatConvertImpl(unsigned char v,
                                         const FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink) { 
-  return {ConvertIntArg(v, conv, sink)}; 
-} 
- 
-// ==================== Ints ==================== 
-IntegralConvertResult FormatConvertImpl(short v,  // NOLINT 
+                                        FormatSinkImpl *sink) {
+  return {ConvertIntArg(v, conv, sink)};
+}
+
+// ==================== Ints ====================
+IntegralConvertResult FormatConvertImpl(short v,  // NOLINT
                                         const FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink) { 
-  return {ConvertIntArg(v, conv, sink)}; 
-} 
-IntegralConvertResult FormatConvertImpl(unsigned short v,  // NOLINT 
+                                        FormatSinkImpl *sink) {
+  return {ConvertIntArg(v, conv, sink)};
+}
+IntegralConvertResult FormatConvertImpl(unsigned short v,  // NOLINT
                                         const FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink) { 
-  return {ConvertIntArg(v, conv, sink)}; 
-} 
+                                        FormatSinkImpl *sink) {
+  return {ConvertIntArg(v, conv, sink)};
+}
 IntegralConvertResult FormatConvertImpl(int v,
                                         const FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink) { 
-  return {ConvertIntArg(v, conv, sink)}; 
-} 
+                                        FormatSinkImpl *sink) {
+  return {ConvertIntArg(v, conv, sink)};
+}
 IntegralConvertResult FormatConvertImpl(unsigned v,
                                         const FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink) { 
-  return {ConvertIntArg(v, conv, sink)}; 
-} 
-IntegralConvertResult FormatConvertImpl(long v,  // NOLINT 
+                                        FormatSinkImpl *sink) {
+  return {ConvertIntArg(v, conv, sink)};
+}
+IntegralConvertResult FormatConvertImpl(long v,  // NOLINT
                                         const FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink) { 
-  return {ConvertIntArg(v, conv, sink)}; 
-} 
-IntegralConvertResult FormatConvertImpl(unsigned long v,  // NOLINT 
+                                        FormatSinkImpl *sink) {
+  return {ConvertIntArg(v, conv, sink)};
+}
+IntegralConvertResult FormatConvertImpl(unsigned long v,  // NOLINT
                                         const FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink) { 
-  return {ConvertIntArg(v, conv, sink)}; 
-} 
-IntegralConvertResult FormatConvertImpl(long long v,  // NOLINT 
+                                        FormatSinkImpl *sink) {
+  return {ConvertIntArg(v, conv, sink)};
+}
+IntegralConvertResult FormatConvertImpl(long long v,  // NOLINT
                                         const FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink) { 
-  return {ConvertIntArg(v, conv, sink)}; 
-} 
-IntegralConvertResult FormatConvertImpl(unsigned long long v,  // NOLINT 
+                                        FormatSinkImpl *sink) {
+  return {ConvertIntArg(v, conv, sink)};
+}
+IntegralConvertResult FormatConvertImpl(unsigned long long v,  // NOLINT
                                         const FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink) { 
-  return {ConvertIntArg(v, conv, sink)}; 
-} 
+                                        FormatSinkImpl *sink) {
+  return {ConvertIntArg(v, conv, sink)};
+}
 IntegralConvertResult FormatConvertImpl(y_absl::int128 v,
                                         const FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink) { 
-  return {ConvertIntArg(v, conv, sink)}; 
-} 
+                                        FormatSinkImpl *sink) {
+  return {ConvertIntArg(v, conv, sink)};
+}
 IntegralConvertResult FormatConvertImpl(y_absl::uint128 v,
                                         const FormatConversionSpecImpl conv,
-                                        FormatSinkImpl *sink) { 
-  return {ConvertIntArg(v, conv, sink)}; 
-} 
- 
-ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_(); 
- 
- 
- 
-}  // namespace str_format_internal 
- 
+                                        FormatSinkImpl *sink) {
+  return {ConvertIntArg(v, conv, sink)};
+}
+
+ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_();
+
+
+
+}  // namespace str_format_internal
+
 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 d10e8a2433..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
@@ -12,52 +12,52 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_ARG_H_ 
-#define ABSL_STRINGS_INTERNAL_STR_FORMAT_ARG_H_ 
- 
-#include <string.h> 
-#include <wchar.h> 
- 
-#include <cstdio> 
-#include <iomanip> 
-#include <limits> 
-#include <memory> 
-#include <sstream> 
+#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_ARG_H_
+#define ABSL_STRINGS_INTERNAL_STR_FORMAT_ARG_H_
+
+#include <string.h>
+#include <wchar.h>
+
+#include <cstdio>
+#include <iomanip>
+#include <limits>
+#include <memory>
+#include <sstream>
 #include <util/generic/string.h>
 #include <util/stream/str.h>
-#include <type_traits> 
- 
+#include <type_traits>
+
 #include "y_absl/base/port.h"
 #include "y_absl/meta/type_traits.h"
 #include "y_absl/numeric/int128.h"
 #include "y_absl/strings/internal/str_format/extension.h"
 #include "y_absl/strings/string_view.h"
- 
+
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
- 
+
 class Cord;
-class FormatCountCapture; 
-class FormatSink; 
- 
+class FormatCountCapture;
+class FormatSink;
+
 template <y_absl::FormatConversionCharSet C>
 struct FormatConvertResult;
 class FormatConversionSpec;
 
-namespace str_format_internal { 
- 
-template <typename T, typename = void> 
-struct HasUserDefinedConvert : std::false_type {}; 
- 
-template <typename T> 
+namespace str_format_internal {
+
+template <typename T, typename = void>
+struct HasUserDefinedConvert : std::false_type {};
+
+template <typename T>
 struct HasUserDefinedConvert<T, void_t<decltype(AbslFormatConvert(
                                     std::declval<const T&>(),
                                     std::declval<const FormatConversionSpec&>(),
                                     std::declval<FormatSink*>()))>>
     : std::true_type {};
- 
+
 void AbslFormatConvert();  // Stops the lexical name lookup
-template <typename T> 
+template <typename T>
 auto FormatConvertImpl(const T& v, FormatConversionSpecImpl conv,
                        FormatSinkImpl* sink)
     -> decltype(AbslFormatConvert(v,
@@ -73,12 +73,12 @@ auto FormatConvertImpl(const T& v, FormatConversionSpecImpl conv,
 }
 
 template <typename T>
-class StreamedWrapper; 
- 
-// If 'v' can be converted (in the printf sense) according to 'conv', 
-// then convert it, appending to `sink` and return `true`. 
-// Otherwise fail and return `false`. 
- 
+class StreamedWrapper;
+
+// If 'v' can be converted (in the printf sense) according to 'conv',
+// then convert it, appending to `sink` and return `true`.
+// Otherwise fail and return `false`.
+
 // AbslFormatConvert(v, conv, sink) is intended to be found by ADL on 'v'
 // as an extension mechanism. These FormatConvertImpl functions are the default
 // implementations.
@@ -86,16 +86,16 @@ class StreamedWrapper;
 // serves as a disambiguator to reject possible unintended 'AbslFormatConvert'
 // functions in the namespaces associated with 'v'.
 
-// Raw pointers. 
-struct VoidPtr { 
-  VoidPtr() = default; 
-  template <typename T, 
-            decltype(reinterpret_cast<uintptr_t>(std::declval<T*>())) = 0> 
-  VoidPtr(T* ptr)  // NOLINT 
-      : value(ptr ? reinterpret_cast<uintptr_t>(ptr) : 0) {} 
-  uintptr_t value; 
-}; 
- 
+// Raw pointers.
+struct VoidPtr {
+  VoidPtr() = default;
+  template <typename T,
+            decltype(reinterpret_cast<uintptr_t>(std::declval<T*>())) = 0>
+  VoidPtr(T* ptr)  // NOLINT
+      : value(ptr ? reinterpret_cast<uintptr_t>(ptr) : 0) {}
+  uintptr_t value;
+};
+
 template <FormatConversionCharSet C>
 struct ArgConvertResult {
   bool value;
@@ -116,7 +116,7 @@ using StringConvertResult =
 ArgConvertResult<FormatConversionCharSetInternal::p> FormatConvertImpl(
     VoidPtr v, FormatConversionSpecImpl conv, FormatSinkImpl* sink);
 
-// Strings. 
+// Strings.
 StringConvertResult FormatConvertImpl(const TString& v,
                                       FormatConversionSpecImpl conv,
                                       FormatSinkImpl* sink);
@@ -135,28 +135,28 @@ ArgConvertResult<FormatConversionCharSetUnion(
     FormatConversionCharSetInternal::s, FormatConversionCharSetInternal::p)>
 FormatConvertImpl(const char* v, const FormatConversionSpecImpl conv,
                   FormatSinkImpl* sink);
- 
+
 template <class AbslCord, typename std::enable_if<std::is_same<
                               AbslCord, y_absl::Cord>::value>::type* = nullptr>
 StringConvertResult FormatConvertImpl(const AbslCord& value,
                                       FormatConversionSpecImpl conv,
                                       FormatSinkImpl* sink) {
   bool is_left = conv.has_left_flag();
-  size_t space_remaining = 0; 
- 
-  int width = conv.width(); 
-  if (width >= 0) space_remaining = width; 
- 
-  size_t to_write = value.size(); 
- 
-  int precision = conv.precision(); 
-  if (precision >= 0) 
-    to_write = (std::min)(to_write, static_cast<size_t>(precision)); 
- 
-  space_remaining = Excess(to_write, space_remaining); 
- 
-  if (space_remaining > 0 && !is_left) sink->Append(space_remaining, ' '); 
- 
+  size_t space_remaining = 0;
+
+  int width = conv.width();
+  if (width >= 0) space_remaining = width;
+
+  size_t to_write = value.size();
+
+  int precision = conv.precision();
+  if (precision >= 0)
+    to_write = (std::min)(to_write, static_cast<size_t>(precision));
+
+  space_remaining = Excess(to_write, space_remaining);
+
+  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);
@@ -164,143 +164,143 @@ StringConvertResult FormatConvertImpl(const AbslCord& value,
     } else {
       to_write -= piece.size();
     }
-    sink->Append(piece); 
+    sink->Append(piece);
     if (to_write == 0) {
       break;
     }
-  } 
- 
-  if (space_remaining > 0 && is_left) sink->Append(space_remaining, ' '); 
-  return {true}; 
-} 
- 
+  }
+
+  if (space_remaining > 0 && is_left) sink->Append(space_remaining, ' ');
+  return {true};
+}
+
 using IntegralConvertResult = ArgConvertResult<FormatConversionCharSetUnion(
     FormatConversionCharSetInternal::c,
     FormatConversionCharSetInternal::kNumeric,
     FormatConversionCharSetInternal::kStar)>;
 using FloatingConvertResult =
     ArgConvertResult<FormatConversionCharSetInternal::kFloating>;
- 
-// Floats. 
+
+// Floats.
 FloatingConvertResult FormatConvertImpl(float v, FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink); 
+                                        FormatSinkImpl* sink);
 FloatingConvertResult FormatConvertImpl(double v, FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink); 
+                                        FormatSinkImpl* sink);
 FloatingConvertResult FormatConvertImpl(long double v,
                                         FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink); 
- 
-// Chars. 
+                                        FormatSinkImpl* sink);
+
+// Chars.
 IntegralConvertResult FormatConvertImpl(char v, FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink); 
+                                        FormatSinkImpl* sink);
 IntegralConvertResult FormatConvertImpl(signed char v,
                                         FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink); 
+                                        FormatSinkImpl* sink);
 IntegralConvertResult FormatConvertImpl(unsigned char v,
                                         FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink); 
- 
-// Ints. 
-IntegralConvertResult FormatConvertImpl(short v,  // NOLINT 
+                                        FormatSinkImpl* sink);
+
+// Ints.
+IntegralConvertResult FormatConvertImpl(short v,  // NOLINT
                                         FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink); 
-IntegralConvertResult FormatConvertImpl(unsigned short v,  // NOLINT 
+                                        FormatSinkImpl* sink);
+IntegralConvertResult FormatConvertImpl(unsigned short v,  // NOLINT
                                         FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink); 
+                                        FormatSinkImpl* sink);
 IntegralConvertResult FormatConvertImpl(int v, FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink); 
+                                        FormatSinkImpl* sink);
 IntegralConvertResult FormatConvertImpl(unsigned v,
                                         FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink); 
-IntegralConvertResult FormatConvertImpl(long v,  // NOLINT 
+                                        FormatSinkImpl* sink);
+IntegralConvertResult FormatConvertImpl(long v,  // NOLINT
                                         FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink); 
-IntegralConvertResult FormatConvertImpl(unsigned long v,  // NOLINT 
+                                        FormatSinkImpl* sink);
+IntegralConvertResult FormatConvertImpl(unsigned long v,  // NOLINT
                                         FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink); 
-IntegralConvertResult FormatConvertImpl(long long v,  // NOLINT 
+                                        FormatSinkImpl* sink);
+IntegralConvertResult FormatConvertImpl(long long v,  // NOLINT
                                         FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink); 
-IntegralConvertResult FormatConvertImpl(unsigned long long v,  // NOLINT 
+                                        FormatSinkImpl* sink);
+IntegralConvertResult FormatConvertImpl(unsigned long long v,  // NOLINT
                                         FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink); 
+                                        FormatSinkImpl* sink);
 IntegralConvertResult FormatConvertImpl(int128 v, FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink); 
+                                        FormatSinkImpl* sink);
 IntegralConvertResult FormatConvertImpl(uint128 v,
                                         FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink); 
-template <typename T, enable_if_t<std::is_same<T, bool>::value, int> = 0> 
+                                        FormatSinkImpl* sink);
+template <typename T, enable_if_t<std::is_same<T, bool>::value, int> = 0>
 IntegralConvertResult FormatConvertImpl(T v, FormatConversionSpecImpl conv,
-                                        FormatSinkImpl* sink) { 
-  return FormatConvertImpl(static_cast<int>(v), conv, sink); 
-} 
- 
-// We provide this function to help the checker, but it is never defined. 
-// FormatArgImpl will use the underlying Convert functions instead. 
-template <typename T> 
-typename std::enable_if<std::is_enum<T>::value && 
-                            !HasUserDefinedConvert<T>::value, 
-                        IntegralConvertResult>::type 
+                                        FormatSinkImpl* sink) {
+  return FormatConvertImpl(static_cast<int>(v), conv, sink);
+}
+
+// We provide this function to help the checker, but it is never defined.
+// FormatArgImpl will use the underlying Convert functions instead.
+template <typename T>
+typename std::enable_if<std::is_enum<T>::value &&
+                            !HasUserDefinedConvert<T>::value,
+                        IntegralConvertResult>::type
 FormatConvertImpl(T v, FormatConversionSpecImpl conv, FormatSinkImpl* sink);
- 
-template <typename T> 
+
+template <typename T>
 StringConvertResult FormatConvertImpl(const StreamedWrapper<T>& v,
                                       FormatConversionSpecImpl conv,
                                       FormatSinkImpl* out) {
   TString buf;
   TStringOutput oss(buf);
-  oss << v.v_; 
+  oss << v.v_;
   if (!buf) return {false};
   return str_format_internal::FormatConvertImpl(buf, conv, out);
-} 
- 
-// Use templates and dependent types to delay evaluation of the function 
-// until after FormatCountCapture is fully defined. 
-struct FormatCountCaptureHelper { 
-  template <class T = int> 
+}
+
+// Use templates and dependent types to delay evaluation of the function
+// until after FormatCountCapture is fully defined.
+struct FormatCountCaptureHelper {
+  template <class T = int>
   static ArgConvertResult<FormatConversionCharSetInternal::n> ConvertHelper(
       const FormatCountCapture& v, FormatConversionSpecImpl conv,
       FormatSinkImpl* sink) {
     const y_absl::enable_if_t<sizeof(T) != 0, FormatCountCapture>& v2 = v;
- 
+
     if (conv.conversion_char() !=
         str_format_internal::FormatConversionCharInternal::n) {
       return {false};
     }
-    *v2.p_ = static_cast<int>(sink->size()); 
-    return {true}; 
-  } 
-}; 
- 
-template <class T = int> 
+    *v2.p_ = static_cast<int>(sink->size());
+    return {true};
+  }
+};
+
+template <class T = int>
 ArgConvertResult<FormatConversionCharSetInternal::n> FormatConvertImpl(
     const FormatCountCapture& v, FormatConversionSpecImpl conv,
     FormatSinkImpl* sink) {
-  return FormatCountCaptureHelper::ConvertHelper(v, conv, sink); 
-} 
- 
-// Helper friend struct to hide implementation details from the public API of 
-// FormatArgImpl. 
-struct FormatArgImplFriend { 
-  template <typename Arg> 
-  static bool ToInt(Arg arg, int* out) { 
+  return FormatCountCaptureHelper::ConvertHelper(v, conv, sink);
+}
+
+// Helper friend struct to hide implementation details from the public API of
+// FormatArgImpl.
+struct FormatArgImplFriend {
+  template <typename Arg>
+  static bool ToInt(Arg arg, int* out) {
     // A value initialized FormatConversionSpecImpl has a `none` conv, which
     // tells the dispatcher to run the `int` conversion.
-    return arg.dispatcher_(arg.data_, {}, out); 
-  } 
- 
-  template <typename Arg> 
+    return arg.dispatcher_(arg.data_, {}, out);
+  }
+
+  template <typename Arg>
   static bool Convert(Arg arg, FormatConversionSpecImpl conv,
-                      FormatSinkImpl* out) { 
-    return arg.dispatcher_(arg.data_, conv, out); 
-  } 
- 
-  template <typename Arg> 
-  static typename Arg::Dispatcher GetVTablePtrForTest(Arg arg) { 
-    return arg.dispatcher_; 
-  } 
-}; 
- 
+                      FormatSinkImpl* out) {
+    return arg.dispatcher_(arg.data_, conv, out);
+  }
+
+  template <typename Arg>
+  static typename Arg::Dispatcher GetVTablePtrForTest(Arg arg) {
+    return arg.dispatcher_;
+  }
+};
+
 template <typename Arg>
 constexpr FormatConversionCharSet ArgumentToConv() {
   return y_absl::str_format_internal::ExtractCharSet(
@@ -310,219 +310,219 @@ constexpr FormatConversionCharSet ArgumentToConv() {
           std::declval<FormatSinkImpl*>())){});
 }
 
-// A type-erased handle to a format argument. 
-class FormatArgImpl { 
- private: 
-  enum { kInlinedSpace = 8 }; 
- 
-  using VoidPtr = str_format_internal::VoidPtr; 
- 
-  union Data { 
-    const void* ptr; 
-    const volatile void* volatile_ptr; 
-    char buf[kInlinedSpace]; 
-  }; 
- 
+// A type-erased handle to a format argument.
+class FormatArgImpl {
+ private:
+  enum { kInlinedSpace = 8 };
+
+  using VoidPtr = str_format_internal::VoidPtr;
+
+  union Data {
+    const void* ptr;
+    const volatile void* volatile_ptr;
+    char buf[kInlinedSpace];
+  };
+
   using Dispatcher = bool (*)(Data, FormatConversionSpecImpl, void* out);
- 
-  template <typename T> 
-  struct store_by_value 
-      : std::integral_constant<bool, (sizeof(T) <= kInlinedSpace) && 
-                                         (std::is_integral<T>::value || 
-                                          std::is_floating_point<T>::value || 
-                                          std::is_pointer<T>::value || 
-                                          std::is_same<VoidPtr, T>::value)> {}; 
- 
-  enum StoragePolicy { ByPointer, ByVolatilePointer, ByValue }; 
-  template <typename T> 
-  struct storage_policy 
-      : std::integral_constant<StoragePolicy, 
-                               (std::is_volatile<T>::value 
-                                    ? ByVolatilePointer 
-                                    : (store_by_value<T>::value ? ByValue 
-                                                                : ByPointer))> { 
-  }; 
- 
-  // To reduce the number of vtables we will decay values before hand. 
-  // Anything with a user-defined Convert will get its own vtable. 
-  // For everything else: 
-  //   - Decay char* and char arrays into `const char*` 
-  //   - Decay any other pointer to `const void*` 
-  //   - Decay all enums to their underlying type. 
-  //   - Decay function pointers to void*. 
-  template <typename T, typename = void> 
-  struct DecayType { 
-    static constexpr bool kHasUserDefined = 
-        str_format_internal::HasUserDefinedConvert<T>::value; 
-    using type = typename std::conditional< 
-        !kHasUserDefined && std::is_convertible<T, const char*>::value, 
-        const char*, 
-        typename std::conditional<!kHasUserDefined && 
-                                      std::is_convertible<T, VoidPtr>::value, 
-                                  VoidPtr, const T&>::type>::type; 
-  }; 
-  template <typename T> 
-  struct DecayType<T, 
-                   typename std::enable_if< 
-                       !str_format_internal::HasUserDefinedConvert<T>::value && 
-                       std::is_enum<T>::value>::type> { 
-    using type = typename std::underlying_type<T>::type; 
-  }; 
- 
- public: 
-  template <typename T> 
-  explicit FormatArgImpl(const T& value) { 
-    using D = typename DecayType<T>::type; 
-    static_assert( 
-        std::is_same<D, const T&>::value || storage_policy<D>::value == ByValue, 
-        "Decayed types must be stored by value"); 
-    Init(static_cast<D>(value)); 
-  } 
- 
- private: 
-  friend struct str_format_internal::FormatArgImplFriend; 
-  template <typename T, StoragePolicy = storage_policy<T>::value> 
-  struct Manager; 
- 
-  template <typename T> 
-  struct Manager<T, ByPointer> { 
-    static Data SetValue(const T& value) { 
-      Data data; 
-      data.ptr = std::addressof(value); 
-      return data; 
-    } 
- 
-    static const T& Value(Data arg) { return *static_cast<const T*>(arg.ptr); } 
-  }; 
- 
-  template <typename T> 
-  struct Manager<T, ByVolatilePointer> { 
-    static Data SetValue(const T& value) { 
-      Data data; 
-      data.volatile_ptr = &value; 
-      return data; 
-    } 
- 
-    static const T& Value(Data arg) { 
-      return *static_cast<const T*>(arg.volatile_ptr); 
-    } 
-  }; 
- 
-  template <typename T> 
-  struct Manager<T, ByValue> { 
-    static Data SetValue(const T& value) { 
-      Data data; 
-      memcpy(data.buf, &value, sizeof(value)); 
-      return data; 
-    } 
- 
-    static T Value(Data arg) { 
-      T value; 
-      memcpy(&value, arg.buf, sizeof(T)); 
-      return value; 
-    } 
-  }; 
- 
-  template <typename T> 
-  void Init(const T& value) { 
-    data_ = Manager<T>::SetValue(value); 
-    dispatcher_ = &Dispatch<T>; 
-  } 
- 
-  template <typename T> 
-  static int ToIntVal(const T& val) { 
-    using CommonType = typename std::conditional<std::is_signed<T>::value, 
-                                                 int64_t, uint64_t>::type; 
-    if (static_cast<CommonType>(val) > 
-        static_cast<CommonType>((std::numeric_limits<int>::max)())) { 
-      return (std::numeric_limits<int>::max)(); 
-    } else if (std::is_signed<T>::value && 
-               static_cast<CommonType>(val) < 
-                   static_cast<CommonType>((std::numeric_limits<int>::min)())) { 
-      return (std::numeric_limits<int>::min)(); 
-    } 
-    return static_cast<int>(val); 
-  } 
- 
-  template <typename T> 
-  static bool ToInt(Data arg, int* out, std::true_type /* is_integral */, 
-                    std::false_type) { 
-    *out = ToIntVal(Manager<T>::Value(arg)); 
-    return true; 
-  } 
- 
-  template <typename T> 
-  static bool ToInt(Data arg, int* out, std::false_type, 
-                    std::true_type /* is_enum */) { 
-    *out = ToIntVal(static_cast<typename std::underlying_type<T>::type>( 
-        Manager<T>::Value(arg))); 
-    return true; 
-  } 
- 
-  template <typename T> 
-  static bool ToInt(Data, int*, std::false_type, std::false_type) { 
-    return false; 
-  } 
- 
-  template <typename T> 
+
+  template <typename T>
+  struct store_by_value
+      : std::integral_constant<bool, (sizeof(T) <= kInlinedSpace) &&
+                                         (std::is_integral<T>::value ||
+                                          std::is_floating_point<T>::value ||
+                                          std::is_pointer<T>::value ||
+                                          std::is_same<VoidPtr, T>::value)> {};
+
+  enum StoragePolicy { ByPointer, ByVolatilePointer, ByValue };
+  template <typename T>
+  struct storage_policy
+      : std::integral_constant<StoragePolicy,
+                               (std::is_volatile<T>::value
+                                    ? ByVolatilePointer
+                                    : (store_by_value<T>::value ? ByValue
+                                                                : ByPointer))> {
+  };
+
+  // To reduce the number of vtables we will decay values before hand.
+  // Anything with a user-defined Convert will get its own vtable.
+  // For everything else:
+  //   - Decay char* and char arrays into `const char*`
+  //   - Decay any other pointer to `const void*`
+  //   - Decay all enums to their underlying type.
+  //   - Decay function pointers to void*.
+  template <typename T, typename = void>
+  struct DecayType {
+    static constexpr bool kHasUserDefined =
+        str_format_internal::HasUserDefinedConvert<T>::value;
+    using type = typename std::conditional<
+        !kHasUserDefined && std::is_convertible<T, const char*>::value,
+        const char*,
+        typename std::conditional<!kHasUserDefined &&
+                                      std::is_convertible<T, VoidPtr>::value,
+                                  VoidPtr, const T&>::type>::type;
+  };
+  template <typename T>
+  struct DecayType<T,
+                   typename std::enable_if<
+                       !str_format_internal::HasUserDefinedConvert<T>::value &&
+                       std::is_enum<T>::value>::type> {
+    using type = typename std::underlying_type<T>::type;
+  };
+
+ public:
+  template <typename T>
+  explicit FormatArgImpl(const T& value) {
+    using D = typename DecayType<T>::type;
+    static_assert(
+        std::is_same<D, const T&>::value || storage_policy<D>::value == ByValue,
+        "Decayed types must be stored by value");
+    Init(static_cast<D>(value));
+  }
+
+ private:
+  friend struct str_format_internal::FormatArgImplFriend;
+  template <typename T, StoragePolicy = storage_policy<T>::value>
+  struct Manager;
+
+  template <typename T>
+  struct Manager<T, ByPointer> {
+    static Data SetValue(const T& value) {
+      Data data;
+      data.ptr = std::addressof(value);
+      return data;
+    }
+
+    static const T& Value(Data arg) { return *static_cast<const T*>(arg.ptr); }
+  };
+
+  template <typename T>
+  struct Manager<T, ByVolatilePointer> {
+    static Data SetValue(const T& value) {
+      Data data;
+      data.volatile_ptr = &value;
+      return data;
+    }
+
+    static const T& Value(Data arg) {
+      return *static_cast<const T*>(arg.volatile_ptr);
+    }
+  };
+
+  template <typename T>
+  struct Manager<T, ByValue> {
+    static Data SetValue(const T& value) {
+      Data data;
+      memcpy(data.buf, &value, sizeof(value));
+      return data;
+    }
+
+    static T Value(Data arg) {
+      T value;
+      memcpy(&value, arg.buf, sizeof(T));
+      return value;
+    }
+  };
+
+  template <typename T>
+  void Init(const T& value) {
+    data_ = Manager<T>::SetValue(value);
+    dispatcher_ = &Dispatch<T>;
+  }
+
+  template <typename T>
+  static int ToIntVal(const T& val) {
+    using CommonType = typename std::conditional<std::is_signed<T>::value,
+                                                 int64_t, uint64_t>::type;
+    if (static_cast<CommonType>(val) >
+        static_cast<CommonType>((std::numeric_limits<int>::max)())) {
+      return (std::numeric_limits<int>::max)();
+    } else if (std::is_signed<T>::value &&
+               static_cast<CommonType>(val) <
+                   static_cast<CommonType>((std::numeric_limits<int>::min)())) {
+      return (std::numeric_limits<int>::min)();
+    }
+    return static_cast<int>(val);
+  }
+
+  template <typename T>
+  static bool ToInt(Data arg, int* out, std::true_type /* is_integral */,
+                    std::false_type) {
+    *out = ToIntVal(Manager<T>::Value(arg));
+    return true;
+  }
+
+  template <typename T>
+  static bool ToInt(Data arg, int* out, std::false_type,
+                    std::true_type /* is_enum */) {
+    *out = ToIntVal(static_cast<typename std::underlying_type<T>::type>(
+        Manager<T>::Value(arg)));
+    return true;
+  }
+
+  template <typename T>
+  static bool ToInt(Data, int*, std::false_type, std::false_type) {
+    return false;
+  }
+
+  template <typename T>
   static bool Dispatch(Data arg, FormatConversionSpecImpl spec, void* out) {
-    // A `none` conv indicates that we want the `int` conversion. 
+    // A `none` conv indicates that we want the `int` conversion.
     if (ABSL_PREDICT_FALSE(spec.conversion_char() ==
                            FormatConversionCharInternal::kNone)) {
-      return ToInt<T>(arg, static_cast<int*>(out), std::is_integral<T>(), 
-                      std::is_enum<T>()); 
-    } 
+      return ToInt<T>(arg, static_cast<int*>(out), std::is_integral<T>(),
+                      std::is_enum<T>());
+    }
     if (ABSL_PREDICT_FALSE(!Contains(ArgumentToConv<T>(),
                                      spec.conversion_char()))) {
       return false;
     }
-    return str_format_internal::FormatConvertImpl( 
+    return str_format_internal::FormatConvertImpl(
                Manager<T>::Value(arg), spec,
                static_cast<FormatSinkImpl*>(out))
-        .value; 
-  } 
- 
-  Data data_; 
-  Dispatcher dispatcher_; 
-}; 
- 
+        .value;
+  }
+
+  Data data_;
+  Dispatcher dispatcher_;
+};
+
 #define ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(T, E)                     \
   E template bool FormatArgImpl::Dispatch<T>(Data, FormatConversionSpecImpl, \
                                              void*)
- 
-#define ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_(...)                   \ 
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(str_format_internal::VoidPtr,     \ 
-                                             __VA_ARGS__);                     \ 
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(bool, __VA_ARGS__);               \ 
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(char, __VA_ARGS__);               \ 
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(signed char, __VA_ARGS__);        \ 
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned char, __VA_ARGS__);      \ 
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(short, __VA_ARGS__); /* NOLINT */ \ 
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned short,      /* NOLINT */ \ 
-                                             __VA_ARGS__);                     \ 
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(int, __VA_ARGS__);                \ 
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned int, __VA_ARGS__);       \ 
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(long, __VA_ARGS__); /* NOLINT */  \ 
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned long,      /* NOLINT */  \ 
-                                             __VA_ARGS__);                     \ 
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(long long, /* NOLINT */           \ 
-                                             __VA_ARGS__);                     \ 
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned long long, /* NOLINT */  \ 
-                                             __VA_ARGS__);                     \ 
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(int128, __VA_ARGS__);             \ 
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(uint128, __VA_ARGS__);            \ 
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(float, __VA_ARGS__);              \ 
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(double, __VA_ARGS__);             \ 
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(long double, __VA_ARGS__);        \ 
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(const char*, __VA_ARGS__);        \ 
+
+#define ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_(...)                   \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(str_format_internal::VoidPtr,     \
+                                             __VA_ARGS__);                     \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(bool, __VA_ARGS__);               \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(char, __VA_ARGS__);               \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(signed char, __VA_ARGS__);        \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned char, __VA_ARGS__);      \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(short, __VA_ARGS__); /* NOLINT */ \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned short,      /* NOLINT */ \
+                                             __VA_ARGS__);                     \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(int, __VA_ARGS__);                \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned int, __VA_ARGS__);       \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(long, __VA_ARGS__); /* NOLINT */  \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned long,      /* NOLINT */  \
+                                             __VA_ARGS__);                     \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(long long, /* NOLINT */           \
+                                             __VA_ARGS__);                     \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(unsigned long long, /* NOLINT */  \
+                                             __VA_ARGS__);                     \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(int128, __VA_ARGS__);             \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(uint128, __VA_ARGS__);            \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(float, __VA_ARGS__);              \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(double, __VA_ARGS__);             \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(long double, __VA_ARGS__);        \
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(const char*, __VA_ARGS__);        \
   ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(TString, __VA_ARGS__);        \
-  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(string_view, __VA_ARGS__) 
- 
-ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_(extern); 
- 
- 
-}  // namespace str_format_internal 
+  ABSL_INTERNAL_FORMAT_DISPATCH_INSTANTIATE_(string_view, __VA_ARGS__)
+
+ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_(extern);
+
+
+}  // namespace str_format_internal
 ABSL_NAMESPACE_END
 }  // namespace y_absl
- 
-#endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_ARG_H_ 
+
+#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 b1a1a321a9..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
@@ -13,73 +13,73 @@
 // limitations under the License.
 
 #include "y_absl/strings/internal/str_format/bind.h"
- 
-#include <cerrno> 
-#include <limits> 
-#include <sstream> 
+
+#include <cerrno>
+#include <limits>
+#include <sstream>
 #include <util/generic/string.h>
- 
+
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-namespace str_format_internal { 
- 
-namespace { 
- 
-inline bool BindFromPosition(int position, int* value, 
+namespace str_format_internal {
+
+namespace {
+
+inline bool BindFromPosition(int position, int* value,
                              y_absl::Span<const FormatArgImpl> pack) {
-  assert(position > 0); 
-  if (static_cast<size_t>(position) > pack.size()) { 
-    return false; 
-  } 
-  // -1 because positions are 1-based 
-  return FormatArgImplFriend::ToInt(pack[position - 1], value); 
-} 
- 
-class ArgContext { 
- public: 
+  assert(position > 0);
+  if (static_cast<size_t>(position) > pack.size()) {
+    return false;
+  }
+  // -1 because positions are 1-based
+  return FormatArgImplFriend::ToInt(pack[position - 1], value);
+}
+
+class ArgContext {
+ public:
   explicit ArgContext(y_absl::Span<const FormatArgImpl> pack) : pack_(pack) {}
- 
-  // Fill 'bound' with the results of applying the context's argument pack 
-  // to the specified 'unbound'. We synthesize a BoundConversion by 
-  // lining up a UnboundConversion with a user argument. We also 
-  // resolve any '*' specifiers for width and precision, so after 
-  // this call, 'bound' has all the information it needs to be formatted. 
-  // Returns false on failure. 
-  bool Bind(const UnboundConversion* unbound, BoundConversion* bound); 
- 
- private: 
+
+  // Fill 'bound' with the results of applying the context's argument pack
+  // to the specified 'unbound'. We synthesize a BoundConversion by
+  // lining up a UnboundConversion with a user argument. We also
+  // resolve any '*' specifiers for width and precision, so after
+  // this call, 'bound' has all the information it needs to be formatted.
+  // Returns false on failure.
+  bool Bind(const UnboundConversion* unbound, BoundConversion* bound);
+
+ private:
   y_absl::Span<const FormatArgImpl> pack_;
-}; 
- 
-inline bool ArgContext::Bind(const UnboundConversion* unbound, 
-                             BoundConversion* bound) { 
-  const FormatArgImpl* arg = nullptr; 
-  int arg_position = unbound->arg_position; 
-  if (static_cast<size_t>(arg_position - 1) >= pack_.size()) return false; 
-  arg = &pack_[arg_position - 1];  // 1-based 
- 
+};
+
+inline bool ArgContext::Bind(const UnboundConversion* unbound,
+                             BoundConversion* bound) {
+  const FormatArgImpl* arg = nullptr;
+  int arg_position = unbound->arg_position;
+  if (static_cast<size_t>(arg_position - 1) >= pack_.size()) return false;
+  arg = &pack_[arg_position - 1];  // 1-based
+
   if (unbound->flags != Flags::kBasic) {
-    int width = unbound->width.value(); 
-    bool force_left = false; 
-    if (unbound->width.is_from_arg()) { 
-      if (!BindFromPosition(unbound->width.get_from_arg(), &width, pack_)) 
-        return false; 
-      if (width < 0) { 
-        // "A negative field width is taken as a '-' flag followed by a 
-        // positive field width." 
-        force_left = true; 
-        // Make sure we don't overflow the width when negating it. 
-        width = -std::max(width, -std::numeric_limits<int>::max()); 
-      } 
-    } 
- 
-    int precision = unbound->precision.value(); 
-    if (unbound->precision.is_from_arg()) { 
-      if (!BindFromPosition(unbound->precision.get_from_arg(), &precision, 
-                            pack_)) 
-        return false; 
-    } 
- 
+    int width = unbound->width.value();
+    bool force_left = false;
+    if (unbound->width.is_from_arg()) {
+      if (!BindFromPosition(unbound->width.get_from_arg(), &width, pack_))
+        return false;
+      if (width < 0) {
+        // "A negative field width is taken as a '-' flag followed by a
+        // positive field width."
+        force_left = true;
+        // Make sure we don't overflow the width when negating it.
+        width = -std::max(width, -std::numeric_limits<int>::max());
+      }
+    }
+
+    int precision = unbound->precision.value();
+    if (unbound->precision.is_from_arg()) {
+      if (!BindFromPosition(unbound->precision.get_from_arg(), &precision,
+                            pack_))
+        return false;
+    }
+
     FormatConversionSpecImplFriend::SetWidth(width, bound);
     FormatConversionSpecImplFriend::SetPrecision(precision, bound);
 
@@ -89,170 +89,170 @@ inline bool ArgContext::Bind(const UnboundConversion* unbound,
     } else {
       FormatConversionSpecImplFriend::SetFlags(unbound->flags, bound);
     }
-  } else { 
+  } else {
     FormatConversionSpecImplFriend::SetFlags(unbound->flags, bound);
     FormatConversionSpecImplFriend::SetWidth(-1, bound);
     FormatConversionSpecImplFriend::SetPrecision(-1, bound);
-  } 
+  }
   FormatConversionSpecImplFriend::SetConversionChar(unbound->conv, bound);
-  bound->set_arg(arg); 
-  return true; 
-} 
- 
-template <typename Converter> 
-class ConverterConsumer { 
- public: 
+  bound->set_arg(arg);
+  return true;
+}
+
+template <typename Converter>
+class ConverterConsumer {
+ public:
   ConverterConsumer(Converter converter, y_absl::Span<const FormatArgImpl> pack)
-      : converter_(converter), arg_context_(pack) {} 
- 
-  bool Append(string_view s) { 
-    converter_.Append(s); 
-    return true; 
-  } 
-  bool ConvertOne(const UnboundConversion& conv, string_view conv_string) { 
-    BoundConversion bound; 
-    if (!arg_context_.Bind(&conv, &bound)) return false; 
-    return converter_.ConvertOne(bound, conv_string); 
-  } 
- 
- private: 
-  Converter converter_; 
-  ArgContext arg_context_; 
-}; 
- 
-template <typename Converter> 
-bool ConvertAll(const UntypedFormatSpecImpl format, 
+      : converter_(converter), arg_context_(pack) {}
+
+  bool Append(string_view s) {
+    converter_.Append(s);
+    return true;
+  }
+  bool ConvertOne(const UnboundConversion& conv, string_view conv_string) {
+    BoundConversion bound;
+    if (!arg_context_.Bind(&conv, &bound)) return false;
+    return converter_.ConvertOne(bound, conv_string);
+  }
+
+ private:
+  Converter converter_;
+  ArgContext arg_context_;
+};
+
+template <typename Converter>
+bool ConvertAll(const UntypedFormatSpecImpl format,
                 y_absl::Span<const FormatArgImpl> args, Converter converter) {
-  if (format.has_parsed_conversion()) { 
-    return format.parsed_conversion()->ProcessFormat( 
-        ConverterConsumer<Converter>(converter, args)); 
-  } else { 
-    return ParseFormatString(format.str(), 
-                             ConverterConsumer<Converter>(converter, args)); 
-  } 
-} 
- 
-class DefaultConverter { 
- public: 
-  explicit DefaultConverter(FormatSinkImpl* sink) : sink_(sink) {} 
- 
-  void Append(string_view s) const { sink_->Append(s); } 
- 
-  bool ConvertOne(const BoundConversion& bound, string_view /*conv*/) const { 
-    return FormatArgImplFriend::Convert(*bound.arg(), bound, sink_); 
-  } 
- 
- private: 
-  FormatSinkImpl* sink_; 
-}; 
- 
-class SummarizingConverter { 
- public: 
-  explicit SummarizingConverter(FormatSinkImpl* sink) : sink_(sink) {} 
- 
-  void Append(string_view s) const { sink_->Append(s); } 
- 
-  bool ConvertOne(const BoundConversion& bound, string_view /*conv*/) const { 
-    UntypedFormatSpecImpl spec("%d"); 
- 
-    std::ostringstream ss; 
+  if (format.has_parsed_conversion()) {
+    return format.parsed_conversion()->ProcessFormat(
+        ConverterConsumer<Converter>(converter, args));
+  } else {
+    return ParseFormatString(format.str(),
+                             ConverterConsumer<Converter>(converter, args));
+  }
+}
+
+class DefaultConverter {
+ public:
+  explicit DefaultConverter(FormatSinkImpl* sink) : sink_(sink) {}
+
+  void Append(string_view s) const { sink_->Append(s); }
+
+  bool ConvertOne(const BoundConversion& bound, string_view /*conv*/) const {
+    return FormatArgImplFriend::Convert(*bound.arg(), bound, sink_);
+  }
+
+ private:
+  FormatSinkImpl* sink_;
+};
+
+class SummarizingConverter {
+ public:
+  explicit SummarizingConverter(FormatSinkImpl* sink) : sink_(sink) {}
+
+  void Append(string_view s) const { sink_->Append(s); }
+
+  bool ConvertOne(const BoundConversion& bound, string_view /*conv*/) const {
+    UntypedFormatSpecImpl spec("%d");
+
+    std::ostringstream ss;
     ss << "{" << Streamable(spec, {*bound.arg()}) << ":"
        << FormatConversionSpecImplFriend::FlagsToString(bound);
-    if (bound.width() >= 0) ss << bound.width(); 
-    if (bound.precision() >= 0) ss << "." << bound.precision(); 
+    if (bound.width() >= 0) ss << bound.width();
+    if (bound.precision() >= 0) ss << "." << bound.precision();
     ss << bound.conversion_char() << "}";
-    Append(ss.str()); 
-    return true; 
-  } 
- 
- private: 
-  FormatSinkImpl* sink_; 
-}; 
- 
-}  // namespace 
- 
-bool BindWithPack(const UnboundConversion* props, 
+    Append(ss.str());
+    return true;
+  }
+
+ private:
+  FormatSinkImpl* sink_;
+};
+
+}  // namespace
+
+bool BindWithPack(const UnboundConversion* props,
                   y_absl::Span<const FormatArgImpl> pack,
-                  BoundConversion* bound) { 
-  return ArgContext(pack).Bind(props, bound); 
-} 
- 
+                  BoundConversion* bound) {
+  return ArgContext(pack).Bind(props, bound);
+}
+
 TString Summarize(const UntypedFormatSpecImpl format,
                       y_absl::Span<const FormatArgImpl> args) {
-  typedef SummarizingConverter Converter; 
+  typedef SummarizingConverter Converter;
   TString out;
-  { 
-    // inner block to destroy sink before returning out. It ensures a last 
-    // flush. 
-    FormatSinkImpl sink(&out); 
-    if (!ConvertAll(format, args, Converter(&sink))) { 
-      return ""; 
-    } 
-  } 
-  return out; 
-} 
- 
-bool FormatUntyped(FormatRawSinkImpl raw_sink, 
-                   const UntypedFormatSpecImpl format, 
+  {
+    // inner block to destroy sink before returning out. It ensures a last
+    // flush.
+    FormatSinkImpl sink(&out);
+    if (!ConvertAll(format, args, Converter(&sink))) {
+      return "";
+    }
+  }
+  return out;
+}
+
+bool FormatUntyped(FormatRawSinkImpl raw_sink,
+                   const UntypedFormatSpecImpl format,
                    y_absl::Span<const FormatArgImpl> args) {
-  FormatSinkImpl sink(raw_sink); 
-  using Converter = DefaultConverter; 
-  return ConvertAll(format, args, Converter(&sink)); 
-} 
- 
-std::ostream& Streamable::Print(std::ostream& os) const { 
-  if (!FormatUntyped(&os, format_, args_)) os.setstate(std::ios::failbit); 
-  return os; 
-} 
- 
+  FormatSinkImpl sink(raw_sink);
+  using Converter = DefaultConverter;
+  return ConvertAll(format, args, Converter(&sink));
+}
+
+std::ostream& Streamable::Print(std::ostream& os) const {
+  if (!FormatUntyped(&os, format_, args_)) os.setstate(std::ios::failbit);
+  return os;
+}
+
 TString& AppendPack(TString* out, const UntypedFormatSpecImpl format,
                         y_absl::Span<const FormatArgImpl> args) {
-  size_t orig = out->size(); 
-  if (ABSL_PREDICT_FALSE(!FormatUntyped(out, format, args))) { 
-    out->erase(orig); 
-  } 
-  return *out; 
-} 
- 
+  size_t orig = out->size();
+  if (ABSL_PREDICT_FALSE(!FormatUntyped(out, format, args))) {
+    out->erase(orig);
+  }
+  return *out;
+}
+
 TString FormatPack(const UntypedFormatSpecImpl format,
                        y_absl::Span<const FormatArgImpl> args) {
   TString out;
-  if (ABSL_PREDICT_FALSE(!FormatUntyped(&out, format, args))) { 
-    out.clear(); 
-  } 
-  return out; 
-} 
- 
-int FprintF(std::FILE* output, const UntypedFormatSpecImpl format, 
+  if (ABSL_PREDICT_FALSE(!FormatUntyped(&out, format, args))) {
+    out.clear();
+  }
+  return out;
+}
+
+int FprintF(std::FILE* output, const UntypedFormatSpecImpl format,
             y_absl::Span<const FormatArgImpl> args) {
-  FILERawSink sink(output); 
-  if (!FormatUntyped(&sink, format, args)) { 
-    errno = EINVAL; 
-    return -1; 
-  } 
-  if (sink.error()) { 
-    errno = sink.error(); 
-    return -1; 
-  } 
+  FILERawSink sink(output);
+  if (!FormatUntyped(&sink, format, args)) {
+    errno = EINVAL;
+    return -1;
+  }
+  if (sink.error()) {
+    errno = sink.error();
+    return -1;
+  }
   if (sink.count() > static_cast<size_t>(std::numeric_limits<int>::max())) {
-    errno = EFBIG; 
-    return -1; 
-  } 
-  return static_cast<int>(sink.count()); 
-} 
- 
-int SnprintF(char* output, size_t size, const UntypedFormatSpecImpl format, 
+    errno = EFBIG;
+    return -1;
+  }
+  return static_cast<int>(sink.count());
+}
+
+int SnprintF(char* output, size_t size, const UntypedFormatSpecImpl format,
              y_absl::Span<const FormatArgImpl> args) {
-  BufferRawSink sink(output, size ? size - 1 : 0); 
-  if (!FormatUntyped(&sink, format, args)) { 
-    errno = EINVAL; 
-    return -1; 
-  } 
-  size_t total = sink.total_written(); 
-  if (size) output[std::min(total, size - 1)] = 0; 
-  return static_cast<int>(total); 
-} 
- 
-}  // namespace str_format_internal 
+  BufferRawSink sink(output, size ? size - 1 : 0);
+  if (!FormatUntyped(&sink, format, args)) {
+    errno = EINVAL;
+    return -1;
+  }
+  size_t total = sink.total_written();
+  if (size) output[std::min(total, size - 1)] = 0;
+  return static_cast<int>(total);
+}
+
+}  // namespace str_format_internal
 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 7f2eb2094f..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
@@ -12,206 +12,206 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_BIND_H_ 
-#define ABSL_STRINGS_INTERNAL_STR_FORMAT_BIND_H_ 
- 
-#include <array> 
-#include <cstdio> 
-#include <sstream> 
+#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_BIND_H_
+#define ABSL_STRINGS_INTERNAL_STR_FORMAT_BIND_H_
+
+#include <array>
+#include <cstdio>
+#include <sstream>
 #include <util/generic/string.h>
- 
+
 #include "y_absl/base/port.h"
 #include "y_absl/strings/internal/str_format/arg.h"
 #include "y_absl/strings/internal/str_format/checker.h"
 #include "y_absl/strings/internal/str_format/parser.h"
 #include "y_absl/types/span.h"
- 
+
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
- 
-class UntypedFormatSpec; 
- 
-namespace str_format_internal { 
- 
+
+class UntypedFormatSpec;
+
+namespace str_format_internal {
+
 class BoundConversion : public FormatConversionSpecImpl {
- public: 
-  const FormatArgImpl* arg() const { return arg_; } 
-  void set_arg(const FormatArgImpl* a) { arg_ = a; } 
- 
- private: 
-  const FormatArgImpl* arg_; 
-}; 
- 
-// This is the type-erased class that the implementation uses. 
-class UntypedFormatSpecImpl { 
- public: 
-  UntypedFormatSpecImpl() = delete; 
- 
-  explicit UntypedFormatSpecImpl(string_view s) 
-      : data_(s.data()), size_(s.size()) {} 
-  explicit UntypedFormatSpecImpl( 
-      const str_format_internal::ParsedFormatBase* pc) 
-      : data_(pc), size_(~size_t{}) {} 
- 
-  bool has_parsed_conversion() const { return size_ == ~size_t{}; } 
- 
-  string_view str() const { 
-    assert(!has_parsed_conversion()); 
-    return string_view(static_cast<const char*>(data_), size_); 
-  } 
-  const str_format_internal::ParsedFormatBase* parsed_conversion() const { 
-    assert(has_parsed_conversion()); 
-    return static_cast<const str_format_internal::ParsedFormatBase*>(data_); 
-  } 
- 
-  template <typename T> 
-  static const UntypedFormatSpecImpl& Extract(const T& s) { 
-    return s.spec_; 
-  } 
- 
- private: 
-  const void* data_; 
-  size_t size_; 
-}; 
- 
+ public:
+  const FormatArgImpl* arg() const { return arg_; }
+  void set_arg(const FormatArgImpl* a) { arg_ = a; }
+
+ private:
+  const FormatArgImpl* arg_;
+};
+
+// This is the type-erased class that the implementation uses.
+class UntypedFormatSpecImpl {
+ public:
+  UntypedFormatSpecImpl() = delete;
+
+  explicit UntypedFormatSpecImpl(string_view s)
+      : data_(s.data()), size_(s.size()) {}
+  explicit UntypedFormatSpecImpl(
+      const str_format_internal::ParsedFormatBase* pc)
+      : data_(pc), size_(~size_t{}) {}
+
+  bool has_parsed_conversion() const { return size_ == ~size_t{}; }
+
+  string_view str() const {
+    assert(!has_parsed_conversion());
+    return string_view(static_cast<const char*>(data_), size_);
+  }
+  const str_format_internal::ParsedFormatBase* parsed_conversion() const {
+    assert(has_parsed_conversion());
+    return static_cast<const str_format_internal::ParsedFormatBase*>(data_);
+  }
+
+  template <typename T>
+  static const UntypedFormatSpecImpl& Extract(const T& s) {
+    return s.spec_;
+  }
+
+ private:
+  const void* data_;
+  size_t size_;
+};
+
 template <typename T, FormatConversionCharSet...>
-struct MakeDependent { 
-  using type = T; 
-}; 
- 
-// Implicitly convertible from `const char*`, `string_view`, and the 
-// `ExtendedParsedFormat` type. This abstraction allows all format functions to 
-// operate on any without providing too many overloads. 
+struct MakeDependent {
+  using type = T;
+};
+
+// Implicitly convertible from `const char*`, `string_view`, and the
+// `ExtendedParsedFormat` type. This abstraction allows all format functions to
+// operate on any without providing too many overloads.
 template <FormatConversionCharSet... Args>
-class FormatSpecTemplate 
-    : public MakeDependent<UntypedFormatSpec, Args...>::type { 
-  using Base = typename MakeDependent<UntypedFormatSpec, Args...>::type; 
- 
- public: 
+class FormatSpecTemplate
+    : public MakeDependent<UntypedFormatSpec, Args...>::type {
+  using Base = typename MakeDependent<UntypedFormatSpec, Args...>::type;
+
+ public:
 #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 
-  // just 'method is deleted'. 
-  FormatSpecTemplate(...)  // NOLINT 
+  // We use the 'unavailable' attribute to give a better compiler error than
+  // just 'method is deleted'.
+  FormatSpecTemplate(...)  // NOLINT
       __attribute__((unavailable("Format string is not constexpr.")));
- 
-  // Honeypot overload for when the format is constexpr and invalid. 
-  // We use the 'unavailable' attribute to give a better compiler error than 
-  // just 'method is deleted'. 
-  // To avoid checking the format twice, we just check that the format is 
+
+  // Honeypot overload for when the format is constexpr and invalid.
+  // We use the 'unavailable' attribute to give a better compiler error than
+  // just 'method is deleted'.
+  // To avoid checking the format twice, we just check that the format is
   // constexpr. If it is valid, then the overload below will kick in.
-  // We add the template here to make this overload have lower priority. 
-  template <typename = void> 
-  FormatSpecTemplate(const char* s)  // NOLINT 
-      __attribute__(( 
-          enable_if(str_format_internal::EnsureConstexpr(s), "constexpr trap"), 
-          unavailable( 
-              "Format specified does not match the arguments passed."))); 
- 
-  template <typename T = void> 
-  FormatSpecTemplate(string_view s)  // NOLINT 
-      __attribute__((enable_if(str_format_internal::EnsureConstexpr(s), 
-                               "constexpr trap"))) { 
-    static_assert(sizeof(T*) == 0, 
-                  "Format specified does not match the arguments passed."); 
-  } 
- 
-  // Good format overload. 
-  FormatSpecTemplate(const char* s)  // NOLINT 
+  // We add the template here to make this overload have lower priority.
+  template <typename = void>
+  FormatSpecTemplate(const char* s)  // NOLINT
+      __attribute__((
+          enable_if(str_format_internal::EnsureConstexpr(s), "constexpr trap"),
+          unavailable(
+              "Format specified does not match the arguments passed.")));
+
+  template <typename T = void>
+  FormatSpecTemplate(string_view s)  // NOLINT
+      __attribute__((enable_if(str_format_internal::EnsureConstexpr(s),
+                               "constexpr trap"))) {
+    static_assert(sizeof(T*) == 0,
+                  "Format specified does not match the arguments passed.");
+  }
+
+  // Good format overload.
+  FormatSpecTemplate(const char* s)  // NOLINT
       __attribute__((enable_if(ValidFormatImpl<Args...>(s), "bad format trap")))
-      : Base(s) {} 
- 
-  FormatSpecTemplate(string_view s)  // NOLINT 
+      : Base(s) {}
+
+  FormatSpecTemplate(string_view s)  // NOLINT
       __attribute__((enable_if(ValidFormatImpl<Args...>(s), "bad format trap")))
-      : Base(s) {} 
- 
-#else  // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER 
- 
-  FormatSpecTemplate(const char* s) : Base(s) {}  // NOLINT 
-  FormatSpecTemplate(string_view s) : Base(s) {}  // NOLINT 
- 
-#endif  // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER 
- 
+      : Base(s) {}
+
+#else  // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
+
+  FormatSpecTemplate(const char* s) : Base(s) {}  // NOLINT
+  FormatSpecTemplate(string_view s) : Base(s) {}  // NOLINT
+
+#endif  // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
+
   template <
       FormatConversionCharSet... C,
       typename = typename std::enable_if<sizeof...(C) == sizeof...(Args)>::type,
       typename = typename std::enable_if<AllOf(Contains(Args,
                                                         C)...)>::type>
-  FormatSpecTemplate(const ExtendedParsedFormat<C...>& pc)  // NOLINT 
-      : Base(&pc) {} 
-}; 
- 
-class Streamable { 
- public: 
-  Streamable(const UntypedFormatSpecImpl& format, 
+  FormatSpecTemplate(const ExtendedParsedFormat<C...>& pc)  // NOLINT
+      : Base(&pc) {}
+};
+
+class Streamable {
+ public:
+  Streamable(const UntypedFormatSpecImpl& format,
              y_absl::Span<const FormatArgImpl> args)
-      : format_(format) { 
-    if (args.size() <= ABSL_ARRAYSIZE(few_args_)) { 
-      for (size_t i = 0; i < args.size(); ++i) { 
-        few_args_[i] = args[i]; 
-      } 
+      : format_(format) {
+    if (args.size() <= ABSL_ARRAYSIZE(few_args_)) {
+      for (size_t i = 0; i < args.size(); ++i) {
+        few_args_[i] = args[i];
+      }
       args_ = y_absl::MakeSpan(few_args_, args.size());
-    } else { 
-      many_args_.assign(args.begin(), args.end()); 
-      args_ = many_args_; 
-    } 
-  } 
- 
-  std::ostream& Print(std::ostream& os) const; 
- 
-  friend std::ostream& operator<<(std::ostream& os, const Streamable& l) { 
-    return l.Print(os); 
-  } 
- 
- private: 
-  const UntypedFormatSpecImpl& format_; 
+    } else {
+      many_args_.assign(args.begin(), args.end());
+      args_ = many_args_;
+    }
+  }
+
+  std::ostream& Print(std::ostream& os) const;
+
+  friend std::ostream& operator<<(std::ostream& os, const Streamable& l) {
+    return l.Print(os);
+  }
+
+ private:
+  const UntypedFormatSpecImpl& format_;
   y_absl::Span<const FormatArgImpl> args_;
-  // if args_.size() is 4 or less: 
-  FormatArgImpl few_args_[4] = {FormatArgImpl(0), FormatArgImpl(0), 
-                                FormatArgImpl(0), FormatArgImpl(0)}; 
-  // if args_.size() is more than 4: 
-  std::vector<FormatArgImpl> many_args_; 
-}; 
- 
-// for testing 
+  // if args_.size() is 4 or less:
+  FormatArgImpl few_args_[4] = {FormatArgImpl(0), FormatArgImpl(0),
+                                FormatArgImpl(0), FormatArgImpl(0)};
+  // if args_.size() is more than 4:
+  std::vector<FormatArgImpl> many_args_;
+};
+
+// for testing
 TString Summarize(UntypedFormatSpecImpl format,
                       y_absl::Span<const FormatArgImpl> args);
-bool BindWithPack(const UnboundConversion* props, 
+bool BindWithPack(const UnboundConversion* props,
                   y_absl::Span<const FormatArgImpl> pack, BoundConversion* bound);
- 
-bool FormatUntyped(FormatRawSinkImpl raw_sink, 
-                   UntypedFormatSpecImpl format, 
+
+bool FormatUntyped(FormatRawSinkImpl raw_sink,
+                   UntypedFormatSpecImpl format,
                    y_absl::Span<const FormatArgImpl> args);
- 
+
 TString& AppendPack(TString* out, UntypedFormatSpecImpl format,
                         y_absl::Span<const FormatArgImpl> args);
- 
+
 TString FormatPack(const UntypedFormatSpecImpl format,
                        y_absl::Span<const FormatArgImpl> args);
- 
-int FprintF(std::FILE* output, UntypedFormatSpecImpl format, 
+
+int FprintF(std::FILE* output, UntypedFormatSpecImpl format,
             y_absl::Span<const FormatArgImpl> args);
-int SnprintF(char* output, size_t size, UntypedFormatSpecImpl format, 
+int SnprintF(char* output, size_t size, UntypedFormatSpecImpl format,
              y_absl::Span<const FormatArgImpl> args);
- 
+
 // Returned by Streamed(v). Converts via '%s' to the TString created
-// by std::ostream << v. 
-template <typename T> 
-class StreamedWrapper { 
- public: 
-  explicit StreamedWrapper(const T& v) : v_(v) { } 
- 
- private: 
-  template <typename S> 
+// by std::ostream << v.
+template <typename T>
+class StreamedWrapper {
+ public:
+  explicit StreamedWrapper(const T& v) : v_(v) { }
+
+ private:
+  template <typename S>
   friend ArgConvertResult<FormatConversionCharSetInternal::s> FormatConvertImpl(
       const StreamedWrapper<S>& v, FormatConversionSpecImpl conv,
       FormatSinkImpl* out);
-  const T& v_; 
-}; 
- 
-}  // namespace str_format_internal 
+  const T& v_;
+};
+
+}  // namespace str_format_internal
 ABSL_NAMESPACE_END
 }  // namespace y_absl
- 
-#endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_BIND_H_ 
+
+#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 f3690064e3..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
@@ -12,322 +12,322 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_CHECKER_H_ 
-#define ABSL_STRINGS_INTERNAL_STR_FORMAT_CHECKER_H_ 
- 
+#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/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 
+
+// Compile time check support for entry points.
+
+#ifndef ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
 #if ABSL_HAVE_ATTRIBUTE(enable_if) && !defined(__native_client__)
-#define ABSL_INTERNAL_ENABLE_FORMAT_CHECKER 1 
+#define ABSL_INTERNAL_ENABLE_FORMAT_CHECKER 1
 #endif  // ABSL_HAVE_ATTRIBUTE(enable_if) && !defined(__native_client__)
-#endif  // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER 
- 
+#endif  // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
+
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-namespace str_format_internal { 
- 
-constexpr bool AllOf() { return true; } 
- 
-template <typename... T> 
-constexpr bool AllOf(bool b, T... t) { 
-  return b && AllOf(t...); 
-} 
- 
+namespace str_format_internal {
+
+constexpr bool AllOf() { return true; }
+
+template <typename... T>
+constexpr bool AllOf(bool b, T... t) {
+  return b && AllOf(t...);
+}
+
 #ifdef ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
- 
-constexpr bool ContainsChar(const char* chars, char c) { 
-  return *chars == c || (*chars && ContainsChar(chars + 1, c)); 
-} 
- 
-// A constexpr compatible list of Convs. 
-struct ConvList { 
+
+constexpr bool ContainsChar(const char* chars, char c) {
+  return *chars == c || (*chars && ContainsChar(chars + 1, c));
+}
+
+// A constexpr compatible list of Convs.
+struct ConvList {
   const FormatConversionCharSet* array;
-  int count; 
- 
-  // We do the bound check here to avoid having to do it on the callers. 
+  int count;
+
+  // We do the bound check here to avoid having to do it on the callers.
   // Returning an empty FormatConversionCharSet has the same effect as
   // short circuiting because it will never match any conversion.
   constexpr FormatConversionCharSet operator[](int i) const {
     return i < count ? array[i] : FormatConversionCharSet{};
-  } 
- 
-  constexpr ConvList without_front() const { 
-    return count != 0 ? ConvList{array + 1, count - 1} : *this; 
-  } 
-}; 
- 
-template <size_t count> 
-struct ConvListT { 
-  // Make sure the array has size > 0. 
+  }
+
+  constexpr ConvList without_front() const {
+    return count != 0 ? ConvList{array + 1, count - 1} : *this;
+  }
+};
+
+template <size_t count>
+struct ConvListT {
+  // Make sure the array has size > 0.
   FormatConversionCharSet list[count ? count : 1];
-}; 
- 
-constexpr char GetChar(string_view str, size_t index) { 
-  return index < str.size() ? str[index] : char{}; 
-} 
- 
-constexpr string_view ConsumeFront(string_view str, size_t len = 1) { 
-  return len <= str.size() ? string_view(str.data() + len, str.size() - len) 
-                           : string_view(); 
-} 
- 
-constexpr string_view ConsumeAnyOf(string_view format, const char* chars) { 
-  return ContainsChar(chars, GetChar(format, 0)) 
-             ? ConsumeAnyOf(ConsumeFront(format), chars) 
-             : format; 
-} 
- 
-constexpr bool IsDigit(char c) { return c >= '0' && c <= '9'; } 
- 
-// Helper class for the ParseDigits function. 
-// It encapsulates the two return values we need there. 
-struct Integer { 
-  string_view format; 
-  int value; 
- 
-  // If the next character is a '$', consume it. 
-  // Otherwise, make `this` an invalid positional argument. 
-  constexpr Integer ConsumePositionalDollar() const { 
-    return GetChar(format, 0) == '$' ? Integer{ConsumeFront(format), value} 
-                                     : Integer{format, 0}; 
-  } 
-}; 
- 
-constexpr Integer ParseDigits(string_view format, int value = 0) { 
-  return IsDigit(GetChar(format, 0)) 
-             ? ParseDigits(ConsumeFront(format), 
-                           10 * value + GetChar(format, 0) - '0') 
-             : Integer{format, value}; 
-} 
- 
-// Parse digits for a positional argument. 
-// The parsing also consumes the '$'. 
-constexpr Integer ParsePositional(string_view format) { 
-  return ParseDigits(format).ConsumePositionalDollar(); 
-} 
- 
-// Parses a single conversion specifier. 
-// See ConvParser::Run() for post conditions. 
-class ConvParser { 
-  constexpr ConvParser SetFormat(string_view format) const { 
-    return ConvParser(format, args_, error_, arg_position_, is_positional_); 
-  } 
- 
-  constexpr ConvParser SetArgs(ConvList args) const { 
-    return ConvParser(format_, args, error_, arg_position_, is_positional_); 
-  } 
- 
-  constexpr ConvParser SetError(bool error) const { 
-    return ConvParser(format_, args_, error_ || error, arg_position_, 
-                      is_positional_); 
-  } 
- 
-  constexpr ConvParser SetArgPosition(int arg_position) const { 
-    return ConvParser(format_, args_, error_, arg_position, is_positional_); 
-  } 
- 
-  // Consumes the next arg and verifies that it matches `conv`. 
-  // `error_` is set if there is no next arg or if it doesn't match `conv`. 
-  constexpr ConvParser ConsumeNextArg(char conv) const { 
-    return SetArgs(args_.without_front()).SetError(!Contains(args_[0], conv)); 
-  } 
- 
-  // Verify that positional argument `i.value` matches `conv`. 
-  // `error_` is set if `i.value` is not a valid argument or if it doesn't 
-  // match. 
-  constexpr ConvParser VerifyPositional(Integer i, char conv) const { 
-    return SetFormat(i.format).SetError(!Contains(args_[i.value - 1], conv)); 
-  } 
- 
-  // Parse the position of the arg and store it in `arg_position_`. 
-  constexpr ConvParser ParseArgPosition(Integer arg) const { 
-    return SetFormat(arg.format).SetArgPosition(arg.value); 
-  } 
- 
-  // Consume the flags. 
-  constexpr ConvParser ParseFlags() const { 
-    return SetFormat(ConsumeAnyOf(format_, "-+ #0")); 
-  } 
- 
-  // Consume the width. 
-  // If it is '*', we verify that it matches `args_`. `error_` is set if it 
-  // doesn't match. 
-  constexpr ConvParser ParseWidth() const { 
-    return IsDigit(GetChar(format_, 0)) 
-               ? SetFormat(ParseDigits(format_).format) 
-               : GetChar(format_, 0) == '*' 
-                     ? is_positional_ 
-                           ? VerifyPositional( 
-                                 ParsePositional(ConsumeFront(format_)), '*') 
-                           : SetFormat(ConsumeFront(format_)) 
-                                 .ConsumeNextArg('*') 
-                     : *this; 
-  } 
- 
-  // Consume the precision. 
-  // If it is '*', we verify that it matches `args_`. `error_` is set if it 
-  // doesn't match. 
-  constexpr ConvParser ParsePrecision() const { 
-    return GetChar(format_, 0) != '.' 
-               ? *this 
-               : GetChar(format_, 1) == '*' 
-                     ? is_positional_ 
-                           ? VerifyPositional( 
-                                 ParsePositional(ConsumeFront(format_, 2)), '*') 
-                           : SetFormat(ConsumeFront(format_, 2)) 
-                                 .ConsumeNextArg('*') 
-                     : SetFormat(ParseDigits(ConsumeFront(format_)).format); 
-  } 
- 
-  // Consume the length characters. 
-  constexpr ConvParser ParseLength() const { 
-    return SetFormat(ConsumeAnyOf(format_, "lLhjztq")); 
-  } 
- 
-  // Consume the conversion character and verify that it matches `args_`. 
-  // `error_` is set if it doesn't match. 
-  constexpr ConvParser ParseConversion() const { 
-    return is_positional_ 
-               ? VerifyPositional({ConsumeFront(format_), arg_position_}, 
-                                  GetChar(format_, 0)) 
-               : ConsumeNextArg(GetChar(format_, 0)) 
-                     .SetFormat(ConsumeFront(format_)); 
-  } 
- 
-  constexpr ConvParser(string_view format, ConvList args, bool error, 
-                       int arg_position, bool is_positional) 
-      : format_(format), 
-        args_(args), 
-        error_(error), 
-        arg_position_(arg_position), 
-        is_positional_(is_positional) {} 
- 
- public: 
-  constexpr ConvParser(string_view format, ConvList args, bool is_positional) 
-      : format_(format), 
-        args_(args), 
-        error_(false), 
-        arg_position_(0), 
-        is_positional_(is_positional) {} 
- 
-  // Consume the whole conversion specifier. 
-  // `format()` will be set to the character after the conversion character. 
-  // `error()` will be set if any of the arguments do not match. 
-  constexpr ConvParser Run() const { 
-    return (is_positional_ ? ParseArgPosition(ParsePositional(format_)) : *this) 
-        .ParseFlags() 
-        .ParseWidth() 
-        .ParsePrecision() 
-        .ParseLength() 
-        .ParseConversion(); 
-  } 
- 
-  constexpr string_view format() const { return format_; } 
-  constexpr ConvList args() const { return args_; } 
-  constexpr bool error() const { return error_; } 
-  constexpr bool is_positional() const { return is_positional_; } 
- 
- private: 
-  string_view format_; 
-  // Current list of arguments. If we are not in positional mode we will consume 
-  // from the front. 
-  ConvList args_; 
-  bool error_; 
-  // Holds the argument position of the conversion character, if we are in 
-  // positional mode. Otherwise, it is unspecified. 
-  int arg_position_; 
-  // Whether we are in positional mode. 
-  // It changes the behavior of '*' and where to find the converted argument. 
-  bool is_positional_; 
-}; 
- 
-// Parses a whole format expression. 
-// See FormatParser::Run(). 
-class FormatParser { 
-  static constexpr bool FoundPercent(string_view format) { 
-    return format.empty() || 
-           (GetChar(format, 0) == '%' && GetChar(format, 1) != '%'); 
-  } 
- 
-  // We use an inner function to increase the recursion limit. 
-  // The inner function consumes up to `limit` characters on every run. 
-  // This increases the limit from 512 to ~512*limit. 
-  static constexpr string_view ConsumeNonPercentInner(string_view format, 
-                                                      int limit = 20) { 
-    return FoundPercent(format) || !limit 
-               ? format 
-               : ConsumeNonPercentInner( 
-                     ConsumeFront(format, GetChar(format, 0) == '%' && 
-                                                  GetChar(format, 1) == '%' 
-                                              ? 2 
-                                              : 1), 
-                     limit - 1); 
-  } 
- 
-  // Consume characters until the next conversion spec %. 
-  // It skips %%. 
-  static constexpr string_view ConsumeNonPercent(string_view format) { 
-    return FoundPercent(format) 
-               ? format 
-               : ConsumeNonPercent(ConsumeNonPercentInner(format)); 
-  } 
- 
-  static constexpr bool IsPositional(string_view format) { 
-    return IsDigit(GetChar(format, 0)) ? IsPositional(ConsumeFront(format)) 
-                                       : GetChar(format, 0) == '$'; 
-  } 
- 
-  constexpr bool RunImpl(bool is_positional) const { 
-    // In non-positional mode we require all arguments to be consumed. 
-    // In positional mode just reaching the end of the format without errors is 
-    // enough. 
-    return (format_.empty() && (is_positional || args_.count == 0)) || 
-           (!format_.empty() && 
-            ValidateArg( 
-                ConvParser(ConsumeFront(format_), args_, is_positional).Run())); 
-  } 
- 
-  constexpr bool ValidateArg(ConvParser conv) const { 
-    return !conv.error() && FormatParser(conv.format(), conv.args()) 
-                                .RunImpl(conv.is_positional()); 
-  } 
- 
- public: 
-  constexpr FormatParser(string_view format, ConvList args) 
-      : format_(ConsumeNonPercent(format)), args_(args) {} 
- 
-  // Runs the parser for `format` and `args`. 
-  // It verifies that the format is valid and that all conversion specifiers 
-  // match the arguments passed. 
-  // In non-positional mode it also verfies that all arguments are consumed. 
-  constexpr bool Run() const { 
-    return RunImpl(!format_.empty() && IsPositional(ConsumeFront(format_))); 
-  } 
- 
- private: 
-  string_view format_; 
-  // Current list of arguments. 
-  // If we are not in positional mode we will consume from the front and will 
-  // have to be empty in the end. 
-  ConvList args_; 
-}; 
- 
+};
+
+constexpr char GetChar(string_view str, size_t index) {
+  return index < str.size() ? str[index] : char{};
+}
+
+constexpr string_view ConsumeFront(string_view str, size_t len = 1) {
+  return len <= str.size() ? string_view(str.data() + len, str.size() - len)
+                           : string_view();
+}
+
+constexpr string_view ConsumeAnyOf(string_view format, const char* chars) {
+  return ContainsChar(chars, GetChar(format, 0))
+             ? ConsumeAnyOf(ConsumeFront(format), chars)
+             : format;
+}
+
+constexpr bool IsDigit(char c) { return c >= '0' && c <= '9'; }
+
+// Helper class for the ParseDigits function.
+// It encapsulates the two return values we need there.
+struct Integer {
+  string_view format;
+  int value;
+
+  // If the next character is a '$', consume it.
+  // Otherwise, make `this` an invalid positional argument.
+  constexpr Integer ConsumePositionalDollar() const {
+    return GetChar(format, 0) == '$' ? Integer{ConsumeFront(format), value}
+                                     : Integer{format, 0};
+  }
+};
+
+constexpr Integer ParseDigits(string_view format, int value = 0) {
+  return IsDigit(GetChar(format, 0))
+             ? ParseDigits(ConsumeFront(format),
+                           10 * value + GetChar(format, 0) - '0')
+             : Integer{format, value};
+}
+
+// Parse digits for a positional argument.
+// The parsing also consumes the '$'.
+constexpr Integer ParsePositional(string_view format) {
+  return ParseDigits(format).ConsumePositionalDollar();
+}
+
+// Parses a single conversion specifier.
+// See ConvParser::Run() for post conditions.
+class ConvParser {
+  constexpr ConvParser SetFormat(string_view format) const {
+    return ConvParser(format, args_, error_, arg_position_, is_positional_);
+  }
+
+  constexpr ConvParser SetArgs(ConvList args) const {
+    return ConvParser(format_, args, error_, arg_position_, is_positional_);
+  }
+
+  constexpr ConvParser SetError(bool error) const {
+    return ConvParser(format_, args_, error_ || error, arg_position_,
+                      is_positional_);
+  }
+
+  constexpr ConvParser SetArgPosition(int arg_position) const {
+    return ConvParser(format_, args_, error_, arg_position, is_positional_);
+  }
+
+  // Consumes the next arg and verifies that it matches `conv`.
+  // `error_` is set if there is no next arg or if it doesn't match `conv`.
+  constexpr ConvParser ConsumeNextArg(char conv) const {
+    return SetArgs(args_.without_front()).SetError(!Contains(args_[0], conv));
+  }
+
+  // Verify that positional argument `i.value` matches `conv`.
+  // `error_` is set if `i.value` is not a valid argument or if it doesn't
+  // match.
+  constexpr ConvParser VerifyPositional(Integer i, char conv) const {
+    return SetFormat(i.format).SetError(!Contains(args_[i.value - 1], conv));
+  }
+
+  // Parse the position of the arg and store it in `arg_position_`.
+  constexpr ConvParser ParseArgPosition(Integer arg) const {
+    return SetFormat(arg.format).SetArgPosition(arg.value);
+  }
+
+  // Consume the flags.
+  constexpr ConvParser ParseFlags() const {
+    return SetFormat(ConsumeAnyOf(format_, "-+ #0"));
+  }
+
+  // Consume the width.
+  // If it is '*', we verify that it matches `args_`. `error_` is set if it
+  // doesn't match.
+  constexpr ConvParser ParseWidth() const {
+    return IsDigit(GetChar(format_, 0))
+               ? SetFormat(ParseDigits(format_).format)
+               : GetChar(format_, 0) == '*'
+                     ? is_positional_
+                           ? VerifyPositional(
+                                 ParsePositional(ConsumeFront(format_)), '*')
+                           : SetFormat(ConsumeFront(format_))
+                                 .ConsumeNextArg('*')
+                     : *this;
+  }
+
+  // Consume the precision.
+  // If it is '*', we verify that it matches `args_`. `error_` is set if it
+  // doesn't match.
+  constexpr ConvParser ParsePrecision() const {
+    return GetChar(format_, 0) != '.'
+               ? *this
+               : GetChar(format_, 1) == '*'
+                     ? is_positional_
+                           ? VerifyPositional(
+                                 ParsePositional(ConsumeFront(format_, 2)), '*')
+                           : SetFormat(ConsumeFront(format_, 2))
+                                 .ConsumeNextArg('*')
+                     : SetFormat(ParseDigits(ConsumeFront(format_)).format);
+  }
+
+  // Consume the length characters.
+  constexpr ConvParser ParseLength() const {
+    return SetFormat(ConsumeAnyOf(format_, "lLhjztq"));
+  }
+
+  // Consume the conversion character and verify that it matches `args_`.
+  // `error_` is set if it doesn't match.
+  constexpr ConvParser ParseConversion() const {
+    return is_positional_
+               ? VerifyPositional({ConsumeFront(format_), arg_position_},
+                                  GetChar(format_, 0))
+               : ConsumeNextArg(GetChar(format_, 0))
+                     .SetFormat(ConsumeFront(format_));
+  }
+
+  constexpr ConvParser(string_view format, ConvList args, bool error,
+                       int arg_position, bool is_positional)
+      : format_(format),
+        args_(args),
+        error_(error),
+        arg_position_(arg_position),
+        is_positional_(is_positional) {}
+
+ public:
+  constexpr ConvParser(string_view format, ConvList args, bool is_positional)
+      : format_(format),
+        args_(args),
+        error_(false),
+        arg_position_(0),
+        is_positional_(is_positional) {}
+
+  // Consume the whole conversion specifier.
+  // `format()` will be set to the character after the conversion character.
+  // `error()` will be set if any of the arguments do not match.
+  constexpr ConvParser Run() const {
+    return (is_positional_ ? ParseArgPosition(ParsePositional(format_)) : *this)
+        .ParseFlags()
+        .ParseWidth()
+        .ParsePrecision()
+        .ParseLength()
+        .ParseConversion();
+  }
+
+  constexpr string_view format() const { return format_; }
+  constexpr ConvList args() const { return args_; }
+  constexpr bool error() const { return error_; }
+  constexpr bool is_positional() const { return is_positional_; }
+
+ private:
+  string_view format_;
+  // Current list of arguments. If we are not in positional mode we will consume
+  // from the front.
+  ConvList args_;
+  bool error_;
+  // Holds the argument position of the conversion character, if we are in
+  // positional mode. Otherwise, it is unspecified.
+  int arg_position_;
+  // Whether we are in positional mode.
+  // It changes the behavior of '*' and where to find the converted argument.
+  bool is_positional_;
+};
+
+// Parses a whole format expression.
+// See FormatParser::Run().
+class FormatParser {
+  static constexpr bool FoundPercent(string_view format) {
+    return format.empty() ||
+           (GetChar(format, 0) == '%' && GetChar(format, 1) != '%');
+  }
+
+  // We use an inner function to increase the recursion limit.
+  // The inner function consumes up to `limit` characters on every run.
+  // This increases the limit from 512 to ~512*limit.
+  static constexpr string_view ConsumeNonPercentInner(string_view format,
+                                                      int limit = 20) {
+    return FoundPercent(format) || !limit
+               ? format
+               : ConsumeNonPercentInner(
+                     ConsumeFront(format, GetChar(format, 0) == '%' &&
+                                                  GetChar(format, 1) == '%'
+                                              ? 2
+                                              : 1),
+                     limit - 1);
+  }
+
+  // Consume characters until the next conversion spec %.
+  // It skips %%.
+  static constexpr string_view ConsumeNonPercent(string_view format) {
+    return FoundPercent(format)
+               ? format
+               : ConsumeNonPercent(ConsumeNonPercentInner(format));
+  }
+
+  static constexpr bool IsPositional(string_view format) {
+    return IsDigit(GetChar(format, 0)) ? IsPositional(ConsumeFront(format))
+                                       : GetChar(format, 0) == '$';
+  }
+
+  constexpr bool RunImpl(bool is_positional) const {
+    // In non-positional mode we require all arguments to be consumed.
+    // In positional mode just reaching the end of the format without errors is
+    // enough.
+    return (format_.empty() && (is_positional || args_.count == 0)) ||
+           (!format_.empty() &&
+            ValidateArg(
+                ConvParser(ConsumeFront(format_), args_, is_positional).Run()));
+  }
+
+  constexpr bool ValidateArg(ConvParser conv) const {
+    return !conv.error() && FormatParser(conv.format(), conv.args())
+                                .RunImpl(conv.is_positional());
+  }
+
+ public:
+  constexpr FormatParser(string_view format, ConvList args)
+      : format_(ConsumeNonPercent(format)), args_(args) {}
+
+  // Runs the parser for `format` and `args`.
+  // It verifies that the format is valid and that all conversion specifiers
+  // match the arguments passed.
+  // In non-positional mode it also verfies that all arguments are consumed.
+  constexpr bool Run() const {
+    return RunImpl(!format_.empty() && IsPositional(ConsumeFront(format_)));
+  }
+
+ private:
+  string_view format_;
+  // Current list of arguments.
+  // If we are not in positional mode we will consume from the front and will
+  // have to be empty in the end.
+  ConvList args_;
+};
+
 template <FormatConversionCharSet... C>
-constexpr bool ValidFormatImpl(string_view format) { 
-  return FormatParser(format, 
-                      {ConvListT<sizeof...(C)>{{C...}}.list, sizeof...(C)}) 
-      .Run(); 
-} 
- 
-#endif  // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER 
- 
-}  // namespace str_format_internal 
+constexpr bool ValidFormatImpl(string_view format) {
+  return FormatParser(format,
+                      {ConvListT<sizeof...(C)>{{C...}}.list, sizeof...(C)})
+      .Run();
+}
+
+#endif  // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
+
+}  // namespace str_format_internal
 ABSL_NAMESPACE_END
 }  // namespace y_absl
- 
-#endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_CHECKER_H_ 
+
+#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 fb0757081d..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
@@ -1,28 +1,28 @@
-// 
-// Copyright 2017 The Abseil Authors. 
-// 
-// Licensed under the Apache License, Version 2.0 (the "License"); 
-// you may not use this file except in compliance with the License. 
-// You may obtain a copy of the License at 
-// 
-//      https://www.apache.org/licenses/LICENSE-2.0 
-// 
-// Unless required by applicable law or agreed to in writing, software 
-// distributed under the License is distributed on an "AS IS" BASIS, 
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-// See the License for the specific language governing permissions and 
-// limitations under the License. 
- 
+//
+// Copyright 2017 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/str_format/extension.h"
- 
-#include <errno.h> 
-#include <algorithm> 
+
+#include <errno.h>
+#include <algorithm>
 #include <util/generic/string.h>
- 
+
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-namespace str_format_internal { 
- 
+namespace str_format_internal {
+
 TString FlagsToString(Flags v) {
   TString s;
   s.append(FlagsContains(v, Flags::kLeft) ? "-" : "");
@@ -30,9 +30,9 @@ TString FlagsToString(Flags v) {
   s.append(FlagsContains(v, Flags::kSignCol) ? " " : "");
   s.append(FlagsContains(v, Flags::kAlt) ? "#" : "");
   s.append(FlagsContains(v, Flags::kZero) ? "0" : "");
-  return s; 
-} 
- 
+  return s;
+}
+
 #define ABSL_INTERNAL_X_VAL(id) \
   constexpr y_absl::FormatConversionChar FormatConversionCharInternal::id;
 ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL, )
@@ -58,18 +58,18 @@ constexpr FormatConversionCharSet FormatConversionCharSetInternal::kPointer;
 
 bool FormatSinkImpl::PutPaddedString(string_view value, int width,
                                      int precision, bool left) {
-  size_t space_remaining = 0; 
+  size_t space_remaining = 0;
   if (width >= 0) space_remaining = width;
   size_t n = value.size();
   if (precision >= 0) n = std::min(n, static_cast<size_t>(precision));
   string_view shown(value.data(), n);
-  space_remaining = Excess(shown.size(), space_remaining); 
+  space_remaining = Excess(shown.size(), space_remaining);
   if (!left) Append(space_remaining, ' ');
-  Append(shown); 
+  Append(shown);
   if (left) Append(space_remaining, ' ');
-  return true; 
-} 
- 
-}  // namespace str_format_internal 
+  return true;
+}
+
+}  // namespace str_format_internal
 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 e18b8ae796..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
@@ -1,133 +1,133 @@
-// 
-// Copyright 2017 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_STR_FORMAT_EXTENSION_H_ 
-#define ABSL_STRINGS_INTERNAL_STR_FORMAT_EXTENSION_H_ 
- 
-#include <limits.h> 
-
-#include <cstddef> 
-#include <cstring> 
-#include <ostream> 
- 
+//
+// Copyright 2017 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_STR_FORMAT_EXTENSION_H_
+#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/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
 
 enum class FormatConversionChar : uint8_t;
 enum class FormatConversionCharSet : uint64_t;
 
-namespace str_format_internal { 
- 
-class FormatRawSinkImpl { 
- public: 
-  // Implicitly convert from any type that provides the hook function as 
-  // described above. 
-  template <typename T, decltype(str_format_internal::InvokeFlush( 
-                            std::declval<T*>(), string_view()))* = nullptr> 
-  FormatRawSinkImpl(T* raw)  // NOLINT 
-      : sink_(raw), write_(&FormatRawSinkImpl::Flush<T>) {} 
- 
-  void Write(string_view s) { write_(sink_, s); } 
- 
-  template <typename T> 
-  static FormatRawSinkImpl Extract(T s) { 
-    return s.sink_; 
-  } 
- 
- private: 
-  template <typename T> 
-  static void Flush(void* r, string_view s) { 
-    str_format_internal::InvokeFlush(static_cast<T*>(r), s); 
-  } 
- 
-  void* sink_; 
-  void (*write_)(void*, string_view); 
-}; 
- 
-// An abstraction to which conversions write their string data. 
-class FormatSinkImpl { 
- public: 
-  explicit FormatSinkImpl(FormatRawSinkImpl raw) : raw_(raw) {} 
- 
-  ~FormatSinkImpl() { Flush(); } 
- 
-  void Flush() { 
-    raw_.Write(string_view(buf_, pos_ - buf_)); 
-    pos_ = buf_; 
-  } 
- 
-  void Append(size_t n, char c) { 
-    if (n == 0) return; 
-    size_ += n; 
-    auto raw_append = [&](size_t count) { 
-      memset(pos_, c, count); 
-      pos_ += count; 
-    }; 
-    while (n > Avail()) { 
-      n -= Avail(); 
-      if (Avail() > 0) { 
-        raw_append(Avail()); 
-      } 
-      Flush(); 
-    } 
-    raw_append(n); 
-  } 
- 
-  void Append(string_view v) { 
-    size_t n = v.size(); 
-    if (n == 0) return; 
-    size_ += n; 
-    if (n >= Avail()) { 
-      Flush(); 
-      raw_.Write(v); 
-      return; 
-    } 
-    memcpy(pos_, v.data(), n); 
-    pos_ += n; 
-  } 
- 
-  size_t size() const { return size_; } 
- 
-  // Put 'v' to 'sink' with specified width, precision, and left flag. 
+namespace str_format_internal {
+
+class FormatRawSinkImpl {
+ public:
+  // Implicitly convert from any type that provides the hook function as
+  // described above.
+  template <typename T, decltype(str_format_internal::InvokeFlush(
+                            std::declval<T*>(), string_view()))* = nullptr>
+  FormatRawSinkImpl(T* raw)  // NOLINT
+      : sink_(raw), write_(&FormatRawSinkImpl::Flush<T>) {}
+
+  void Write(string_view s) { write_(sink_, s); }
+
+  template <typename T>
+  static FormatRawSinkImpl Extract(T s) {
+    return s.sink_;
+  }
+
+ private:
+  template <typename T>
+  static void Flush(void* r, string_view s) {
+    str_format_internal::InvokeFlush(static_cast<T*>(r), s);
+  }
+
+  void* sink_;
+  void (*write_)(void*, string_view);
+};
+
+// An abstraction to which conversions write their string data.
+class FormatSinkImpl {
+ public:
+  explicit FormatSinkImpl(FormatRawSinkImpl raw) : raw_(raw) {}
+
+  ~FormatSinkImpl() { Flush(); }
+
+  void Flush() {
+    raw_.Write(string_view(buf_, pos_ - buf_));
+    pos_ = buf_;
+  }
+
+  void Append(size_t n, char c) {
+    if (n == 0) return;
+    size_ += n;
+    auto raw_append = [&](size_t count) {
+      memset(pos_, c, count);
+      pos_ += count;
+    };
+    while (n > Avail()) {
+      n -= Avail();
+      if (Avail() > 0) {
+        raw_append(Avail());
+      }
+      Flush();
+    }
+    raw_append(n);
+  }
+
+  void Append(string_view v) {
+    size_t n = v.size();
+    if (n == 0) return;
+    size_ += n;
+    if (n >= Avail()) {
+      Flush();
+      raw_.Write(v);
+      return;
+    }
+    memcpy(pos_, v.data(), n);
+    pos_ += n;
+  }
+
+  size_t size() const { return size_; }
+
+  // Put 'v' to 'sink' with specified width, precision, and left flag.
   bool PutPaddedString(string_view v, int width, int precision, bool left);
- 
-  template <typename T> 
-  T Wrap() { 
-    return T(this); 
-  } 
- 
-  template <typename T> 
-  static FormatSinkImpl* Extract(T* s) { 
-    return s->sink_; 
-  } 
- 
- private: 
-  size_t Avail() const { return buf_ + sizeof(buf_) - pos_; } 
- 
-  FormatRawSinkImpl raw_; 
-  size_t size_ = 0; 
-  char* pos_ = buf_; 
-  char buf_[1024]; 
-}; 
- 
+
+  template <typename T>
+  T Wrap() {
+    return T(this);
+  }
+
+  template <typename T>
+  static FormatSinkImpl* Extract(T* s) {
+    return s->sink_;
+  }
+
+ private:
+  size_t Avail() const { return buf_ + sizeof(buf_) - pos_; }
+
+  FormatRawSinkImpl raw_;
+  size_t size_ = 0;
+  char* pos_ = buf_;
+  char buf_[1024];
+};
+
 enum class Flags : uint8_t {
   kBasic = 0,
   kLeft = 1 << 0,
@@ -138,8 +138,8 @@ enum class Flags : uint8_t {
   // This is not a real flag. It just exists to turn off kBasic when no other
   // flags are set. This is for when width/precision are specified.
   kNonBasic = 1 << 5,
-}; 
- 
+};
+
 constexpr Flags operator|(Flags a, Flags b) {
   return static_cast<Flags>(static_cast<uint8_t>(a) | static_cast<uint8_t>(b));
 }
@@ -155,20 +155,20 @@ inline std::ostream& operator<<(std::ostream& os, Flags v) {
   return os << FlagsToString(v);
 }
 
-// clang-format off 
+// clang-format off
 #define ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(X_VAL, X_SEP) \
-  /* text */ \ 
+  /* text */ \
   X_VAL(c) X_SEP X_VAL(s) X_SEP \
-  /* ints */ \ 
-  X_VAL(d) X_SEP X_VAL(i) X_SEP X_VAL(o) X_SEP \ 
-  X_VAL(u) X_SEP X_VAL(x) X_SEP X_VAL(X) X_SEP \ 
-  /* floats */ \ 
-  X_VAL(f) X_SEP X_VAL(F) X_SEP X_VAL(e) X_SEP X_VAL(E) X_SEP \ 
-  X_VAL(g) X_SEP X_VAL(G) X_SEP X_VAL(a) X_SEP X_VAL(A) X_SEP \ 
-  /* misc */ \ 
-  X_VAL(n) X_SEP X_VAL(p) 
+  /* ints */ \
+  X_VAL(d) X_SEP X_VAL(i) X_SEP X_VAL(o) X_SEP \
+  X_VAL(u) X_SEP X_VAL(x) X_SEP X_VAL(X) X_SEP \
+  /* floats */ \
+  X_VAL(f) X_SEP X_VAL(F) X_SEP X_VAL(e) X_SEP X_VAL(E) X_SEP \
+  X_VAL(g) X_SEP X_VAL(G) X_SEP X_VAL(a) X_SEP X_VAL(A) X_SEP \
+  /* misc */ \
+  X_VAL(n) X_SEP X_VAL(p)
 // clang-format on
- 
+
 // This type should not be referenced, it exists only to provide labels
 // internally that match the values declared in FormatConversionChar in
 // str_format.h. This is meant to allow internal libraries to use the same
@@ -186,9 +186,9 @@ struct FormatConversionCharInternal {
   // clang-format off
   enum class Enum : uint8_t {
     c, s,                    // text
-    d, i, o, u, x, X,        // int 
-    f, F, e, E, g, G, a, A,  // float 
-    n, p,                    // misc 
+    d, i, o, u, x, X,        // int
+    f, F, e, E, g, G, a, A,  // float
+    n, p,                    // misc
     kNone
   };
   // clang-format on
@@ -202,7 +202,7 @@ struct FormatConversionCharInternal {
       static_cast<FormatConversionChar>(Enum::kNone);
 };
 // clang-format on
- 
+
 inline FormatConversionChar FormatConversionCharFromChar(char c) {
   switch (c) {
 #define ABSL_INTERNAL_X_VAL(id) \
@@ -210,10 +210,10 @@ inline FormatConversionChar FormatConversionCharFromChar(char c) {
     return FormatConversionCharInternal::id;
     ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_X_VAL, )
 #undef ABSL_INTERNAL_X_VAL
-  } 
+  }
   return FormatConversionCharInternal::kNone;
 }
- 
+
 inline bool FormatConversionCharIsUpper(FormatConversionChar c) {
   if (c == FormatConversionCharInternal::X ||
       c == FormatConversionCharInternal::F ||
@@ -223,9 +223,9 @@ inline bool FormatConversionCharIsUpper(FormatConversionChar c) {
     return true;
   } else {
     return false;
-  } 
+  }
 }
- 
+
 inline bool FormatConversionCharIsFloat(FormatConversionChar c) {
   if (c == FormatConversionCharInternal::a ||
       c == FormatConversionCharInternal::e ||
@@ -238,9 +238,9 @@ inline bool FormatConversionCharIsFloat(FormatConversionChar c) {
     return true;
   } else {
     return false;
-  } 
+  }
 }
- 
+
 inline char FormatConversionCharToChar(FormatConversionChar c) {
   if (c == FormatConversionCharInternal::kNone) {
     return '\0';
@@ -258,16 +258,16 @@ inline char FormatConversionCharToChar(FormatConversionChar c) {
 #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;
 }
- 
+
 struct FormatConversionSpecImplFriend;
- 
+
 class FormatConversionSpecImpl {
  public:
   // Width and precison are not specified, no flags are set.
@@ -281,34 +281,34 @@ 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 {
-    // Keep this field first in the struct . It generates better code when 
-    // accessing it when ConversionSpec is passed by value in registers. 
+    // 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, "");
-    return conv_; 
-  } 
- 
-  // Returns the specified width. If width is unspecfied, it returns a negative 
-  // value. 
-  int width() const { return width_; } 
-  // Returns the specified precision. If precision is unspecfied, it returns a 
-  // negative value. 
-  int precision() const { return precision_; } 
- 
+    return conv_;
+  }
+
+  // Returns the specified width. If width is unspecfied, it returns a negative
+  // value.
+  int width() const { return width_; }
+  // Returns the specified precision. If precision is unspecfied, it returns a
+  // negative value.
+  int precision() const { return precision_; }
+
   template <typename T>
   T Wrap() {
     return T(*this);
   }
- 
- private: 
+
+ private:
   friend struct str_format_internal::FormatConversionSpecImplFriend;
   FormatConversionChar conv_ = FormatConversionCharInternal::kNone;
-  Flags flags_; 
-  int width_; 
-  int precision_; 
-}; 
- 
+  Flags flags_;
+  int width_;
+  int precision_;
+};
+
 struct FormatConversionSpecImplFriend final {
   static void SetFlags(Flags f, FormatConversionSpecImpl* conv) {
     conv->flags_ = f;
@@ -351,18 +351,18 @@ constexpr uint64_t FormatConversionCharToConvInt(FormatConversionChar c) {
 }
 
 constexpr uint64_t FormatConversionCharToConvInt(char conv) {
-  return 
+  return
 #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
-                  conv == '*' 
-          ? 1 
-          : 0; 
-} 
- 
+                  conv == '*'
+          ? 1
+          : 0;
+}
+
 constexpr FormatConversionCharSet FormatConversionCharToConvValue(char conv) {
   return static_cast<FormatConversionCharSet>(
       FormatConversionCharToConvInt(conv));
@@ -374,11 +374,11 @@ struct FormatConversionCharSetInternal {
       FormatConversionCharToConvValue(#c[0]);
   ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(ABSL_INTERNAL_CHAR_SET_CASE, )
 #undef ABSL_INTERNAL_CHAR_SET_CASE
- 
-  // Used for width/precision '*' specification. 
+
+  // Used for width/precision '*' specification.
   static constexpr FormatConversionCharSet kStar =
       FormatConversionCharToConvValue('*');
- 
+
   static constexpr FormatConversionCharSet kIntegral =
       FormatConversionCharSetUnion(d, i, u, o, x, X);
   static constexpr FormatConversionCharSet kFloating =
@@ -386,25 +386,25 @@ struct FormatConversionCharSetInternal {
   static constexpr FormatConversionCharSet kNumeric =
       FormatConversionCharSetUnion(kIntegral, kFloating);
   static constexpr FormatConversionCharSet kPointer = p;
-}; 
- 
-// Type safe OR operator. 
-// We need this for two reasons: 
-//  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. 
+};
+
+// Type safe OR operator.
+// We need this for two reasons:
+//  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) {
   return FormatConversionCharSetUnion(a, b);
-} 
- 
+}
+
 // Overloaded conversion functions to support y_absl::ParsedFormat.
-// Get a conversion with a single character in it. 
+// Get a conversion with a single character in it.
 constexpr FormatConversionCharSet ToFormatConversionCharSet(char c) {
   return static_cast<FormatConversionCharSet>(
       FormatConversionCharToConvValue(c));
-} 
- 
+}
+
 // Get a conversion with a single character in it.
 constexpr FormatConversionCharSet ToFormatConversionCharSet(
     FormatConversionCharSet c) {
@@ -414,32 +414,32 @@ constexpr FormatConversionCharSet ToFormatConversionCharSet(
 template <typename T>
 void ToFormatConversionCharSet(T) = delete;
 
-// Checks whether `c` exists in `set`. 
+// Checks whether `c` exists in `set`.
 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` 
+}
+
+// Checks whether all the characters in `c` are contained in `set`
 constexpr bool Contains(FormatConversionCharSet set,
                         FormatConversionCharSet c) {
-  return (static_cast<uint64_t>(set) & static_cast<uint64_t>(c)) == 
-         static_cast<uint64_t>(c); 
-} 
- 
+  return (static_cast<uint64_t>(set) & static_cast<uint64_t>(c)) ==
+         static_cast<uint64_t>(c);
+}
+
 // Checks whether all the characters in `c` are contained in `set`
 constexpr bool Contains(FormatConversionCharSet set, FormatConversionChar c) {
   return (static_cast<uint64_t>(set) & FormatConversionCharToConvInt(c)) != 0;
 }
- 
-// Return capacity - used, clipped to a minimum of 0. 
-inline size_t Excess(size_t used, size_t capacity) { 
-  return used < capacity ? capacity - used : 0; 
-} 
- 
-}  // namespace str_format_internal 
- 
+
+// Return capacity - used, clipped to a minimum of 0.
+inline size_t Excess(size_t used, size_t capacity) {
+  return used < capacity ? capacity - used : 0;
+}
+
+}  // namespace str_format_internal
+
 ABSL_NAMESPACE_END
 }  // namespace y_absl
- 
-#endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_EXTENSION_H_ 
+
+#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 fb85d1a5aa..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
@@ -13,15 +13,15 @@
 // limitations under the License.
 
 #include "y_absl/strings/internal/str_format/float_conversion.h"
- 
-#include <string.h> 
 
-#include <algorithm> 
-#include <cassert> 
-#include <cmath> 
+#include <string.h>
+
+#include <algorithm>
+#include <cassert>
+#include <cmath>
 #include <limits>
 #include <util/generic/string.h>
- 
+
 #include "y_absl/base/attributes.h"
 #include "y_absl/base/config.h"
 #include "y_absl/base/optimization.h"
@@ -33,13 +33,13 @@
 #include "y_absl/strings/numbers.h"
 #include "y_absl/types/optional.h"
 #include "y_absl/types/span.h"
- 
+
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-namespace str_format_internal { 
- 
-namespace { 
- 
+namespace str_format_internal {
+
+namespace {
+
 using ::y_absl::numeric_internal::IsDoubleDouble;
 
 // The code below wants to avoid heap allocations.
@@ -933,404 +933,404 @@ void FormatA(const HexFloatTypeParams float_traits, Int mantissa, int exp,
 }
 
 char *CopyStringTo(y_absl::string_view v, char *out) {
-  std::memcpy(out, v.data(), v.size()); 
-  return out + v.size(); 
-} 
- 
-template <typename Float> 
+  std::memcpy(out, v.data(), v.size());
+  return out + v.size();
+}
+
+template <typename Float>
 bool FallbackToSnprintf(const Float v, const FormatConversionSpecImpl &conv,
-                        FormatSinkImpl *sink) { 
-  int w = conv.width() >= 0 ? conv.width() : 0; 
-  int p = conv.precision() >= 0 ? conv.precision() : -1; 
-  char fmt[32]; 
-  { 
-    char *fp = fmt; 
-    *fp++ = '%'; 
+                        FormatSinkImpl *sink) {
+  int w = conv.width() >= 0 ? conv.width() : 0;
+  int p = conv.precision() >= 0 ? conv.precision() : -1;
+  char fmt[32];
+  {
+    char *fp = fmt;
+    *fp++ = '%';
     fp = CopyStringTo(FormatConversionSpecImplFriend::FlagsToString(conv), fp);
-    fp = CopyStringTo("*.*", fp); 
-    if (std::is_same<long double, Float>()) { 
-      *fp++ = 'L'; 
-    } 
+    fp = CopyStringTo("*.*", fp);
+    if (std::is_same<long double, Float>()) {
+      *fp++ = 'L';
+    }
     *fp++ = FormatConversionCharToChar(conv.conversion_char());
-    *fp = 0; 
-    assert(fp < fmt + sizeof(fmt)); 
-  } 
+    *fp = 0;
+    assert(fp < fmt + sizeof(fmt));
+  }
   TString space(512, '\0');
   y_absl::string_view result;
-  while (true) { 
-    int n = snprintf(&space[0], space.size(), fmt, w, p, v); 
-    if (n < 0) return false; 
-    if (static_cast<size_t>(n) < space.size()) { 
+  while (true) {
+    int n = snprintf(&space[0], space.size(), fmt, w, p, v);
+    if (n < 0) return false;
+    if (static_cast<size_t>(n) < space.size()) {
       result = y_absl::string_view(space.data(), n);
-      break; 
-    } 
-    space.resize(n + 1); 
-  } 
-  sink->Append(result); 
-  return true; 
-} 
- 
-// 128-bits in decimal: ceil(128*log(2)/log(10)) 
-//   or std::numeric_limits<__uint128_t>::digits10 
-constexpr int kMaxFixedPrecision = 39; 
- 
-constexpr int kBufferLength = /*sign*/ 1 + 
-                              /*integer*/ kMaxFixedPrecision + 
-                              /*point*/ 1 + 
-                              /*fraction*/ kMaxFixedPrecision + 
-                              /*exponent e+123*/ 5; 
- 
-struct Buffer { 
-  void push_front(char c) { 
-    assert(begin > data); 
-    *--begin = c; 
-  } 
-  void push_back(char c) { 
-    assert(end < data + sizeof(data)); 
-    *end++ = c; 
-  } 
-  void pop_back() { 
-    assert(begin < end); 
-    --end; 
-  } 
- 
-  char &back() { 
-    assert(begin < end); 
-    return end[-1]; 
-  } 
- 
-  char last_digit() const { return end[-1] == '.' ? end[-2] : end[-1]; } 
- 
-  int size() const { return static_cast<int>(end - begin); } 
- 
-  char data[kBufferLength]; 
-  char *begin; 
-  char *end; 
-}; 
- 
-enum class FormatStyle { Fixed, Precision }; 
- 
-// If the value is Inf or Nan, print it and return true. 
-// Otherwise, return false. 
-template <typename Float> 
-bool ConvertNonNumericFloats(char sign_char, Float v, 
+      break;
+    }
+    space.resize(n + 1);
+  }
+  sink->Append(result);
+  return true;
+}
+
+// 128-bits in decimal: ceil(128*log(2)/log(10))
+//   or std::numeric_limits<__uint128_t>::digits10
+constexpr int kMaxFixedPrecision = 39;
+
+constexpr int kBufferLength = /*sign*/ 1 +
+                              /*integer*/ kMaxFixedPrecision +
+                              /*point*/ 1 +
+                              /*fraction*/ kMaxFixedPrecision +
+                              /*exponent e+123*/ 5;
+
+struct Buffer {
+  void push_front(char c) {
+    assert(begin > data);
+    *--begin = c;
+  }
+  void push_back(char c) {
+    assert(end < data + sizeof(data));
+    *end++ = c;
+  }
+  void pop_back() {
+    assert(begin < end);
+    --end;
+  }
+
+  char &back() {
+    assert(begin < end);
+    return end[-1];
+  }
+
+  char last_digit() const { return end[-1] == '.' ? end[-2] : end[-1]; }
+
+  int size() const { return static_cast<int>(end - begin); }
+
+  char data[kBufferLength];
+  char *begin;
+  char *end;
+};
+
+enum class FormatStyle { Fixed, Precision };
+
+// If the value is Inf or Nan, print it and return true.
+// Otherwise, return false.
+template <typename Float>
+bool ConvertNonNumericFloats(char sign_char, Float v,
                              const FormatConversionSpecImpl &conv,
                              FormatSinkImpl *sink) {
-  char text[4], *ptr = text; 
+  char text[4], *ptr = text;
   if (sign_char != '\0') *ptr++ = sign_char;
-  if (std::isnan(v)) { 
+  if (std::isnan(v)) {
     ptr = std::copy_n(
         FormatConversionCharIsUpper(conv.conversion_char()) ? "NAN" : "nan", 3,
         ptr);
-  } else if (std::isinf(v)) { 
+  } else if (std::isinf(v)) {
     ptr = std::copy_n(
         FormatConversionCharIsUpper(conv.conversion_char()) ? "INF" : "inf", 3,
         ptr);
-  } else { 
-    return false; 
-  } 
- 
-  return sink->PutPaddedString(string_view(text, ptr - text), conv.width(), -1, 
+  } else {
+    return false;
+  }
+
+  return sink->PutPaddedString(string_view(text, ptr - text), conv.width(), -1,
                                conv.has_left_flag());
-} 
- 
-// Round up the last digit of the value. 
-// It will carry over and potentially overflow. 'exp' will be adjusted in that 
-// case. 
-template <FormatStyle mode> 
-void RoundUp(Buffer *buffer, int *exp) { 
-  char *p = &buffer->back(); 
-  while (p >= buffer->begin && (*p == '9' || *p == '.')) { 
-    if (*p == '9') *p = '0'; 
-    --p; 
-  } 
- 
-  if (p < buffer->begin) { 
-    *p = '1'; 
-    buffer->begin = p; 
-    if (mode == FormatStyle::Precision) { 
-      std::swap(p[1], p[2]);  // move the . 
-      ++*exp; 
-      buffer->pop_back(); 
-    } 
-  } else { 
-    ++*p; 
-  } 
-} 
- 
-void PrintExponent(int exp, char e, Buffer *out) { 
-  out->push_back(e); 
-  if (exp < 0) { 
-    out->push_back('-'); 
-    exp = -exp; 
-  } else { 
-    out->push_back('+'); 
-  } 
-  // Exponent digits. 
-  if (exp > 99) { 
-    out->push_back(exp / 100 + '0'); 
-    out->push_back(exp / 10 % 10 + '0'); 
-    out->push_back(exp % 10 + '0'); 
-  } else { 
-    out->push_back(exp / 10 + '0'); 
-    out->push_back(exp % 10 + '0'); 
-  } 
-} 
- 
-template <typename Float, typename Int> 
-constexpr bool CanFitMantissa() { 
-  return 
-#if defined(__clang__) && !defined(__SSE3__) 
-      // Workaround for clang bug: https://bugs.llvm.org/show_bug.cgi?id=38289 
-      // Casting from long double to uint64_t is miscompiled and drops bits. 
-      (!std::is_same<Float, long double>::value || 
-       !std::is_same<Int, uint64_t>::value) && 
-#endif 
-      std::numeric_limits<Float>::digits <= std::numeric_limits<Int>::digits; 
-} 
- 
-template <typename Float> 
-struct Decomposed { 
+}
+
+// Round up the last digit of the value.
+// It will carry over and potentially overflow. 'exp' will be adjusted in that
+// case.
+template <FormatStyle mode>
+void RoundUp(Buffer *buffer, int *exp) {
+  char *p = &buffer->back();
+  while (p >= buffer->begin && (*p == '9' || *p == '.')) {
+    if (*p == '9') *p = '0';
+    --p;
+  }
+
+  if (p < buffer->begin) {
+    *p = '1';
+    buffer->begin = p;
+    if (mode == FormatStyle::Precision) {
+      std::swap(p[1], p[2]);  // move the .
+      ++*exp;
+      buffer->pop_back();
+    }
+  } else {
+    ++*p;
+  }
+}
+
+void PrintExponent(int exp, char e, Buffer *out) {
+  out->push_back(e);
+  if (exp < 0) {
+    out->push_back('-');
+    exp = -exp;
+  } else {
+    out->push_back('+');
+  }
+  // Exponent digits.
+  if (exp > 99) {
+    out->push_back(exp / 100 + '0');
+    out->push_back(exp / 10 % 10 + '0');
+    out->push_back(exp % 10 + '0');
+  } else {
+    out->push_back(exp / 10 + '0');
+    out->push_back(exp % 10 + '0');
+  }
+}
+
+template <typename Float, typename Int>
+constexpr bool CanFitMantissa() {
+  return
+#if defined(__clang__) && !defined(__SSE3__)
+      // Workaround for clang bug: https://bugs.llvm.org/show_bug.cgi?id=38289
+      // Casting from long double to uint64_t is miscompiled and drops bits.
+      (!std::is_same<Float, long double>::value ||
+       !std::is_same<Int, uint64_t>::value) &&
+#endif
+      std::numeric_limits<Float>::digits <= std::numeric_limits<Int>::digits;
+}
+
+template <typename Float>
+struct Decomposed {
   using MantissaType =
       y_absl::conditional_t<std::is_same<long double, Float>::value, uint128,
                           uint64_t>;
   static_assert(std::numeric_limits<Float>::digits <= sizeof(MantissaType) * 8,
                 "");
   MantissaType mantissa;
-  int exponent; 
-}; 
- 
-// Decompose the double into an integer mantissa and an exponent. 
-template <typename Float> 
-Decomposed<Float> Decompose(Float v) { 
-  int exp; 
-  Float m = std::frexp(v, &exp); 
-  m = std::ldexp(m, std::numeric_limits<Float>::digits); 
-  exp -= std::numeric_limits<Float>::digits; 
+  int exponent;
+};
+
+// Decompose the double into an integer mantissa and an exponent.
+template <typename Float>
+Decomposed<Float> Decompose(Float v) {
+  int exp;
+  Float m = std::frexp(v, &exp);
+  m = std::ldexp(m, std::numeric_limits<Float>::digits);
+  exp -= std::numeric_limits<Float>::digits;
 
   return {static_cast<typename Decomposed<Float>::MantissaType>(m), exp};
-} 
- 
-// Print 'digits' as decimal. 
-// In Fixed mode, we add a '.' at the end. 
-// In Precision mode, we add a '.' after the first digit. 
-template <FormatStyle mode, typename Int> 
-int PrintIntegralDigits(Int digits, Buffer *out) { 
-  int printed = 0; 
-  if (digits) { 
-    for (; digits; digits /= 10) out->push_front(digits % 10 + '0'); 
-    printed = out->size(); 
-    if (mode == FormatStyle::Precision) { 
-      out->push_front(*out->begin); 
-      out->begin[1] = '.'; 
-    } else { 
-      out->push_back('.'); 
-    } 
-  } else if (mode == FormatStyle::Fixed) { 
-    out->push_front('0'); 
-    out->push_back('.'); 
-    printed = 1; 
-  } 
-  return printed; 
-} 
- 
-// Back out 'extra_digits' digits and round up if necessary. 
-bool RemoveExtraPrecision(int extra_digits, bool has_leftover_value, 
-                          Buffer *out, int *exp_out) { 
-  if (extra_digits <= 0) return false; 
- 
-  // Back out the extra digits 
-  out->end -= extra_digits; 
- 
-  bool needs_to_round_up = [&] { 
-    // We look at the digit just past the end. 
-    // There must be 'extra_digits' extra valid digits after end. 
-    if (*out->end > '5') return true; 
-    if (*out->end < '5') return false; 
-    if (has_leftover_value || std::any_of(out->end + 1, out->end + extra_digits, 
-                                          [](char c) { return c != '0'; })) 
-      return true; 
- 
-    // Ends in ...50*, round to even. 
-    return out->last_digit() % 2 == 1; 
-  }(); 
- 
-  if (needs_to_round_up) { 
-    RoundUp<FormatStyle::Precision>(out, exp_out); 
-  } 
-  return true; 
-} 
- 
-// Print the value into the buffer. 
-// This will not include the exponent, which will be returned in 'exp_out' for 
-// Precision mode. 
-template <typename Int, typename Float, FormatStyle mode> 
-bool FloatToBufferImpl(Int int_mantissa, int exp, int precision, Buffer *out, 
-                       int *exp_out) { 
-  assert((CanFitMantissa<Float, Int>())); 
- 
-  const int int_bits = std::numeric_limits<Int>::digits; 
- 
-  // In precision mode, we start printing one char to the right because it will 
-  // also include the '.' 
-  // In fixed mode we put the dot afterwards on the right. 
-  out->begin = out->end = 
-      out->data + 1 + kMaxFixedPrecision + (mode == FormatStyle::Precision); 
- 
-  if (exp >= 0) { 
-    if (std::numeric_limits<Float>::digits + exp > int_bits) { 
-      // The value will overflow the Int 
-      return false; 
-    } 
-    int digits_printed = PrintIntegralDigits<mode>(int_mantissa << exp, out); 
-    int digits_to_zero_pad = precision; 
-    if (mode == FormatStyle::Precision) { 
-      *exp_out = digits_printed - 1; 
-      digits_to_zero_pad -= digits_printed - 1; 
-      if (RemoveExtraPrecision(-digits_to_zero_pad, false, out, exp_out)) { 
-        return true; 
-      } 
-    } 
-    for (; digits_to_zero_pad-- > 0;) out->push_back('0'); 
-    return true; 
-  } 
- 
-  exp = -exp; 
-  // We need at least 4 empty bits for the next decimal digit. 
-  // We will multiply by 10. 
-  if (exp > int_bits - 4) return false; 
- 
-  const Int mask = (Int{1} << exp) - 1; 
- 
-  // Print the integral part first. 
-  int digits_printed = PrintIntegralDigits<mode>(int_mantissa >> exp, out); 
-  int_mantissa &= mask; 
- 
-  int fractional_count = precision; 
-  if (mode == FormatStyle::Precision) { 
-    if (digits_printed == 0) { 
-      // Find the first non-zero digit, when in Precision mode. 
-      *exp_out = 0; 
-      if (int_mantissa) { 
-        while (int_mantissa <= mask) { 
-          int_mantissa *= 10; 
-          --*exp_out; 
-        } 
-      } 
-      out->push_front(static_cast<char>(int_mantissa >> exp) + '0'); 
-      out->push_back('.'); 
-      int_mantissa &= mask; 
-    } else { 
-      // We already have a digit, and a '.' 
-      *exp_out = digits_printed - 1; 
-      fractional_count -= *exp_out; 
-      if (RemoveExtraPrecision(-fractional_count, int_mantissa != 0, out, 
-                               exp_out)) { 
-        // If we had enough digits, return right away. 
-        // The code below will try to round again otherwise. 
-        return true; 
-      } 
-    } 
-  } 
- 
-  auto get_next_digit = [&] { 
-    int_mantissa *= 10; 
-    int digit = static_cast<int>(int_mantissa >> exp); 
-    int_mantissa &= mask; 
-    return digit; 
-  }; 
- 
-  // Print fractional_count more digits, if available. 
-  for (; fractional_count > 0; --fractional_count) { 
-    out->push_back(get_next_digit() + '0'); 
-  } 
- 
-  int next_digit = get_next_digit(); 
-  if (next_digit > 5 || 
-      (next_digit == 5 && (int_mantissa || out->last_digit() % 2 == 1))) { 
-    RoundUp<mode>(out, exp_out); 
-  } 
- 
-  return true; 
-} 
- 
-template <FormatStyle mode, typename Float> 
-bool FloatToBuffer(Decomposed<Float> decomposed, int precision, Buffer *out, 
-                   int *exp) { 
-  if (precision > kMaxFixedPrecision) return false; 
- 
-  // Try with uint64_t. 
-  if (CanFitMantissa<Float, std::uint64_t>() && 
-      FloatToBufferImpl<std::uint64_t, Float, mode>( 
-          static_cast<std::uint64_t>(decomposed.mantissa), 
-          static_cast<std::uint64_t>(decomposed.exponent), precision, out, exp)) 
-    return true; 
- 
-#if defined(ABSL_HAVE_INTRINSIC_INT128) 
-  // If that is not enough, try with __uint128_t. 
-  return CanFitMantissa<Float, __uint128_t>() && 
-         FloatToBufferImpl<__uint128_t, Float, mode>( 
-             static_cast<__uint128_t>(decomposed.mantissa), 
-             static_cast<__uint128_t>(decomposed.exponent), precision, out, 
-             exp); 
-#endif 
-  return false; 
-} 
- 
+}
+
+// Print 'digits' as decimal.
+// In Fixed mode, we add a '.' at the end.
+// In Precision mode, we add a '.' after the first digit.
+template <FormatStyle mode, typename Int>
+int PrintIntegralDigits(Int digits, Buffer *out) {
+  int printed = 0;
+  if (digits) {
+    for (; digits; digits /= 10) out->push_front(digits % 10 + '0');
+    printed = out->size();
+    if (mode == FormatStyle::Precision) {
+      out->push_front(*out->begin);
+      out->begin[1] = '.';
+    } else {
+      out->push_back('.');
+    }
+  } else if (mode == FormatStyle::Fixed) {
+    out->push_front('0');
+    out->push_back('.');
+    printed = 1;
+  }
+  return printed;
+}
+
+// Back out 'extra_digits' digits and round up if necessary.
+bool RemoveExtraPrecision(int extra_digits, bool has_leftover_value,
+                          Buffer *out, int *exp_out) {
+  if (extra_digits <= 0) return false;
+
+  // Back out the extra digits
+  out->end -= extra_digits;
+
+  bool needs_to_round_up = [&] {
+    // We look at the digit just past the end.
+    // There must be 'extra_digits' extra valid digits after end.
+    if (*out->end > '5') return true;
+    if (*out->end < '5') return false;
+    if (has_leftover_value || std::any_of(out->end + 1, out->end + extra_digits,
+                                          [](char c) { return c != '0'; }))
+      return true;
+
+    // Ends in ...50*, round to even.
+    return out->last_digit() % 2 == 1;
+  }();
+
+  if (needs_to_round_up) {
+    RoundUp<FormatStyle::Precision>(out, exp_out);
+  }
+  return true;
+}
+
+// Print the value into the buffer.
+// This will not include the exponent, which will be returned in 'exp_out' for
+// Precision mode.
+template <typename Int, typename Float, FormatStyle mode>
+bool FloatToBufferImpl(Int int_mantissa, int exp, int precision, Buffer *out,
+                       int *exp_out) {
+  assert((CanFitMantissa<Float, Int>()));
+
+  const int int_bits = std::numeric_limits<Int>::digits;
+
+  // In precision mode, we start printing one char to the right because it will
+  // also include the '.'
+  // In fixed mode we put the dot afterwards on the right.
+  out->begin = out->end =
+      out->data + 1 + kMaxFixedPrecision + (mode == FormatStyle::Precision);
+
+  if (exp >= 0) {
+    if (std::numeric_limits<Float>::digits + exp > int_bits) {
+      // The value will overflow the Int
+      return false;
+    }
+    int digits_printed = PrintIntegralDigits<mode>(int_mantissa << exp, out);
+    int digits_to_zero_pad = precision;
+    if (mode == FormatStyle::Precision) {
+      *exp_out = digits_printed - 1;
+      digits_to_zero_pad -= digits_printed - 1;
+      if (RemoveExtraPrecision(-digits_to_zero_pad, false, out, exp_out)) {
+        return true;
+      }
+    }
+    for (; digits_to_zero_pad-- > 0;) out->push_back('0');
+    return true;
+  }
+
+  exp = -exp;
+  // We need at least 4 empty bits for the next decimal digit.
+  // We will multiply by 10.
+  if (exp > int_bits - 4) return false;
+
+  const Int mask = (Int{1} << exp) - 1;
+
+  // Print the integral part first.
+  int digits_printed = PrintIntegralDigits<mode>(int_mantissa >> exp, out);
+  int_mantissa &= mask;
+
+  int fractional_count = precision;
+  if (mode == FormatStyle::Precision) {
+    if (digits_printed == 0) {
+      // Find the first non-zero digit, when in Precision mode.
+      *exp_out = 0;
+      if (int_mantissa) {
+        while (int_mantissa <= mask) {
+          int_mantissa *= 10;
+          --*exp_out;
+        }
+      }
+      out->push_front(static_cast<char>(int_mantissa >> exp) + '0');
+      out->push_back('.');
+      int_mantissa &= mask;
+    } else {
+      // We already have a digit, and a '.'
+      *exp_out = digits_printed - 1;
+      fractional_count -= *exp_out;
+      if (RemoveExtraPrecision(-fractional_count, int_mantissa != 0, out,
+                               exp_out)) {
+        // If we had enough digits, return right away.
+        // The code below will try to round again otherwise.
+        return true;
+      }
+    }
+  }
+
+  auto get_next_digit = [&] {
+    int_mantissa *= 10;
+    int digit = static_cast<int>(int_mantissa >> exp);
+    int_mantissa &= mask;
+    return digit;
+  };
+
+  // Print fractional_count more digits, if available.
+  for (; fractional_count > 0; --fractional_count) {
+    out->push_back(get_next_digit() + '0');
+  }
+
+  int next_digit = get_next_digit();
+  if (next_digit > 5 ||
+      (next_digit == 5 && (int_mantissa || out->last_digit() % 2 == 1))) {
+    RoundUp<mode>(out, exp_out);
+  }
+
+  return true;
+}
+
+template <FormatStyle mode, typename Float>
+bool FloatToBuffer(Decomposed<Float> decomposed, int precision, Buffer *out,
+                   int *exp) {
+  if (precision > kMaxFixedPrecision) return false;
+
+  // Try with uint64_t.
+  if (CanFitMantissa<Float, std::uint64_t>() &&
+      FloatToBufferImpl<std::uint64_t, Float, mode>(
+          static_cast<std::uint64_t>(decomposed.mantissa),
+          static_cast<std::uint64_t>(decomposed.exponent), precision, out, exp))
+    return true;
+
+#if defined(ABSL_HAVE_INTRINSIC_INT128)
+  // If that is not enough, try with __uint128_t.
+  return CanFitMantissa<Float, __uint128_t>() &&
+         FloatToBufferImpl<__uint128_t, Float, mode>(
+             static_cast<__uint128_t>(decomposed.mantissa),
+             static_cast<__uint128_t>(decomposed.exponent), precision, out,
+             exp);
+#endif
+  return false;
+}
+
 void WriteBufferToSink(char sign_char, y_absl::string_view str,
                        const FormatConversionSpecImpl &conv,
                        FormatSinkImpl *sink) {
-  int left_spaces = 0, zeros = 0, right_spaces = 0; 
-  int missing_chars = 
-      conv.width() >= 0 ? std::max(conv.width() - static_cast<int>(str.size()) - 
-                                       static_cast<int>(sign_char != 0), 
-                                   0) 
-                        : 0; 
+  int left_spaces = 0, zeros = 0, right_spaces = 0;
+  int missing_chars =
+      conv.width() >= 0 ? std::max(conv.width() - static_cast<int>(str.size()) -
+                                       static_cast<int>(sign_char != 0),
+                                   0)
+                        : 0;
   if (conv.has_left_flag()) {
-    right_spaces = missing_chars; 
+    right_spaces = missing_chars;
   } else if (conv.has_zero_flag()) {
-    zeros = missing_chars; 
-  } else { 
-    left_spaces = missing_chars; 
-  } 
- 
-  sink->Append(left_spaces, ' '); 
+    zeros = missing_chars;
+  } else {
+    left_spaces = missing_chars;
+  }
+
+  sink->Append(left_spaces, ' ');
   if (sign_char != '\0') sink->Append(1, sign_char);
-  sink->Append(zeros, '0'); 
-  sink->Append(str); 
-  sink->Append(right_spaces, ' '); 
-} 
- 
-template <typename Float> 
+  sink->Append(zeros, '0');
+  sink->Append(str);
+  sink->Append(right_spaces, ' ');
+}
+
+template <typename Float>
 bool FloatToSink(const Float v, const FormatConversionSpecImpl &conv,
-                 FormatSinkImpl *sink) { 
-  // Print the sign or the sign column. 
-  Float abs_v = v; 
-  char sign_char = 0; 
-  if (std::signbit(abs_v)) { 
-    sign_char = '-'; 
-    abs_v = -abs_v; 
+                 FormatSinkImpl *sink) {
+  // Print the sign or the sign column.
+  Float abs_v = v;
+  char sign_char = 0;
+  if (std::signbit(abs_v)) {
+    sign_char = '-';
+    abs_v = -abs_v;
   } else if (conv.has_show_pos_flag()) {
-    sign_char = '+'; 
+    sign_char = '+';
   } else if (conv.has_sign_col_flag()) {
-    sign_char = ' '; 
-  } 
- 
-  // Print nan/inf. 
-  if (ConvertNonNumericFloats(sign_char, abs_v, conv, sink)) { 
-    return true; 
-  } 
- 
-  int precision = conv.precision() < 0 ? 6 : conv.precision(); 
- 
-  int exp = 0; 
- 
-  auto decomposed = Decompose(abs_v); 
- 
-  Buffer buffer; 
- 
+    sign_char = ' ';
+  }
+
+  // Print nan/inf.
+  if (ConvertNonNumericFloats(sign_char, abs_v, conv, sink)) {
+    return true;
+  }
+
+  int precision = conv.precision() < 0 ? 6 : conv.precision();
+
+  int exp = 0;
+
+  auto decomposed = Decompose(abs_v);
+
+  Buffer buffer;
+
   FormatConversionChar c = conv.conversion_char();
- 
+
   if (c == FormatConversionCharInternal::f ||
       c == FormatConversionCharInternal::F) {
     FormatF(decomposed.mantissa, decomposed.exponent,
@@ -1366,7 +1366,7 @@ bool FloatToSink(const Float v, const FormatConversionSpecImpl &conv,
         // Have 1.23456, needs 1234.56
         // Move the '.' exp positions to the right.
         std::rotate(buffer.begin + 1, buffer.begin + 2, buffer.begin + exp + 2);
-      } 
+      }
       exp = 0;
     }
     if (!conv.has_alt_flag()) {
@@ -1386,38 +1386,38 @@ bool FloatToSink(const Float v, const FormatConversionSpecImpl &conv,
     return true;
   } else {
     return false;
-  } 
- 
-  WriteBufferToSink(sign_char, 
+  }
+
+  WriteBufferToSink(sign_char,
                     y_absl::string_view(buffer.begin, buffer.end - buffer.begin),
                     conv, sink);
- 
-  return true; 
-} 
- 
-}  // namespace 
- 
+
+  return true;
+}
+
+}  // namespace
+
 bool ConvertFloatImpl(long double v, const FormatConversionSpecImpl &conv,
-                      FormatSinkImpl *sink) { 
+                      FormatSinkImpl *sink) {
   if (IsDoubleDouble()) {
     // This is the `double-double` representation of `long double`. We do not
     // handle it natively. Fallback to snprintf.
     return FallbackToSnprintf(v, conv, sink);
   }
 
-  return FloatToSink(v, conv, sink); 
-} 
- 
+  return FloatToSink(v, conv, sink);
+}
+
 bool ConvertFloatImpl(float v, const FormatConversionSpecImpl &conv,
-                      FormatSinkImpl *sink) { 
+                      FormatSinkImpl *sink) {
   return FloatToSink(static_cast<double>(v), conv, sink);
-} 
- 
+}
+
 bool ConvertFloatImpl(double v, const FormatConversionSpecImpl &conv,
-                      FormatSinkImpl *sink) { 
-  return FloatToSink(v, conv, sink); 
-} 
- 
-}  // namespace str_format_internal 
+                      FormatSinkImpl *sink) {
+  return FloatToSink(v, conv, sink);
+}
+
+}  // namespace str_format_internal
 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 049c2c979c..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
@@ -12,26 +12,26 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_FLOAT_CONVERSION_H_ 
-#define ABSL_STRINGS_INTERNAL_STR_FORMAT_FLOAT_CONVERSION_H_ 
- 
+#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_FLOAT_CONVERSION_H_
+#define ABSL_STRINGS_INTERNAL_STR_FORMAT_FLOAT_CONVERSION_H_
+
 #include "y_absl/strings/internal/str_format/extension.h"
- 
+
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-namespace str_format_internal { 
- 
+namespace str_format_internal {
+
 bool ConvertFloatImpl(float v, const FormatConversionSpecImpl &conv,
-                      FormatSinkImpl *sink); 
- 
+                      FormatSinkImpl *sink);
+
 bool ConvertFloatImpl(double v, const FormatConversionSpecImpl &conv,
-                      FormatSinkImpl *sink); 
- 
+                      FormatSinkImpl *sink);
+
 bool ConvertFloatImpl(long double v, const FormatConversionSpecImpl &conv,
-                      FormatSinkImpl *sink); 
- 
-}  // namespace str_format_internal 
+                      FormatSinkImpl *sink);
+
+}  // namespace str_format_internal
 ABSL_NAMESPACE_END
 }  // namespace y_absl
- 
-#endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_FLOAT_CONVERSION_H_ 
+
+#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 cdf65429db..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
@@ -1,72 +1,72 @@
-// Copyright 2017 The Abseil Authors. 
-// 
-// Licensed under the Apache License, Version 2.0 (the "License"); 
-// you may not use this file except in compliance with the License. 
-// You may obtain a copy of the License at 
-// 
-//      https://www.apache.org/licenses/LICENSE-2.0 
-// 
-// Unless required by applicable law or agreed to in writing, software 
-// distributed under the License is distributed on an "AS IS" BASIS, 
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-// See the License for the specific language governing permissions and 
-// limitations under the License. 
- 
+// Copyright 2017 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/str_format/output.h"
- 
-#include <errno.h> 
-#include <cstring> 
- 
+
+#include <errno.h>
+#include <cstring>
+
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-namespace str_format_internal { 
- 
-namespace { 
-struct ClearErrnoGuard { 
-  ClearErrnoGuard() : old_value(errno) { errno = 0; } 
-  ~ClearErrnoGuard() { 
-    if (!errno) errno = old_value; 
-  } 
-  int old_value; 
-}; 
-}  // namespace 
- 
-void BufferRawSink::Write(string_view v) { 
-  size_t to_write = std::min(v.size(), size_); 
-  std::memcpy(buffer_, v.data(), to_write); 
-  buffer_ += to_write; 
-  size_ -= to_write; 
-  total_written_ += v.size(); 
-} 
- 
-void FILERawSink::Write(string_view v) { 
-  while (!v.empty() && !error_) { 
-    // Reset errno to zero in case the libc implementation doesn't set errno 
-    // when a failure occurs. 
-    ClearErrnoGuard guard; 
- 
-    if (size_t result = std::fwrite(v.data(), 1, v.size(), output_)) { 
-      // Some progress was made. 
-      count_ += result; 
-      v.remove_prefix(result); 
-    } else { 
-      if (errno == EINTR) { 
-        continue; 
-      } else if (errno) { 
-        error_ = errno; 
-      } else if (std::ferror(output_)) { 
-        // Non-POSIX compliant libc implementations may not set errno, so we 
-        // have check the streams error indicator. 
-        error_ = EBADF; 
-      } else { 
-        // We're likely on a non-POSIX system that encountered EINTR but had no 
-        // way of reporting it. 
-        continue; 
-      } 
-    } 
-  } 
-} 
- 
-}  // namespace str_format_internal 
+namespace str_format_internal {
+
+namespace {
+struct ClearErrnoGuard {
+  ClearErrnoGuard() : old_value(errno) { errno = 0; }
+  ~ClearErrnoGuard() {
+    if (!errno) errno = old_value;
+  }
+  int old_value;
+};
+}  // namespace
+
+void BufferRawSink::Write(string_view v) {
+  size_t to_write = std::min(v.size(), size_);
+  std::memcpy(buffer_, v.data(), to_write);
+  buffer_ += to_write;
+  size_ -= to_write;
+  total_written_ += v.size();
+}
+
+void FILERawSink::Write(string_view v) {
+  while (!v.empty() && !error_) {
+    // Reset errno to zero in case the libc implementation doesn't set errno
+    // when a failure occurs.
+    ClearErrnoGuard guard;
+
+    if (size_t result = std::fwrite(v.data(), 1, v.size(), output_)) {
+      // Some progress was made.
+      count_ += result;
+      v.remove_prefix(result);
+    } else {
+      if (errno == EINTR) {
+        continue;
+      } else if (errno) {
+        error_ = errno;
+      } else if (std::ferror(output_)) {
+        // Non-POSIX compliant libc implementations may not set errno, so we
+        // have check the streams error indicator.
+        error_ = EBADF;
+      } else {
+        // We're likely on a non-POSIX system that encountered EINTR but had no
+        // way of reporting it.
+        continue;
+      }
+    }
+  }
+}
+
+}  // namespace str_format_internal
 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 fee403f83e..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
@@ -1,96 +1,96 @@
-// Copyright 2017 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. 
-// 
-// Output extension hooks for the Format library. 
-// `internal::InvokeFlush` calls the appropriate flush function for the 
-// specified output argument. 
-// `BufferRawSink` is a simple output sink for a char buffer. Used by SnprintF. 
-// `FILERawSink` is a std::FILE* based sink. Used by PrintF and FprintF. 
- 
-#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_OUTPUT_H_ 
-#define ABSL_STRINGS_INTERNAL_STR_FORMAT_OUTPUT_H_ 
- 
-#include <cstdio> 
-#include <ostream> 
+// Copyright 2017 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.
+//
+// Output extension hooks for the Format library.
+// `internal::InvokeFlush` calls the appropriate flush function for the
+// specified output argument.
+// `BufferRawSink` is a simple output sink for a char buffer. Used by SnprintF.
+// `FILERawSink` is a std::FILE* based sink. Used by PrintF and FprintF.
+
+#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_OUTPUT_H_
+#define ABSL_STRINGS_INTERNAL_STR_FORMAT_OUTPUT_H_
+
+#include <cstdio>
+#include <ostream>
 #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 str_format_internal { 
- 
-// RawSink implementation that writes into a char* buffer. 
-// It will not overflow the buffer, but will keep the total count of chars 
-// that would have been written. 
-class BufferRawSink { 
- public: 
-  BufferRawSink(char* buffer, size_t size) : buffer_(buffer), size_(size) {} 
- 
-  size_t total_written() const { return total_written_; } 
-  void Write(string_view v); 
- 
- private: 
-  char* buffer_; 
-  size_t size_; 
-  size_t total_written_ = 0; 
-}; 
- 
-// RawSink implementation that writes into a FILE*. 
-// It keeps track of the total number of bytes written and any error encountered 
-// during the writes. 
-class FILERawSink { 
- public: 
-  explicit FILERawSink(std::FILE* output) : output_(output) {} 
- 
-  void Write(string_view v); 
- 
-  size_t count() const { return count_; } 
-  int error() const { return error_; } 
- 
- private: 
-  std::FILE* output_; 
-  int error_ = 0; 
-  size_t count_ = 0; 
-}; 
- 
-// Provide RawSink integration with common types from the STL. 
+namespace str_format_internal {
+
+// RawSink implementation that writes into a char* buffer.
+// It will not overflow the buffer, but will keep the total count of chars
+// that would have been written.
+class BufferRawSink {
+ public:
+  BufferRawSink(char* buffer, size_t size) : buffer_(buffer), size_(size) {}
+
+  size_t total_written() const { return total_written_; }
+  void Write(string_view v);
+
+ private:
+  char* buffer_;
+  size_t size_;
+  size_t total_written_ = 0;
+};
+
+// RawSink implementation that writes into a FILE*.
+// It keeps track of the total number of bytes written and any error encountered
+// during the writes.
+class FILERawSink {
+ public:
+  explicit FILERawSink(std::FILE* output) : output_(output) {}
+
+  void Write(string_view v);
+
+  size_t count() const { return count_; }
+  int error() const { return error_; }
+
+ private:
+  std::FILE* output_;
+  int error_ = 0;
+  size_t count_ = 0;
+};
+
+// Provide RawSink integration with common types from the STL.
 inline void AbslFormatFlush(TString* out, string_view s) {
-  out->append(s.data(), s.size()); 
-} 
-inline void AbslFormatFlush(std::ostream* out, string_view s) { 
-  out->write(s.data(), s.size()); 
-} 
- 
-inline void AbslFormatFlush(FILERawSink* sink, string_view v) { 
-  sink->Write(v); 
-} 
- 
-inline void AbslFormatFlush(BufferRawSink* sink, string_view v) { 
-  sink->Write(v); 
-} 
- 
+  out->append(s.data(), s.size());
+}
+inline void AbslFormatFlush(std::ostream* out, string_view s) {
+  out->write(s.data(), s.size());
+}
+
+inline void AbslFormatFlush(FILERawSink* sink, string_view v) {
+  sink->Write(v);
+}
+
+inline void AbslFormatFlush(BufferRawSink* sink, string_view v) {
+  sink->Write(v);
+}
+
 // This is a SFINAE to get a better compiler error message when the type
 // is not supported.
-template <typename T> 
+template <typename T>
 auto InvokeFlush(T* out, string_view s) -> decltype(AbslFormatFlush(out, s)) {
   AbslFormatFlush(out, s);
-} 
- 
-}  // namespace str_format_internal 
+}
+
+}  // namespace str_format_internal
 ABSL_NAMESPACE_END
 }  // namespace y_absl
- 
-#endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_OUTPUT_H_ 
+
+#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 e6b03cc873..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
@@ -13,24 +13,24 @@
 // limitations under the License.
 
 #include "y_absl/strings/internal/str_format/parser.h"
- 
-#include <assert.h> 
-#include <string.h> 
-#include <wchar.h> 
-#include <cctype> 
-#include <cstdint> 
- 
-#include <algorithm> 
-#include <initializer_list> 
-#include <limits> 
-#include <ostream> 
+
+#include <assert.h>
+#include <string.h>
+#include <wchar.h>
+#include <cctype>
+#include <cstdint>
+
+#include <algorithm>
+#include <initializer_list>
+#include <limits>
+#include <ostream>
 #include <util/generic/string.h>
-#include <unordered_set> 
- 
+#include <unordered_set>
+
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-namespace str_format_internal { 
- 
+namespace str_format_internal {
+
 using CC = FormatConversionCharInternal;
 using LM = LengthMod;
 
@@ -41,7 +41,7 @@ constexpr auto f_pos = Flags::kShowPos;
 constexpr auto f_left = Flags::kLeft;
 constexpr auto f_zero = Flags::kZero;
 
-ABSL_CONST_INIT const ConvTag kTags[256] = { 
+ABSL_CONST_INIT const ConvTag kTags[256] = {
     {},     {},    {},    {},    {},    {},     {},    {},     // 00-07
     {},     {},    {},    {},    {},    {},     {},    {},     // 08-0f
     {},     {},    {},    {},    {},    {},     {},    {},     // 10-17
@@ -74,17 +74,17 @@ ABSL_CONST_INIT const ConvTag kTags[256] = {
     {},     {},    {},    {},    {},    {},     {},    {},     // e8-ef
     {},     {},    {},    {},    {},    {},     {},    {},     // f0-f7
     {},     {},    {},    {},    {},    {},     {},    {},     // f8-ff
-}; 
- 
-namespace { 
- 
-bool CheckFastPathSetting(const UnboundConversion& conv) { 
+};
+
+namespace {
+
+bool CheckFastPathSetting(const UnboundConversion& conv) {
   bool width_precision_needed =
       conv.width.value() >= 0 || conv.precision.value() >= 0;
   if (width_precision_needed && conv.flags == Flags::kBasic) {
-    fprintf(stderr, 
-            "basic=%d left=%d show_pos=%d sign_col=%d alt=%d zero=%d " 
-            "width=%d precision=%d\n", 
+    fprintf(stderr,
+            "basic=%d left=%d show_pos=%d sign_col=%d alt=%d zero=%d "
+            "width=%d precision=%d\n",
             conv.flags == Flags::kBasic ? 1 : 0,
             FlagsContains(conv.flags, Flags::kLeft) ? 1 : 0,
             FlagsContains(conv.flags, Flags::kShowPos) ? 1 : 0,
@@ -93,57 +93,57 @@ bool CheckFastPathSetting(const UnboundConversion& conv) {
             FlagsContains(conv.flags, Flags::kZero) ? 1 : 0, conv.width.value(),
             conv.precision.value());
     return false;
-  } 
+  }
   return true;
-} 
- 
-template <bool is_positional> 
-const char *ConsumeConversion(const char *pos, const char *const end, 
-                              UnboundConversion *conv, int *next_arg) { 
-  const char* const original_pos = pos; 
-  char c; 
-  // Read the next char into `c` and update `pos`. Returns false if there are 
-  // no more chars to read. 
-#define ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR()          \ 
-  do {                                                  \ 
-    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \ 
-    c = *pos++;                                         \ 
-  } while (0) 
- 
-  const auto parse_digits = [&] { 
-    int digits = c - '0'; 
-    // We do not want to overflow `digits` so we consume at most digits10 
-    // digits. If there are more digits the parsing will fail later on when the 
-    // digit doesn't match the expected characters. 
-    int num_digits = std::numeric_limits<int>::digits10; 
-    for (;;) { 
-      if (ABSL_PREDICT_FALSE(pos == end)) break; 
-      c = *pos++; 
-      if (!std::isdigit(c)) break; 
-      --num_digits; 
-      if (ABSL_PREDICT_FALSE(!num_digits)) break; 
-      digits = 10 * digits + c - '0'; 
-    } 
-    return digits; 
-  }; 
- 
-  if (is_positional) { 
-    ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR(); 
-    if (ABSL_PREDICT_FALSE(c < '1' || c > '9')) return nullptr; 
-    conv->arg_position = parse_digits(); 
-    assert(conv->arg_position > 0); 
-    if (ABSL_PREDICT_FALSE(c != '$')) return nullptr; 
-  } 
- 
-  ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR(); 
- 
-  // We should start with the basic flag on. 
+}
+
+template <bool is_positional>
+const char *ConsumeConversion(const char *pos, const char *const end,
+                              UnboundConversion *conv, int *next_arg) {
+  const char* const original_pos = pos;
+  char c;
+  // Read the next char into `c` and update `pos`. Returns false if there are
+  // no more chars to read.
+#define ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR()          \
+  do {                                                  \
+    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
+    c = *pos++;                                         \
+  } while (0)
+
+  const auto parse_digits = [&] {
+    int digits = c - '0';
+    // We do not want to overflow `digits` so we consume at most digits10
+    // digits. If there are more digits the parsing will fail later on when the
+    // digit doesn't match the expected characters.
+    int num_digits = std::numeric_limits<int>::digits10;
+    for (;;) {
+      if (ABSL_PREDICT_FALSE(pos == end)) break;
+      c = *pos++;
+      if (!std::isdigit(c)) break;
+      --num_digits;
+      if (ABSL_PREDICT_FALSE(!num_digits)) break;
+      digits = 10 * digits + c - '0';
+    }
+    return digits;
+  };
+
+  if (is_positional) {
+    ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
+    if (ABSL_PREDICT_FALSE(c < '1' || c > '9')) return nullptr;
+    conv->arg_position = parse_digits();
+    assert(conv->arg_position > 0);
+    if (ABSL_PREDICT_FALSE(c != '$')) return nullptr;
+  }
+
+  ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
+
+  // We should start with the basic flag on.
   assert(conv->flags == Flags::kBasic);
- 
-  // Any non alpha character makes this conversion not basic. 
-  // This includes flags (-+ #0), width (1-9, *) or precision (.). 
-  // All conversion characters and length modifiers are alpha characters. 
-  if (c < 'A') { 
+
+  // Any non alpha character makes this conversion not basic.
+  // This includes flags (-+ #0), width (1-9, *) or precision (.).
+  // All conversion characters and length modifiers are alpha characters.
+  if (c < 'A') {
     while (c <= '0') {
       auto tag = GetTagForChar(c);
       if (tag.is_flags()) {
@@ -151,87 +151,87 @@ const char *ConsumeConversion(const char *pos, const char *const end,
         ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
       } else {
         break;
-      } 
-    } 
- 
-    if (c <= '9') { 
-      if (c >= '0') { 
-        int maybe_width = parse_digits(); 
-        if (!is_positional && c == '$') { 
-          if (ABSL_PREDICT_FALSE(*next_arg != 0)) return nullptr; 
-          // Positional conversion. 
-          *next_arg = -1; 
-          return ConsumeConversion<true>(original_pos, end, conv, next_arg); 
-        } 
+      }
+    }
+
+    if (c <= '9') {
+      if (c >= '0') {
+        int maybe_width = parse_digits();
+        if (!is_positional && c == '$') {
+          if (ABSL_PREDICT_FALSE(*next_arg != 0)) return nullptr;
+          // Positional conversion.
+          *next_arg = -1;
+          return ConsumeConversion<true>(original_pos, end, conv, next_arg);
+        }
         conv->flags = conv->flags | Flags::kNonBasic;
-        conv->width.set_value(maybe_width); 
-      } else if (c == '*') { 
+        conv->width.set_value(maybe_width);
+      } else if (c == '*') {
         conv->flags = conv->flags | Flags::kNonBasic;
-        ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR(); 
-        if (is_positional) { 
-          if (ABSL_PREDICT_FALSE(c < '1' || c > '9')) return nullptr; 
-          conv->width.set_from_arg(parse_digits()); 
-          if (ABSL_PREDICT_FALSE(c != '$')) return nullptr; 
-          ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR(); 
-        } else { 
-          conv->width.set_from_arg(++*next_arg); 
-        } 
-      } 
-    } 
- 
-    if (c == '.') { 
+        ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
+        if (is_positional) {
+          if (ABSL_PREDICT_FALSE(c < '1' || c > '9')) return nullptr;
+          conv->width.set_from_arg(parse_digits());
+          if (ABSL_PREDICT_FALSE(c != '$')) return nullptr;
+          ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
+        } else {
+          conv->width.set_from_arg(++*next_arg);
+        }
+      }
+    }
+
+    if (c == '.') {
       conv->flags = conv->flags | Flags::kNonBasic;
-      ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR(); 
-      if (std::isdigit(c)) { 
-        conv->precision.set_value(parse_digits()); 
-      } else if (c == '*') { 
-        ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR(); 
-        if (is_positional) { 
-          if (ABSL_PREDICT_FALSE(c < '1' || c > '9')) return nullptr; 
-          conv->precision.set_from_arg(parse_digits()); 
-          if (c != '$') return nullptr; 
-          ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR(); 
-        } else { 
-          conv->precision.set_from_arg(++*next_arg); 
-        } 
-      } else { 
-        conv->precision.set_value(0); 
-      } 
-    } 
-  } 
- 
-  auto tag = GetTagForChar(c); 
- 
-  if (ABSL_PREDICT_FALSE(!tag.is_conv())) { 
-    if (ABSL_PREDICT_FALSE(!tag.is_length())) return nullptr; 
- 
-    // It is a length modifier. 
-    using str_format_internal::LengthMod; 
-    LengthMod length_mod = tag.as_length(); 
-    ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR(); 
+      ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
+      if (std::isdigit(c)) {
+        conv->precision.set_value(parse_digits());
+      } else if (c == '*') {
+        ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
+        if (is_positional) {
+          if (ABSL_PREDICT_FALSE(c < '1' || c > '9')) return nullptr;
+          conv->precision.set_from_arg(parse_digits());
+          if (c != '$') return nullptr;
+          ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
+        } else {
+          conv->precision.set_from_arg(++*next_arg);
+        }
+      } else {
+        conv->precision.set_value(0);
+      }
+    }
+  }
+
+  auto tag = GetTagForChar(c);
+
+  if (ABSL_PREDICT_FALSE(!tag.is_conv())) {
+    if (ABSL_PREDICT_FALSE(!tag.is_length())) return nullptr;
+
+    // It is a length modifier.
+    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;
-      ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR(); 
+      ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
     } 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; 
-    } 
-    tag = GetTagForChar(c); 
-    if (ABSL_PREDICT_FALSE(!tag.is_conv())) return nullptr; 
-  } 
- 
-  assert(CheckFastPathSetting(*conv)); 
-  (void)(&CheckFastPathSetting); 
- 
-  conv->conv = tag.as_conv(); 
-  if (!is_positional) conv->arg_position = ++*next_arg; 
-  return pos; 
-} 
- 
-}  // namespace 
- 
+      ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
+    } else {
+      conv->length_mod = length_mod;
+    }
+    tag = GetTagForChar(c);
+    if (ABSL_PREDICT_FALSE(!tag.is_conv())) return nullptr;
+  }
+
+  assert(CheckFastPathSetting(*conv));
+  (void)(&CheckFastPathSetting);
+
+  conv->conv = tag.as_conv();
+  if (!is_positional) conv->arg_position = ++*next_arg;
+  return pos;
+}
+
+}  // namespace
+
 TString LengthModToString(LengthMod v) {
   switch (v) {
     case LengthMod::h:
@@ -258,82 +258,82 @@ TString LengthModToString(LengthMod v) {
   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); 
-  return ConsumeConversion<false>(p, end, conv, next_arg); 
-} 
- 
-struct ParsedFormatBase::ParsedFormatConsumer { 
-  explicit ParsedFormatConsumer(ParsedFormatBase *parsedformat) 
-      : parsed(parsedformat), data_pos(parsedformat->data_.get()) {} 
- 
-  bool Append(string_view s) { 
-    if (s.empty()) return true; 
- 
-    size_t text_end = AppendText(s); 
- 
-    if (!parsed->items_.empty() && !parsed->items_.back().is_conversion) { 
-      // Let's extend the existing text run. 
-      parsed->items_.back().text_end = text_end; 
-    } else { 
-      // Let's make a new text run. 
-      parsed->items_.push_back({false, text_end, {}}); 
-    } 
-    return true; 
-  } 
- 
-  bool ConvertOne(const UnboundConversion &conv, string_view s) { 
-    size_t text_end = AppendText(s); 
-    parsed->items_.push_back({true, text_end, conv}); 
-    return true; 
-  } 
- 
-  size_t AppendText(string_view s) { 
-    memcpy(data_pos, s.data(), s.size()); 
-    data_pos += s.size(); 
-    return static_cast<size_t>(data_pos - parsed->data_.get()); 
-  } 
- 
-  ParsedFormatBase *parsed; 
-  char* data_pos; 
-}; 
- 
+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);
+  return ConsumeConversion<false>(p, end, conv, next_arg);
+}
+
+struct ParsedFormatBase::ParsedFormatConsumer {
+  explicit ParsedFormatConsumer(ParsedFormatBase *parsedformat)
+      : parsed(parsedformat), data_pos(parsedformat->data_.get()) {}
+
+  bool Append(string_view s) {
+    if (s.empty()) return true;
+
+    size_t text_end = AppendText(s);
+
+    if (!parsed->items_.empty() && !parsed->items_.back().is_conversion) {
+      // Let's extend the existing text run.
+      parsed->items_.back().text_end = text_end;
+    } else {
+      // Let's make a new text run.
+      parsed->items_.push_back({false, text_end, {}});
+    }
+    return true;
+  }
+
+  bool ConvertOne(const UnboundConversion &conv, string_view s) {
+    size_t text_end = AppendText(s);
+    parsed->items_.push_back({true, text_end, conv});
+    return true;
+  }
+
+  size_t AppendText(string_view s) {
+    memcpy(data_pos, s.data(), s.size());
+    data_pos += s.size();
+    return static_cast<size_t>(data_pos - parsed->data_.get());
+  }
+
+  ParsedFormatBase *parsed;
+  char* data_pos;
+};
+
 ParsedFormatBase::ParsedFormatBase(
     string_view format, bool allow_ignored,
     std::initializer_list<FormatConversionCharSet> convs)
-    : data_(format.empty() ? nullptr : new char[format.size()]) { 
-  has_error_ = !ParseFormatString(format, ParsedFormatConsumer(this)) || 
-               !MatchesConversions(allow_ignored, convs); 
-} 
- 
-bool ParsedFormatBase::MatchesConversions( 
+    : data_(format.empty() ? nullptr : new char[format.size()]) {
+  has_error_ = !ParseFormatString(format, ParsedFormatConsumer(this)) ||
+               !MatchesConversions(allow_ignored, convs);
+}
+
+bool ParsedFormatBase::MatchesConversions(
     bool allow_ignored,
     std::initializer_list<FormatConversionCharSet> convs) const {
-  std::unordered_set<int> used; 
-  auto add_if_valid_conv = [&](int pos, char c) { 
-      if (static_cast<size_t>(pos) > convs.size() || 
-          !Contains(convs.begin()[pos - 1], c)) 
-        return false; 
-      used.insert(pos); 
-      return true; 
-  }; 
-  for (const ConversionItem &item : items_) { 
-    if (!item.is_conversion) continue; 
-    auto &conv = item.conv; 
-    if (conv.precision.is_from_arg() && 
-        !add_if_valid_conv(conv.precision.get_from_arg(), '*')) 
-      return false; 
-    if (conv.width.is_from_arg() && 
-        !add_if_valid_conv(conv.width.get_from_arg(), '*')) 
-      return false; 
+  std::unordered_set<int> used;
+  auto add_if_valid_conv = [&](int pos, char c) {
+      if (static_cast<size_t>(pos) > convs.size() ||
+          !Contains(convs.begin()[pos - 1], c))
+        return false;
+      used.insert(pos);
+      return true;
+  };
+  for (const ConversionItem &item : items_) {
+    if (!item.is_conversion) continue;
+    auto &conv = item.conv;
+    if (conv.precision.is_from_arg() &&
+        !add_if_valid_conv(conv.precision.get_from_arg(), '*'))
+      return false;
+    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;
-  } 
-  return used.size() == convs.size() || allow_ignored; 
-} 
- 
-}  // namespace str_format_internal 
+  }
+  return used.size() == convs.size() || allow_ignored;
+}
+
+}  // namespace str_format_internal
 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 02a4792b4e..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
@@ -12,88 +12,88 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_PARSER_H_ 
-#define ABSL_STRINGS_INTERNAL_STR_FORMAT_PARSER_H_ 
- 
-#include <limits.h> 
-#include <stddef.h> 
-#include <stdlib.h> 
- 
-#include <cassert> 
+#ifndef ABSL_STRINGS_INTERNAL_STR_FORMAT_PARSER_H_
+#define ABSL_STRINGS_INTERNAL_STR_FORMAT_PARSER_H_
+
+#include <limits.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+#include <cassert>
 #include <cstdint>
-#include <initializer_list> 
-#include <iosfwd> 
-#include <iterator> 
-#include <memory> 
+#include <initializer_list>
+#include <iosfwd>
+#include <iterator>
+#include <memory>
 #include <util/generic/string.h>
-#include <vector> 
- 
+#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
-namespace str_format_internal { 
- 
+namespace str_format_internal {
+
 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 { 
+// The analyzed properties of a single specified conversion.
+struct UnboundConversion {
   UnboundConversion() {}
- 
-  class InputValue { 
-   public: 
-    void set_value(int value) { 
-      assert(value >= 0); 
-      value_ = value; 
-    } 
-    int value() const { return value_; } 
- 
-    // Marks the value as "from arg". aka the '*' format. 
-    // Requires `value >= 1`. 
-    // When set, is_from_arg() return true and get_from_arg() returns the 
-    // original value. 
-    // `value()`'s return value is unspecfied in this state. 
-    void set_from_arg(int value) { 
-      assert(value > 0); 
-      value_ = -value - 1; 
-    } 
-    bool is_from_arg() const { return value_ < -1; } 
-    int get_from_arg() const { 
-      assert(is_from_arg()); 
-      return -value_ - 1; 
-    } 
- 
-   private: 
-    int value_ = -1; 
-  }; 
- 
-  // No need to initialize. It will always be set in the parser. 
-  int arg_position; 
- 
-  InputValue width; 
-  InputValue precision; 
- 
+
+  class InputValue {
+   public:
+    void set_value(int value) {
+      assert(value >= 0);
+      value_ = value;
+    }
+    int value() const { return value_; }
+
+    // Marks the value as "from arg". aka the '*' format.
+    // Requires `value >= 1`.
+    // When set, is_from_arg() return true and get_from_arg() returns the
+    // original value.
+    // `value()`'s return value is unspecfied in this state.
+    void set_from_arg(int value) {
+      assert(value > 0);
+      value_ = -value - 1;
+    }
+    bool is_from_arg() const { return value_ < -1; }
+    int get_from_arg() const {
+      assert(is_from_arg());
+      return -value_ - 1;
+    }
+
+   private:
+    int value_ = -1;
+  };
+
+  // No need to initialize. It will always be set in the parser.
+  int arg_position;
+
+  InputValue width;
+  InputValue precision;
+
   Flags flags = Flags::kBasic;
   LengthMod length_mod = LengthMod::none;
   FormatConversionChar conv = FormatConversionCharInternal::kNone;
-}; 
- 
-// Consume conversion spec prefix (not including '%') of [p, end) if valid. 
-// Examples of valid specs would be e.g.: "s", "d", "-12.6f". 
-// If valid, it returns the first character following the conversion spec, 
-// and the spec part is broken down and returned in 'conv'. 
-// If invalid, returns nullptr. 
-const char* ConsumeUnboundConversion(const char* p, const char* end, 
-                                     UnboundConversion* conv, int* next_arg); 
- 
-// Helper tag class for the table below. 
+};
+
+// Consume conversion spec prefix (not including '%') of [p, end) if valid.
+// Examples of valid specs would be e.g.: "s", "d", "-12.6f".
+// If valid, it returns the first character following the conversion spec,
+// and the spec part is broken down and returned in 'conv'.
+// If invalid, returns nullptr.
+const char* ConsumeUnboundConversion(const char* p, const char* end,
+                                     UnboundConversion* conv, int* next_arg);
+
+// Helper tag class for the table below.
 // It allows fast `char -> ConversionChar/LengthMod/Flags` checking and
 // conversions.
-class ConvTag { 
- public: 
+class ConvTag {
+ public:
   constexpr ConvTag(FormatConversionChar conversion_char)  // NOLINT
       : tag_(static_cast<uint8_t>(conversion_char)) {}
   constexpr ConvTag(LengthMod length_mod)  // NOLINT
@@ -101,257 +101,257 @@ class ConvTag {
   constexpr ConvTag(Flags flags)  // NOLINT
       : tag_(0xc0 | static_cast<uint8_t>(flags)) {}
   constexpr ConvTag() : tag_(0xFF) {}
- 
+
   bool is_conv() const { return (tag_ & 0x80) == 0; }
   bool is_length() const { return (tag_ & 0xC0) == 0x80; }
   bool is_flags() const { return (tag_ & 0xE0) == 0xC0; }
 
   FormatConversionChar as_conv() const {
-    assert(is_conv()); 
+    assert(is_conv());
     assert(!is_length());
     assert(!is_flags());
     return static_cast<FormatConversionChar>(tag_);
-  } 
-  LengthMod as_length() const { 
+  }
+  LengthMod as_length() const {
     assert(!is_conv());
-    assert(is_length()); 
+    assert(is_length());
     assert(!is_flags());
     return static_cast<LengthMod>(tag_ & 0x3F);
-  } 
+  }
   Flags as_flags() const {
     assert(!is_conv());
     assert(!is_length());
     assert(is_flags());
     return static_cast<Flags>(tag_ & 0x1F);
   }
- 
- private: 
+
+ private:
   uint8_t tag_;
-}; 
- 
-extern const ConvTag kTags[256]; 
-// Keep a single table for all the conversion chars and length modifiers. 
-inline ConvTag GetTagForChar(char c) { 
-  return kTags[static_cast<unsigned char>(c)]; 
-} 
- 
-// Parse the format string provided in 'src' and pass the identified items into 
-// 'consumer'. 
-// Text runs will be passed by calling 
-//   Consumer::Append(string_view); 
-// ConversionItems will be passed by calling 
-//   Consumer::ConvertOne(UnboundConversion, string_view); 
-// In the case of ConvertOne, the string_view that is passed is the 
-// portion of the format string corresponding to the conversion, not including 
-// the leading %. On success, it returns true. On failure, it stops and returns 
-// false. 
-template <typename Consumer> 
-bool ParseFormatString(string_view src, Consumer consumer) { 
-  int next_arg = 0; 
-  const char* p = src.data(); 
-  const char* const end = p + src.size(); 
-  while (p != end) { 
-    const char* percent = static_cast<const char*>(memchr(p, '%', end - p)); 
-    if (!percent) { 
-      // We found the last substring. 
-      return consumer.Append(string_view(p, end - p)); 
-    } 
-    // We found a percent, so push the text run then process the percent. 
-    if (ABSL_PREDICT_FALSE(!consumer.Append(string_view(p, percent - p)))) { 
-      return false; 
-    } 
-    if (ABSL_PREDICT_FALSE(percent + 1 >= end)) return false; 
- 
-    auto tag = GetTagForChar(percent[1]); 
-    if (tag.is_conv()) { 
-      if (ABSL_PREDICT_FALSE(next_arg < 0)) { 
+};
+
+extern const ConvTag kTags[256];
+// Keep a single table for all the conversion chars and length modifiers.
+inline ConvTag GetTagForChar(char c) {
+  return kTags[static_cast<unsigned char>(c)];
+}
+
+// Parse the format string provided in 'src' and pass the identified items into
+// 'consumer'.
+// Text runs will be passed by calling
+//   Consumer::Append(string_view);
+// ConversionItems will be passed by calling
+//   Consumer::ConvertOne(UnboundConversion, string_view);
+// In the case of ConvertOne, the string_view that is passed is the
+// portion of the format string corresponding to the conversion, not including
+// the leading %. On success, it returns true. On failure, it stops and returns
+// false.
+template <typename Consumer>
+bool ParseFormatString(string_view src, Consumer consumer) {
+  int next_arg = 0;
+  const char* p = src.data();
+  const char* const end = p + src.size();
+  while (p != end) {
+    const char* percent = static_cast<const char*>(memchr(p, '%', end - p));
+    if (!percent) {
+      // We found the last substring.
+      return consumer.Append(string_view(p, end - p));
+    }
+    // We found a percent, so push the text run then process the percent.
+    if (ABSL_PREDICT_FALSE(!consumer.Append(string_view(p, percent - p)))) {
+      return false;
+    }
+    if (ABSL_PREDICT_FALSE(percent + 1 >= end)) return false;
+
+    auto tag = GetTagForChar(percent[1]);
+    if (tag.is_conv()) {
+      if (ABSL_PREDICT_FALSE(next_arg < 0)) {
         // This indicates an error in the format string.
-        // The only way to get `next_arg < 0` here is to have a positional 
-        // argument first which sets next_arg to -1 and then a non-positional 
-        // argument. 
-        return false; 
-      } 
-      p = percent + 2; 
- 
-      // Keep this case separate from the one below. 
-      // ConvertOne is more efficient when the compiler can see that the `basic` 
-      // flag is set. 
-      UnboundConversion conv; 
-      conv.conv = tag.as_conv(); 
-      conv.arg_position = ++next_arg; 
-      if (ABSL_PREDICT_FALSE( 
-              !consumer.ConvertOne(conv, string_view(percent + 1, 1)))) { 
-        return false; 
-      } 
-    } else if (percent[1] != '%') { 
-      UnboundConversion conv; 
-      p = ConsumeUnboundConversion(percent + 1, end, &conv, &next_arg); 
-      if (ABSL_PREDICT_FALSE(p == nullptr)) return false; 
-      if (ABSL_PREDICT_FALSE(!consumer.ConvertOne( 
-          conv, string_view(percent + 1, p - (percent + 1))))) { 
-        return false; 
-      } 
-    } else { 
-      if (ABSL_PREDICT_FALSE(!consumer.Append("%"))) return false; 
-      p = percent + 2; 
-      continue; 
-    } 
-  } 
-  return true; 
-} 
- 
-// Always returns true, or fails to compile in a constexpr context if s does not 
-// point to a constexpr char array. 
-constexpr bool EnsureConstexpr(string_view s) { 
-  return s.empty() || s[0] == s[0]; 
-} 
- 
-class ParsedFormatBase { 
- public: 
+        // The only way to get `next_arg < 0` here is to have a positional
+        // argument first which sets next_arg to -1 and then a non-positional
+        // argument.
+        return false;
+      }
+      p = percent + 2;
+
+      // Keep this case separate from the one below.
+      // ConvertOne is more efficient when the compiler can see that the `basic`
+      // flag is set.
+      UnboundConversion conv;
+      conv.conv = tag.as_conv();
+      conv.arg_position = ++next_arg;
+      if (ABSL_PREDICT_FALSE(
+              !consumer.ConvertOne(conv, string_view(percent + 1, 1)))) {
+        return false;
+      }
+    } else if (percent[1] != '%') {
+      UnboundConversion conv;
+      p = ConsumeUnboundConversion(percent + 1, end, &conv, &next_arg);
+      if (ABSL_PREDICT_FALSE(p == nullptr)) return false;
+      if (ABSL_PREDICT_FALSE(!consumer.ConvertOne(
+          conv, string_view(percent + 1, p - (percent + 1))))) {
+        return false;
+      }
+    } else {
+      if (ABSL_PREDICT_FALSE(!consumer.Append("%"))) return false;
+      p = percent + 2;
+      continue;
+    }
+  }
+  return true;
+}
+
+// Always returns true, or fails to compile in a constexpr context if s does not
+// point to a constexpr char array.
+constexpr bool EnsureConstexpr(string_view s) {
+  return s.empty() || s[0] == s[0];
+}
+
+class ParsedFormatBase {
+ public:
   explicit ParsedFormatBase(
       string_view format, bool allow_ignored,
       std::initializer_list<FormatConversionCharSet> convs);
- 
-  ParsedFormatBase(const ParsedFormatBase& other) { *this = other; } 
- 
-  ParsedFormatBase(ParsedFormatBase&& other) { *this = std::move(other); } 
- 
-  ParsedFormatBase& operator=(const ParsedFormatBase& other) { 
-    if (this == &other) return *this; 
-    has_error_ = other.has_error_; 
-    items_ = other.items_; 
-    size_t text_size = items_.empty() ? 0 : items_.back().text_end; 
-    data_.reset(new char[text_size]); 
-    memcpy(data_.get(), other.data_.get(), text_size); 
-    return *this; 
-  } 
- 
-  ParsedFormatBase& operator=(ParsedFormatBase&& other) { 
-    if (this == &other) return *this; 
-    has_error_ = other.has_error_; 
-    data_ = std::move(other.data_); 
-    items_ = std::move(other.items_); 
-    // Reset the vector to make sure the invariants hold. 
-    other.items_.clear(); 
-    return *this; 
-  } 
- 
-  template <typename Consumer> 
-  bool ProcessFormat(Consumer consumer) const { 
-    const char* const base = data_.get(); 
-    string_view text(base, 0); 
-    for (const auto& item : items_) { 
-      const char* const end = text.data() + text.size(); 
-      text = string_view(end, (base + item.text_end) - end); 
-      if (item.is_conversion) { 
-        if (!consumer.ConvertOne(item.conv, text)) return false; 
-      } else { 
-        if (!consumer.Append(text)) return false; 
-      } 
-    } 
-    return !has_error_; 
-  } 
- 
-  bool has_error() const { return has_error_; } 
- 
- private: 
-  // Returns whether the conversions match and if !allow_ignored it verifies 
-  // that all conversions are used by the format. 
+
+  ParsedFormatBase(const ParsedFormatBase& other) { *this = other; }
+
+  ParsedFormatBase(ParsedFormatBase&& other) { *this = std::move(other); }
+
+  ParsedFormatBase& operator=(const ParsedFormatBase& other) {
+    if (this == &other) return *this;
+    has_error_ = other.has_error_;
+    items_ = other.items_;
+    size_t text_size = items_.empty() ? 0 : items_.back().text_end;
+    data_.reset(new char[text_size]);
+    memcpy(data_.get(), other.data_.get(), text_size);
+    return *this;
+  }
+
+  ParsedFormatBase& operator=(ParsedFormatBase&& other) {
+    if (this == &other) return *this;
+    has_error_ = other.has_error_;
+    data_ = std::move(other.data_);
+    items_ = std::move(other.items_);
+    // Reset the vector to make sure the invariants hold.
+    other.items_.clear();
+    return *this;
+  }
+
+  template <typename Consumer>
+  bool ProcessFormat(Consumer consumer) const {
+    const char* const base = data_.get();
+    string_view text(base, 0);
+    for (const auto& item : items_) {
+      const char* const end = text.data() + text.size();
+      text = string_view(end, (base + item.text_end) - end);
+      if (item.is_conversion) {
+        if (!consumer.ConvertOne(item.conv, text)) return false;
+      } else {
+        if (!consumer.Append(text)) return false;
+      }
+    }
+    return !has_error_;
+  }
+
+  bool has_error() const { return has_error_; }
+
+ private:
+  // Returns whether the conversions match and if !allow_ignored it verifies
+  // that all conversions are used by the format.
   bool MatchesConversions(
       bool allow_ignored,
       std::initializer_list<FormatConversionCharSet> convs) const;
- 
-  struct ParsedFormatConsumer; 
- 
-  struct ConversionItem { 
-    bool is_conversion; 
-    // Points to the past-the-end location of this element in the data_ array. 
-    size_t text_end; 
-    UnboundConversion conv; 
-  }; 
- 
-  bool has_error_; 
-  std::unique_ptr<char[]> data_; 
-  std::vector<ConversionItem> items_; 
-}; 
- 
- 
-// A value type representing a preparsed format.  These can be created, copied 
-// around, and reused to speed up formatting loops. 
-// The user must specify through the template arguments the conversion 
-// characters used in the format. This will be checked at compile time. 
-// 
-// This class uses Conv enum values to specify each argument. 
-// This allows for more flexibility as you can specify multiple possible 
-// conversion characters for each argument. 
-// ParsedFormat<char...> is a simplified alias for when the user only 
-// needs to specify a single conversion character for each argument. 
-// 
-// Example: 
-//   // Extended format supports multiple characters per argument: 
-//   using MyFormat = ExtendedParsedFormat<Conv::d | Conv::x>; 
-//   MyFormat GetFormat(bool use_hex) { 
-//     if (use_hex) return MyFormat("foo %x bar"); 
-//     return MyFormat("foo %d bar"); 
-//   } 
-//   // 'format' can be used with any value that supports 'd' and 'x', 
-//   // like `int`. 
-//   auto format = GetFormat(use_hex); 
-//   value = StringF(format, i); 
-// 
-// This class also supports runtime format checking with the ::New() and 
-// ::NewAllowIgnored() factory functions. 
-// This is the only API that allows the user to pass a runtime specified format 
-// string. These factory functions will return NULL if the format does not match 
-// the conversions requested by the user. 
+
+  struct ParsedFormatConsumer;
+
+  struct ConversionItem {
+    bool is_conversion;
+    // Points to the past-the-end location of this element in the data_ array.
+    size_t text_end;
+    UnboundConversion conv;
+  };
+
+  bool has_error_;
+  std::unique_ptr<char[]> data_;
+  std::vector<ConversionItem> items_;
+};
+
+
+// A value type representing a preparsed format.  These can be created, copied
+// around, and reused to speed up formatting loops.
+// The user must specify through the template arguments the conversion
+// characters used in the format. This will be checked at compile time.
+//
+// This class uses Conv enum values to specify each argument.
+// This allows for more flexibility as you can specify multiple possible
+// conversion characters for each argument.
+// ParsedFormat<char...> is a simplified alias for when the user only
+// needs to specify a single conversion character for each argument.
+//
+// Example:
+//   // Extended format supports multiple characters per argument:
+//   using MyFormat = ExtendedParsedFormat<Conv::d | Conv::x>;
+//   MyFormat GetFormat(bool use_hex) {
+//     if (use_hex) return MyFormat("foo %x bar");
+//     return MyFormat("foo %d bar");
+//   }
+//   // 'format' can be used with any value that supports 'd' and 'x',
+//   // like `int`.
+//   auto format = GetFormat(use_hex);
+//   value = StringF(format, i);
+//
+// This class also supports runtime format checking with the ::New() and
+// ::NewAllowIgnored() factory functions.
+// This is the only API that allows the user to pass a runtime specified format
+// string. These factory functions will return NULL if the format does not match
+// the conversions requested by the user.
 template <FormatConversionCharSet... C>
-class ExtendedParsedFormat : public str_format_internal::ParsedFormatBase { 
- public: 
-  explicit ExtendedParsedFormat(string_view format) 
+class ExtendedParsedFormat : public str_format_internal::ParsedFormatBase {
+ public:
+  explicit ExtendedParsedFormat(string_view format)
 #ifdef ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
-      __attribute__(( 
-          enable_if(str_format_internal::EnsureConstexpr(format), 
+      __attribute__((
+          enable_if(str_format_internal::EnsureConstexpr(format),
                     "Format string is not constexpr."),
-          enable_if(str_format_internal::ValidFormatImpl<C...>(format), 
-                    "Format specified does not match the template arguments."))) 
-#endif  // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER 
-      : ExtendedParsedFormat(format, false) { 
-  } 
- 
-  // ExtendedParsedFormat factory function. 
-  // The user still has to specify the conversion characters, but they will not 
-  // be checked at compile time. Instead, it will be checked at runtime. 
-  // This delays the checking to runtime, but allows the user to pass 
-  // dynamically sourced formats. 
-  // It returns NULL if the format does not match the conversion characters. 
-  // The user is responsible for checking the return value before using it. 
-  // 
-  // The 'New' variant will check that all the specified arguments are being 
-  // consumed by the format and return NULL if any argument is being ignored. 
-  // The 'NewAllowIgnored' variant will not verify this and will allow formats 
-  // that ignore arguments. 
-  static std::unique_ptr<ExtendedParsedFormat> New(string_view format) { 
-    return New(format, false); 
-  } 
-  static std::unique_ptr<ExtendedParsedFormat> NewAllowIgnored( 
-      string_view format) { 
-    return New(format, true); 
-  } 
- 
- private: 
-  static std::unique_ptr<ExtendedParsedFormat> New(string_view format, 
-                                                   bool allow_ignored) { 
-    std::unique_ptr<ExtendedParsedFormat> conv( 
-        new ExtendedParsedFormat(format, allow_ignored)); 
-    if (conv->has_error()) return nullptr; 
-    return conv; 
-  } 
- 
-  ExtendedParsedFormat(string_view s, bool allow_ignored) 
-      : ParsedFormatBase(s, allow_ignored, {C...}) {} 
-}; 
-}  // namespace str_format_internal 
+          enable_if(str_format_internal::ValidFormatImpl<C...>(format),
+                    "Format specified does not match the template arguments.")))
+#endif  // ABSL_INTERNAL_ENABLE_FORMAT_CHECKER
+      : ExtendedParsedFormat(format, false) {
+  }
+
+  // ExtendedParsedFormat factory function.
+  // The user still has to specify the conversion characters, but they will not
+  // be checked at compile time. Instead, it will be checked at runtime.
+  // This delays the checking to runtime, but allows the user to pass
+  // dynamically sourced formats.
+  // It returns NULL if the format does not match the conversion characters.
+  // The user is responsible for checking the return value before using it.
+  //
+  // The 'New' variant will check that all the specified arguments are being
+  // consumed by the format and return NULL if any argument is being ignored.
+  // The 'NewAllowIgnored' variant will not verify this and will allow formats
+  // that ignore arguments.
+  static std::unique_ptr<ExtendedParsedFormat> New(string_view format) {
+    return New(format, false);
+  }
+  static std::unique_ptr<ExtendedParsedFormat> NewAllowIgnored(
+      string_view format) {
+    return New(format, true);
+  }
+
+ private:
+  static std::unique_ptr<ExtendedParsedFormat> New(string_view format,
+                                                   bool allow_ignored) {
+    std::unique_ptr<ExtendedParsedFormat> conv(
+        new ExtendedParsedFormat(format, allow_ignored));
+    if (conv->has_error()) return nullptr;
+    return conv;
+  }
+
+  ExtendedParsedFormat(string_view s, bool allow_ignored)
+      : ParsedFormatBase(s, allow_ignored, {C...}) {}
+};
+}  // namespace str_format_internal
 ABSL_NAMESPACE_END
 }  // namespace y_absl
- 
-#endif  // ABSL_STRINGS_INTERNAL_STR_FORMAT_PARSER_H_ 
+
+#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 aabeb54a28..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
@@ -1,17 +1,17 @@
-# Generated by devtools/yamaker. 
- 
-LIBRARY() 
- 
+# Generated by devtools/yamaker.
+
+LIBRARY()
+
 OWNER(
     somov
     g:cpp-contrib
 )
- 
-LICENSE(Apache-2.0) 
- 
+
+LICENSE(Apache-2.0)
+
 LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
 
-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/spinlock_wait
@@ -20,21 +20,21 @@ PEERDIR(
     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
-) 
- 
+)
+
 ADDINCL(
     GLOBAL contrib/restricted/abseil-cpp-tstring
 )
- 
-NO_COMPILER_WARNINGS() 
- 
-SRCS( 
-    arg.cc 
-    bind.cc 
-    extension.cc 
-    float_conversion.cc 
-    output.cc 
-    parser.cc 
-) 
- 
-END() 
+
+NO_COMPILER_WARNINGS()
+
+SRCS(
+    arg.cc
+    bind.cc
+    extension.cc
+    float_conversion.cc
+    output.cc
+    parser.cc
+)
+
+END()
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 32f114807a..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
@@ -1,314 +1,314 @@
-// 
-// Copyright 2017 The Abseil Authors. 
-// 
-// Licensed under the Apache License, Version 2.0 (the "License"); 
-// you may not use this file except in compliance with the License. 
-// You may obtain a copy of the License at 
-// 
-//      https://www.apache.org/licenses/LICENSE-2.0 
-// 
-// Unless required by applicable law or agreed to in writing, software 
-// distributed under the License is distributed on an "AS IS" BASIS, 
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-// See the License for the specific language governing permissions and 
-// limitations under the License. 
-// 
- 
-// This file declares INTERNAL parts of the Join API that are inlined/templated 
-// or otherwise need to be available at compile time. The main abstractions 
-// defined in this file are: 
-// 
-//   - A handful of default Formatters 
-//   - JoinAlgorithm() overloads 
-//   - JoinRange() overloads 
-//   - JoinTuple() 
-// 
-// DO NOT INCLUDE THIS FILE DIRECTLY. Use this file by including 
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// This file declares INTERNAL parts of the Join API that are inlined/templated
+// or otherwise need to be available at compile time. The main abstractions
+// defined in this file are:
+//
+//   - A handful of default Formatters
+//   - JoinAlgorithm() overloads
+//   - JoinRange() overloads
+//   - JoinTuple()
+//
+// DO NOT INCLUDE THIS FILE DIRECTLY. Use this file by including
 // y_absl/strings/str_join.h
-// 
+//
 // IWYU pragma: private, include "y_absl/strings/str_join.h"
- 
-#ifndef ABSL_STRINGS_INTERNAL_STR_JOIN_INTERNAL_H_ 
-#define ABSL_STRINGS_INTERNAL_STR_JOIN_INTERNAL_H_ 
- 
-#include <cstring> 
-#include <iterator> 
-#include <memory> 
+
+#ifndef ABSL_STRINGS_INTERNAL_STR_JOIN_INTERNAL_H_
+#define ABSL_STRINGS_INTERNAL_STR_JOIN_INTERNAL_H_
+
+#include <cstring>
+#include <iterator>
+#include <memory>
 #include <util/generic/string.h>
-#include <type_traits> 
-#include <utility> 
- 
+#include <type_traits>
+#include <utility>
+
 #include "y_absl/strings/internal/ostringstream.h"
 #include "y_absl/strings/internal/resize_uninitialized.h"
 #include "y_absl/strings/str_cat.h"
- 
+
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-namespace strings_internal { 
- 
-// 
-// Formatter objects 
-// 
-// The following are implementation classes for standard Formatter objects. The 
-// factory functions that users will call to create and use these formatters are 
-// defined and documented in strings/join.h. 
-// 
- 
-// The default formatter. Converts alpha-numeric types to strings. 
-struct AlphaNumFormatterImpl { 
-  // This template is needed in order to support passing in a dereferenced 
-  // vector<bool>::iterator 
-  template <typename T> 
+namespace strings_internal {
+
+//
+// Formatter objects
+//
+// The following are implementation classes for standard Formatter objects. The
+// factory functions that users will call to create and use these formatters are
+// defined and documented in strings/join.h.
+//
+
+// The default formatter. Converts alpha-numeric types to strings.
+struct AlphaNumFormatterImpl {
+  // This template is needed in order to support passing in a dereferenced
+  // vector<bool>::iterator
+  template <typename T>
   void operator()(TString* out, const T& t) const {
-    StrAppend(out, AlphaNum(t)); 
-  } 
- 
+    StrAppend(out, AlphaNum(t));
+  }
+
   void operator()(TString* out, const AlphaNum& t) const {
-    StrAppend(out, t); 
-  } 
-}; 
- 
-// A type that's used to overload the JoinAlgorithm() function (defined below) 
-// for ranges that do not require additional formatting (e.g., a range of 
-// strings). 
- 
-struct NoFormatter : public AlphaNumFormatterImpl {}; 
- 
-// Formats types to strings using the << operator. 
-class StreamFormatterImpl { 
- public: 
-  // The method isn't const because it mutates state. Making it const will 
-  // render StreamFormatterImpl thread-hostile. 
-  template <typename T> 
+    StrAppend(out, t);
+  }
+};
+
+// A type that's used to overload the JoinAlgorithm() function (defined below)
+// for ranges that do not require additional formatting (e.g., a range of
+// strings).
+
+struct NoFormatter : public AlphaNumFormatterImpl {};
+
+// Formats types to strings using the << operator.
+class StreamFormatterImpl {
+ public:
+  // The method isn't const because it mutates state. Making it const will
+  // render StreamFormatterImpl thread-hostile.
+  template <typename T>
   void operator()(TString* out, const T& t) {
-    // The stream is created lazily to avoid paying the relatively high cost 
-    // of its construction when joining an empty range. 
-    if (strm_) { 
-      strm_->clear();  // clear the bad, fail and eof bits in case they were set 
-      strm_->str(out); 
-    } else { 
-      strm_.reset(new strings_internal::OStringStream(out)); 
-    } 
-    *strm_ << t; 
-  } 
- 
- private: 
-  std::unique_ptr<strings_internal::OStringStream> strm_; 
-}; 
- 
-// Formats a std::pair<>. The 'first' member is formatted using f1_ and the 
-// 'second' member is formatted using f2_. sep_ is the separator. 
-template <typename F1, typename F2> 
-class PairFormatterImpl { 
- public: 
+    // The stream is created lazily to avoid paying the relatively high cost
+    // of its construction when joining an empty range.
+    if (strm_) {
+      strm_->clear();  // clear the bad, fail and eof bits in case they were set
+      strm_->str(out);
+    } else {
+      strm_.reset(new strings_internal::OStringStream(out));
+    }
+    *strm_ << t;
+  }
+
+ private:
+  std::unique_ptr<strings_internal::OStringStream> strm_;
+};
+
+// Formats a std::pair<>. The 'first' member is formatted using f1_ and the
+// 'second' member is formatted using f2_. sep_ is the separator.
+template <typename F1, typename F2>
+class PairFormatterImpl {
+ public:
   PairFormatterImpl(F1 f1, y_absl::string_view sep, F2 f2)
-      : f1_(std::move(f1)), sep_(sep), f2_(std::move(f2)) {} 
- 
-  template <typename T> 
+      : f1_(std::move(f1)), sep_(sep), f2_(std::move(f2)) {}
+
+  template <typename T>
   void operator()(TString* out, const T& p) {
-    f1_(out, p.first); 
-    out->append(sep_); 
-    f2_(out, p.second); 
-  } 
- 
-  template <typename T> 
+    f1_(out, p.first);
+    out->append(sep_);
+    f2_(out, p.second);
+  }
+
+  template <typename T>
   void operator()(TString* out, const T& p) const {
-    f1_(out, p.first); 
-    out->append(sep_); 
-    f2_(out, p.second); 
-  } 
- 
- private: 
-  F1 f1_; 
+    f1_(out, p.first);
+    out->append(sep_);
+    f2_(out, p.second);
+  }
+
+ private:
+  F1 f1_;
   TString sep_;
-  F2 f2_; 
-}; 
- 
-// Wraps another formatter and dereferences the argument to operator() then 
-// passes the dereferenced argument to the wrapped formatter. This can be 
-// useful, for example, to join a std::vector<int*>. 
-template <typename Formatter> 
-class DereferenceFormatterImpl { 
- public: 
-  DereferenceFormatterImpl() : f_() {} 
-  explicit DereferenceFormatterImpl(Formatter&& f) 
-      : f_(std::forward<Formatter>(f)) {} 
- 
-  template <typename T> 
+  F2 f2_;
+};
+
+// Wraps another formatter and dereferences the argument to operator() then
+// passes the dereferenced argument to the wrapped formatter. This can be
+// useful, for example, to join a std::vector<int*>.
+template <typename Formatter>
+class DereferenceFormatterImpl {
+ public:
+  DereferenceFormatterImpl() : f_() {}
+  explicit DereferenceFormatterImpl(Formatter&& f)
+      : f_(std::forward<Formatter>(f)) {}
+
+  template <typename T>
   void operator()(TString* out, const T& t) {
-    f_(out, *t); 
-  } 
- 
-  template <typename T> 
+    f_(out, *t);
+  }
+
+  template <typename T>
   void operator()(TString* out, const T& t) const {
-    f_(out, *t); 
-  } 
- 
- private: 
-  Formatter f_; 
-}; 
- 
-// DefaultFormatter<T> is a traits class that selects a default Formatter to use 
-// for the given type T. The ::Type member names the Formatter to use. This is 
-// used by the strings::Join() functions that do NOT take a Formatter argument, 
-// in which case a default Formatter must be chosen. 
-// 
-// AlphaNumFormatterImpl is the default in the base template, followed by 
-// specializations for other types. 
-template <typename ValueType> 
-struct DefaultFormatter { 
-  typedef AlphaNumFormatterImpl Type; 
-}; 
-template <> 
-struct DefaultFormatter<const char*> { 
-  typedef AlphaNumFormatterImpl Type; 
-}; 
-template <> 
-struct DefaultFormatter<char*> { 
-  typedef AlphaNumFormatterImpl Type; 
-}; 
-template <> 
+    f_(out, *t);
+  }
+
+ private:
+  Formatter f_;
+};
+
+// DefaultFormatter<T> is a traits class that selects a default Formatter to use
+// for the given type T. The ::Type member names the Formatter to use. This is
+// used by the strings::Join() functions that do NOT take a Formatter argument,
+// in which case a default Formatter must be chosen.
+//
+// AlphaNumFormatterImpl is the default in the base template, followed by
+// specializations for other types.
+template <typename ValueType>
+struct DefaultFormatter {
+  typedef AlphaNumFormatterImpl Type;
+};
+template <>
+struct DefaultFormatter<const char*> {
+  typedef AlphaNumFormatterImpl Type;
+};
+template <>
+struct DefaultFormatter<char*> {
+  typedef AlphaNumFormatterImpl Type;
+};
+template <>
 struct DefaultFormatter<TString> {
-  typedef NoFormatter Type; 
-}; 
-template <> 
+  typedef NoFormatter Type;
+};
+template <>
 struct DefaultFormatter<y_absl::string_view> {
-  typedef NoFormatter Type; 
-}; 
-template <typename ValueType> 
-struct DefaultFormatter<ValueType*> { 
-  typedef DereferenceFormatterImpl<typename DefaultFormatter<ValueType>::Type> 
-      Type; 
-}; 
- 
-template <typename ValueType> 
-struct DefaultFormatter<std::unique_ptr<ValueType>> 
-    : public DefaultFormatter<ValueType*> {}; 
- 
-// 
-// JoinAlgorithm() functions 
-// 
- 
-// The main joining algorithm. This simply joins the elements in the given 
-// iterator range, each separated by the given separator, into an output string, 
-// and formats each element using the provided Formatter object. 
-template <typename Iterator, typename Formatter> 
+  typedef NoFormatter Type;
+};
+template <typename ValueType>
+struct DefaultFormatter<ValueType*> {
+  typedef DereferenceFormatterImpl<typename DefaultFormatter<ValueType>::Type>
+      Type;
+};
+
+template <typename ValueType>
+struct DefaultFormatter<std::unique_ptr<ValueType>>
+    : public DefaultFormatter<ValueType*> {};
+
+//
+// JoinAlgorithm() functions
+//
+
+// The main joining algorithm. This simply joins the elements in the given
+// iterator range, each separated by the given separator, into an output string,
+// and formats each element using the provided Formatter object.
+template <typename Iterator, typename Formatter>
 TString JoinAlgorithm(Iterator start, Iterator end, y_absl::string_view s,
-                          Formatter&& f) { 
+                          Formatter&& f) {
   TString result;
   y_absl::string_view sep("");
-  for (Iterator it = start; it != end; ++it) { 
-    result.append(sep.data(), sep.size()); 
-    f(&result, *it); 
-    sep = s; 
-  } 
-  return result; 
-} 
- 
-// A joining algorithm that's optimized for a forward iterator range of 
-// string-like objects that do not need any additional formatting. This is to 
-// optimize the common case of joining, say, a std::vector<string> or a 
+  for (Iterator it = start; it != end; ++it) {
+    result.append(sep.data(), sep.size());
+    f(&result, *it);
+    sep = s;
+  }
+  return result;
+}
+
+// A joining algorithm that's optimized for a forward iterator range of
+// string-like objects that do not need any additional formatting. This is to
+// optimize the common case of joining, say, a std::vector<string> or a
 // std::vector<y_absl::string_view>.
-// 
-// This is an overload of the previous JoinAlgorithm() function. Here the 
-// Formatter argument is of type NoFormatter. Since NoFormatter is an internal 
-// type, this overload is only invoked when strings::Join() is called with a 
+//
+// This is an overload of the previous JoinAlgorithm() function. Here the
+// Formatter argument is of type NoFormatter. Since NoFormatter is an internal
+// type, this overload is only invoked when strings::Join() is called with a
 // range of string-like objects (e.g., TString, y_absl::string_view), and an
-// explicit Formatter argument was NOT specified. 
-// 
-// The optimization is that the needed space will be reserved in the output 
-// string to avoid the need to resize while appending. To do this, the iterator 
-// range will be traversed twice: once to calculate the total needed size, and 
-// then again to copy the elements and delimiters to the output string. 
-template <typename Iterator, 
-          typename = typename std::enable_if<std::is_convertible< 
-              typename std::iterator_traits<Iterator>::iterator_category, 
-              std::forward_iterator_tag>::value>::type> 
+// explicit Formatter argument was NOT specified.
+//
+// The optimization is that the needed space will be reserved in the output
+// string to avoid the need to resize while appending. To do this, the iterator
+// range will be traversed twice: once to calculate the total needed size, and
+// then again to copy the elements and delimiters to the output string.
+template <typename Iterator,
+          typename = typename std::enable_if<std::is_convertible<
+              typename std::iterator_traits<Iterator>::iterator_category,
+              std::forward_iterator_tag>::value>::type>
 TString JoinAlgorithm(Iterator start, Iterator end, y_absl::string_view s,
-                          NoFormatter) { 
+                          NoFormatter) {
   TString result;
-  if (start != end) { 
-    // Sums size 
-    size_t result_size = start->size(); 
-    for (Iterator it = start; ++it != end;) { 
-      result_size += s.size(); 
-      result_size += it->size(); 
-    } 
- 
-    if (result_size > 0) { 
-      STLStringResizeUninitialized(&result, result_size); 
- 
-      // Joins strings 
-      char* result_buf = &*result.begin(); 
-      memcpy(result_buf, start->data(), start->size()); 
-      result_buf += start->size(); 
-      for (Iterator it = start; ++it != end;) { 
-        memcpy(result_buf, s.data(), s.size()); 
-        result_buf += s.size(); 
-        memcpy(result_buf, it->data(), it->size()); 
-        result_buf += it->size(); 
-      } 
-    } 
-  } 
- 
-  return result; 
-} 
- 
-// JoinTupleLoop implements a loop over the elements of a std::tuple, which 
-// are heterogeneous. The primary template matches the tuple interior case. It 
-// continues the iteration after appending a separator (for nonzero indices) 
-// and formatting an element of the tuple. The specialization for the I=N case 
-// matches the end-of-tuple, and terminates the iteration. 
-template <size_t I, size_t N> 
-struct JoinTupleLoop { 
-  template <typename Tup, typename Formatter> 
+  if (start != end) {
+    // Sums size
+    size_t result_size = start->size();
+    for (Iterator it = start; ++it != end;) {
+      result_size += s.size();
+      result_size += it->size();
+    }
+
+    if (result_size > 0) {
+      STLStringResizeUninitialized(&result, result_size);
+
+      // Joins strings
+      char* result_buf = &*result.begin();
+      memcpy(result_buf, start->data(), start->size());
+      result_buf += start->size();
+      for (Iterator it = start; ++it != end;) {
+        memcpy(result_buf, s.data(), s.size());
+        result_buf += s.size();
+        memcpy(result_buf, it->data(), it->size());
+        result_buf += it->size();
+      }
+    }
+  }
+
+  return result;
+}
+
+// JoinTupleLoop implements a loop over the elements of a std::tuple, which
+// are heterogeneous. The primary template matches the tuple interior case. It
+// continues the iteration after appending a separator (for nonzero indices)
+// and formatting an element of the tuple. The specialization for the I=N case
+// matches the end-of-tuple, and terminates the iteration.
+template <size_t I, size_t N>
+struct JoinTupleLoop {
+  template <typename Tup, typename Formatter>
   void operator()(TString* out, const Tup& tup, y_absl::string_view sep,
-                  Formatter&& fmt) { 
-    if (I > 0) out->append(sep.data(), sep.size()); 
-    fmt(out, std::get<I>(tup)); 
-    JoinTupleLoop<I + 1, N>()(out, tup, sep, fmt); 
-  } 
-}; 
-template <size_t N> 
-struct JoinTupleLoop<N, N> { 
-  template <typename Tup, typename Formatter> 
+                  Formatter&& fmt) {
+    if (I > 0) out->append(sep.data(), sep.size());
+    fmt(out, std::get<I>(tup));
+    JoinTupleLoop<I + 1, N>()(out, tup, sep, fmt);
+  }
+};
+template <size_t N>
+struct JoinTupleLoop<N, N> {
+  template <typename Tup, typename Formatter>
   void operator()(TString*, const Tup&, y_absl::string_view, Formatter&&) {}
-}; 
- 
-template <typename... T, typename Formatter> 
+};
+
+template <typename... T, typename Formatter>
 TString JoinAlgorithm(const std::tuple<T...>& tup, y_absl::string_view sep,
-                          Formatter&& fmt) { 
+                          Formatter&& fmt) {
   TString result;
-  JoinTupleLoop<0, sizeof...(T)>()(&result, tup, sep, fmt); 
-  return result; 
-} 
- 
-template <typename Iterator> 
+  JoinTupleLoop<0, sizeof...(T)>()(&result, tup, sep, fmt);
+  return result;
+}
+
+template <typename Iterator>
 TString JoinRange(Iterator first, Iterator last,
                       y_absl::string_view separator) {
-  // No formatter was explicitly given, so a default must be chosen. 
-  typedef typename std::iterator_traits<Iterator>::value_type ValueType; 
-  typedef typename DefaultFormatter<ValueType>::Type Formatter; 
-  return JoinAlgorithm(first, last, separator, Formatter()); 
-} 
- 
-template <typename Range, typename Formatter> 
+  // No formatter was explicitly given, so a default must be chosen.
+  typedef typename std::iterator_traits<Iterator>::value_type ValueType;
+  typedef typename DefaultFormatter<ValueType>::Type Formatter;
+  return JoinAlgorithm(first, last, separator, Formatter());
+}
+
+template <typename Range, typename Formatter>
 TString JoinRange(const Range& range, y_absl::string_view separator,
-                      Formatter&& fmt) { 
-  using std::begin; 
-  using std::end; 
-  return JoinAlgorithm(begin(range), end(range), separator, fmt); 
-} 
- 
-template <typename Range> 
+                      Formatter&& fmt) {
+  using std::begin;
+  using std::end;
+  return JoinAlgorithm(begin(range), end(range), separator, fmt);
+}
+
+template <typename Range>
 TString JoinRange(const Range& range, y_absl::string_view separator) {
-  using std::begin; 
-  using std::end; 
-  return JoinRange(begin(range), end(range), separator); 
-} 
- 
-}  // namespace strings_internal 
+  using std::begin;
+  using std::end;
+  return JoinRange(begin(range), end(range), separator);
+}
+
+}  // namespace strings_internal
 ABSL_NAMESPACE_END
 }  // namespace y_absl
- 
-#endif  // ABSL_STRINGS_INTERNAL_STR_JOIN_INTERNAL_H_ 
+
+#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 14f93e8e98..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
@@ -1,187 +1,187 @@
-// Copyright 2017 The Abseil Authors. 
-// 
-// Licensed under the Apache License, Version 2.0 (the "License"); 
-// you may not use this file except in compliance with the License. 
-// You may obtain a copy of the License at 
-// 
-//      https://www.apache.org/licenses/LICENSE-2.0 
-// 
-// Unless required by applicable law or agreed to in writing, software 
-// distributed under the License is distributed on an "AS IS" BASIS, 
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-// See the License for the specific language governing permissions and 
-// limitations under the License. 
-// 
- 
-// This file declares INTERNAL parts of the Split API that are inline/templated 
-// or otherwise need to be available at compile time. The main abstractions 
-// defined in here are 
-// 
-//   - ConvertibleToStringView 
-//   - SplitIterator<> 
-//   - Splitter<> 
-// 
-// DO NOT INCLUDE THIS FILE DIRECTLY. Use this file by including 
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// This file declares INTERNAL parts of the Split API that are inline/templated
+// or otherwise need to be available at compile time. The main abstractions
+// defined in here are
+//
+//   - ConvertibleToStringView
+//   - SplitIterator<>
+//   - Splitter<>
+//
+// DO NOT INCLUDE THIS FILE DIRECTLY. Use this file by including
 // y_absl/strings/str_split.h.
-// 
+//
 // IWYU pragma: private, include "y_absl/strings/str_split.h"
- 
-#ifndef ABSL_STRINGS_INTERNAL_STR_SPLIT_INTERNAL_H_ 
-#define ABSL_STRINGS_INTERNAL_STR_SPLIT_INTERNAL_H_ 
- 
-#include <array> 
-#include <initializer_list> 
-#include <iterator> 
+
+#ifndef ABSL_STRINGS_INTERNAL_STR_SPLIT_INTERNAL_H_
+#define ABSL_STRINGS_INTERNAL_STR_SPLIT_INTERNAL_H_
+
+#include <array>
+#include <initializer_list>
+#include <iterator>
 #include <tuple>
-#include <type_traits> 
-#include <utility> 
-#include <vector> 
- 
+#include <type_traits>
+#include <utility>
+#include <vector>
+
 #include "y_absl/base/macros.h"
 #include "y_absl/base/port.h"
 #include "y_absl/meta/type_traits.h"
 #include "y_absl/strings/string_view.h"
- 
-#ifdef _GLIBCXX_DEBUG 
+
+#ifdef _GLIBCXX_DEBUG
 #include "y_absl/strings/internal/stl_type_traits.h"
-#endif  // _GLIBCXX_DEBUG 
- 
+#endif  // _GLIBCXX_DEBUG
+
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-namespace strings_internal { 
- 
+namespace strings_internal {
+
 // This class is implicitly constructible from everything that y_absl::string_view
 // is implicitly constructible from, except for rvalue strings.  This means it
 // can be used as a function parameter in places where passing a temporary
 // string might cause memory lifetime issues.
-class ConvertibleToStringView { 
- public: 
-  ConvertibleToStringView(const char* s)  // NOLINT(runtime/explicit) 
-      : value_(s) {} 
-  ConvertibleToStringView(char* s) : value_(s) {}  // NOLINT(runtime/explicit) 
+class ConvertibleToStringView {
+ public:
+  ConvertibleToStringView(const char* s)  // NOLINT(runtime/explicit)
+      : value_(s) {}
+  ConvertibleToStringView(char* s) : value_(s) {}  // NOLINT(runtime/explicit)
   ConvertibleToStringView(y_absl::string_view s)     // NOLINT(runtime/explicit)
-      : value_(s) {} 
+      : value_(s) {}
   ConvertibleToStringView(const TString& s)  // NOLINT(runtime/explicit)
-      : value_(s) {} 
- 
+      : value_(s) {}
+
   // Disable conversion from rvalue strings.
   ConvertibleToStringView(TString&& s) = delete;
   ConvertibleToStringView(const TString&& s) = delete;
- 
+
   y_absl::string_view value() const { return value_; }
- 
- private: 
+
+ private:
   y_absl::string_view value_;
-}; 
- 
-// An iterator that enumerates the parts of a string from a Splitter. The text 
-// to be split, the Delimiter, and the Predicate are all taken from the given 
-// Splitter object. Iterators may only be compared if they refer to the same 
-// Splitter instance. 
-// 
-// This class is NOT part of the public splitting API. 
-template <typename Splitter> 
-class SplitIterator { 
- public: 
-  using iterator_category = std::input_iterator_tag; 
+};
+
+// An iterator that enumerates the parts of a string from a Splitter. The text
+// to be split, the Delimiter, and the Predicate are all taken from the given
+// Splitter object. Iterators may only be compared if they refer to the same
+// Splitter instance.
+//
+// This class is NOT part of the public splitting API.
+template <typename Splitter>
+class SplitIterator {
+ public:
+  using iterator_category = std::input_iterator_tag;
   using value_type = y_absl::string_view;
-  using difference_type = ptrdiff_t; 
-  using pointer = const value_type*; 
-  using reference = const value_type&; 
- 
-  enum State { kInitState, kLastState, kEndState }; 
-  SplitIterator(State state, const Splitter* splitter) 
-      : pos_(0), 
-        state_(state), 
-        splitter_(splitter), 
-        delimiter_(splitter->delimiter()), 
-        predicate_(splitter->predicate()) { 
-    // Hack to maintain backward compatibility. This one block makes it so an 
+  using difference_type = ptrdiff_t;
+  using pointer = const value_type*;
+  using reference = const value_type&;
+
+  enum State { kInitState, kLastState, kEndState };
+  SplitIterator(State state, const Splitter* splitter)
+      : pos_(0),
+        state_(state),
+        splitter_(splitter),
+        delimiter_(splitter->delimiter()),
+        predicate_(splitter->predicate()) {
+    // Hack to maintain backward compatibility. This one block makes it so an
     // empty y_absl::string_view whose .data() happens to be nullptr behaves
     // *differently* from an otherwise empty y_absl::string_view whose .data() is
-    // not nullptr. This is an undesirable difference in general, but this 
-    // behavior is maintained to avoid breaking existing code that happens to 
-    // depend on this old behavior/bug. Perhaps it will be fixed one day. The 
-    // difference in behavior is as follows: 
+    // not nullptr. This is an undesirable difference in general, but this
+    // behavior is maintained to avoid breaking existing code that happens to
+    // depend on this old behavior/bug. Perhaps it will be fixed one day. The
+    // difference in behavior is as follows:
     //   Split(y_absl::string_view(""), '-');  // {""}
     //   Split(y_absl::string_view(), '-');    // {}
-    if (splitter_->text().data() == nullptr) { 
-      state_ = kEndState; 
-      pos_ = splitter_->text().size(); 
-      return; 
-    } 
- 
-    if (state_ == kEndState) { 
-      pos_ = splitter_->text().size(); 
-    } else { 
-      ++(*this); 
-    } 
-  } 
- 
-  bool at_end() const { return state_ == kEndState; } 
- 
-  reference operator*() const { return curr_; } 
-  pointer operator->() const { return &curr_; } 
- 
-  SplitIterator& operator++() { 
-    do { 
-      if (state_ == kLastState) { 
-        state_ = kEndState; 
-        return *this; 
-      } 
+    if (splitter_->text().data() == nullptr) {
+      state_ = kEndState;
+      pos_ = splitter_->text().size();
+      return;
+    }
+
+    if (state_ == kEndState) {
+      pos_ = splitter_->text().size();
+    } else {
+      ++(*this);
+    }
+  }
+
+  bool at_end() const { return state_ == kEndState; }
+
+  reference operator*() const { return curr_; }
+  pointer operator->() const { return &curr_; }
+
+  SplitIterator& operator++() {
+    do {
+      if (state_ == kLastState) {
+        state_ = kEndState;
+        return *this;
+      }
       const y_absl::string_view text = splitter_->text();
       const y_absl::string_view d = delimiter_.Find(text, pos_);
-      if (d.data() == text.data() + text.size()) state_ = kLastState; 
-      curr_ = text.substr(pos_, d.data() - (text.data() + pos_)); 
-      pos_ += curr_.size() + d.size(); 
-    } while (!predicate_(curr_)); 
-    return *this; 
-  } 
- 
-  SplitIterator operator++(int) { 
-    SplitIterator old(*this); 
-    ++(*this); 
-    return old; 
-  } 
- 
-  friend bool operator==(const SplitIterator& a, const SplitIterator& b) { 
-    return a.state_ == b.state_ && a.pos_ == b.pos_; 
-  } 
- 
-  friend bool operator!=(const SplitIterator& a, const SplitIterator& b) { 
-    return !(a == b); 
-  } 
- 
- private: 
-  size_t pos_; 
-  State state_; 
+      if (d.data() == text.data() + text.size()) state_ = kLastState;
+      curr_ = text.substr(pos_, d.data() - (text.data() + pos_));
+      pos_ += curr_.size() + d.size();
+    } while (!predicate_(curr_));
+    return *this;
+  }
+
+  SplitIterator operator++(int) {
+    SplitIterator old(*this);
+    ++(*this);
+    return old;
+  }
+
+  friend bool operator==(const SplitIterator& a, const SplitIterator& b) {
+    return a.state_ == b.state_ && a.pos_ == b.pos_;
+  }
+
+  friend bool operator!=(const SplitIterator& a, const SplitIterator& b) {
+    return !(a == b);
+  }
+
+ private:
+  size_t pos_;
+  State state_;
   y_absl::string_view curr_;
-  const Splitter* splitter_; 
-  typename Splitter::DelimiterType delimiter_; 
-  typename Splitter::PredicateType predicate_; 
-}; 
- 
-// HasMappedType<T>::value is true iff there exists a type T::mapped_type. 
-template <typename T, typename = void> 
-struct HasMappedType : std::false_type {}; 
-template <typename T> 
+  const Splitter* splitter_;
+  typename Splitter::DelimiterType delimiter_;
+  typename Splitter::PredicateType predicate_;
+};
+
+// HasMappedType<T>::value is true iff there exists a type T::mapped_type.
+template <typename T, typename = void>
+struct HasMappedType : std::false_type {};
+template <typename T>
 struct HasMappedType<T, y_absl::void_t<typename T::mapped_type>>
-    : std::true_type {}; 
- 
-// HasValueType<T>::value is true iff there exists a type T::value_type. 
-template <typename T, typename = void> 
-struct HasValueType : std::false_type {}; 
-template <typename T> 
+    : std::true_type {};
+
+// HasValueType<T>::value is true iff there exists a type T::value_type.
+template <typename T, typename = void>
+struct HasValueType : std::false_type {};
+template <typename T>
 struct HasValueType<T, y_absl::void_t<typename T::value_type>> : std::true_type {
-}; 
- 
-// HasConstIterator<T>::value is true iff there exists a type T::const_iterator. 
-template <typename T, typename = void> 
-struct HasConstIterator : std::false_type {}; 
-template <typename T> 
+};
+
+// HasConstIterator<T>::value is true iff there exists a type T::const_iterator.
+template <typename T, typename = void>
+struct HasConstIterator : std::false_type {};
+template <typename T>
 struct HasConstIterator<T, y_absl::void_t<typename T::const_iterator>>
-    : std::true_type {}; 
- 
+    : std::true_type {};
+
 // HasEmplace<T>::value is true iff there exists a method T::emplace().
 template <typename T, typename = void>
 struct HasEmplace : std::false_type {};
@@ -189,213 +189,213 @@ template <typename T>
 struct HasEmplace<T, y_absl::void_t<decltype(std::declval<T>().emplace())>>
     : std::true_type {};
 
-// IsInitializerList<T>::value is true iff T is an std::initializer_list. More 
-// details below in Splitter<> where this is used. 
-std::false_type IsInitializerListDispatch(...);  // default: No 
-template <typename T> 
-std::true_type IsInitializerListDispatch(std::initializer_list<T>*); 
-template <typename T> 
-struct IsInitializerList 
-    : decltype(IsInitializerListDispatch(static_cast<T*>(nullptr))) {}; 
- 
-// A SplitterIsConvertibleTo<C>::type alias exists iff the specified condition 
-// is true for type 'C'. 
-// 
-// Restricts conversion to container-like types (by testing for the presence of 
-// a const_iterator member type) and also to disable conversion to an 
-// std::initializer_list (which also has a const_iterator). Otherwise, code 
-// compiled in C++11 will get an error due to ambiguous conversion paths (in 
-// C++11 std::vector<T>::operator= is overloaded to take either a std::vector<T> 
-// or an std::initializer_list<T>). 
- 
-template <typename C, bool has_value_type, bool has_mapped_type> 
-struct SplitterIsConvertibleToImpl : std::false_type {}; 
- 
-template <typename C> 
-struct SplitterIsConvertibleToImpl<C, true, false> 
+// IsInitializerList<T>::value is true iff T is an std::initializer_list. More
+// details below in Splitter<> where this is used.
+std::false_type IsInitializerListDispatch(...);  // default: No
+template <typename T>
+std::true_type IsInitializerListDispatch(std::initializer_list<T>*);
+template <typename T>
+struct IsInitializerList
+    : decltype(IsInitializerListDispatch(static_cast<T*>(nullptr))) {};
+
+// A SplitterIsConvertibleTo<C>::type alias exists iff the specified condition
+// is true for type 'C'.
+//
+// Restricts conversion to container-like types (by testing for the presence of
+// a const_iterator member type) and also to disable conversion to an
+// std::initializer_list (which also has a const_iterator). Otherwise, code
+// compiled in C++11 will get an error due to ambiguous conversion paths (in
+// C++11 std::vector<T>::operator= is overloaded to take either a std::vector<T>
+// or an std::initializer_list<T>).
+
+template <typename C, bool has_value_type, bool has_mapped_type>
+struct SplitterIsConvertibleToImpl : std::false_type {};
+
+template <typename C>
+struct SplitterIsConvertibleToImpl<C, true, false>
     : std::is_constructible<typename C::value_type, y_absl::string_view> {};
- 
-template <typename C> 
-struct SplitterIsConvertibleToImpl<C, true, true> 
+
+template <typename C>
+struct SplitterIsConvertibleToImpl<C, true, true>
     : y_absl::conjunction<
           std::is_constructible<typename C::key_type, y_absl::string_view>,
           std::is_constructible<typename C::mapped_type, y_absl::string_view>> {};
- 
-template <typename C> 
-struct SplitterIsConvertibleTo 
-    : SplitterIsConvertibleToImpl< 
-          C, 
-#ifdef _GLIBCXX_DEBUG 
-          !IsStrictlyBaseOfAndConvertibleToSTLContainer<C>::value && 
-#endif  // _GLIBCXX_DEBUG 
-              !IsInitializerList< 
-                  typename std::remove_reference<C>::type>::value && 
-              HasValueType<C>::value && HasConstIterator<C>::value, 
-          HasMappedType<C>::value> { 
-}; 
- 
+
+template <typename C>
+struct SplitterIsConvertibleTo
+    : SplitterIsConvertibleToImpl<
+          C,
+#ifdef _GLIBCXX_DEBUG
+          !IsStrictlyBaseOfAndConvertibleToSTLContainer<C>::value &&
+#endif  // _GLIBCXX_DEBUG
+              !IsInitializerList<
+                  typename std::remove_reference<C>::type>::value &&
+              HasValueType<C>::value && HasConstIterator<C>::value,
+          HasMappedType<C>::value> {
+};
+
 // This class implements the range that is returned by y_absl::StrSplit(). This
-// class has templated conversion operators that allow it to be implicitly 
-// converted to a variety of types that the caller may have specified on the 
-// left-hand side of an assignment. 
-// 
-// The main interface for interacting with this class is through its implicit 
-// conversion operators. However, this class may also be used like a container 
-// in that it has .begin() and .end() member functions. It may also be used 
-// within a range-for loop. 
-// 
-// Output containers can be collections of any type that is constructible from 
+// class has templated conversion operators that allow it to be implicitly
+// converted to a variety of types that the caller may have specified on the
+// left-hand side of an assignment.
+//
+// The main interface for interacting with this class is through its implicit
+// conversion operators. However, this class may also be used like a container
+// in that it has .begin() and .end() member functions. It may also be used
+// within a range-for loop.
+//
+// Output containers can be collections of any type that is constructible from
 // an y_absl::string_view.
-// 
-// An Predicate functor may be supplied. This predicate will be used to filter 
-// the split strings: only strings for which the predicate returns true will be 
+//
+// An Predicate functor may be supplied. This predicate will be used to filter
+// the split strings: only strings for which the predicate returns true will be
 // kept. A Predicate object is any unary functor that takes an y_absl::string_view
-// and returns bool. 
+// and returns bool.
 //
 // The StringType parameter can be either string_view or string, depending on
 // whether the Splitter refers to a string stored elsewhere, or if the string
 // resides inside the Splitter itself.
 template <typename Delimiter, typename Predicate, typename StringType>
-class Splitter { 
- public: 
-  using DelimiterType = Delimiter; 
-  using PredicateType = Predicate; 
-  using const_iterator = strings_internal::SplitIterator<Splitter>; 
-  using value_type = typename std::iterator_traits<const_iterator>::value_type; 
- 
+class Splitter {
+ public:
+  using DelimiterType = Delimiter;
+  using PredicateType = Predicate;
+  using const_iterator = strings_internal::SplitIterator<Splitter>;
+  using value_type = typename std::iterator_traits<const_iterator>::value_type;
+
   Splitter(StringType input_text, Delimiter d, Predicate p)
-      : text_(std::move(input_text)), 
-        delimiter_(std::move(d)), 
-        predicate_(std::move(p)) {} 
- 
+      : text_(std::move(input_text)),
+        delimiter_(std::move(d)),
+        predicate_(std::move(p)) {}
+
   y_absl::string_view text() const { return text_; }
-  const Delimiter& delimiter() const { return delimiter_; } 
-  const Predicate& predicate() const { return predicate_; } 
- 
+  const Delimiter& delimiter() const { return delimiter_; }
+  const Predicate& predicate() const { return predicate_; }
+
   // Range functions that iterate the split substrings as y_absl::string_view
-  // objects. These methods enable a Splitter to be used in a range-based for 
-  // loop. 
-  const_iterator begin() const { return {const_iterator::kInitState, this}; } 
-  const_iterator end() const { return {const_iterator::kEndState, this}; } 
- 
-  // An implicit conversion operator that is restricted to only those containers 
-  // that the splitter is convertible to. 
-  template <typename Container, 
-            typename = typename std::enable_if< 
-                SplitterIsConvertibleTo<Container>::value>::type> 
-  operator Container() const {  // NOLINT(runtime/explicit) 
-    return ConvertToContainer<Container, typename Container::value_type, 
-                              HasMappedType<Container>::value>()(*this); 
-  } 
- 
-  // Returns a pair with its .first and .second members set to the first two 
-  // strings returned by the begin() iterator. Either/both of .first and .second 
-  // will be constructed with empty strings if the iterator doesn't have a 
-  // corresponding value. 
-  template <typename First, typename Second> 
-  operator std::pair<First, Second>() const {  // NOLINT(runtime/explicit) 
+  // objects. These methods enable a Splitter to be used in a range-based for
+  // loop.
+  const_iterator begin() const { return {const_iterator::kInitState, this}; }
+  const_iterator end() const { return {const_iterator::kEndState, this}; }
+
+  // An implicit conversion operator that is restricted to only those containers
+  // that the splitter is convertible to.
+  template <typename Container,
+            typename = typename std::enable_if<
+                SplitterIsConvertibleTo<Container>::value>::type>
+  operator Container() const {  // NOLINT(runtime/explicit)
+    return ConvertToContainer<Container, typename Container::value_type,
+                              HasMappedType<Container>::value>()(*this);
+  }
+
+  // Returns a pair with its .first and .second members set to the first two
+  // strings returned by the begin() iterator. Either/both of .first and .second
+  // will be constructed with empty strings if the iterator doesn't have a
+  // corresponding value.
+  template <typename First, typename Second>
+  operator std::pair<First, Second>() const {  // NOLINT(runtime/explicit)
     y_absl::string_view first, second;
-    auto it = begin(); 
-    if (it != end()) { 
-      first = *it; 
-      if (++it != end()) { 
-        second = *it; 
-      } 
-    } 
-    return {First(first), Second(second)}; 
-  } 
- 
- private: 
-  // ConvertToContainer is a functor converting a Splitter to the requested 
-  // Container of ValueType. It is specialized below to optimize splitting to 
-  // certain combinations of Container and ValueType. 
-  // 
-  // This base template handles the generic case of storing the split results in 
-  // the requested non-map-like container and converting the split substrings to 
-  // the requested type. 
-  template <typename Container, typename ValueType, bool is_map = false> 
-  struct ConvertToContainer { 
-    Container operator()(const Splitter& splitter) const { 
-      Container c; 
-      auto it = std::inserter(c, c.end()); 
+    auto it = begin();
+    if (it != end()) {
+      first = *it;
+      if (++it != end()) {
+        second = *it;
+      }
+    }
+    return {First(first), Second(second)};
+  }
+
+ private:
+  // ConvertToContainer is a functor converting a Splitter to the requested
+  // Container of ValueType. It is specialized below to optimize splitting to
+  // certain combinations of Container and ValueType.
+  //
+  // This base template handles the generic case of storing the split results in
+  // the requested non-map-like container and converting the split substrings to
+  // the requested type.
+  template <typename Container, typename ValueType, bool is_map = false>
+  struct ConvertToContainer {
+    Container operator()(const Splitter& splitter) const {
+      Container c;
+      auto it = std::inserter(c, c.end());
       for (const auto& sp : splitter) {
-        *it++ = ValueType(sp); 
-      } 
-      return c; 
-    } 
-  }; 
- 
+        *it++ = ValueType(sp);
+      }
+      return c;
+    }
+  };
+
   // Partial specialization for a std::vector<y_absl::string_view>.
-  // 
-  // Optimized for the common case of splitting to a 
+  //
+  // Optimized for the common case of splitting to a
   // std::vector<y_absl::string_view>. In this case we first split the results to
   // a small array of y_absl::string_view on the stack, to reduce reallocations.
-  template <typename A> 
+  template <typename A>
   struct ConvertToContainer<std::vector<y_absl::string_view, A>,
                             y_absl::string_view, false> {
     std::vector<y_absl::string_view, A> operator()(
-        const Splitter& splitter) const { 
-      struct raw_view { 
-        const char* data; 
-        size_t size; 
+        const Splitter& splitter) const {
+      struct raw_view {
+        const char* data;
+        size_t size;
         operator y_absl::string_view() const {  // NOLINT(runtime/explicit)
-          return {data, size}; 
-        } 
-      }; 
+          return {data, size};
+        }
+      };
       std::vector<y_absl::string_view, A> v;
-      std::array<raw_view, 16> ar; 
-      for (auto it = splitter.begin(); !it.at_end();) { 
-        size_t index = 0; 
-        do { 
-          ar[index].data = it->data(); 
-          ar[index].size = it->size(); 
-          ++it; 
-        } while (++index != ar.size() && !it.at_end()); 
-        v.insert(v.end(), ar.begin(), ar.begin() + index); 
-      } 
-      return v; 
-    } 
-  }; 
- 
+      std::array<raw_view, 16> ar;
+      for (auto it = splitter.begin(); !it.at_end();) {
+        size_t index = 0;
+        do {
+          ar[index].data = it->data();
+          ar[index].size = it->size();
+          ++it;
+        } while (++index != ar.size() && !it.at_end());
+        v.insert(v.end(), ar.begin(), ar.begin() + index);
+      }
+      return v;
+    }
+  };
+
   // Partial specialization for a std::vector<TString>.
-  // 
+  //
   // Optimized for the common case of splitting to a std::vector<TString>.
   // In this case we first split the results to a std::vector<y_absl::string_view>
   // so the returned std::vector<TString> can have space reserved to avoid
   // TString moves.
-  template <typename A> 
+  template <typename A>
   struct ConvertToContainer<std::vector<TString, A>, TString, false> {
     std::vector<TString, A> operator()(const Splitter& splitter) const {
       const std::vector<y_absl::string_view> v = splitter;
       return std::vector<TString, A>(v.begin(), v.end());
-    } 
-  }; 
- 
-  // Partial specialization for containers of pairs (e.g., maps). 
-  // 
-  // The algorithm is to insert a new pair into the map for each even-numbered 
-  // item, with the even-numbered item as the key with a default-constructed 
-  // value. Each odd-numbered item will then be assigned to the last pair's 
-  // value. 
-  template <typename Container, typename First, typename Second> 
-  struct ConvertToContainer<Container, std::pair<const First, Second>, true> { 
+    }
+  };
+
+  // Partial specialization for containers of pairs (e.g., maps).
+  //
+  // The algorithm is to insert a new pair into the map for each even-numbered
+  // item, with the even-numbered item as the key with a default-constructed
+  // value. Each odd-numbered item will then be assigned to the last pair's
+  // value.
+  template <typename Container, typename First, typename Second>
+  struct ConvertToContainer<Container, std::pair<const First, Second>, true> {
     using iterator = typename Container::iterator;
 
-    Container operator()(const Splitter& splitter) const { 
-      Container m; 
+    Container operator()(const Splitter& splitter) const {
+      Container m;
       iterator it;
-      bool insert = true; 
+      bool insert = true;
       for (const y_absl::string_view sv : splitter) {
-        if (insert) { 
+        if (insert) {
           it = InsertOrEmplace(&m, sv);
-        } else { 
+        } else {
           it->second = Second(sv);
-        } 
-        insert = !insert; 
-      } 
-      return m; 
-    } 
- 
+        }
+        insert = !insert;
+      }
+      return m;
+    }
+
     // Inserts the key and an empty value into the map, returning an iterator to
     // the inserted item. We use emplace() if available, otherwise insert().
     template <typename M>
@@ -411,20 +411,20 @@ class Splitter {
         M* m, y_absl::string_view key) {
       return ToIter(m->insert(std::make_pair(First(key), Second(""))));
     }
- 
+
     static iterator ToIter(std::pair<iterator, bool> pair) {
       return pair.first;
     }
     static iterator ToIter(iterator iter) { return iter; }
-  }; 
- 
+  };
+
   StringType text_;
-  Delimiter delimiter_; 
-  Predicate predicate_; 
-}; 
- 
-}  // namespace strings_internal 
+  Delimiter delimiter_;
+  Predicate predicate_;
+};
+
+}  // namespace strings_internal
 ABSL_NAMESPACE_END
 }  // namespace y_absl
- 
-#endif  // ABSL_STRINGS_INTERNAL_STR_SPLIT_INTERNAL_H_ 
+
+#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 0d7d12b86f..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
@@ -1,53 +1,53 @@
-// Copyright 2017 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. 
- 
-// UTF8 utilities, implemented to reduce dependencies. 
- 
+// Copyright 2017 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.
+
+// UTF8 utilities, implemented to reduce dependencies.
+
 #include "y_absl/strings/internal/utf8.h"
- 
+
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-namespace strings_internal { 
- 
-size_t EncodeUTF8Char(char *buffer, char32_t utf8_char) { 
-  if (utf8_char <= 0x7F) { 
-    *buffer = static_cast<char>(utf8_char); 
-    return 1; 
-  } else if (utf8_char <= 0x7FF) { 
-    buffer[1] = 0x80 | (utf8_char & 0x3F); 
-    utf8_char >>= 6; 
-    buffer[0] = 0xC0 | utf8_char; 
-    return 2; 
-  } else if (utf8_char <= 0xFFFF) { 
-    buffer[2] = 0x80 | (utf8_char & 0x3F); 
-    utf8_char >>= 6; 
-    buffer[1] = 0x80 | (utf8_char & 0x3F); 
-    utf8_char >>= 6; 
-    buffer[0] = 0xE0 | utf8_char; 
-    return 3; 
-  } else { 
-    buffer[3] = 0x80 | (utf8_char & 0x3F); 
-    utf8_char >>= 6; 
-    buffer[2] = 0x80 | (utf8_char & 0x3F); 
-    utf8_char >>= 6; 
-    buffer[1] = 0x80 | (utf8_char & 0x3F); 
-    utf8_char >>= 6; 
-    buffer[0] = 0xF0 | utf8_char; 
-    return 4; 
-  } 
-} 
- 
-}  // namespace strings_internal 
+namespace strings_internal {
+
+size_t EncodeUTF8Char(char *buffer, char32_t utf8_char) {
+  if (utf8_char <= 0x7F) {
+    *buffer = static_cast<char>(utf8_char);
+    return 1;
+  } else if (utf8_char <= 0x7FF) {
+    buffer[1] = 0x80 | (utf8_char & 0x3F);
+    utf8_char >>= 6;
+    buffer[0] = 0xC0 | utf8_char;
+    return 2;
+  } else if (utf8_char <= 0xFFFF) {
+    buffer[2] = 0x80 | (utf8_char & 0x3F);
+    utf8_char >>= 6;
+    buffer[1] = 0x80 | (utf8_char & 0x3F);
+    utf8_char >>= 6;
+    buffer[0] = 0xE0 | utf8_char;
+    return 3;
+  } else {
+    buffer[3] = 0x80 | (utf8_char & 0x3F);
+    utf8_char >>= 6;
+    buffer[2] = 0x80 | (utf8_char & 0x3F);
+    utf8_char >>= 6;
+    buffer[1] = 0x80 | (utf8_char & 0x3F);
+    utf8_char >>= 6;
+    buffer[0] = 0xF0 | utf8_char;
+    return 4;
+  }
+}
+
+}  // namespace strings_internal
 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 d237336c84..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
@@ -1,50 +1,50 @@
-// Copyright 2017 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. 
-// 
-// UTF8 utilities, implemented to reduce dependencies. 
- 
-#ifndef ABSL_STRINGS_INTERNAL_UTF8_H_ 
-#define ABSL_STRINGS_INTERNAL_UTF8_H_ 
- 
-#include <cstddef> 
-#include <cstdint> 
- 
+// Copyright 2017 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.
+//
+// UTF8 utilities, implemented to reduce dependencies.
+
+#ifndef ABSL_STRINGS_INTERNAL_UTF8_H_
+#define ABSL_STRINGS_INTERNAL_UTF8_H_
+
+#include <cstddef>
+#include <cstdint>
+
 #include "y_absl/base/config.h"
 
 namespace y_absl {
 ABSL_NAMESPACE_BEGIN
-namespace strings_internal { 
- 
-// For Unicode code points 0 through 0x10FFFF, EncodeUTF8Char writes 
-// out the UTF-8 encoding into buffer, and returns the number of chars 
-// it wrote. 
-// 
-// As described in https://tools.ietf.org/html/rfc3629#section-3 , the encodings 
-// are: 
-//    00 -     7F : 0xxxxxxx 
-//    80 -    7FF : 110xxxxx 10xxxxxx 
-//   800 -   FFFF : 1110xxxx 10xxxxxx 10xxxxxx 
-// 10000 - 10FFFF : 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx 
-// 
-// Values greater than 0x10FFFF are not supported and may or may not write 
-// characters into buffer, however never will more than kMaxEncodedUTF8Size 
-// bytes be written, regardless of the value of utf8_char. 
-enum { kMaxEncodedUTF8Size = 4 }; 
-size_t EncodeUTF8Char(char *buffer, char32_t utf8_char); 
- 
-}  // namespace strings_internal 
+namespace strings_internal {
+
+// For Unicode code points 0 through 0x10FFFF, EncodeUTF8Char writes
+// out the UTF-8 encoding into buffer, and returns the number of chars
+// it wrote.
+//
+// As described in https://tools.ietf.org/html/rfc3629#section-3 , the encodings
+// are:
+//    00 -     7F : 0xxxxxxx
+//    80 -    7FF : 110xxxxx 10xxxxxx
+//   800 -   FFFF : 1110xxxx 10xxxxxx 10xxxxxx
+// 10000 - 10FFFF : 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+//
+// Values greater than 0x10FFFF are not supported and may or may not write
+// characters into buffer, however never will more than kMaxEncodedUTF8Size
+// bytes be written, regardless of the value of utf8_char.
+enum { kMaxEncodedUTF8Size = 4 };
+size_t EncodeUTF8Char(char *buffer, char32_t utf8_char);
+
+}  // namespace strings_internal
 ABSL_NAMESPACE_END
 }  // namespace y_absl
- 
-#endif  // ABSL_STRINGS_INTERNAL_UTF8_H_ 
+
+#endif  // ABSL_STRINGS_INTERNAL_UTF8_H_