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

4 files changed, 250 insertions, 250 deletions

diff --git a/contrib/restricted/abseil-cpp/absl/numeric/int128.cc b/contrib/restricted/abseil-cpp/absl/numeric/int128.cc
index 4f91e48463..f42f625d10 100644
--- a/contrib/restricted/abseil-cpp/absl/numeric/int128.cc
+++ b/contrib/restricted/abseil-cpp/absl/numeric/int128.cc
@@ -138,21 +138,21 @@ uint128::uint128(float v) : uint128(MakeUint128FromFloat(v)) {}
 uint128::uint128(double v) : uint128(MakeUint128FromFloat(v)) {}
 uint128::uint128(long double v) : uint128(MakeUint128FromFloat(v)) {}
 
-#if !defined(ABSL_HAVE_INTRINSIC_INT128)
+#if !defined(ABSL_HAVE_INTRINSIC_INT128) 
 uint128 operator/(uint128 lhs, uint128 rhs) {
   uint128 quotient = 0;
   uint128 remainder = 0;
   DivModImpl(lhs, rhs, &quotient, &remainder);
   return quotient;
 }
-
+ 
 uint128 operator%(uint128 lhs, uint128 rhs) {
   uint128 quotient = 0;
   uint128 remainder = 0;
   DivModImpl(lhs, rhs, &quotient, &remainder);
   return remainder;
 }
