//

// 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 <string>

#include <utility>

#include "absl/base/config.h"

#include "absl/base/macros.h"

#include "absl/base/port.h"

#include "absl/types/compare.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) && !defined(_M_ARM64EC)

#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) {

#if defined(ABSL_HAVE_INTRINSIC_INT128)

    return H::combine(std::move(h), static_cast<unsigned __int128>(v));

#else

    return H::combine(std::move(h), Uint128High64(v), Uint128Low64(v));

#endif

  }

  // Support for absl::StrCat() etc.

  template <typename Sink>

  friend void AbslStringify(Sink& sink, uint128 v) {

    sink.Append(v.ToString());

  }

 private:

  constexpr uint128(uint64_t high, uint64_t low);

  std::string ToString() const;

  // 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

};

// 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;

  ABSL_INTERNAL_DISABLE_DEPRECATED_DECLARATION_WARNING

  static constexpr float_denorm_style has_denorm = denorm_absent;

  ABSL_INTERNAL_RESTORE_DEPRECATED_DECLARATION_WARNING

  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) {

#if defined(ABSL_HAVE_INTRINSIC_INT128)

    return H::combine(std::move(h), v.v_);

#else

    return H::combine(std::move(h), Int128High64(v), Int128Low64(v));

#endif

  }

  // Support for absl::StrCat() etc.

  template <typename Sink>

  friend void AbslStringify(Sink& sink, int128 v) {

    sink.Append(v.ToString());

  }

 private:

  constexpr int128(int64_t high, uint64_t low);

  std::string ToString() const;

#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;

  ABSL_INTERNAL_DISABLE_DEPRECATED_DECLARATION_WARNING

  static constexpr float_denorm_style has_denorm = denorm_absent;

  ABSL_INTERNAL_RESTORE_DEPRECATED_DECLARATION_WARNING

  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 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 {

  // Note: This method might return Inf.

  constexpr float pow_2_64 = 18446744073709551616.0f;

  return static_cast<float>(lo_) + static_cast<float>(hi_) * pow_2_64;

}

inline uint128::operator double() const {

  constexpr double pow_2_64 = 18446744073709551616.0;

  return static_cast<double>(lo_) + static_cast<double>(hi_) * pow_2_64;

}

inline uint128::operator long double() const {

  constexpr long double pow_2_64 = 18446744073709551616.0L;

  return static_cast<long double>(lo_) +

         static_cast<long double>(hi_) * pow_2_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));

#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));

#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); }

#ifdef __cpp_impl_three_way_comparison

constexpr absl::strong_ordering operator<=>(uint128 lhs, uint128 rhs) {

#if defined(ABSL_HAVE_INTRINSIC_INT128)

  if (auto lhs_128 = static_cast<unsigned __int128>(lhs),

      rhs_128 = static_cast<unsigned __int128>(rhs);

      lhs_128 < rhs_128) {

    return absl::strong_ordering::less;

  } else if (lhs_128 > rhs_128) {

    return absl::strong_ordering::greater;

  } else {

    return absl::strong_ordering::equal;

  }

#else

  if (uint64_t lhs_high = Uint128High64(lhs), rhs_high = Uint128High64(rhs);

      lhs_high < rhs_high) {

    return absl::strong_ordering::less;

  } else if (lhs_high > rhs_high) {

    return absl::strong_ordering::greater;

  } else if (uint64_t lhs_low = Uint128Low64(lhs), rhs_low = Uint128Low64(rhs);

             lhs_low < rhs_low) {

    return absl::strong_ordering::less;

  } else if (lhs_low > rhs_low) {

    return absl::strong_ordering::greater;

  } else {

    return absl::strong_ordering::equal;

  }

#endif

}

#endif

// 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

  return !Uint128High64(val) && !Uint128Low64(val);

#endif

}

// 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));

#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),

                     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),

                     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),

                     Uint128Low64(lhs) ^ Uint128Low64(rhs));

#endif

}

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;

}

// 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.

  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.

  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

  // can be used for uint128 storage.

  return static_cast<unsigned __int128>(lhs) *

         static_cast<unsigned __int128>(rhs);

#elif defined(_MSC_VER) && defined(_M_X64) && !defined(_M_ARM64EC)

  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) /

         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) {

  uint128 tmp(*this);

  *this += 1;

  return tmp;

}