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

1 files changed, 999 insertions, 999 deletions

diff --git a/contrib/restricted/abseil-cpp/absl/numeric/int128.h b/contrib/restricted/abseil-cpp/absl/numeric/int128.h
index 9a0e6ebccc..c7ad96befd 100644
--- a/contrib/restricted/abseil-cpp/absl/numeric/int128.h
+++ b/contrib/restricted/abseil-cpp/absl/numeric/int128.h
@@ -1,826 +1,826 @@
-// 
-// 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. 
-// 
-// ----------------------------------------------------------------------------- 
-// File: int128.h 
-// ----------------------------------------------------------------------------- 
-// 
-// This header file defines 128-bit integer types, `uint128` and `int128`. 
+//
+// 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.
+//
+// -----------------------------------------------------------------------------
+// File: int128.h
+// -----------------------------------------------------------------------------
+//
+// 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.
- 
-#ifndef ABSL_NUMERIC_INT128_H_ 
-#define ABSL_NUMERIC_INT128_H_ 
- 
-#include <cassert> 
-#include <cmath> 
-#include <cstdint> 
-#include <cstring> 
-#include <iosfwd> 
-#include <limits> 
-#include <utility> 
- 
-#include "absl/base/config.h" 
-#include "absl/base/macros.h" 
-#include "absl/base/port.h" 
- 
-#if defined(_MSC_VER) 
-// In very old versions of MSVC and when the /Zc:wchar_t flag is off, wchar_t is 
-// a typedef for unsigned short.  Otherwise wchar_t is mapped to the __wchar_t 
-// builtin type.  We need to make sure not to define operator wchar_t() 
-// alongside operator unsigned short() in these instances. 
-#define ABSL_INTERNAL_WCHAR_T __wchar_t 
-#if defined(_M_X64) 
-#include <intrin.h> 
-#pragma intrinsic(_umul128) 
-#endif  // defined(_M_X64) 
-#else   // defined(_MSC_VER) 
-#define ABSL_INTERNAL_WCHAR_T wchar_t 
-#endif  // defined(_MSC_VER) 
- 
-namespace absl { 
+
+#ifndef ABSL_NUMERIC_INT128_H_
+#define ABSL_NUMERIC_INT128_H_
+
+#include <cassert>
+#include <cmath>
+#include <cstdint>
+#include <cstring>
+#include <iosfwd>
+#include <limits>
+#include <utility>
+
+#include "absl/base/config.h"
+#include "absl/base/macros.h"
+#include "absl/base/port.h"
+
+#if defined(_MSC_VER)
+// In very old versions of MSVC and when the /Zc:wchar_t flag is off, wchar_t is
+// a typedef for unsigned short.  Otherwise wchar_t is mapped to the __wchar_t
+// builtin type.  We need to make sure not to define operator wchar_t()
+// alongside operator unsigned short() in these instances.
+#define ABSL_INTERNAL_WCHAR_T __wchar_t
+#if defined(_M_X64)
+#include <intrin.h>
+#pragma intrinsic(_umul128)
+#endif  // defined(_M_X64)
+#else   // defined(_MSC_VER)
+#define ABSL_INTERNAL_WCHAR_T wchar_t
+#endif  // defined(_MSC_VER)
+
+namespace absl {
 ABSL_NAMESPACE_BEGIN
- 
-class int128; 
- 
-// uint128 
-// 
-// An unsigned 128-bit integer type. The API is meant to mimic an intrinsic type 
-// as closely as is practical, including exhibiting undefined behavior in 
-// analogous cases (e.g. division by zero). This type is intended to be a 
-// drop-in replacement once C++ supports an intrinsic `uint128_t` type; when 
-// that occurs, existing well-behaved uses of `uint128` will continue to work 
-// using that new type. 
-// 
-// Note: code written with this type will continue to compile once `uint128_t` 
-// is introduced, provided the replacement helper functions 
-// `Uint128(Low|High)64()` and `MakeUint128()` are made. 
-// 
-// A `uint128` supports the following: 
-// 
-//   * Implicit construction from integral types 
-//   * Explicit conversion to integral types 
-// 
-// Additionally, if your compiler supports `__int128`, `uint128` is 
-// interoperable with that type. (Abseil checks for this compatibility through 
-// the `ABSL_HAVE_INTRINSIC_INT128` macro.) 
-// 
-// However, a `uint128` differs from intrinsic integral types in the following 
-// ways: 
-// 
-//   * Errors on implicit conversions that do not preserve value (such as 
-//     loss of precision when converting to float values). 
-//   * Requires explicit construction from and conversion to floating point 
-//     types. 
-//   * Conversion to integral types requires an explicit static_cast() to 
-//     mimic use of the `-Wnarrowing` compiler flag. 
-//   * The alignment requirement of `uint128` may differ from that of an 
-//     intrinsic 128-bit integer type depending on platform and build 
-//     configuration. 
-// 
-// Example: 
-// 
-//     float y = absl::Uint128Max();  // Error. uint128 cannot be implicitly 
-//                                    // converted to float. 
-// 
-//     absl::uint128 v; 
-//     uint64_t i = v;                         // Error 
-//     uint64_t i = static_cast<uint64_t>(v);  // OK 
-// 
-class 
-#if defined(ABSL_HAVE_INTRINSIC_INT128) 
-    alignas(unsigned __int128) 
-#endif  // ABSL_HAVE_INTRINSIC_INT128 
-        uint128 { 
- public: 
-  uint128() = default; 
- 
-  // Constructors from arithmetic types 
-  constexpr uint128(int v);                 // NOLINT(runtime/explicit) 
-  constexpr uint128(unsigned int v);        // NOLINT(runtime/explicit) 
-  constexpr uint128(long v);                // NOLINT(runtime/int) 
-  constexpr uint128(unsigned long v);       // NOLINT(runtime/int) 
-  constexpr uint128(long long v);           // NOLINT(runtime/int) 
-  constexpr uint128(unsigned long long v);  // NOLINT(runtime/int) 
-#ifdef ABSL_HAVE_INTRINSIC_INT128 
-  constexpr uint128(__int128 v);           // NOLINT(runtime/explicit) 
-  constexpr uint128(unsigned __int128 v);  // NOLINT(runtime/explicit) 
-#endif  // ABSL_HAVE_INTRINSIC_INT128 
-  constexpr uint128(int128 v);  // NOLINT(runtime/explicit) 
-  explicit uint128(float v); 
-  explicit uint128(double v); 
-  explicit uint128(long double v); 
- 
-  // Assignment operators from arithmetic types 
-  uint128& operator=(int v); 
-  uint128& operator=(unsigned int v); 
-  uint128& operator=(long v);                // NOLINT(runtime/int) 
-  uint128& operator=(unsigned long v);       // NOLINT(runtime/int) 
-  uint128& operator=(long long v);           // NOLINT(runtime/int) 
-  uint128& operator=(unsigned long long v);  // NOLINT(runtime/int) 
-#ifdef ABSL_HAVE_INTRINSIC_INT128 
-  uint128& operator=(__int128 v); 
-  uint128& operator=(unsigned __int128 v); 
-#endif  // ABSL_HAVE_INTRINSIC_INT128 
-  uint128& operator=(int128 v); 
- 
-  // Conversion operators to other arithmetic types 
-  constexpr explicit operator bool() const; 
-  constexpr explicit operator char() const; 
-  constexpr explicit operator signed char() const; 
-  constexpr explicit operator unsigned char() const; 
-  constexpr explicit operator char16_t() const; 
-  constexpr explicit operator char32_t() const; 
-  constexpr explicit operator ABSL_INTERNAL_WCHAR_T() const; 
-  constexpr explicit operator short() const;  // NOLINT(runtime/int) 
-  // NOLINTNEXTLINE(runtime/int) 
-  constexpr explicit operator unsigned short() const; 
-  constexpr explicit operator int() const; 
-  constexpr explicit operator unsigned int() const; 
-  constexpr explicit operator long() const;  // NOLINT(runtime/int) 
-  // NOLINTNEXTLINE(runtime/int) 
-  constexpr explicit operator unsigned long() const; 
-  // NOLINTNEXTLINE(runtime/int) 
-  constexpr explicit operator long long() const; 
-  // NOLINTNEXTLINE(runtime/int) 
-  constexpr explicit operator unsigned long long() const; 
-#ifdef ABSL_HAVE_INTRINSIC_INT128 
-  constexpr explicit operator __int128() const; 
-  constexpr explicit operator unsigned __int128() const; 
-#endif  // ABSL_HAVE_INTRINSIC_INT128 
-  explicit operator float() const; 
-  explicit operator double() const; 
-  explicit operator long double() const; 
- 
-  // Trivial copy constructor, assignment operator and destructor. 
- 
-  // Arithmetic operators. 
-  uint128& operator+=(uint128 other); 
-  uint128& operator-=(uint128 other); 
-  uint128& operator*=(uint128 other); 
-  // Long division/modulo for uint128. 
-  uint128& operator/=(uint128 other); 
-  uint128& operator%=(uint128 other); 
-  uint128 operator++(int); 
-  uint128 operator--(int); 
-  uint128& operator<<=(int); 
-  uint128& operator>>=(int); 
-  uint128& operator&=(uint128 other); 
-  uint128& operator|=(uint128 other); 
-  uint128& operator^=(uint128 other); 
-  uint128& operator++(); 
-  uint128& operator--(); 
- 
-  // Uint128Low64() 
-  // 
-  // Returns the lower 64-bit value of a `uint128` value. 
-  friend constexpr uint64_t Uint128Low64(uint128 v); 
- 
-  // Uint128High64() 
-  // 
-  // Returns the higher 64-bit value of a `uint128` value. 
-  friend constexpr uint64_t Uint128High64(uint128 v); 
- 
-  // MakeUInt128() 
-  // 
-  // Constructs a `uint128` numeric value from two 64-bit unsigned integers. 
-  // Note that this factory function is the only way to construct a `uint128` 
-  // from integer values greater than 2^64. 
-  // 
-  // Example: 
-  // 
-  //   absl::uint128 big = absl::MakeUint128(1, 0); 
-  friend constexpr uint128 MakeUint128(uint64_t high, uint64_t low); 
- 
-  // Uint128Max() 
-  // 
-  // Returns the highest value for a 128-bit unsigned integer. 
-  friend constexpr uint128 Uint128Max(); 
- 
-  // Support for absl::Hash. 
-  template <typename H> 
-  friend H AbslHashValue(H h, uint128 v) { 
-    return H::combine(std::move(h), Uint128High64(v), Uint128Low64(v)); 
-  } 
- 
- private: 
-  constexpr uint128(uint64_t high, uint64_t low); 
- 
-  // TODO(strel) Update implementation to use __int128 once all users of 
-  // uint128 are fixed to not depend on alignof(uint128) == 8. Also add 
-  // alignas(16) to class definition to keep alignment consistent across 
-  // platforms. 
-#if defined(ABSL_IS_LITTLE_ENDIAN) 
-  uint64_t lo_; 
-  uint64_t hi_; 
-#elif defined(ABSL_IS_BIG_ENDIAN) 
-  uint64_t hi_; 
-  uint64_t lo_; 
-#else  // byte order 
-#error "Unsupported byte order: must be little-endian or big-endian." 
-#endif  // byte order 
-}; 
- 
-// Prefer to use the constexpr `Uint128Max()`. 
-// 
-// TODO(absl-team) deprecate kuint128max once migration tool is released. 
+
+class int128;
+
+// uint128
+//
+// An unsigned 128-bit integer type. The API is meant to mimic an intrinsic type
+// as closely as is practical, including exhibiting undefined behavior in
+// analogous cases (e.g. division by zero). This type is intended to be a
+// drop-in replacement once C++ supports an intrinsic `uint128_t` type; when
+// that occurs, existing well-behaved uses of `uint128` will continue to work
+// using that new type.
+//
+// Note: code written with this type will continue to compile once `uint128_t`
+// is introduced, provided the replacement helper functions
+// `Uint128(Low|High)64()` and `MakeUint128()` are made.
+//
+// A `uint128` supports the following:
+//
+//   * Implicit construction from integral types
+//   * Explicit conversion to integral types
+//
+// Additionally, if your compiler supports `__int128`, `uint128` is
+// interoperable with that type. (Abseil checks for this compatibility through
+// the `ABSL_HAVE_INTRINSIC_INT128` macro.)
+//
+// However, a `uint128` differs from intrinsic integral types in the following
+// ways:
+//
+//   * Errors on implicit conversions that do not preserve value (such as
+//     loss of precision when converting to float values).
+//   * Requires explicit construction from and conversion to floating point
+//     types.
+//   * Conversion to integral types requires an explicit static_cast() to
+//     mimic use of the `-Wnarrowing` compiler flag.
+//   * The alignment requirement of `uint128` may differ from that of an
+//     intrinsic 128-bit integer type depending on platform and build
+//     configuration.
+//
+// Example:
+//
+//     float y = absl::Uint128Max();  // Error. uint128 cannot be implicitly
+//                                    // converted to float.
+//
+//     absl::uint128 v;
+//     uint64_t i = v;                         // Error
+//     uint64_t i = static_cast<uint64_t>(v);  // OK
+//
+class
+#if defined(ABSL_HAVE_INTRINSIC_INT128)
+    alignas(unsigned __int128)
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+        uint128 {
+ public:
+  uint128() = default;
+
+  // Constructors from arithmetic types
+  constexpr uint128(int v);                 // NOLINT(runtime/explicit)
+  constexpr uint128(unsigned int v);        // NOLINT(runtime/explicit)
+  constexpr uint128(long v);                // NOLINT(runtime/int)
+  constexpr uint128(unsigned long v);       // NOLINT(runtime/int)
+  constexpr uint128(long long v);           // NOLINT(runtime/int)
+  constexpr uint128(unsigned long long v);  // NOLINT(runtime/int)
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+  constexpr uint128(__int128 v);           // NOLINT(runtime/explicit)
+  constexpr uint128(unsigned __int128 v);  // NOLINT(runtime/explicit)
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+  constexpr uint128(int128 v);  // NOLINT(runtime/explicit)
+  explicit uint128(float v);
+  explicit uint128(double v);
+  explicit uint128(long double v);
+
+  // Assignment operators from arithmetic types
+  uint128& operator=(int v);
+  uint128& operator=(unsigned int v);
+  uint128& operator=(long v);                // NOLINT(runtime/int)
+  uint128& operator=(unsigned long v);       // NOLINT(runtime/int)
+  uint128& operator=(long long v);           // NOLINT(runtime/int)
+  uint128& operator=(unsigned long long v);  // NOLINT(runtime/int)
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+  uint128& operator=(__int128 v);
+  uint128& operator=(unsigned __int128 v);
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+  uint128& operator=(int128 v);
+
+  // Conversion operators to other arithmetic types
+  constexpr explicit operator bool() const;
+  constexpr explicit operator char() const;
+  constexpr explicit operator signed char() const;
+  constexpr explicit operator unsigned char() const;
+  constexpr explicit operator char16_t() const;
+  constexpr explicit operator char32_t() const;
+  constexpr explicit operator ABSL_INTERNAL_WCHAR_T() const;
+  constexpr explicit operator short() const;  // NOLINT(runtime/int)
+  // NOLINTNEXTLINE(runtime/int)
+  constexpr explicit operator unsigned short() const;
+  constexpr explicit operator int() const;
+  constexpr explicit operator unsigned int() const;
+  constexpr explicit operator long() const;  // NOLINT(runtime/int)
+  // NOLINTNEXTLINE(runtime/int)
+  constexpr explicit operator unsigned long() const;
+  // NOLINTNEXTLINE(runtime/int)
+  constexpr explicit operator long long() const;
+  // NOLINTNEXTLINE(runtime/int)
+  constexpr explicit operator unsigned long long() const;
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+  constexpr explicit operator __int128() const;
+  constexpr explicit operator unsigned __int128() const;
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+  explicit operator float() const;
+  explicit operator double() const;
+  explicit operator long double() const;
+
+  // Trivial copy constructor, assignment operator and destructor.
+
+  // Arithmetic operators.
+  uint128& operator+=(uint128 other);
+  uint128& operator-=(uint128 other);
+  uint128& operator*=(uint128 other);
+  // Long division/modulo for uint128.
+  uint128& operator/=(uint128 other);
+  uint128& operator%=(uint128 other);
+  uint128 operator++(int);
+  uint128 operator--(int);
+  uint128& operator<<=(int);
+  uint128& operator>>=(int);
+  uint128& operator&=(uint128 other);
+  uint128& operator|=(uint128 other);
+  uint128& operator^=(uint128 other);
+  uint128& operator++();
+  uint128& operator--();
+
+  // Uint128Low64()
+  //
+  // Returns the lower 64-bit value of a `uint128` value.
+  friend constexpr uint64_t Uint128Low64(uint128 v);
+
+  // Uint128High64()
+  //
+  // Returns the higher 64-bit value of a `uint128` value.
+  friend constexpr uint64_t Uint128High64(uint128 v);
+
+  // MakeUInt128()
+  //
+  // Constructs a `uint128` numeric value from two 64-bit unsigned integers.
+  // Note that this factory function is the only way to construct a `uint128`
+  // from integer values greater than 2^64.
+  //
+  // Example:
+  //
+  //   absl::uint128 big = absl::MakeUint128(1, 0);
+  friend constexpr uint128 MakeUint128(uint64_t high, uint64_t low);
+
+  // Uint128Max()
+  //
+  // Returns the highest value for a 128-bit unsigned integer.
+  friend constexpr uint128 Uint128Max();
+
+  // Support for absl::Hash.
+  template <typename H>
+  friend H AbslHashValue(H h, uint128 v) {
+    return H::combine(std::move(h), Uint128High64(v), Uint128Low64(v));
+  }
+
+ private:
+  constexpr uint128(uint64_t high, uint64_t low);
+
+  // TODO(strel) Update implementation to use __int128 once all users of
+  // uint128 are fixed to not depend on alignof(uint128) == 8. Also add
+  // alignas(16) to class definition to keep alignment consistent across
+  // platforms.
+#if defined(ABSL_IS_LITTLE_ENDIAN)
+  uint64_t lo_;
+  uint64_t hi_;
+#elif defined(ABSL_IS_BIG_ENDIAN)
+  uint64_t hi_;
+  uint64_t lo_;
+#else  // byte order
+#error "Unsupported byte order: must be little-endian or big-endian."
+#endif  // byte order
+};
+
+// Prefer to use the constexpr `Uint128Max()`.
+//
+// TODO(absl-team) deprecate kuint128max once migration tool is released.
 ABSL_DLL extern const uint128 kuint128max;
- 
-// allow uint128 to be logged 
-std::ostream& operator<<(std::ostream& os, uint128 v); 
- 
-// TODO(strel) add operator>>(std::istream&, uint128) 
- 
-constexpr uint128 Uint128Max() { 
-  return uint128((std::numeric_limits<uint64_t>::max)(), 
-                 (std::numeric_limits<uint64_t>::max)()); 
-} 
- 
+
+// allow uint128 to be logged
+std::ostream& operator<<(std::ostream& os, uint128 v);
+
+// TODO(strel) add operator>>(std::istream&, uint128)
+
+constexpr uint128 Uint128Max() {
+  return uint128((std::numeric_limits<uint64_t>::max)(),
+                 (std::numeric_limits<uint64_t>::max)());
+}
+
 ABSL_NAMESPACE_END
-}  // namespace absl 
- 
-// Specialized numeric_limits for uint128. 
-namespace std { 
-template <> 
-class numeric_limits<absl::uint128> { 
- public: 
-  static constexpr bool is_specialized = true; 
-  static constexpr bool is_signed = false; 
-  static constexpr bool is_integer = true; 
-  static constexpr bool is_exact = true; 
-  static constexpr bool has_infinity = false; 
-  static constexpr bool has_quiet_NaN = false; 
-  static constexpr bool has_signaling_NaN = false; 
-  static constexpr float_denorm_style has_denorm = denorm_absent; 
-  static constexpr bool has_denorm_loss = false; 
-  static constexpr float_round_style round_style = round_toward_zero; 
-  static constexpr bool is_iec559 = false; 
-  static constexpr bool is_bounded = true; 
-  static constexpr bool is_modulo = true; 
-  static constexpr int digits = 128; 
-  static constexpr int digits10 = 38; 
-  static constexpr int max_digits10 = 0; 
-  static constexpr int radix = 2; 
-  static constexpr int min_exponent = 0; 
-  static constexpr int min_exponent10 = 0; 
-  static constexpr int max_exponent = 0; 
-  static constexpr int max_exponent10 = 0; 
-#ifdef ABSL_HAVE_INTRINSIC_INT128 
-  static constexpr bool traps = numeric_limits<unsigned __int128>::traps; 
-#else   // ABSL_HAVE_INTRINSIC_INT128 
-  static constexpr bool traps = numeric_limits<uint64_t>::traps; 
-#endif  // ABSL_HAVE_INTRINSIC_INT128 
-  static constexpr bool tinyness_before = false; 
- 
-  static constexpr absl::uint128 (min)() { return 0; } 
-  static constexpr absl::uint128 lowest() { return 0; } 
-  static constexpr absl::uint128 (max)() { return absl::Uint128Max(); } 
-  static constexpr absl::uint128 epsilon() { return 0; } 
-  static constexpr absl::uint128 round_error() { return 0; } 
-  static constexpr absl::uint128 infinity() { return 0; } 
-  static constexpr absl::uint128 quiet_NaN() { return 0; } 
-  static constexpr absl::uint128 signaling_NaN() { return 0; } 
-  static constexpr absl::uint128 denorm_min() { return 0; } 
-}; 
-}  // namespace std 
- 
-namespace absl { 
+}  // namespace absl
+
+// Specialized numeric_limits for uint128.
+namespace std {
+template <>
+class numeric_limits<absl::uint128> {
+ public:
+  static constexpr bool is_specialized = true;
+  static constexpr bool is_signed = false;
+  static constexpr bool is_integer = true;
+  static constexpr bool is_exact = true;
+  static constexpr bool has_infinity = false;
+  static constexpr bool has_quiet_NaN = false;
+  static constexpr bool has_signaling_NaN = false;
+  static constexpr float_denorm_style has_denorm = denorm_absent;
+  static constexpr bool has_denorm_loss = false;
+  static constexpr float_round_style round_style = round_toward_zero;
+  static constexpr bool is_iec559 = false;
+  static constexpr bool is_bounded = true;
+  static constexpr bool is_modulo = true;
+  static constexpr int digits = 128;
+  static constexpr int digits10 = 38;
+  static constexpr int max_digits10 = 0;
+  static constexpr int radix = 2;
+  static constexpr int min_exponent = 0;
+  static constexpr int min_exponent10 = 0;
+  static constexpr int max_exponent = 0;
+  static constexpr int max_exponent10 = 0;
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+  static constexpr bool traps = numeric_limits<unsigned __int128>::traps;
+#else   // ABSL_HAVE_INTRINSIC_INT128
+  static constexpr bool traps = numeric_limits<uint64_t>::traps;
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+  static constexpr bool tinyness_before = false;
+
+  static constexpr absl::uint128 (min)() { return 0; }
+  static constexpr absl::uint128 lowest() { return 0; }
+  static constexpr absl::uint128 (max)() { return absl::Uint128Max(); }
+  static constexpr absl::uint128 epsilon() { return 0; }
+  static constexpr absl::uint128 round_error() { return 0; }
+  static constexpr absl::uint128 infinity() { return 0; }
+  static constexpr absl::uint128 quiet_NaN() { return 0; }
+  static constexpr absl::uint128 signaling_NaN() { return 0; }
+  static constexpr absl::uint128 denorm_min() { return 0; }
+};
+}  // namespace std
+
+namespace absl {
 ABSL_NAMESPACE_BEGIN
- 
-// int128 
-// 
-// A signed 128-bit integer type. The API is meant to mimic an intrinsic 
-// integral type as closely as is practical, including exhibiting undefined 
-// behavior in analogous cases (e.g. division by zero). 
-// 
-// An `int128` supports the following: 
-// 
-//   * Implicit construction from integral types 
-//   * Explicit conversion to integral types 
-// 
-// However, an `int128` differs from intrinsic integral types in the following 
-// ways: 
-// 
-//   * It is not implicitly convertible to other integral types. 
-//   * Requires explicit construction from and conversion to floating point 
-//     types. 
- 
-// Additionally, if your compiler supports `__int128`, `int128` is 
-// interoperable with that type. (Abseil checks for this compatibility through 
-// the `ABSL_HAVE_INTRINSIC_INT128` macro.) 
-// 
-// The design goal for `int128` is that it will be compatible with a future 
-// `int128_t`, if that type becomes a part of the standard. 
-// 
-// Example: 
-// 
-//     float y = absl::int128(17);  // Error. int128 cannot be implicitly 
-//                                  // converted to float. 
-// 
-//     absl::int128 v; 
-//     int64_t i = v;                        // Error 
-//     int64_t i = static_cast<int64_t>(v);  // OK 
-// 
-class int128 { 
- public: 
-  int128() = default; 
- 
-  // Constructors from arithmetic types 
-  constexpr int128(int v);                 // NOLINT(runtime/explicit) 
-  constexpr int128(unsigned int v);        // NOLINT(runtime/explicit) 
-  constexpr int128(long v);                // NOLINT(runtime/int) 
-  constexpr int128(unsigned long v);       // NOLINT(runtime/int) 
-  constexpr int128(long long v);           // NOLINT(runtime/int) 
-  constexpr int128(unsigned long long v);  // NOLINT(runtime/int) 
-#ifdef ABSL_HAVE_INTRINSIC_INT128 
-  constexpr int128(__int128 v);  // NOLINT(runtime/explicit) 
-  constexpr explicit int128(unsigned __int128 v); 
-#endif  // ABSL_HAVE_INTRINSIC_INT128 
-  constexpr explicit int128(uint128 v); 
-  explicit int128(float v); 
-  explicit int128(double v); 
-  explicit int128(long double v); 
- 
-  // Assignment operators from arithmetic types 
-  int128& operator=(int v); 
-  int128& operator=(unsigned int v); 
-  int128& operator=(long v);                // NOLINT(runtime/int) 
-  int128& operator=(unsigned long v);       // NOLINT(runtime/int) 
-  int128& operator=(long long v);           // NOLINT(runtime/int) 
-  int128& operator=(unsigned long long v);  // NOLINT(runtime/int) 
-#ifdef ABSL_HAVE_INTRINSIC_INT128 
-  int128& operator=(__int128 v); 
-#endif  // ABSL_HAVE_INTRINSIC_INT128 
- 
-  // Conversion operators to other arithmetic types 
-  constexpr explicit operator bool() const; 
-  constexpr explicit operator char() const; 
-  constexpr explicit operator signed char() const; 
-  constexpr explicit operator unsigned char() const; 
-  constexpr explicit operator char16_t() const; 
-  constexpr explicit operator char32_t() const; 
-  constexpr explicit operator ABSL_INTERNAL_WCHAR_T() const; 
-  constexpr explicit operator short() const;  // NOLINT(runtime/int) 
-  // NOLINTNEXTLINE(runtime/int) 
-  constexpr explicit operator unsigned short() const; 
-  constexpr explicit operator int() const; 
-  constexpr explicit operator unsigned int() const; 
-  constexpr explicit operator long() const;  // NOLINT(runtime/int) 
-  // NOLINTNEXTLINE(runtime/int) 
-  constexpr explicit operator unsigned long() const; 
-  // NOLINTNEXTLINE(runtime/int) 
-  constexpr explicit operator long long() const; 
-  // NOLINTNEXTLINE(runtime/int) 
-  constexpr explicit operator unsigned long long() const; 
-#ifdef ABSL_HAVE_INTRINSIC_INT128 
-  constexpr explicit operator __int128() const; 
-  constexpr explicit operator unsigned __int128() const; 
-#endif  // ABSL_HAVE_INTRINSIC_INT128 
-  explicit operator float() const; 
-  explicit operator double() const; 
-  explicit operator long double() const; 
- 
-  // Trivial copy constructor, assignment operator and destructor. 
- 
-  // Arithmetic operators 
-  int128& operator+=(int128 other); 
-  int128& operator-=(int128 other); 
-  int128& operator*=(int128 other); 
-  int128& operator/=(int128 other); 
-  int128& operator%=(int128 other); 
-  int128 operator++(int);  // postfix increment: i++ 
-  int128 operator--(int);  // postfix decrement: i-- 
-  int128& operator++();    // prefix increment:  ++i 
-  int128& operator--();    // prefix decrement:  --i 
-  int128& operator&=(int128 other); 
-  int128& operator|=(int128 other); 
-  int128& operator^=(int128 other); 
-  int128& operator<<=(int amount); 
-  int128& operator>>=(int amount); 
- 
-  // Int128Low64() 
-  // 
-  // Returns the lower 64-bit value of a `int128` value. 
-  friend constexpr uint64_t Int128Low64(int128 v); 
- 
-  // Int128High64() 
-  // 
-  // Returns the higher 64-bit value of a `int128` value. 
-  friend constexpr int64_t Int128High64(int128 v); 
- 
-  // MakeInt128() 
-  // 
-  // Constructs a `int128` numeric value from two 64-bit integers. Note that 
-  // signedness is conveyed in the upper `high` value. 
-  // 
-  //   (absl::int128(1) << 64) * high + low 
-  // 
-  // Note that this factory function is the only way to construct a `int128` 
-  // from integer values greater than 2^64 or less than -2^64. 
-  // 
-  // Example: 
-  // 
-  //   absl::int128 big = absl::MakeInt128(1, 0); 
-  //   absl::int128 big_n = absl::MakeInt128(-1, 0); 
-  friend constexpr int128 MakeInt128(int64_t high, uint64_t low); 
- 
-  // Int128Max() 
-  // 
-  // Returns the maximum value for a 128-bit signed integer. 
-  friend constexpr int128 Int128Max(); 
- 
-  // Int128Min() 
-  // 
-  // Returns the minimum value for a 128-bit signed integer. 
-  friend constexpr int128 Int128Min(); 
- 
-  // Support for absl::Hash. 
-  template <typename H> 
-  friend H AbslHashValue(H h, int128 v) { 
-    return H::combine(std::move(h), Int128High64(v), Int128Low64(v)); 
-  } 
- 
- private: 
-  constexpr int128(int64_t high, uint64_t low); 
- 
-#if defined(ABSL_HAVE_INTRINSIC_INT128) 
-  __int128 v_; 
-#else  // ABSL_HAVE_INTRINSIC_INT128 
-#if defined(ABSL_IS_LITTLE_ENDIAN) 
-  uint64_t lo_; 
-  int64_t hi_; 
-#elif defined(ABSL_IS_BIG_ENDIAN) 
-  int64_t hi_; 
-  uint64_t lo_; 
-#else  // byte order 
-#error "Unsupported byte order: must be little-endian or big-endian." 
-#endif  // byte order 
-#endif  // ABSL_HAVE_INTRINSIC_INT128 
-}; 
- 
-std::ostream& operator<<(std::ostream& os, int128 v); 
- 
-// TODO(absl-team) add operator>>(std::istream&, int128) 
- 
-constexpr int128 Int128Max() { 
-  return int128((std::numeric_limits<int64_t>::max)(), 
-                (std::numeric_limits<uint64_t>::max)()); 
-} 
- 
-constexpr int128 Int128Min() { 
-  return int128((std::numeric_limits<int64_t>::min)(), 0); 
-} 
- 
+
+// int128
+//
+// A signed 128-bit integer type. The API is meant to mimic an intrinsic
+// integral type as closely as is practical, including exhibiting undefined
+// behavior in analogous cases (e.g. division by zero).
+//
+// An `int128` supports the following:
+//
+//   * Implicit construction from integral types
+//   * Explicit conversion to integral types
+//
+// However, an `int128` differs from intrinsic integral types in the following
+// ways:
+//
+//   * It is not implicitly convertible to other integral types.
+//   * Requires explicit construction from and conversion to floating point
+//     types.
+
+// Additionally, if your compiler supports `__int128`, `int128` is
+// interoperable with that type. (Abseil checks for this compatibility through
+// the `ABSL_HAVE_INTRINSIC_INT128` macro.)
+//
+// The design goal for `int128` is that it will be compatible with a future
+// `int128_t`, if that type becomes a part of the standard.
+//
+// Example:
+//
+//     float y = absl::int128(17);  // Error. int128 cannot be implicitly
+//                                  // converted to float.
+//
+//     absl::int128 v;
+//     int64_t i = v;                        // Error
+//     int64_t i = static_cast<int64_t>(v);  // OK
+//
+class int128 {
+ public:
+  int128() = default;
+
+  // Constructors from arithmetic types
+  constexpr int128(int v);                 // NOLINT(runtime/explicit)
+  constexpr int128(unsigned int v);        // NOLINT(runtime/explicit)
+  constexpr int128(long v);                // NOLINT(runtime/int)
+  constexpr int128(unsigned long v);       // NOLINT(runtime/int)
+  constexpr int128(long long v);           // NOLINT(runtime/int)
+  constexpr int128(unsigned long long v);  // NOLINT(runtime/int)
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+  constexpr int128(__int128 v);  // NOLINT(runtime/explicit)
+  constexpr explicit int128(unsigned __int128 v);
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+  constexpr explicit int128(uint128 v);
+  explicit int128(float v);
+  explicit int128(double v);
+  explicit int128(long double v);
+
+  // Assignment operators from arithmetic types
+  int128& operator=(int v);
+  int128& operator=(unsigned int v);
+  int128& operator=(long v);                // NOLINT(runtime/int)
+  int128& operator=(unsigned long v);       // NOLINT(runtime/int)
+  int128& operator=(long long v);           // NOLINT(runtime/int)
+  int128& operator=(unsigned long long v);  // NOLINT(runtime/int)
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+  int128& operator=(__int128 v);
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+
+  // Conversion operators to other arithmetic types
+  constexpr explicit operator bool() const;
+  constexpr explicit operator char() const;
+  constexpr explicit operator signed char() const;
+  constexpr explicit operator unsigned char() const;
+  constexpr explicit operator char16_t() const;
+  constexpr explicit operator char32_t() const;
+  constexpr explicit operator ABSL_INTERNAL_WCHAR_T() const;
+  constexpr explicit operator short() const;  // NOLINT(runtime/int)
+  // NOLINTNEXTLINE(runtime/int)
+  constexpr explicit operator unsigned short() const;
+  constexpr explicit operator int() const;
+  constexpr explicit operator unsigned int() const;
+  constexpr explicit operator long() const;  // NOLINT(runtime/int)
+  // NOLINTNEXTLINE(runtime/int)
+  constexpr explicit operator unsigned long() const;
+  // NOLINTNEXTLINE(runtime/int)
+  constexpr explicit operator long long() const;
+  // NOLINTNEXTLINE(runtime/int)
+  constexpr explicit operator unsigned long long() const;
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+  constexpr explicit operator __int128() const;
+  constexpr explicit operator unsigned __int128() const;
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+  explicit operator float() const;
+  explicit operator double() const;
+  explicit operator long double() const;
+
+  // Trivial copy constructor, assignment operator and destructor.
+
+  // Arithmetic operators
+  int128& operator+=(int128 other);
+  int128& operator-=(int128 other);
+  int128& operator*=(int128 other);
+  int128& operator/=(int128 other);
+  int128& operator%=(int128 other);
+  int128 operator++(int);  // postfix increment: i++
+  int128 operator--(int);  // postfix decrement: i--
+  int128& operator++();    // prefix increment:  ++i
+  int128& operator--();    // prefix decrement:  --i
+  int128& operator&=(int128 other);
+  int128& operator|=(int128 other);
+  int128& operator^=(int128 other);
+  int128& operator<<=(int amount);
+  int128& operator>>=(int amount);
+
+  // Int128Low64()
+  //
+  // Returns the lower 64-bit value of a `int128` value.
+  friend constexpr uint64_t Int128Low64(int128 v);
+
+  // Int128High64()
+  //
+  // Returns the higher 64-bit value of a `int128` value.
+  friend constexpr int64_t Int128High64(int128 v);
+
+  // MakeInt128()
+  //
+  // Constructs a `int128` numeric value from two 64-bit integers. Note that
+  // signedness is conveyed in the upper `high` value.
+  //
+  //   (absl::int128(1) << 64) * high + low
+  //
+  // Note that this factory function is the only way to construct a `int128`
+  // from integer values greater than 2^64 or less than -2^64.
+  //
+  // Example:
+  //
+  //   absl::int128 big = absl::MakeInt128(1, 0);
+  //   absl::int128 big_n = absl::MakeInt128(-1, 0);
+  friend constexpr int128 MakeInt128(int64_t high, uint64_t low);
+
+  // Int128Max()
+  //
+  // Returns the maximum value for a 128-bit signed integer.
+  friend constexpr int128 Int128Max();
+
+  // Int128Min()
+  //
+  // Returns the minimum value for a 128-bit signed integer.
+  friend constexpr int128 Int128Min();
+
+  // Support for absl::Hash.
+  template <typename H>
+  friend H AbslHashValue(H h, int128 v) {
+    return H::combine(std::move(h), Int128High64(v), Int128Low64(v));
+  }
+
+ private:
+  constexpr int128(int64_t high, uint64_t low);
+
+#if defined(ABSL_HAVE_INTRINSIC_INT128)
+  __int128 v_;
+#else  // ABSL_HAVE_INTRINSIC_INT128
+#if defined(ABSL_IS_LITTLE_ENDIAN)
+  uint64_t lo_;
+  int64_t hi_;
+#elif defined(ABSL_IS_BIG_ENDIAN)
+  int64_t hi_;
+  uint64_t lo_;
+#else  // byte order
+#error "Unsupported byte order: must be little-endian or big-endian."
+#endif  // byte order
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+};
+
+std::ostream& operator<<(std::ostream& os, int128 v);
+
+// TODO(absl-team) add operator>>(std::istream&, int128)
+
+constexpr int128 Int128Max() {
+  return int128((std::numeric_limits<int64_t>::max)(),
+                (std::numeric_limits<uint64_t>::max)());
+}
+
+constexpr int128 Int128Min() {
+  return int128((std::numeric_limits<int64_t>::min)(), 0);
+}
+
 ABSL_NAMESPACE_END
-}  // namespace absl 
- 
-// Specialized numeric_limits for int128. 
-namespace std { 
-template <> 
-class numeric_limits<absl::int128> { 
- public: 
-  static constexpr bool is_specialized = true; 
-  static constexpr bool is_signed = true; 
-  static constexpr bool is_integer = true; 
-  static constexpr bool is_exact = true; 
-  static constexpr bool has_infinity = false; 
-  static constexpr bool has_quiet_NaN = false; 
-  static constexpr bool has_signaling_NaN = false; 
-  static constexpr float_denorm_style has_denorm = denorm_absent; 
-  static constexpr bool has_denorm_loss = false; 
-  static constexpr float_round_style round_style = round_toward_zero; 
-  static constexpr bool is_iec559 = false; 
-  static constexpr bool is_bounded = true; 
-  static constexpr bool is_modulo = false; 
-  static constexpr int digits = 127; 
-  static constexpr int digits10 = 38; 
-  static constexpr int max_digits10 = 0; 
-  static constexpr int radix = 2; 
-  static constexpr int min_exponent = 0; 
-  static constexpr int min_exponent10 = 0; 
-  static constexpr int max_exponent = 0; 
-  static constexpr int max_exponent10 = 0; 
-#ifdef ABSL_HAVE_INTRINSIC_INT128 
-  static constexpr bool traps = numeric_limits<__int128>::traps; 
-#else   // ABSL_HAVE_INTRINSIC_INT128 
-  static constexpr bool traps = numeric_limits<uint64_t>::traps; 
-#endif  // ABSL_HAVE_INTRINSIC_INT128 
-  static constexpr bool tinyness_before = false; 
- 
-  static constexpr absl::int128 (min)() { return absl::Int128Min(); } 
-  static constexpr absl::int128 lowest() { return absl::Int128Min(); } 
-  static constexpr absl::int128 (max)() { return absl::Int128Max(); } 
-  static constexpr absl::int128 epsilon() { return 0; } 
-  static constexpr absl::int128 round_error() { return 0; } 
-  static constexpr absl::int128 infinity() { return 0; } 
-  static constexpr absl::int128 quiet_NaN() { return 0; } 
-  static constexpr absl::int128 signaling_NaN() { return 0; } 
-  static constexpr absl::int128 denorm_min() { return 0; } 
-}; 
-}  // namespace std 
- 
-// -------------------------------------------------------------------------- 
-//                      Implementation details follow 
-// -------------------------------------------------------------------------- 
-namespace absl { 
+}  // namespace absl
+
+// Specialized numeric_limits for int128.
+namespace std {
+template <>
+class numeric_limits<absl::int128> {
+ public:
+  static constexpr bool is_specialized = true;
+  static constexpr bool is_signed = true;
+  static constexpr bool is_integer = true;
+  static constexpr bool is_exact = true;
+  static constexpr bool has_infinity = false;
+  static constexpr bool has_quiet_NaN = false;
+  static constexpr bool has_signaling_NaN = false;
+  static constexpr float_denorm_style has_denorm = denorm_absent;
+  static constexpr bool has_denorm_loss = false;
+  static constexpr float_round_style round_style = round_toward_zero;
+  static constexpr bool is_iec559 = false;
+  static constexpr bool is_bounded = true;
+  static constexpr bool is_modulo = false;
+  static constexpr int digits = 127;
+  static constexpr int digits10 = 38;
+  static constexpr int max_digits10 = 0;
+  static constexpr int radix = 2;
+  static constexpr int min_exponent = 0;
+  static constexpr int min_exponent10 = 0;
+  static constexpr int max_exponent = 0;
+  static constexpr int max_exponent10 = 0;
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+  static constexpr bool traps = numeric_limits<__int128>::traps;
+#else   // ABSL_HAVE_INTRINSIC_INT128
+  static constexpr bool traps = numeric_limits<uint64_t>::traps;
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+  static constexpr bool tinyness_before = false;
+
+  static constexpr absl::int128 (min)() { return absl::Int128Min(); }
+  static constexpr absl::int128 lowest() { return absl::Int128Min(); }
+  static constexpr absl::int128 (max)() { return absl::Int128Max(); }
+  static constexpr absl::int128 epsilon() { return 0; }
+  static constexpr absl::int128 round_error() { return 0; }
+  static constexpr absl::int128 infinity() { return 0; }
+  static constexpr absl::int128 quiet_NaN() { return 0; }
+  static constexpr absl::int128 signaling_NaN() { return 0; }
+  static constexpr absl::int128 denorm_min() { return 0; }
+};
+}  // namespace std
+
+// --------------------------------------------------------------------------
+//                      Implementation details follow
+// --------------------------------------------------------------------------
+namespace absl {
 ABSL_NAMESPACE_BEGIN
- 
-constexpr uint128 MakeUint128(uint64_t high, uint64_t low) { 
-  return uint128(high, low); 
-} 
- 
-// Assignment from integer types. 
- 
-inline uint128& uint128::operator=(int v) { return *this = uint128(v); } 
- 
-inline uint128& uint128::operator=(unsigned int v) { 
-  return *this = uint128(v); 
-} 
- 
-inline uint128& uint128::operator=(long v) {  // NOLINT(runtime/int) 
-  return *this = uint128(v); 
-} 
- 
-// NOLINTNEXTLINE(runtime/int) 
-inline uint128& uint128::operator=(unsigned long v) { 
-  return *this = uint128(v); 
-} 
- 
-// NOLINTNEXTLINE(runtime/int) 
-inline uint128& uint128::operator=(long long v) { 
-  return *this = uint128(v); 
-} 
- 
-// NOLINTNEXTLINE(runtime/int) 
-inline uint128& uint128::operator=(unsigned long long v) { 
-  return *this = uint128(v); 
-} 
- 
-#ifdef ABSL_HAVE_INTRINSIC_INT128 
-inline uint128& uint128::operator=(__int128 v) { 
-  return *this = uint128(v); 
-} 
- 
-inline uint128& uint128::operator=(unsigned __int128 v) { 
-  return *this = uint128(v); 
-} 
-#endif  // ABSL_HAVE_INTRINSIC_INT128 
- 
-inline uint128& uint128::operator=(int128 v) { 
-  return *this = uint128(v); 
-} 
- 
-// Arithmetic operators. 
- 
+
+constexpr uint128 MakeUint128(uint64_t high, uint64_t low) {
+  return uint128(high, low);
+}
+
+// Assignment from integer types.
+
+inline uint128& uint128::operator=(int v) { return *this = uint128(v); }
+
+inline uint128& uint128::operator=(unsigned int v) {
+  return *this = uint128(v);
+}
+
+inline uint128& uint128::operator=(long v) {  // NOLINT(runtime/int)
+  return *this = uint128(v);
+}
+
+// NOLINTNEXTLINE(runtime/int)
+inline uint128& uint128::operator=(unsigned long v) {
+  return *this = uint128(v);
+}
+
+// NOLINTNEXTLINE(runtime/int)
+inline uint128& uint128::operator=(long long v) {
+  return *this = uint128(v);
+}
+
+// NOLINTNEXTLINE(runtime/int)
+inline uint128& uint128::operator=(unsigned long long v) {
+  return *this = uint128(v);
+}
+
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+inline uint128& uint128::operator=(__int128 v) {
+  return *this = uint128(v);
+}
+
+inline uint128& uint128::operator=(unsigned __int128 v) {
+  return *this = uint128(v);
+}
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+
+inline uint128& uint128::operator=(int128 v) {
+  return *this = uint128(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);
-uint128 operator*(uint128 lhs, uint128 rhs); 
-uint128 operator/(uint128 lhs, uint128 rhs); 
-uint128 operator%(uint128 lhs, uint128 rhs); 
- 
-inline uint128& uint128::operator<<=(int amount) { 
-  *this = *this << amount; 
-  return *this; 
-} 
- 
-inline uint128& uint128::operator>>=(int amount) { 
-  *this = *this >> amount; 
-  return *this; 
-} 
- 
-inline uint128& uint128::operator+=(uint128 other) { 
-  *this = *this + other; 
-  return *this; 
-} 
- 
-inline uint128& uint128::operator-=(uint128 other) { 
-  *this = *this - other; 
-  return *this; 
-} 
- 
-inline uint128& uint128::operator*=(uint128 other) { 
-  *this = *this * other; 
-  return *this; 
-} 
- 
-inline uint128& uint128::operator/=(uint128 other) { 
-  *this = *this / other; 
-  return *this; 
-} 
- 
-inline uint128& uint128::operator%=(uint128 other) { 
-  *this = *this % other; 
-  return *this; 
-} 
- 
-constexpr uint64_t Uint128Low64(uint128 v) { return v.lo_; } 
- 
-constexpr uint64_t Uint128High64(uint128 v) { return v.hi_; } 
- 
-// Constructors from integer types. 
- 
-#if defined(ABSL_IS_LITTLE_ENDIAN) 
- 
-constexpr uint128::uint128(uint64_t high, uint64_t low) 
-    : lo_{low}, hi_{high} {} 
- 
-constexpr uint128::uint128(int v) 
-    : lo_{static_cast<uint64_t>(v)}, 
-      hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0} {} 
-constexpr uint128::uint128(long v)  // NOLINT(runtime/int) 
-    : lo_{static_cast<uint64_t>(v)}, 
-      hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0} {} 
-constexpr uint128::uint128(long long v)  // NOLINT(runtime/int) 
-    : lo_{static_cast<uint64_t>(v)}, 
-      hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0} {} 
- 
-constexpr uint128::uint128(unsigned int v) : lo_{v}, hi_{0} {} 
-// NOLINTNEXTLINE(runtime/int) 
-constexpr uint128::uint128(unsigned long v) : lo_{v}, hi_{0} {} 
-// NOLINTNEXTLINE(runtime/int) 
-constexpr uint128::uint128(unsigned long long v) : lo_{v}, hi_{0} {} 
- 
-#ifdef ABSL_HAVE_INTRINSIC_INT128 
-constexpr uint128::uint128(__int128 v) 
-    : lo_{static_cast<uint64_t>(v & ~uint64_t{0})}, 
-      hi_{static_cast<uint64_t>(static_cast<unsigned __int128>(v) >> 64)} {} 
-constexpr uint128::uint128(unsigned __int128 v) 
-    : lo_{static_cast<uint64_t>(v & ~uint64_t{0})}, 
-      hi_{static_cast<uint64_t>(v >> 64)} {} 
-#endif  // ABSL_HAVE_INTRINSIC_INT128 
- 
-constexpr uint128::uint128(int128 v) 
-    : lo_{Int128Low64(v)}, hi_{static_cast<uint64_t>(Int128High64(v))} {} 
- 
-#elif defined(ABSL_IS_BIG_ENDIAN) 
- 
-constexpr uint128::uint128(uint64_t high, uint64_t low) 
-    : hi_{high}, lo_{low} {} 
- 
-constexpr uint128::uint128(int v) 
-    : hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0}, 
-      lo_{static_cast<uint64_t>(v)} {} 
-constexpr uint128::uint128(long v)  // NOLINT(runtime/int) 
-    : hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0}, 
-      lo_{static_cast<uint64_t>(v)} {} 
-constexpr uint128::uint128(long long v)  // NOLINT(runtime/int) 
-    : hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0}, 
-      lo_{static_cast<uint64_t>(v)} {} 
- 
-constexpr uint128::uint128(unsigned int v) : hi_{0}, lo_{v} {} 
-// NOLINTNEXTLINE(runtime/int) 
-constexpr uint128::uint128(unsigned long v) : hi_{0}, lo_{v} {} 
-// NOLINTNEXTLINE(runtime/int) 
-constexpr uint128::uint128(unsigned long long v) : hi_{0}, lo_{v} {} 
- 
-#ifdef ABSL_HAVE_INTRINSIC_INT128 
-constexpr uint128::uint128(__int128 v) 
-    : hi_{static_cast<uint64_t>(static_cast<unsigned __int128>(v) >> 64)}, 
-      lo_{static_cast<uint64_t>(v & ~uint64_t{0})} {} 
-constexpr uint128::uint128(unsigned __int128 v) 
-    : hi_{static_cast<uint64_t>(v >> 64)}, 
-      lo_{static_cast<uint64_t>(v & ~uint64_t{0})} {} 
-#endif  // ABSL_HAVE_INTRINSIC_INT128 
- 
-constexpr uint128::uint128(int128 v) 
-    : hi_{static_cast<uint64_t>(Int128High64(v))}, lo_{Int128Low64(v)} {} 
- 
-#else  // byte order 
-#error "Unsupported byte order: must be little-endian or big-endian." 
-#endif  // byte order 
- 
-// Conversion operators to integer types. 
- 
-constexpr uint128::operator bool() const { return lo_ || hi_; } 
- 
-constexpr uint128::operator char() const { return static_cast<char>(lo_); } 
- 
-constexpr uint128::operator signed char() const { 
-  return static_cast<signed char>(lo_); 
-} 
- 
-constexpr uint128::operator unsigned char() const { 
-  return static_cast<unsigned char>(lo_); 
-} 
- 
-constexpr uint128::operator char16_t() const { 
-  return static_cast<char16_t>(lo_); 
-} 
- 
-constexpr uint128::operator char32_t() const { 
-  return static_cast<char32_t>(lo_); 
-} 
- 
-constexpr uint128::operator ABSL_INTERNAL_WCHAR_T() const { 
-  return static_cast<ABSL_INTERNAL_WCHAR_T>(lo_); 
-} 
- 
-// NOLINTNEXTLINE(runtime/int) 
-constexpr uint128::operator short() const { return static_cast<short>(lo_); } 
- 
-constexpr uint128::operator unsigned short() const {  // NOLINT(runtime/int) 
-  return static_cast<unsigned short>(lo_);            // NOLINT(runtime/int) 
-} 
- 
-constexpr uint128::operator int() const { return static_cast<int>(lo_); } 
- 
-constexpr uint128::operator unsigned int() const { 
-  return static_cast<unsigned int>(lo_); 
-} 
- 
-// NOLINTNEXTLINE(runtime/int) 
-constexpr uint128::operator long() const { return static_cast<long>(lo_); } 
- 
-constexpr uint128::operator unsigned long() const {  // NOLINT(runtime/int) 
-  return static_cast<unsigned long>(lo_);            // NOLINT(runtime/int) 
-} 
- 
-constexpr uint128::operator long long() const {  // NOLINT(runtime/int) 
-  return static_cast<long long>(lo_);            // NOLINT(runtime/int) 
-} 
- 
-constexpr uint128::operator unsigned long long() const {  // NOLINT(runtime/int) 
-  return static_cast<unsigned long long>(lo_);            // NOLINT(runtime/int) 
-} 
- 
-#ifdef ABSL_HAVE_INTRINSIC_INT128 
-constexpr uint128::operator __int128() const { 
-  return (static_cast<__int128>(hi_) << 64) + lo_; 
-} 
- 
-constexpr uint128::operator unsigned __int128() const { 
-  return (static_cast<unsigned __int128>(hi_) << 64) + lo_; 
-} 
-#endif  // ABSL_HAVE_INTRINSIC_INT128 
- 
-// Conversion operators to floating point types. 
- 
-inline uint128::operator float() const { 
-  return static_cast<float>(lo_) + std::ldexp(static_cast<float>(hi_), 64); 
-} 
- 
-inline uint128::operator double() const { 
-  return static_cast<double>(lo_) + std::ldexp(static_cast<double>(hi_), 64); 
-} 
- 
-inline uint128::operator long double() const { 
-  return static_cast<long double>(lo_) + 
-         std::ldexp(static_cast<long double>(hi_), 64); 
-} 
- 
-// Comparison operators. 
- 
+uint128 operator*(uint128 lhs, uint128 rhs);
+uint128 operator/(uint128 lhs, uint128 rhs);
+uint128 operator%(uint128 lhs, uint128 rhs);
+
+inline uint128& uint128::operator<<=(int amount) {
+  *this = *this << amount;
+  return *this;
+}
+
+inline uint128& uint128::operator>>=(int amount) {
+  *this = *this >> amount;
+  return *this;
+}
+
+inline uint128& uint128::operator+=(uint128 other) {
+  *this = *this + other;
+  return *this;
+}
+
+inline uint128& uint128::operator-=(uint128 other) {
+  *this = *this - other;
+  return *this;
+}
+
+inline uint128& uint128::operator*=(uint128 other) {
+  *this = *this * other;
+  return *this;
+}
+
+inline uint128& uint128::operator/=(uint128 other) {
+  *this = *this / other;
+  return *this;
+}
+
+inline uint128& uint128::operator%=(uint128 other) {
+  *this = *this % other;
+  return *this;
+}
+
+constexpr uint64_t Uint128Low64(uint128 v) { return v.lo_; }
+
+constexpr uint64_t Uint128High64(uint128 v) { return v.hi_; }
+
+// Constructors from integer types.
+
+#if defined(ABSL_IS_LITTLE_ENDIAN)
+
+constexpr uint128::uint128(uint64_t high, uint64_t low)
+    : lo_{low}, hi_{high} {}
+
+constexpr uint128::uint128(int v)
+    : lo_{static_cast<uint64_t>(v)},
+      hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0} {}
+constexpr uint128::uint128(long v)  // NOLINT(runtime/int)
+    : lo_{static_cast<uint64_t>(v)},
+      hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0} {}
+constexpr uint128::uint128(long long v)  // NOLINT(runtime/int)
+    : lo_{static_cast<uint64_t>(v)},
+      hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0} {}
+
+constexpr uint128::uint128(unsigned int v) : lo_{v}, hi_{0} {}
+// NOLINTNEXTLINE(runtime/int)
+constexpr uint128::uint128(unsigned long v) : lo_{v}, hi_{0} {}
+// NOLINTNEXTLINE(runtime/int)
+constexpr uint128::uint128(unsigned long long v) : lo_{v}, hi_{0} {}
+
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+constexpr uint128::uint128(__int128 v)
+    : lo_{static_cast<uint64_t>(v & ~uint64_t{0})},
+      hi_{static_cast<uint64_t>(static_cast<unsigned __int128>(v) >> 64)} {}
+constexpr uint128::uint128(unsigned __int128 v)
+    : lo_{static_cast<uint64_t>(v & ~uint64_t{0})},
+      hi_{static_cast<uint64_t>(v >> 64)} {}
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+
+constexpr uint128::uint128(int128 v)
+    : lo_{Int128Low64(v)}, hi_{static_cast<uint64_t>(Int128High64(v))} {}
+
+#elif defined(ABSL_IS_BIG_ENDIAN)
+
+constexpr uint128::uint128(uint64_t high, uint64_t low)
+    : hi_{high}, lo_{low} {}
+
+constexpr uint128::uint128(int v)
+    : hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0},
+      lo_{static_cast<uint64_t>(v)} {}
+constexpr uint128::uint128(long v)  // NOLINT(runtime/int)
+    : hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0},
+      lo_{static_cast<uint64_t>(v)} {}
+constexpr uint128::uint128(long long v)  // NOLINT(runtime/int)
+    : hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0},
+      lo_{static_cast<uint64_t>(v)} {}
+
+constexpr uint128::uint128(unsigned int v) : hi_{0}, lo_{v} {}
+// NOLINTNEXTLINE(runtime/int)
+constexpr uint128::uint128(unsigned long v) : hi_{0}, lo_{v} {}
+// NOLINTNEXTLINE(runtime/int)
+constexpr uint128::uint128(unsigned long long v) : hi_{0}, lo_{v} {}
+
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+constexpr uint128::uint128(__int128 v)
+    : hi_{static_cast<uint64_t>(static_cast<unsigned __int128>(v) >> 64)},
+      lo_{static_cast<uint64_t>(v & ~uint64_t{0})} {}
+constexpr uint128::uint128(unsigned __int128 v)
+    : hi_{static_cast<uint64_t>(v >> 64)},
+      lo_{static_cast<uint64_t>(v & ~uint64_t{0})} {}
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+
+constexpr uint128::uint128(int128 v)
+    : hi_{static_cast<uint64_t>(Int128High64(v))}, lo_{Int128Low64(v)} {}
+
+#else  // byte order
+#error "Unsupported byte order: must be little-endian or big-endian."
+#endif  // byte order
+
+// Conversion operators to integer types.
+
+constexpr uint128::operator bool() const { return lo_ || hi_; }
+
+constexpr uint128::operator char() const { return static_cast<char>(lo_); }
+
+constexpr uint128::operator signed char() const {
+  return static_cast<signed char>(lo_);
+}
+
+constexpr uint128::operator unsigned char() const {
+  return static_cast<unsigned char>(lo_);
+}
+
+constexpr uint128::operator char16_t() const {
+  return static_cast<char16_t>(lo_);
+}
+
+constexpr uint128::operator char32_t() const {
+  return static_cast<char32_t>(lo_);
+}
+
+constexpr uint128::operator ABSL_INTERNAL_WCHAR_T() const {
+  return static_cast<ABSL_INTERNAL_WCHAR_T>(lo_);
+}
+
+// NOLINTNEXTLINE(runtime/int)
+constexpr uint128::operator short() const { return static_cast<short>(lo_); }
+
+constexpr uint128::operator unsigned short() const {  // NOLINT(runtime/int)
+  return static_cast<unsigned short>(lo_);            // NOLINT(runtime/int)
+}
+
+constexpr uint128::operator int() const { return static_cast<int>(lo_); }
+
+constexpr uint128::operator unsigned int() const {
+  return static_cast<unsigned int>(lo_);
+}
+
+// NOLINTNEXTLINE(runtime/int)
+constexpr uint128::operator long() const { return static_cast<long>(lo_); }
+
+constexpr uint128::operator unsigned long() const {  // NOLINT(runtime/int)
+  return static_cast<unsigned long>(lo_);            // NOLINT(runtime/int)
+}
+
+constexpr uint128::operator long long() const {  // NOLINT(runtime/int)
+  return static_cast<long long>(lo_);            // NOLINT(runtime/int)
+}
+
+constexpr uint128::operator unsigned long long() const {  // NOLINT(runtime/int)
+  return static_cast<unsigned long long>(lo_);            // NOLINT(runtime/int)
+}
+
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+constexpr uint128::operator __int128() const {
+  return (static_cast<__int128>(hi_) << 64) + lo_;
+}
+
+constexpr uint128::operator unsigned __int128() const {
+  return (static_cast<unsigned __int128>(hi_) << 64) + lo_;
+}
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+
+// Conversion operators to floating point types.
+
+inline uint128::operator float() const {
+  return static_cast<float>(lo_) + std::ldexp(static_cast<float>(hi_), 64);
+}
+
+inline uint128::operator double() const {
+  return static_cast<double>(lo_) + std::ldexp(static_cast<double>(hi_), 64);
+}
+
+inline uint128::operator long double() const {
+  return static_cast<long double>(lo_) +
+         std::ldexp(static_cast<long double>(hi_), 64);
+}
+
+// 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
-  return (Uint128Low64(lhs) == Uint128Low64(rhs) && 
-          Uint128High64(lhs) == Uint128High64(rhs)); 
+  return (Uint128Low64(lhs) == Uint128Low64(rhs) &&
+          Uint128High64(lhs) == Uint128High64(rhs));
 #endif