-#endif  // !defined(ABSL_HAVE_INTRINSIC_INT128)
+#endif  // !defined(ABSL_HAVE_INTRINSIC_INT128) 
 
 namespace {
 
diff --git a/contrib/restricted/abseil-cpp/absl/numeric/int128.h b/contrib/restricted/abseil-cpp/absl/numeric/int128.h
index c7ad96befd..bc47e0503e 100644
--- a/contrib/restricted/abseil-cpp/absl/numeric/int128.h
+++ b/contrib/restricted/abseil-cpp/absl/numeric/int128.h
@@ -18,10 +18,10 @@
 // -----------------------------------------------------------------------------
 //
 // This header file defines 128-bit integer types, `uint128` and `int128`.
-//
-// TODO(absl-team): This module is inconsistent as many inline `uint128` methods
-// are defined in this file, while many inline `int128` methods are defined in
-// the `int128_*_intrinsic.inc` files.
+// 
+// TODO(absl-team): This module is inconsistent as many inline `uint128` methods 
+// are defined in this file, while many inline `int128` methods are defined in 
+// the `int128_*_intrinsic.inc` files. 
 
 #ifndef ABSL_NUMERIC_INT128_H_
 #define ABSL_NUMERIC_INT128_H_
@@ -586,10 +586,10 @@ inline uint128& uint128::operator=(int128 v) {
 
 // Arithmetic operators.
 
-constexpr uint128 operator<<(uint128 lhs, int amount);
-constexpr uint128 operator>>(uint128 lhs, int amount);
-constexpr uint128 operator+(uint128 lhs, uint128 rhs);
-constexpr uint128 operator-(uint128 lhs, uint128 rhs);
+constexpr uint128 operator<<(uint128 lhs, int amount); 
+constexpr uint128 operator>>(uint128 lhs, int amount); 
+constexpr uint128 operator+(uint128 lhs, uint128 rhs); 
+constexpr uint128 operator-(uint128 lhs, uint128 rhs); 
 uint128 operator*(uint128 lhs, uint128 rhs);
 uint128 operator/(uint128 lhs, uint128 rhs);
 uint128 operator%(uint128 lhs, uint128 rhs);
@@ -786,19 +786,19 @@ inline uint128::operator long double() const {
 
 // Comparison operators.
 
-constexpr bool operator==(uint128 lhs, uint128 rhs) {
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
-  return static_cast<unsigned __int128>(lhs) ==
-         static_cast<unsigned __int128>(rhs);
-#else
+constexpr bool operator==(uint128 lhs, uint128 rhs) { 
+#if defined(ABSL_HAVE_INTRINSIC_INT128) 
+  return static_cast<unsigned __int128>(lhs) == 
+         static_cast<unsigned __int128>(rhs); 
+#else 
   return (Uint128Low64(lhs) == Uint128Low64(rhs) &&
           Uint128High64(lhs) == Uint128High64(rhs));
-#endif
+#endif 
 }
 
-constexpr bool operator!=(uint128 lhs, uint128 rhs) { return !(lhs == rhs); }
+constexpr bool operator!=(uint128 lhs, uint128 rhs) { return !(lhs == rhs); } 
 
-constexpr bool operator<(uint128 lhs, uint128 rhs) {
+constexpr bool operator<(uint128 lhs, uint128 rhs) { 
 #ifdef ABSL_HAVE_INTRINSIC_INT128
   return static_cast<unsigned __int128>(lhs) <
          static_cast<unsigned __int128>(rhs);
@@ -809,171 +809,171 @@ constexpr bool operator<(uint128 lhs, uint128 rhs) {
 #endif
 }
 
-constexpr bool operator>(uint128 lhs, uint128 rhs) { return rhs < lhs; }
+constexpr bool operator>(uint128 lhs, uint128 rhs) { return rhs < lhs; } 
 
-constexpr bool operator<=(uint128 lhs, uint128 rhs) { return !(rhs < lhs); }
+constexpr bool operator<=(uint128 lhs, uint128 rhs) { return !(rhs < lhs); } 
 
-constexpr bool operator>=(uint128 lhs, uint128 rhs) { return !(lhs < rhs); }
+constexpr bool operator>=(uint128 lhs, uint128 rhs) { return !(lhs < rhs); } 
 
 // Unary operators.
 
-constexpr inline uint128 operator+(uint128 val) {
-  return val;
-}
-
-constexpr inline int128 operator+(int128 val) {
-  return val;
-}
-
-constexpr uint128 operator-(uint128 val) {
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
-  return -static_cast<unsigned __int128>(val);
-#else
-  return MakeUint128(
-      ~Uint128High64(val) + static_cast<unsigned long>(Uint128Low64(val) == 0),
-      ~Uint128Low64(val) + 1);
-#endif
-}
-
-constexpr inline bool operator!(uint128 val) {
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
-  return !static_cast<unsigned __int128>(val);
-#else
+constexpr inline uint128 operator+(uint128 val) { 
+  return val; 
+}
+
+constexpr inline int128 operator+(int128 val) { 
+  return val; 
+} 
+ 
+constexpr uint128 operator-(uint128 val) { 
+#if defined(ABSL_HAVE_INTRINSIC_INT128) 
+  return -static_cast<unsigned __int128>(val); 
+#else 
+  return MakeUint128( 
+      ~Uint128High64(val) + static_cast<unsigned long>(Uint128Low64(val) == 0), 
+      ~Uint128Low64(val) + 1); 
+#endif 
+} 
+ 
+constexpr inline bool operator!(uint128 val) { 
+#if defined(ABSL_HAVE_INTRINSIC_INT128) 
+  return !static_cast<unsigned __int128>(val); 
+#else 
   return !Uint128High64(val) && !Uint128Low64(val);
-#endif
+#endif 
 }
 
 // Logical operators.
 
-constexpr inline uint128 operator~(uint128 val) {
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
-  return ~static_cast<unsigned __int128>(val);
-#else
+constexpr inline uint128 operator~(uint128 val) { 
+#if defined(ABSL_HAVE_INTRINSIC_INT128) 
+  return ~static_cast<unsigned __int128>(val); 
+#else 
   return MakeUint128(~Uint128High64(val), ~Uint128Low64(val));
-#endif
+#endif 
 }
 
-constexpr inline uint128 operator|(uint128 lhs, uint128 rhs) {
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
-  return static_cast<unsigned __int128>(lhs) |
-         static_cast<unsigned __int128>(rhs);
-#else
+constexpr inline uint128 operator|(uint128 lhs, uint128 rhs) { 
+#if defined(ABSL_HAVE_INTRINSIC_INT128) 
+  return static_cast<unsigned __int128>(lhs) | 
+         static_cast<unsigned __int128>(rhs); 
+#else 
   return MakeUint128(Uint128High64(lhs) | Uint128High64(rhs),
-                     Uint128Low64(lhs) | Uint128Low64(rhs));
-#endif
+                     Uint128Low64(lhs) | Uint128Low64(rhs)); 
+#endif 
 }
 
-constexpr inline uint128 operator&(uint128 lhs, uint128 rhs) {
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
-  return static_cast<unsigned __int128>(lhs) &
-         static_cast<unsigned __int128>(rhs);
-#else
+constexpr inline uint128 operator&(uint128 lhs, uint128 rhs) { 
+#if defined(ABSL_HAVE_INTRINSIC_INT128) 
+  return static_cast<unsigned __int128>(lhs) & 
+         static_cast<unsigned __int128>(rhs); 
+#else 
   return MakeUint128(Uint128High64(lhs) & Uint128High64(rhs),
-                     Uint128Low64(lhs) & Uint128Low64(rhs));
-#endif
+                     Uint128Low64(lhs) & Uint128Low64(rhs)); 
+#endif 
 }
 
-constexpr inline uint128 operator^(uint128 lhs, uint128 rhs) {
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
-  return static_cast<unsigned __int128>(lhs) ^
-         static_cast<unsigned __int128>(rhs);
-#else
+constexpr inline uint128 operator^(uint128 lhs, uint128 rhs) { 
+#if defined(ABSL_HAVE_INTRINSIC_INT128) 
+  return static_cast<unsigned __int128>(lhs) ^ 
+         static_cast<unsigned __int128>(rhs); 
+#else 
   return MakeUint128(Uint128High64(lhs) ^ Uint128High64(rhs),
-                     Uint128Low64(lhs) ^ Uint128Low64(rhs));
-#endif
+                     Uint128Low64(lhs) ^ Uint128Low64(rhs)); 
+#endif 
 }
 
 inline uint128& uint128::operator|=(uint128 other) {
-  *this = *this | other;
+  *this = *this | other; 
   return *this;
 }
 
 inline uint128& uint128::operator&=(uint128 other) {
-  *this = *this & other;
+  *this = *this & other; 
   return *this;
 }
 
 inline uint128& uint128::operator^=(uint128 other) {
-  *this = *this ^ other;
+  *this = *this ^ other; 
   return *this;
 }
 
 // Arithmetic operators.
 
-constexpr uint128 operator<<(uint128 lhs, int amount) {
+constexpr uint128 operator<<(uint128 lhs, int amount) { 
 #ifdef ABSL_HAVE_INTRINSIC_INT128
   return static_cast<unsigned __int128>(lhs) << amount;
 #else
   // uint64_t shifts of >= 64 are undefined, so we will need some
   // special-casing.
-  return amount >= 64 ? MakeUint128(Uint128Low64(lhs) << (amount - 64), 0)
-         : amount == 0 ? lhs
-                       : MakeUint128((Uint128High64(lhs) << amount) |
-                                         (Uint128Low64(lhs) >> (64 - amount)),
-                                     Uint128Low64(lhs) << amount);
+  return amount >= 64 ? MakeUint128(Uint128Low64(lhs) << (amount - 64), 0) 
+         : amount == 0 ? lhs 
+                       : MakeUint128((Uint128High64(lhs) << amount) | 
+                                         (Uint128Low64(lhs) >> (64 - amount)), 
+                                     Uint128Low64(lhs) << amount); 
 #endif
 }
 
-constexpr uint128 operator>>(uint128 lhs, int amount) {
+constexpr uint128 operator>>(uint128 lhs, int amount) { 
 #ifdef ABSL_HAVE_INTRINSIC_INT128
   return static_cast<unsigned __int128>(lhs) >> amount;
 #else
   // uint64_t shifts of >= 64 are undefined, so we will need some
   // special-casing.
-  return amount >= 64 ? MakeUint128(0, Uint128High64(lhs) >> (amount - 64))
-         : amount == 0 ? lhs
-                       : MakeUint128(Uint128High64(lhs) >> amount,
-                                     (Uint128Low64(lhs) >> amount) |
-                                         (Uint128High64(lhs) << (64 - amount)));
-#endif
-}
-
-#if !defined(ABSL_HAVE_INTRINSIC_INT128)
-namespace int128_internal {
-constexpr uint128 AddResult(uint128 result, uint128 lhs) {
-  // check for carry
-  return (Uint128Low64(result) < Uint128Low64(lhs))
-             ? MakeUint128(Uint128High64(result) + 1, Uint128Low64(result))
-             : result;
-}
-}  // namespace int128_internal
-#endif
-
-constexpr uint128 operator+(uint128 lhs, uint128 rhs) {
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
-  return static_cast<unsigned __int128>(lhs) +
-         static_cast<unsigned __int128>(rhs);
-#else
-  return int128_internal::AddResult(
-      MakeUint128(Uint128High64(lhs) + Uint128High64(rhs),
-                  Uint128Low64(lhs) + Uint128Low64(rhs)),
-      lhs);
-#endif
-}
-
-#if !defined(ABSL_HAVE_INTRINSIC_INT128)
-namespace int128_internal {
-constexpr uint128 SubstructResult(uint128 result, uint128 lhs, uint128 rhs) {
-  // check for carry
-  return (Uint128Low64(lhs) < Uint128Low64(rhs))
-             ? MakeUint128(Uint128High64(result) - 1, Uint128Low64(result))
-             : result;
-}
-}  // namespace int128_internal
-#endif
-
-constexpr uint128 operator-(uint128 lhs, uint128 rhs) {
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
-  return static_cast<unsigned __int128>(lhs) -
-         static_cast<unsigned __int128>(rhs);
-#else
-  return int128_internal::SubstructResult(
-      MakeUint128(Uint128High64(lhs) - Uint128High64(rhs),
-                  Uint128Low64(lhs) - Uint128Low64(rhs)),
-      lhs, rhs);
+  return amount >= 64 ? MakeUint128(0, Uint128High64(lhs) >> (amount - 64)) 
+         : amount == 0 ? lhs 
+                       : MakeUint128(Uint128High64(lhs) >> amount, 
+                                     (Uint128Low64(lhs) >> amount) | 
+                                         (Uint128High64(lhs) << (64 - amount))); 
 #endif
 }
 
+#if !defined(ABSL_HAVE_INTRINSIC_INT128) 
+namespace int128_internal { 
+constexpr uint128 AddResult(uint128 result, uint128 lhs) { 
+  // check for carry 
+  return (Uint128Low64(result) < Uint128Low64(lhs)) 
+             ? MakeUint128(Uint128High64(result) + 1, Uint128Low64(result)) 
+             : result; 
+}
+}  // namespace int128_internal 
+#endif 
+
+constexpr uint128 operator+(uint128 lhs, uint128 rhs) { 
+#if defined(ABSL_HAVE_INTRINSIC_INT128) 
+  return static_cast<unsigned __int128>(lhs) + 
+         static_cast<unsigned __int128>(rhs); 
+#else 
+  return int128_internal::AddResult( 
+      MakeUint128(Uint128High64(lhs) + Uint128High64(rhs), 
+                  Uint128Low64(lhs) + Uint128Low64(rhs)), 
+      lhs); 
+#endif 
+}
+
+#if !defined(ABSL_HAVE_INTRINSIC_INT128) 
+namespace int128_internal { 
+constexpr uint128 SubstructResult(uint128 result, uint128 lhs, uint128 rhs) { 
+  // check for carry 
+  return (Uint128Low64(lhs) < Uint128Low64(rhs)) 
+             ? MakeUint128(Uint128High64(result) - 1, Uint128Low64(result)) 
+             : result; 
+} 
+}  // namespace int128_internal 
+#endif 
+ 
+constexpr uint128 operator-(uint128 lhs, uint128 rhs) { 
+#if defined(ABSL_HAVE_INTRINSIC_INT128) 
+  return static_cast<unsigned __int128>(lhs) - 
+         static_cast<unsigned __int128>(rhs); 
+#else 
+  return int128_internal::SubstructResult( 
+      MakeUint128(Uint128High64(lhs) - Uint128High64(rhs), 
+                  Uint128Low64(lhs) - Uint128Low64(rhs)), 
+      lhs, rhs); 
+#endif 
+} 
+ 
 inline uint128 operator*(uint128 lhs, uint128 rhs) {
 #if defined(ABSL_HAVE_INTRINSIC_INT128)
   // TODO(strel) Remove once alignment issues are resolved and unsigned __int128
@@ -1001,18 +1001,18 @@ inline uint128 operator*(uint128 lhs, uint128 rhs) {
 #endif  // ABSL_HAVE_INTRINSIC128
 }
 
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
-inline uint128 operator/(uint128 lhs, uint128 rhs) {
-  return static_cast<unsigned __int128>(lhs) /
-         static_cast<unsigned __int128>(rhs);
-}
-
-inline uint128 operator%(uint128 lhs, uint128 rhs) {
-  return static_cast<unsigned __int128>(lhs) %
-         static_cast<unsigned __int128>(rhs);
-}
-#endif
-
+#if defined(ABSL_HAVE_INTRINSIC_INT128) 
+inline uint128 operator/(uint128 lhs, uint128 rhs) { 
+  return static_cast<unsigned __int128>(lhs) / 
+         static_cast<unsigned __int128>(rhs); 
+} 
+ 
+inline uint128 operator%(uint128 lhs, uint128 rhs) { 
+  return static_cast<unsigned __int128>(lhs) % 
+         static_cast<unsigned __int128>(rhs); 
+} 
+#endif 
+ 
 // Increment/decrement operators.
 
 inline uint128 uint128::operator++(int) {
@@ -1070,17 +1070,17 @@ inline int128& int128::operator=(unsigned long long v) {
 }
 
 // Arithmetic operators.
-constexpr int128 operator-(int128 v);
-constexpr int128 operator+(int128 lhs, int128 rhs);
-constexpr int128 operator-(int128 lhs, int128 rhs);
+constexpr int128 operator-(int128 v); 
+constexpr int128 operator+(int128 lhs, int128 rhs); 
+constexpr int128 operator-(int128 lhs, int128 rhs); 
 int128 operator*(int128 lhs, int128 rhs);
 int128 operator/(int128 lhs, int128 rhs);
 int128 operator%(int128 lhs, int128 rhs);
-constexpr int128 operator|(int128 lhs, int128 rhs);
-constexpr int128 operator&(int128 lhs, int128 rhs);
-constexpr int128 operator^(int128 lhs, int128 rhs);
-constexpr int128 operator<<(int128 lhs, int amount);
-constexpr int128 operator>>(int128 lhs, int amount);
+constexpr int128 operator|(int128 lhs, int128 rhs); 
+constexpr int128 operator&(int128 lhs, int128 rhs); 
+constexpr int128 operator^(int128 lhs, int128 rhs); 
+constexpr int128 operator<<(int128 lhs, int amount); 
+constexpr int128 operator>>(int128 lhs, int amount); 
 
 inline int128& int128::operator+=(int128 other) {
   *this = *this + other;
@@ -1132,9 +1132,9 @@ inline int128& int128::operator>>=(int amount) {
   return *this;
 }
 
-// Forward declaration for comparison operators.
-constexpr bool operator!=(int128 lhs, int128 rhs);
-
+// Forward declaration for comparison operators. 
+constexpr bool operator!=(int128 lhs, int128 rhs); 
+ 
 namespace int128_internal {
 
 // Casts from unsigned to signed while preserving the underlying binary
diff --git a/contrib/restricted/abseil-cpp/absl/numeric/int128_have_intrinsic.inc b/contrib/restricted/abseil-cpp/absl/numeric/int128_have_intrinsic.inc
index 3945fa2983..b6e31f8fa5 100644
--- a/contrib/restricted/abseil-cpp/absl/numeric/int128_have_intrinsic.inc
+++ b/contrib/restricted/abseil-cpp/absl/numeric/int128_have_intrinsic.inc
@@ -155,7 +155,7 @@ constexpr int128::operator unsigned __int128() const {
 #if defined(__clang__) && !defined(__ppc64__)
 inline int128::operator float() const { return static_cast<float>(v_); }
 
-inline int128::operator double() const { return static_cast<double>(v_); }
+inline int128::operator double() const { return static_cast<double>(v_); } 
 
 inline int128::operator long double() const {
   return static_cast<long double>(v_);
@@ -163,8 +163,8 @@ inline int128::operator long double() const {
 
 #else  // Clang on PowerPC
 // Forward declaration for conversion operators to floating point types.
-constexpr int128 operator-(int128 v);
-constexpr bool operator!=(int128 lhs, int128 rhs);
+constexpr int128 operator-(int128 v); 
+constexpr bool operator!=(int128 lhs, int128 rhs); 
 
 inline int128::operator float() const {
   // We must convert the absolute value and then negate as needed, because
@@ -199,45 +199,45 @@ inline int128::operator long double() const {
 
 // Comparison operators.
 
-constexpr bool operator==(int128 lhs, int128 rhs) {
+constexpr bool operator==(int128 lhs, int128 rhs) { 
   return static_cast<__int128>(lhs) == static_cast<__int128>(rhs);
 }
 
-constexpr bool operator!=(int128 lhs, int128 rhs) {
+constexpr bool operator!=(int128 lhs, int128 rhs) { 
   return static_cast<__int128>(lhs) != static_cast<__int128>(rhs);
 }
 
-constexpr bool operator<(int128 lhs, int128 rhs) {
+constexpr bool operator<(int128 lhs, int128 rhs) { 
   return static_cast<__int128>(lhs) < static_cast<__int128>(rhs);
 }
 
-constexpr bool operator>(int128 lhs, int128 rhs) {
+constexpr bool operator>(int128 lhs, int128 rhs) { 
   return static_cast<__int128>(lhs) > static_cast<__int128>(rhs);
 }
 
-constexpr bool operator<=(int128 lhs, int128 rhs) {
+constexpr bool operator<=(int128 lhs, int128 rhs) { 
   return static_cast<__int128>(lhs) <= static_cast<__int128>(rhs);
 }
 
-constexpr bool operator>=(int128 lhs, int128 rhs) {
+constexpr bool operator>=(int128 lhs, int128 rhs) { 
   return static_cast<__int128>(lhs) >= static_cast<__int128>(rhs);
 }
 
 // Unary operators.
 
-constexpr int128 operator-(int128 v) { return -static_cast<__int128>(v); }
+constexpr int128 operator-(int128 v) { return -static_cast<__int128>(v); } 
 
-constexpr bool operator!(int128 v) { return !static_cast<__int128>(v); }
+constexpr bool operator!(int128 v) { return !static_cast<__int128>(v); } 
 
-constexpr int128 operator~(int128 val) { return ~static_cast<__int128>(val); }
+constexpr int128 operator~(int128 val) { return ~static_cast<__int128>(val); } 
 
 // Arithmetic operators.
 
-constexpr int128 operator+(int128 lhs, int128 rhs) {
+constexpr int128 operator+(int128 lhs, int128 rhs) { 
   return static_cast<__int128>(lhs) + static_cast<__int128>(rhs);
 }
 
-constexpr int128 operator-(int128 lhs, int128 rhs) {
+constexpr int128 operator-(int128 lhs, int128 rhs) { 
   return static_cast<__int128>(lhs) - static_cast<__int128>(rhs);
 }
 
@@ -275,22 +275,22 @@ inline int128& int128::operator--() {
   return *this;
 }
 
-constexpr int128 operator|(int128 lhs, int128 rhs) {
+constexpr int128 operator|(int128 lhs, int128 rhs) { 
   return static_cast<__int128>(lhs) | static_cast<__int128>(rhs);
 }
 
-constexpr int128 operator&(int128 lhs, int128 rhs) {
+constexpr int128 operator&(int128 lhs, int128 rhs) { 
   return static_cast<__int128>(lhs) & static_cast<__int128>(rhs);
 }
 
-constexpr int128 operator^(int128 lhs, int128 rhs) {
+constexpr int128 operator^(int128 lhs, int128 rhs) { 
   return static_cast<__int128>(lhs) ^ static_cast<__int128>(rhs);
 }
 
-constexpr int128 operator<<(int128 lhs, int amount) {
+constexpr int128 operator<<(int128 lhs, int amount) { 
   return static_cast<__int128>(lhs) << amount;
 }
 
-constexpr int128 operator>>(int128 lhs, int amount) {
+constexpr int128 operator>>(int128 lhs, int amount) { 
   return static_cast<__int128>(lhs) >> amount;
 }
diff --git a/contrib/restricted/abseil-cpp/absl/numeric/int128_no_intrinsic.inc b/contrib/restricted/abseil-cpp/absl/numeric/int128_no_intrinsic.inc
index 8834804cec..deb1c31c36 100644
--- a/contrib/restricted/abseil-cpp/absl/numeric/int128_no_intrinsic.inc
+++ b/contrib/restricted/abseil-cpp/absl/numeric/int128_no_intrinsic.inc
@@ -165,80 +165,80 @@ inline int128::operator long double() const {
 
 // Comparison operators.
 
-constexpr bool operator==(int128 lhs, int128 rhs) {
+constexpr bool operator==(int128 lhs, int128 rhs) { 
   return (Int128Low64(lhs) == Int128Low64(rhs) &&
           Int128High64(lhs) == Int128High64(rhs));
 }
 
-constexpr bool operator!=(int128 lhs, int128 rhs) { return !(lhs == rhs); }
+constexpr bool operator!=(int128 lhs, int128 rhs) { return !(lhs == rhs); } 
 
-constexpr bool operator<(int128 lhs, int128 rhs) {
+constexpr bool operator<(int128 lhs, int128 rhs) { 
   return (Int128High64(lhs) == Int128High64(rhs))
              ? (Int128Low64(lhs) < Int128Low64(rhs))
              : (Int128High64(lhs) < Int128High64(rhs));
 }
 
-constexpr bool operator>(int128 lhs, int128 rhs) {
+constexpr bool operator>(int128 lhs, int128 rhs) { 
   return (Int128High64(lhs) == Int128High64(rhs))
              ? (Int128Low64(lhs) > Int128Low64(rhs))
              : (Int128High64(lhs) > Int128High64(rhs));
 }
 
-constexpr bool operator<=(int128 lhs, int128 rhs) { return !(lhs > rhs); }
+constexpr bool operator<=(int128 lhs, int128 rhs) { return !(lhs > rhs); } 
 
-constexpr bool operator>=(int128 lhs, int128 rhs) { return !(lhs < rhs); }
+constexpr bool operator>=(int128 lhs, int128 rhs) { return !(lhs < rhs); } 
 
 // Unary operators.
 
-constexpr int128 operator-(int128 v) {
-  return MakeInt128(~Int128High64(v) + (Int128Low64(v) == 0),
-                    ~Int128Low64(v) + 1);
+constexpr int128 operator-(int128 v) { 
+  return MakeInt128(~Int128High64(v) + (Int128Low64(v) == 0), 
+                    ~Int128Low64(v) + 1); 
 }
 
-constexpr bool operator!(int128 v) {
+constexpr bool operator!(int128 v) { 
   return !Int128Low64(v) && !Int128High64(v);
 }
 
-constexpr int128 operator~(int128 val) {
+constexpr int128 operator~(int128 val) { 
   return MakeInt128(~Int128High64(val), ~Int128Low64(val));
 }
 
 // Arithmetic operators.
 
-namespace int128_internal {
-constexpr int128 SignedAddResult(int128 result, int128 lhs) {
-  // check for carry
-  return (Int128Low64(result) < Int128Low64(lhs))
-             ? MakeInt128(Int128High64(result) + 1, Int128Low64(result))
-             : result;
-}
-}  // namespace int128_internal
-constexpr int128 operator+(int128 lhs, int128 rhs) {
-  return int128_internal::SignedAddResult(
-      MakeInt128(Int128High64(lhs) + Int128High64(rhs),
-                 Int128Low64(lhs) + Int128Low64(rhs)),
-      lhs);
-}
-
-namespace int128_internal {
-constexpr int128 SignedSubstructResult(int128 result, int128 lhs, int128 rhs) {
-  // check for carry
-  return (Int128Low64(lhs) < Int128Low64(rhs))
-             ? MakeInt128(Int128High64(result) - 1, Int128Low64(result))
-             : result;
-}
-}  // namespace int128_internal
-constexpr int128 operator-(int128 lhs, int128 rhs) {
-  return int128_internal::SignedSubstructResult(
-      MakeInt128(Int128High64(lhs) - Int128High64(rhs),
-                 Int128Low64(lhs) - Int128Low64(rhs)),
-      lhs, rhs);
-}
+namespace int128_internal { 
+constexpr int128 SignedAddResult(int128 result, int128 lhs) { 
+  // check for carry 
+  return (Int128Low64(result) < Int128Low64(lhs)) 
+             ? MakeInt128(Int128High64(result) + 1, Int128Low64(result)) 
+             : result; 
+}
+}  // namespace int128_internal 
+constexpr int128 operator+(int128 lhs, int128 rhs) { 
+  return int128_internal::SignedAddResult( 
+      MakeInt128(Int128High64(lhs) + Int128High64(rhs), 
+                 Int128Low64(lhs) + Int128Low64(rhs)), 
+      lhs); 
+} 
+
+namespace int128_internal { 
+constexpr int128 SignedSubstructResult(int128 result, int128 lhs, int128 rhs) { 
+  // check for carry 
+  return (Int128Low64(lhs) < Int128Low64(rhs)) 
+             ? MakeInt128(Int128High64(result) - 1, Int128Low64(result)) 
+             : result; 
+}
+}  // namespace int128_internal 
+constexpr int128 operator-(int128 lhs, int128 rhs) { 
+  return int128_internal::SignedSubstructResult( 
+      MakeInt128(Int128High64(lhs) - Int128High64(rhs), 
+                 Int128Low64(lhs) - Int128Low64(rhs)), 
+      lhs, rhs); 
+} 
 
 inline int128 operator*(int128 lhs, int128 rhs) {
-  return MakeInt128(
-      int128_internal::BitCastToSigned(Uint128High64(uint128(lhs) * rhs)),
-      Uint128Low64(uint128(lhs) * rhs));
+  return MakeInt128( 
+      int128_internal::BitCastToSigned(Uint128High64(uint128(lhs) * rhs)), 
+      Uint128Low64(uint128(lhs) * rhs)); 
 }
 
 inline int128 int128::operator++(int) {
@@ -263,49 +263,49 @@ inline int128& int128::operator--() {
   return *this;
 }
 
-constexpr int128 operator|(int128 lhs, int128 rhs) {
+constexpr int128 operator|(int128 lhs, int128 rhs) { 
   return MakeInt128(Int128High64(lhs) | Int128High64(rhs),
                     Int128Low64(lhs) | Int128Low64(rhs));
 }
 
-constexpr int128 operator&(int128 lhs, int128 rhs) {
+constexpr int128 operator&(int128 lhs, int128 rhs) { 
   return MakeInt128(Int128High64(lhs) & Int128High64(rhs),
                     Int128Low64(lhs) & Int128Low64(rhs));
 }
 
-constexpr int128 operator^(int128 lhs, int128 rhs) {
+constexpr int128 operator^(int128 lhs, int128 rhs) { 
   return MakeInt128(Int128High64(lhs) ^ Int128High64(rhs),
                     Int128Low64(lhs) ^ Int128Low64(rhs));
 }
 
-constexpr int128 operator<<(int128 lhs, int amount) {
-  // int64_t shifts of >= 64 are undefined, so we need some special-casing.
-  return amount >= 64
-             ? MakeInt128(
-                   static_cast<int64_t>(Int128Low64(lhs) << (amount - 64)), 0)
-         : amount == 0
-             ? lhs
-             : MakeInt128(
-                   (Int128High64(lhs) << amount) |
-                       static_cast<int64_t>(Int128Low64(lhs) >> (64 - amount)),
-                   Int128Low64(lhs) << amount);
-}
-
-constexpr int128 operator>>(int128 lhs, int amount) {
-  // int64_t shifts of >= 64 are undefined, so we need some special-casing.
-  // The (Int128High64(lhs) >> 32) >> 32 "trick" causes the the most significant
-  // int64 to be inititialized with all zeros or all ones correctly. It takes
-  // into account whether the number is negative or positive, and whether the
-  // current architecture does arithmetic or logical right shifts for negative
-  // numbers.
-  return amount >= 64
-             ? MakeInt128(
-                   (Int128High64(lhs) >> 32) >> 32,
-                   static_cast<uint64_t>(Int128High64(lhs) >> (amount - 64)))
-         : amount == 0
-             ? lhs
-             : MakeInt128(Int128High64(lhs) >> amount,
-                          (Int128Low64(lhs) >> amount) |
-                              (static_cast<uint64_t>(Int128High64(lhs))
-                               << (64 - amount)));
+constexpr int128 operator<<(int128 lhs, int amount) { 
+  // int64_t shifts of >= 64 are undefined, so we need some special-casing. 
+  return amount >= 64 
+             ? MakeInt128( 
+                   static_cast<int64_t>(Int128Low64(lhs) << (amount - 64)), 0) 
+         : amount == 0 
+             ? lhs 
+             : MakeInt128( 
+                   (Int128High64(lhs) << amount) | 
+                       static_cast<int64_t>(Int128Low64(lhs) >> (64 - amount)), 
+                   Int128Low64(lhs) << amount); 
+}
+
+constexpr int128 operator>>(int128 lhs, int amount) { 
+  // int64_t shifts of >= 64 are undefined, so we need some special-casing. 
+  // The (Int128High64(lhs) >> 32) >> 32 "trick" causes the the most significant 
+  // int64 to be inititialized with all zeros or all ones correctly. It takes 
+  // into account whether the number is negative or positive, and whether the 
+  // current architecture does arithmetic or logical right shifts for negative 
+  // numbers. 
+  return amount >= 64 
+             ? MakeInt128( 
+                   (Int128High64(lhs) >> 32) >> 32, 
+                   static_cast<uint64_t>(Int128High64(lhs) >> (amount - 64))) 
+         : amount == 0 
+             ? lhs 
+             : MakeInt128(Int128High64(lhs) >> amount, 
+                          (Int128Low64(lhs) >> amount) | 
+                              (static_cast<uint64_t>(Int128High64(lhs)) 
+                               << (64 - amount))); 
 }