-} 
- 
+}
+
 constexpr bool operator!=(uint128 lhs, uint128 rhs) { return !(lhs == rhs); }
- 
+
 constexpr bool operator<(uint128 lhs, uint128 rhs) {
 #ifdef ABSL_HAVE_INTRINSIC_INT128
   return static_cast<unsigned __int128>(lhs) <
          static_cast<unsigned __int128>(rhs);
 #else
-  return (Uint128High64(lhs) == Uint128High64(rhs)) 
-             ? (Uint128Low64(lhs) < Uint128Low64(rhs)) 
-             : (Uint128High64(lhs) < Uint128High64(rhs)); 
+  return (Uint128High64(lhs) == Uint128High64(rhs))
+             ? (Uint128Low64(lhs) < Uint128Low64(rhs))
+             : (Uint128High64(lhs) < Uint128High64(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 !(lhs < rhs); }
- 
-// Unary operators. 
- 
+
+// Unary operators.
+
 constexpr inline uint128 operator+(uint128 val) {
   return val;
-} 
- 
+}
+
 constexpr inline int128 operator+(int128 val) {
   return val;
 }
@@ -839,95 +839,95 @@ constexpr inline bool operator!(uint128 val) {
 #if defined(ABSL_HAVE_INTRINSIC_INT128)
   return !static_cast<unsigned __int128>(val);
 #else
-  return !Uint128High64(val) && !Uint128Low64(val); 
+  return !Uint128High64(val) && !Uint128Low64(val);
 #endif
-} 
- 
-// Logical operators. 
- 
+}
+
+// Logical operators.
+
 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)); 
+  return MakeUint128(~Uint128High64(val), ~Uint128Low64(val));
 #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
-  return MakeUint128(Uint128High64(lhs) | Uint128High64(rhs), 
+  return MakeUint128(Uint128High64(lhs) | Uint128High64(rhs),
                      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
-  return MakeUint128(Uint128High64(lhs) & Uint128High64(rhs), 
+  return MakeUint128(Uint128High64(lhs) & Uint128High64(rhs),
                      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
-  return MakeUint128(Uint128High64(lhs) ^ Uint128High64(rhs), 
+  return MakeUint128(Uint128High64(lhs) ^ Uint128High64(rhs),
                      Uint128Low64(lhs) ^ Uint128Low64(rhs));
 #endif
-} 
- 
-inline uint128& uint128::operator|=(uint128 other) { 
+}
+
+inline uint128& uint128::operator|=(uint128 other) {
   *this = *this | other;
-  return *this; 
-} 
- 
-inline uint128& uint128::operator&=(uint128 other) { 
+  return *this;
+}
+
+inline uint128& uint128::operator&=(uint128 other) {
   *this = *this & other;
-  return *this; 
-} 
- 
-inline uint128& uint128::operator^=(uint128 other) { 
+  return *this;
+}
+
+inline uint128& uint128::operator^=(uint128 other) {
   *this = *this ^ other;
-  return *this; 
-} 
- 
-// Arithmetic operators. 
- 
+  return *this;
+}
+
+// Arithmetic operators.
+
 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. 
+  // 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);
 #endif
-} 
- 
+}
+
 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. 
+  // 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) {
@@ -935,10 +935,10 @@ constexpr uint128 AddResult(uint128 result, uint128 lhs) {
   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) +
@@ -949,8 +949,8 @@ constexpr uint128 operator+(uint128 lhs, uint128 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) {
@@ -974,33 +974,33 @@ constexpr uint128 operator-(uint128 lhs, uint128 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 
-  // can be used for uint128 storage. 
-  return static_cast<unsigned __int128>(lhs) * 
-         static_cast<unsigned __int128>(rhs); 
-#elif defined(_MSC_VER) && defined(_M_X64) 
-  uint64_t carry; 
-  uint64_t low = _umul128(Uint128Low64(lhs), Uint128Low64(rhs), &carry); 
-  return MakeUint128(Uint128Low64(lhs) * Uint128High64(rhs) + 
-                         Uint128High64(lhs) * Uint128Low64(rhs) + carry, 
-                     low); 
-#else   // ABSL_HAVE_INTRINSIC128 
-  uint64_t a32 = Uint128Low64(lhs) >> 32; 
-  uint64_t a00 = Uint128Low64(lhs) & 0xffffffff; 
-  uint64_t b32 = Uint128Low64(rhs) >> 32; 
-  uint64_t b00 = Uint128Low64(rhs) & 0xffffffff; 
-  uint128 result = 
-      MakeUint128(Uint128High64(lhs) * Uint128Low64(rhs) + 
-                      Uint128Low64(lhs) * Uint128High64(rhs) + a32 * b32, 
-                  a00 * b00); 
-  result += uint128(a32 * b00) << 32; 
-  result += uint128(a00 * b32) << 32; 
-  return result; 
-#endif  // ABSL_HAVE_INTRINSIC128 
-} 
- 
+inline uint128 operator*(uint128 lhs, uint128 rhs) {
+#if defined(ABSL_HAVE_INTRINSIC_INT128)
+  // TODO(strel) Remove once alignment issues are resolved and unsigned __int128
+  // can be used for uint128 storage.
+  return static_cast<unsigned __int128>(lhs) *
+         static_cast<unsigned __int128>(rhs);
+#elif defined(_MSC_VER) && defined(_M_X64)
+  uint64_t carry;
+  uint64_t low = _umul128(Uint128Low64(lhs), Uint128Low64(rhs), &carry);
+  return MakeUint128(Uint128Low64(lhs) * Uint128High64(rhs) +
+                         Uint128High64(lhs) * Uint128Low64(rhs) + carry,
+                     low);
+#else   // ABSL_HAVE_INTRINSIC128
+  uint64_t a32 = Uint128Low64(lhs) >> 32;
+  uint64_t a00 = Uint128Low64(lhs) & 0xffffffff;
+  uint64_t b32 = Uint128Low64(rhs) >> 32;
+  uint64_t b00 = Uint128Low64(rhs) & 0xffffffff;
+  uint128 result =
+      MakeUint128(Uint128High64(lhs) * Uint128Low64(rhs) +
+                      Uint128Low64(lhs) * Uint128High64(rhs) + a32 * b32,
+                  a00 * b00);
+  result += uint128(a32 * b00) << 32;
+  result += uint128(a00 * b32) << 32;
+  return result;
+#endif  // ABSL_HAVE_INTRINSIC128
+}
+
 #if defined(ABSL_HAVE_INTRINSIC_INT128)
 inline uint128 operator/(uint128 lhs, uint128 rhs) {
   return static_cast<unsigned __int128>(lhs) /
@@ -1013,153 +1013,153 @@ inline uint128 operator%(uint128 lhs, uint128 rhs) {
 }
 #endif
 
-// Increment/decrement operators. 
- 
-inline uint128 uint128::operator++(int) { 
-  uint128 tmp(*this); 
-  *this += 1; 
-  return tmp; 
-} 
- 
-inline uint128 uint128::operator--(int) { 
-  uint128 tmp(*this); 
-  *this -= 1; 
-  return tmp; 
-} 
- 
-inline uint128& uint128::operator++() { 
-  *this += 1; 
-  return *this; 
-} 
- 
-inline uint128& uint128::operator--() { 
-  *this -= 1; 
-  return *this; 
-} 
- 
-constexpr int128 MakeInt128(int64_t high, uint64_t low) { 
-  return int128(high, low); 
-} 
- 
-// Assignment from integer types. 
-inline int128& int128::operator=(int v) { 
-  return *this = int128(v); 
-} 
- 
-inline int128& int128::operator=(unsigned int v) { 
-  return *this = int128(v); 
-} 
- 
-inline int128& int128::operator=(long v) {  // NOLINT(runtime/int) 
-  return *this = int128(v); 
-} 
- 
-// NOLINTNEXTLINE(runtime/int) 
-inline int128& int128::operator=(unsigned long v) { 
-  return *this = int128(v); 
-} 
- 
-// NOLINTNEXTLINE(runtime/int) 
-inline int128& int128::operator=(long long v) { 
-  return *this = int128(v); 
-} 
- 
-// NOLINTNEXTLINE(runtime/int) 
-inline int128& int128::operator=(unsigned long long v) { 
-  return *this = int128(v); 
-} 
- 
-// Arithmetic operators. 
+// Increment/decrement operators.
+
+inline uint128 uint128::operator++(int) {
+  uint128 tmp(*this);
+  *this += 1;
+  return tmp;
+}
+
+inline uint128 uint128::operator--(int) {
+  uint128 tmp(*this);
+  *this -= 1;
+  return tmp;
+}
+
+inline uint128& uint128::operator++() {
+  *this += 1;
+  return *this;
+}
+
+inline uint128& uint128::operator--() {
+  *this -= 1;
+  return *this;
+}
+
+constexpr int128 MakeInt128(int64_t high, uint64_t low) {
+  return int128(high, low);
+}
+
+// Assignment from integer types.
+inline int128& int128::operator=(int v) {
+  return *this = int128(v);
+}
+
+inline int128& int128::operator=(unsigned int v) {
+  return *this = int128(v);
+}
+
+inline int128& int128::operator=(long v) {  // NOLINT(runtime/int)
+  return *this = int128(v);
+}
+
+// NOLINTNEXTLINE(runtime/int)
+inline int128& int128::operator=(unsigned long v) {
+  return *this = int128(v);
+}
+
+// NOLINTNEXTLINE(runtime/int)
+inline int128& int128::operator=(long long v) {
+  return *this = int128(v);
+}
+
+// NOLINTNEXTLINE(runtime/int)
+inline int128& int128::operator=(unsigned long long v) {
+  return *this = int128(v);
+}
+
+// Arithmetic operators.
 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); 
+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);
- 
-inline int128& int128::operator+=(int128 other) { 
-  *this = *this + other; 
-  return *this; 
-} 
- 
-inline int128& int128::operator-=(int128 other) { 
-  *this = *this - other; 
-  return *this; 
-} 
- 
-inline int128& int128::operator*=(int128 other) { 
-  *this = *this * other; 
-  return *this; 
-} 
- 
-inline int128& int128::operator/=(int128 other) { 
-  *this = *this / other; 
-  return *this; 
-} 
- 
-inline int128& int128::operator%=(int128 other) { 
-  *this = *this % other; 
-  return *this; 
-} 
- 
-inline int128& int128::operator|=(int128 other) { 
-  *this = *this | other; 
-  return *this; 
-} 
- 
-inline int128& int128::operator&=(int128 other) { 
-  *this = *this & other; 
-  return *this; 
-} 
- 
-inline int128& int128::operator^=(int128 other) { 
-  *this = *this ^ other; 
-  return *this; 
-} 
- 
-inline int128& int128::operator<<=(int amount) { 
-  *this = *this << amount; 
-  return *this; 
-} 
- 
-inline int128& int128::operator>>=(int amount) { 
-  *this = *this >> amount; 
-  return *this; 
-} 
- 
+
+inline int128& int128::operator+=(int128 other) {
+  *this = *this + other;
+  return *this;
+}
+
+inline int128& int128::operator-=(int128 other) {
+  *this = *this - other;
+  return *this;
+}
+
+inline int128& int128::operator*=(int128 other) {
+  *this = *this * other;
+  return *this;
+}
+
+inline int128& int128::operator/=(int128 other) {
+  *this = *this / other;
+  return *this;
+}
+
+inline int128& int128::operator%=(int128 other) {
+  *this = *this % other;
+  return *this;
+}
+
+inline int128& int128::operator|=(int128 other) {
+  *this = *this | other;
+  return *this;
+}
+
+inline int128& int128::operator&=(int128 other) {
+  *this = *this & other;
+  return *this;
+}
+
+inline int128& int128::operator^=(int128 other) {
+  *this = *this ^ other;
+  return *this;
+}
+
+inline int128& int128::operator<<=(int amount) {
+  *this = *this << amount;
+  return *this;
+}
+
+inline int128& int128::operator>>=(int amount) {
+  *this = *this >> amount;
+  return *this;
+}
+
 // 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 
-// representation. 
-constexpr int64_t BitCastToSigned(uint64_t v) { 
-  // Casting an unsigned integer to a signed integer of the same 
-  // width is implementation defined behavior if the source value would not fit 
-  // in the destination type. We step around it with a roundtrip bitwise not 
-  // operation to make sure this function remains constexpr. Clang, GCC, and 
-  // MSVC optimize this to a no-op on x86-64. 
-  return v & (uint64_t{1} << 63) ? ~static_cast<int64_t>(~v) 
-                                 : static_cast<int64_t>(v); 
-} 
- 
-}  // namespace int128_internal 
- 
-#if defined(ABSL_HAVE_INTRINSIC_INT128) 
-#include "absl/numeric/int128_have_intrinsic.inc"  // IWYU pragma: export 
-#else  // ABSL_HAVE_INTRINSIC_INT128 
-#include "absl/numeric/int128_no_intrinsic.inc"  // IWYU pragma: export 
-#endif  // ABSL_HAVE_INTRINSIC_INT128 
- 
+namespace int128_internal {
+
+// Casts from unsigned to signed while preserving the underlying binary
+// representation.
+constexpr int64_t BitCastToSigned(uint64_t v) {
+  // Casting an unsigned integer to a signed integer of the same
+  // width is implementation defined behavior if the source value would not fit
+  // in the destination type. We step around it with a roundtrip bitwise not
+  // operation to make sure this function remains constexpr. Clang, GCC, and
+  // MSVC optimize this to a no-op on x86-64.
+  return v & (uint64_t{1} << 63) ? ~static_cast<int64_t>(~v)
+                                 : static_cast<int64_t>(v);
+}
+
+}  // namespace int128_internal
+
+#if defined(ABSL_HAVE_INTRINSIC_INT128)
+#include "absl/numeric/int128_have_intrinsic.inc"  // IWYU pragma: export
+#else  // ABSL_HAVE_INTRINSIC_INT128
+#include "absl/numeric/int128_no_intrinsic.inc"  // IWYU pragma: export
+#endif  // ABSL_HAVE_INTRINSIC_INT128
+
 ABSL_NAMESPACE_END
-}  // namespace absl 
- 
-#undef ABSL_INTERNAL_WCHAR_T 
- 
-#endif  // ABSL_NUMERIC_INT128_H_ 
+}  // namespace absl
+
+#undef ABSL_INTERNAL_WCHAR_T
+
+#endif  // ABSL_NUMERIC_INT128_H_