pe_extended_signed_int

#ifndef PE_EXTENDED_SIGNED_INT_
#define PE_EXTENDED_SIGNED_INT_

#include "pe_base"
#include "pe_int128"
#include "pe_type_traits"
#include "pe_int"
#include "pe_bit"
#include "pe_extended_unsigned_int"

namespace pe {
// Extended integers

// Extended signed integer.
template <typename ET, bool is_builtin>
struct ExtendedSignedIntImpl;

template <typename ET>
struct ExtendedSignedIntImpl<ET, true>
    : public ExtendedUnsignedIntImpl<ET, true> {
  using base = ExtendedUnsignedIntImpl<ET, true>;
  using UnsignedT = ExtendedUnsignedIntImpl<ET, true>;
  using SignedT = ExtendedSignedIntImpl<ET, true>;

 public:
  ExtendedSignedIntImpl(ET low = 0) : base(low) {}
  ExtendedSignedIntImpl(ET low, ET hi) : base(low, hi) {}

  template <typename T,
            typename TT = REQUIRES((is_builtin_integer_v<T>)) RETURN(T)>
  ExtendedSignedIntImpl(T v) : base(v) {}

  ExtendedSignedIntImpl(const std::string& str) : base(str) {}

  ExtendedSignedIntImpl(const ExtendedSignedIntImpl& other) : base(other) {}

  ExtendedSignedIntImpl& operator=(const ET& other) {
    base::low_ = other;
    base::hi_ = 0;
    return *this;
  }

  template <typename T,
            typename TT = REQUIRES((is_builtin_integer_v<T>)) RETURN(T)>
  ExtendedSignedIntImpl& operator=(const T& other) {
    base::operator=(other);
    return *this;
  }

  ExtendedSignedIntImpl& operator=(const std::string& str) {
    base::operator=(str);
    return *this;
  }

  ExtendedSignedIntImpl& operator=(const ExtendedSignedIntImpl& other) {
    base::low_ = other.low();
    base::hi_ = other.hi();
    return *this;
  }

  ExtendedSignedIntImpl& operator=(
      const ExtendedSignedIntImpl&& other) noexcept {
    base::low_ = std::move(other.low());
    base::hi_ = std::move(other.hi());
    return *this;
  }

 public:
  void MakeAbs() {
    if (base::GetHighestBit()) {
      base::FlipBits();
      base::AddOne();
    }
  }

  static void DivideInplace(ExtendedSignedIntImpl& self,
                            const ExtendedSignedIntImpl& other) {
    int s1 = self.IntSign();
    int s2 = other.IntSign();
    if (s1 == 0) {
      return;
    }

    PE_ASSERT(s2 != 0);

    if (other.hi_ == 0 && other.low_ == 1) {
      return;
    }

    self.MakeAbs();

    if (s2 > 0) {
      base::DivideInplace(self, other);
    } else {
      base::DivideInplace(self, other.Abs());
    }

    if (s1 * s2 < 0) {
      self.FlipBits();
      self.AddOne();
    }
  }

  static void DivideInplace(ExtendedSignedIntImpl& self,
                            const ExtendedSignedIntImpl& other,
                            ExtendedSignedIntImpl& remain) {
    int s1 = self.IntSign();
    int s2 = other.IntSign();
    if (s1 == 0) {
      remain.MakeZeroBits();
      return;
    }

    PE_ASSERT(s2 != 0);

    if (other.hi_ == 0 && other.low_ == 1) {
      remain.MakeZeroBits();
      return;
    }

    self.MakeAbs();

    if (s2 > 0) {
      base::DivideInplace(self, other, remain);
    } else {
      base::DivideInplace(self, other.Abs(), remain);
    }

    if (s1 * s2 < 0) {
      self.FlipBits();
      self.AddOne();
    }

    if (s1 < 0) {
      remain.FlipBits();
      remain.AddOne();
    }
  }

  static void RemainInplace(ExtendedSignedIntImpl& self,
                            const ExtendedSignedIntImpl& other) {
    int s1 = self.IntSign();
    int s2 = other.IntSign();
    if (s1 == 0) {
      return;
    }

    PE_ASSERT(s2 != 0);

    if (other.hi_ == 0 && other.low_ == 1) {
      self.MakeZeroBits();
      return;
    }

    self.MakeAbs();

    if (s2 > 0) {
      base::RemainInplace(self, other);
    } else {
      base::RemainInplace(self, other.Abs());
    }

    if (s1 < 0) {
      base::FlipBits();
      base::AddOne();
    }
  }

 public:
  using base::low;

  using base::hi;

  int sign() const { return base::GetHighestBit() ? -1 : (IsZero() ? 0 : 1); }

  int CompareTo(const ExtendedSignedIntImpl& other) const {
    int s1 = IntSign();
    int s2 = other.IntSign();
    if (s1 != s2) {
      return s1 < s2 ? -1 : (s1 > s2);
    }
    if (s1 == 0) {
      return 0;
    }
    if (s1 < 0) {
      return -base::CompareTo(other);
    } else {
      return base::CompareTo(other);
    }
  }

  int IntSign() const {
    return base::GetHighestBit() ? -1 : (IsZero() ? 0 : 1);
  }

  using base::IsEven;

  using base::IsOdd;

  using base::IsZero;

  using base::LowerBits;

  ExtendedSignedIntImpl Abs() const {
    ExtendedSignedIntImpl ret(*this);
    // Note it doesn't work if *this = minimum value.
    if (ret.IntSign() < 0) {
      ret.FlipBits();
      ret.AddOne();
    }
    return ret;
  }

  ExtendedSignedIntImpl FAbs() const {
    ExtendedSignedIntImpl ret(*this);
    // Note it doesn't work if *this = minimum value.
    if (ret.IntSign() < 0) {
      ret.FlipBits();
      ret.AddOne();
    }
    return ret;
  }

  using base::ToInt;

  template <typename T>
  T ToFloat() const {
    if (IntSign() >= 0) {
      return base::template ToFloat<T>();
    } else {
      return -Abs().template ToFloat<T>();
    }
  }

  std::string ToString() const {
    if (IsZero()) {
      return "0";
    }
    if (base::hi_ == 0) {
      return pe::ToString(base::low_);
    }

    int sign = IntSign();

    if (sign > 0) {
      return base::ToString();
    } else {
      return "-" + Abs().base::ToString();
    }
  }

  std::string to_string() const { return ToString(); }

  ExtendedSignedIntImpl Difference(const ExtendedSignedIntImpl& other) const {
    auto t = base::Difference(other);
    return ExtendedSignedIntImpl(t.low(), t.hi());
  }

 public:
  // Operators
  ExtendedSignedIntImpl operator+() const { return *this; }

  ExtendedSignedIntImpl operator-() const {
    ExtendedSignedIntImpl ret(*this);
    base::FlipBits();
    base::AddOne();
    return ret;
  }

  ExtendedSignedIntImpl operator~() const {
    return ExtendedSignedIntImpl(~base::low_, ~base::hi_);
  }

  ExtendedSignedIntImpl& operator+=(const ExtendedSignedIntImpl& other) {
    base::operator+=(other);
    return *this;
  }

  ExtendedSignedIntImpl& operator+=(const ET& other) {
    base::operator+=(other);
    return *this;
  }

  ExtendedSignedIntImpl& operator-=(const ExtendedSignedIntImpl& other) {
    if (other.IsZero()) {
      return *this;
    }

    ExtendedSignedIntImpl t = other;
    t.FlipBits();
    t.AddOne();

    return *this += t;
  }

  ExtendedSignedIntImpl& operator-=(const ET& other) {
    if (other == 0) {
      return *this;
    }

    ExtendedSignedIntImpl t = other;
    t.FlipBits();
    t.AddOne();

    return *this += t;
  }

  ExtendedSignedIntImpl& operator*=(const ExtendedSignedIntImpl& other) {
    if (IsZero() || other.IsZero()) {
      base::low_ = base::hi_ = 0;
      return *this;
    }

    int s1 = IntSign();
    int s2 = other.IntSign();

    MakeAbs();

    if (s2 > 0) {
      base::operator*=(other);
    } else {
      base::operator*=(other.Abs());
    }

    if (s1 * s2 < 0) {
      base::FlipBits();
      base::AddOne();
    }
    return *this;
  }

  ExtendedSignedIntImpl& operator*=(const ET& other) {
    if (IsZero() || other == 0) {
      base::low_ = base::hi_ = 0;
      return *this;
    }

    return *this *= ExtendedSignedIntImpl(other);
  }

  ExtendedSignedIntImpl& operator/=(const ExtendedSignedIntImpl& other) {
    DivideInplace(*this, other);
    return *this;
  }

  ExtendedSignedIntImpl& operator/=(const ET& other) {
    return *this /= ExtendedSignedIntImpl(other);
  }

  ExtendedSignedIntImpl& operator%=(const ExtendedSignedIntImpl& other) {
    RemainInplace(*this, other);
    return *this;
  }

  ExtendedSignedIntImpl& operator%=(const ET& other) {
    return *this %= ExtendedSignedIntImpl(other);
  }

  ExtendedSignedIntImpl& operator&=(const ExtendedSignedIntImpl& other) {
    base::low_ &= other.low();
    base::hi_ &= other.hi();
    return *this;
  }

  ExtendedSignedIntImpl& operator&=(const ET& other) {
    base::low_ &= other;
    base::hi_ = 0;
    return *this;
  }

  ExtendedSignedIntImpl& operator^=(const ExtendedSignedIntImpl& other) {
    base::low_ ^= other.low();
    base::hi_ ^= other.hi();
    return *this;
  }

  ExtendedSignedIntImpl& operator^=(const ET& other) {
    base::low_ ^= other;
    return *this;
  }

  ExtendedSignedIntImpl& operator|=(const ExtendedSignedIntImpl& other) {
    base::low_ |= other.low();
    base::hi_ |= other.hi();
    return *this;
  }

  ExtendedSignedIntImpl& operator|=(const ET& other) {
    base::low_ |= other;
    return *this;
  }

  ExtendedSignedIntImpl& operator>>=(int cnt) {
    base::ArithmeticShiftRight(cnt);
    return *this;
  }

  ExtendedSignedIntImpl& operator<<=(int cnt) {
    base::ShiftLeft(cnt);
    return *this;
  }

  ExtendedSignedIntImpl& operator++() {
    base::AddOne();
    return *this;
  }

  ExtendedSignedIntImpl operator++(int) {
    ExtendedSignedIntImpl ret(*this);
    ++*this;
    return ret;
  }

  ExtendedSignedIntImpl& operator--() {
    if (base::low_) {
      --base::low_;
    } else {
      --base::low_;
      --base::hi_;
    }
    return *this;
  }

  ExtendedSignedIntImpl operator--(int) {
    ExtendedSignedIntImpl ret(*this);
    --*this;
    return ret;
  }

 public:
  // All the binary operators are friend operators
  // Comparison operators
#if PE_HAS_CPP20
  friend inline int operator<=>(const ExtendedSignedIntImpl& l,
                                const ExtendedSignedIntImpl& r) {
    return l.CompareTo(r);
  }
  friend inline int operator==(const ExtendedSignedIntImpl& l,
                               const ExtendedSignedIntImpl& r) {
    return l.CompareTo(r) == 0;
  }
  friend inline int operator!=(const ExtendedSignedIntImpl& l,
                               const ExtendedSignedIntImpl& r) {
    return l.CompareTo(r) != 0;
  }
#else
  friend inline int operator<(const ExtendedSignedIntImpl& l,
                              const ExtendedSignedIntImpl& r) {
    return l.CompareTo(r) < 0;
  }
  friend inline int operator<=(const ExtendedSignedIntImpl& l,
                               const ExtendedSignedIntImpl& r) {
    return l.CompareTo(r) <= 0;
  }
  friend inline int operator>(const ExtendedSignedIntImpl& l,
                              const ExtendedSignedIntImpl& r) {
    return l.CompareTo(r) > 0;
  }
  friend inline int operator>=(const ExtendedSignedIntImpl& l,
                               const ExtendedSignedIntImpl& r) {
    return l.CompareTo(r) >= 0;
  }
  friend inline int operator==(const ExtendedSignedIntImpl& l,
                               const ExtendedSignedIntImpl& r) {
    return l.CompareTo(r) == 0;
  }
  friend inline int operator!=(const ExtendedSignedIntImpl& l,
                               const ExtendedSignedIntImpl& r) {
    return l.CompareTo(r) != 0;
  }
#endif
  friend inline ExtendedSignedIntImpl operator+(
      const ExtendedSignedIntImpl& l, const ExtendedSignedIntImpl& r) {
    ExtendedSignedIntImpl ret(l);
    ret += r;
    return ret;
  }
  friend inline ExtendedSignedIntImpl operator-(
      const ExtendedSignedIntImpl& l, const ExtendedSignedIntImpl& r) {
    ExtendedSignedIntImpl ret(l);
    ret -= r;
    return ret;
  }
  friend inline ExtendedSignedIntImpl operator*(
      const ExtendedSignedIntImpl& l, const ExtendedSignedIntImpl& r) {
    ExtendedSignedIntImpl ret(l);
    ret *= r;
    return ret;
  }
  friend inline ExtendedSignedIntImpl operator/(
      const ExtendedSignedIntImpl& l, const ExtendedSignedIntImpl& r) {
    ExtendedSignedIntImpl ret(l);
    ret /= r;
    return ret;
  }
  friend inline ExtendedSignedIntImpl operator%(
      const ExtendedSignedIntImpl& l, const ExtendedSignedIntImpl& r) {
    ExtendedSignedIntImpl ret(l);
    ret %= r;
    return ret;
  }
  friend inline ExtendedSignedIntImpl operator&(
      const ExtendedSignedIntImpl& l, const ExtendedSignedIntImpl& r) {
    ExtendedSignedIntImpl ret(l);
    ret &= r;
    return ret;
  }
  friend inline ExtendedSignedIntImpl operator^(
      const ExtendedSignedIntImpl& l, const ExtendedSignedIntImpl& r) {
    ExtendedSignedIntImpl ret(l);
    ret ^= r;
    return ret;
  }
  friend inline ExtendedSignedIntImpl operator|(
      const ExtendedSignedIntImpl& l, const ExtendedSignedIntImpl& r) {
    ExtendedSignedIntImpl ret(l);
    ret |= r;
    return ret;
  }
  friend inline ExtendedSignedIntImpl operator<<(const ExtendedSignedIntImpl& l,
                                                 const int cnt) {
    ExtendedSignedIntImpl ret(l);
    ret <<= cnt;
    return ret;
  }
  friend inline ExtendedSignedIntImpl operator>>(const ExtendedSignedIntImpl& l,
                                                 const int cnt) {
    ExtendedSignedIntImpl ret(l);
    ret >>= cnt;
    return ret;
  }
  friend inline std::ostream& operator<<(std::ostream& o,
                                         const ExtendedSignedIntImpl& n) {
    return o << n.ToString();
  }
};

template <typename ET>
struct ExtendedSignedIntImpl<ET, false>
    : public ExtendedUnsignedIntImpl<ET, false> {
  using base = ExtendedUnsignedIntImpl<ET, false>;
  using UnsignedT = ExtendedUnsignedIntImpl<ET, false>;
  using SignedT = ExtendedSignedIntImpl<ET, false>;

 public:
  ExtendedSignedIntImpl(ET low = 0) : base(low) {}
  ExtendedSignedIntImpl(ET low, ET hi) : base(low, hi) {}

  template <typename T,
            typename TT = REQUIRES((is_builtin_integer_v<T>)) RETURN(T)>
  ExtendedSignedIntImpl(T v) : base(v) {}

  ExtendedSignedIntImpl(const std::string& str) : base(str) {}

  ExtendedSignedIntImpl(const ExtendedSignedIntImpl& other)
      : base(other.low(), other.hi()) {}

  ExtendedSignedIntImpl& operator=(const ET& other) {
    base::low_ = other;
    base::hi_.MakeZeroBits();
    return *this;
  }

  template <typename T,
            typename TT = REQUIRES((is_builtin_integer_v<T>)) RETURN(T)>
  ExtendedSignedIntImpl& operator=(const T& other) {
    base::operator=(other);
    return *this;
  }

  ExtendedSignedIntImpl& operator=(const std::string& str) {
    base::operator=(str);
    return *this;
  }

  ExtendedSignedIntImpl& operator=(const ExtendedSignedIntImpl& other) {
    base::low_ = other.low();
    base::hi_ = other.hi();
    return *this;
  }

  ExtendedSignedIntImpl& operator=(
      const ExtendedSignedIntImpl&& other) noexcept {
    base::low_ = std::move(other.low());
    base::hi_ = std::move(other.hi());
    return *this;
  }

 public:
  void MakeAbs() {
    if (base::GetHighestBit()) {
      base::FlipBits();
      base::AddOne();
    }
  }

  static void DivideInplace(ExtendedSignedIntImpl& self,
                            const ExtendedSignedIntImpl& other) {
    int s1 = self.IntSign();
    int s2 = other.IntSign();
    if (s1 == 0) {
      return;
    }

    PE_ASSERT(s2 != 0);

    if (other.hi_ == 0 && other.low_ == 1) {
      return;
    }

    self.MakeAbs();

    if (s2 > 0) {
      base::DivideInplace(self, other);
    } else {
      base::DivideInplace(self, other.Abs());
    }

    if (s1 * s2 < 0) {
      self.FlipBits();
      self.AddOne();
    }
  }

  static void DivideInplace(ExtendedSignedIntImpl& self,
                            const ExtendedSignedIntImpl& other,
                            ExtendedSignedIntImpl& remain) {
    int s1 = self.IntSign();
    int s2 = other.IntSign();
    if (s1 == 0) {
      remain.MakeZeroBits();
      return;
    }

    PE_ASSERT(s2 != 0);

    if (other.hi_ == 0 && other.low_ == 1) {
      remain.MakeZeroBits();
      return;
    }

    self.MakeAbs();
    if (s2 > 0) {
      base::DivideInplace(self, other, remain);
    } else {
      base::DivideInplace(self, other.Abs(), remain);
    }

    if (s1 * s2 < 0) {
      self.FlipBits();
      self.AddOne();
    }

    if (s1 < 0) {
      remain.FlipBits();
      remain.AddOne();
    }
  }

  static void RemainInplace(ExtendedSignedIntImpl& self,
                            const ExtendedSignedIntImpl& other) {
    int s1 = self.IntSign();
    int s2 = other.IntSign();
    if (s1 == 0) {
      return;
    }

    PE_ASSERT(s2 != 0);

    if (other.hi_ == 0 && other.low_ == 1) {
      self.MakeZeroBits();
      return;
    }

    self.MakeAbs();
    if (s2 > 0) {
      base::RemainInplace(self, other);
    } else {
      base::RemainInplace(self, other.Abs());
    }

    if (s1 < 0) {
      self.FlipBits();
      self.AddOne();
    }
  }

 public:
  using base::low;

  using base::hi;

  int sign() const {
    return base::low_.IntSign() || base::hi_.IntSign() ? 1 : 0;
  }

  int CompareTo(const ExtendedSignedIntImpl& other) const {
    int s1 = IntSign();
    int s2 = other.IntSign();
    if (s1 != s2) {
      return s1 < s2 ? -1 : (s1 > s2);
    }
    if (s1 == 0) {
      return 0;
    }
    if (s1 < 0) {
      return -base::CompareTo(other);
    } else {
      return base::CompareTo(other);
    }
  }

  int IntSign() const {
    return base::GetHighestBit() ? -1 : (IsZero() ? 0 : 1);
  }

  using base::IsZero;

  using base::IsEven;

  using base::IsOdd;

  using base::LowerBits;

  ExtendedSignedIntImpl Abs() const {
    ExtendedSignedIntImpl ret(*this);
    // Note it doesn't work if *this = minimum value.
    if (ret.IntSign() < 0) {
      ret.FlipBits();
      ret.AddOne();
    }
    return ret;
  }

  ExtendedSignedIntImpl FAbs() const {
    ExtendedSignedIntImpl ret(*this);
    // Note it doesn't work if *this = minimum value.
    if (ret.IntSign() < 0) {
      ret.FlipBits();
      ret.AddOne();
    }
    return ret;
  }

  using base::ToInt;

  template <typename T>
  T ToFloat() const {
    if (IntSign() >= 0) {
      return base::template ToFloat<T>();
    } else {
      return -Abs().template ToFloat<T>();
    }
  }

  std::string ToString() const {
    if (IsZero()) {
      return "0";
    }
    if (base::hi_ == 0) {
      return pe::ToString(base::low_);
    }

    int sign = IntSign();

    if (sign > 0) {
      return base::ToString();
    } else {
      return "-" + Abs().base::ToString();
    }
  }

  std::string to_string() const { return ToString(); }

  ExtendedSignedIntImpl Difference(const ExtendedSignedIntImpl& other) const {
    auto t = base::Difference(other);
    return ExtendedSignedIntImpl(t.low(), t.hi());
  }

 public:
  // Operators
  ExtendedSignedIntImpl operator+() const { return *this; }

  ExtendedSignedIntImpl operator-() const {
    ExtendedSignedIntImpl ret(*this);
    base::FlipBits();
    base::AddOne();
    return ret;
  }

  ExtendedSignedIntImpl operator~() const {
    return ExtendedSignedIntImpl(~base::low_, ~base::hi_);
  }

  ExtendedSignedIntImpl& operator+=(const ExtendedSignedIntImpl& other) {
    base::operator+=(other);
    return *this;
  }

  ExtendedSignedIntImpl& operator+=(const ET& other) {
    return *this += ExtendedSignedIntImpl(other);
  }

  template <typename T>
  REQUIRES((is_builtin_integer_v<T>))
  RETURN(ExtendedSignedIntImpl&) operator+=(const T& other) {
    return *this += ExtendedSignedIntImpl(other);
  }

  ExtendedSignedIntImpl& operator-=(const ExtendedSignedIntImpl& other) {
    if (other.IsZero()) {
      return *this;
    }

    ExtendedSignedIntImpl t = other;
    t.FlipBits();
    t.AddOne();

    return *this += t;
  }

  ExtendedSignedIntImpl& operator-=(const ET& other) {
    return *this -= ExtendedSignedIntImpl(other);
  }

  template <typename T>
  REQUIRES((is_builtin_integer_v<T>))
  RETURN(ExtendedSignedIntImpl&) operator-=(const T& other) {
    return *this -= ExtendedSignedIntImpl(other);
  }

  ExtendedSignedIntImpl& operator*=(const ExtendedSignedIntImpl& other) {
    if (IsZero() || other.IsZero()) {
      base::low_.MakeZeroBits();
      base::hi_.MakeZeroBits();
      return *this;
    }

    int s1 = IntSign();
    int s2 = other.IntSign();

    MakeAbs();

    if (s2 > 0) {
      base::operator*=(other);
    } else {
      base::operator*=(other.Abs());
    }

    if (s1 * s2 < 0) {
      base::FlipBits();
      base::AddOne();
    }

    return *this;
  }

  ExtendedSignedIntImpl& operator*=(const ET& other) {
    return *this *= ExtendedSignedIntImpl(other);
  }

  template <typename T>
  REQUIRES((is_builtin_integer_v<T>))
  RETURN(ExtendedSignedIntImpl&) operator*=(const T& other) {
    return *this *= ExtendedSignedIntImpl(other);
  }

  ExtendedSignedIntImpl& operator/=(const ExtendedSignedIntImpl& other) {
    DivideInplace(*this, other);
    return *this;
  }

  ExtendedSignedIntImpl& operator/=(const ET& other) {
    return *this /= ExtendedSignedIntImpl(other);
  }

  template <typename T>
  REQUIRES((is_builtin_integer_v<T>))
  RETURN(ExtendedSignedIntImpl&) operator/=(const T& other) {
    return *this /= ExtendedSignedIntImpl(other);
  }

  ExtendedSignedIntImpl& operator%=(const ExtendedSignedIntImpl& other) {
    RemainInplace(*this, other);
    return *this;
  }

  ExtendedSignedIntImpl& operator%=(const ET& other) {
    return *this %= ExtendedSignedIntImpl(other);
  }

  template <typename T>
  REQUIRES((is_builtin_integer_v<T>))
  RETURN(ExtendedSignedIntImpl&) operator%=(const T& other) {
    return *this %= ExtendedSignedIntImpl(other);
  }

  ExtendedSignedIntImpl& operator&=(const ExtendedSignedIntImpl& other) {
    base::low_ &= other.low();
    base::hi_ &= other.hi();
    return *this;
  }

  template <typename T>
  REQUIRES((is_builtin_integer_v<T>))
  RETURN(ExtendedSignedIntImpl&) operator&=(const T& other) {
    return *this &= ExtendedSignedIntImpl(other);
  }

  ExtendedSignedIntImpl& operator&=(const ET& other) {
    return *this &= ExtendedSignedIntImpl(other);
  }

  ExtendedSignedIntImpl& operator^=(const ExtendedSignedIntImpl& other) {
    base::low_ ^= other.low();
    base::hi_ ^= other.hi();
    return *this;
  }

  ExtendedSignedIntImpl& operator^=(const ET& other) {
    return *this ^= ExtendedSignedIntImpl(other);
  }

  template <typename T>
  REQUIRES((is_builtin_integer_v<T>))
  RETURN(ExtendedSignedIntImpl&) operator^=(const T& other) {
    return *this ^= ExtendedSignedIntImpl(other);
  }

  ExtendedSignedIntImpl& operator|=(const ExtendedSignedIntImpl& other) {
    base::low_ |= other.low();
    base::hi_ |= other.hi();
    return *this;
  }

  ExtendedSignedIntImpl& operator|=(const ET& other) {
    return *this |= ExtendedSignedIntImpl(other);
  }

  template <typename T>
  REQUIRES((is_builtin_integer_v<T>))
  RETURN(ExtendedSignedIntImpl&) operator|=(const T& other) {
    return *this |= ExtendedSignedIntImpl(other);
  }

  ExtendedSignedIntImpl& operator>>=(int cnt) {
    base::ArithmeticShiftRight(cnt);
    return *this;
  }

  ExtendedSignedIntImpl& operator<<=(int cnt) {
    base::ShiftLeft(cnt);
    return *this;
  }

  ExtendedSignedIntImpl& operator++() {
    base::AddOne();
    return *this;
  }

  ExtendedSignedIntImpl operator++(int) {
    ExtendedSignedIntImpl ret(*this);
    ++*this;
    return ret;
  }

  ExtendedSignedIntImpl& operator--() {
    if (!base::low_.IsZero()) {
      --base::low_;
    } else {
      --base::low_;
      --base::hi_;
    }
    return *this;
  }

  ExtendedSignedIntImpl operator--(int) {
    ExtendedSignedIntImpl ret(*this);
    --*this;
    return ret;
  }

 public:
// All the binary operators are friend operators
// Comparison operators
#if PE_HAS_CPP20
  friend inline int operator<=>(const ExtendedSignedIntImpl& l,
                                const ExtendedSignedIntImpl& r) {
    return l.CompareTo(r);
  }
  friend inline int operator==(const ExtendedSignedIntImpl& l,
                               const ExtendedSignedIntImpl& r) {
    return l.CompareTo(r) == 0;
  }
  friend inline int operator!=(const ExtendedSignedIntImpl& l,
                               const ExtendedSignedIntImpl& r) {
    return l.CompareTo(r) != 0;
  }
#else
  friend inline int operator<(const ExtendedSignedIntImpl& l,
                              const ExtendedSignedIntImpl& r) {
    return l.CompareTo(r) < 0;
  }
  friend inline int operator<=(const ExtendedSignedIntImpl& l,
                               const ExtendedSignedIntImpl& r) {
    return l.CompareTo(r) <= 0;
  }
  friend inline int operator>(const ExtendedSignedIntImpl& l,
                              const ExtendedSignedIntImpl& r) {
    return l.CompareTo(r) > 0;
  }
  friend inline int operator>=(const ExtendedSignedIntImpl& l,
                               const ExtendedSignedIntImpl& r) {
    return l.CompareTo(r) >= 0;
  }
  friend inline int operator==(const ExtendedSignedIntImpl& l,
                               const ExtendedSignedIntImpl& r) {
    return l.CompareTo(r) == 0;
  }
  friend inline int operator!=(const ExtendedSignedIntImpl& l,
                               const ExtendedSignedIntImpl& r) {
    return l.CompareTo(r) != 0;
  }
#endif
  friend inline ExtendedSignedIntImpl operator+(
      const ExtendedSignedIntImpl& l, const ExtendedSignedIntImpl& r) {
    ExtendedSignedIntImpl ret(l);
    ret += r;
    return ret;
  }
  friend inline ExtendedSignedIntImpl operator-(
      const ExtendedSignedIntImpl& l, const ExtendedSignedIntImpl& r) {
    ExtendedSignedIntImpl ret(l);
    ret -= r;
    return ret;
  }
  friend inline ExtendedSignedIntImpl operator*(
      const ExtendedSignedIntImpl& l, const ExtendedSignedIntImpl& r) {
    ExtendedSignedIntImpl ret(l);
    ret *= r;
    return ret;
  }
  friend inline ExtendedSignedIntImpl operator/(
      const ExtendedSignedIntImpl& l, const ExtendedSignedIntImpl& r) {
    ExtendedSignedIntImpl ret(l);
    ret /= r;
    return ret;
  }
  friend inline ExtendedSignedIntImpl operator%(
      const ExtendedSignedIntImpl& l, const ExtendedSignedIntImpl& r) {
    ExtendedSignedIntImpl ret(l);
    ret %= r;
    return ret;
  }
  friend inline ExtendedSignedIntImpl operator&(
      const ExtendedSignedIntImpl& l, const ExtendedSignedIntImpl& r) {
    ExtendedSignedIntImpl ret(l);
    ret &= r;
    return ret;
  }
  friend inline ExtendedSignedIntImpl operator^(
      const ExtendedSignedIntImpl& l, const ExtendedSignedIntImpl& r) {
    ExtendedSignedIntImpl ret(l);
    ret ^= r;
    return ret;
  }
  friend inline ExtendedSignedIntImpl operator|(
      const ExtendedSignedIntImpl& l, const ExtendedSignedIntImpl& r) {
    ExtendedSignedIntImpl ret(l);
    ret |= r;
    return ret;
  }
  friend inline ExtendedSignedIntImpl operator<<(const ExtendedSignedIntImpl& l,
                                                 const int cnt) {
    ExtendedSignedIntImpl ret(l);
    ret <<= cnt;
    return ret;
  }
  friend inline ExtendedSignedIntImpl operator>>(const ExtendedSignedIntImpl& l,
                                                 const int cnt) {
    ExtendedSignedIntImpl ret(l);
    ret >>= cnt;
    return ret;
  }
  friend inline std::ostream& operator<<(std::ostream& o,
                                         const ExtendedSignedIntImpl& n) {
    return o << n.ToString();
  }
};

template <typename ET, bool is_builtin_integer>
SL int IsZero(const ExtendedSignedIntImpl<ET, is_builtin_integer>& x) {
  return x.IsZero();
}

template <typename ET, bool is_builtin_integer>
SL int IntSign(const ExtendedSignedIntImpl<ET, is_builtin_integer>& x) {
  return x.IntSign();
}

template <typename ET, bool is_builtin_integer>
SL int IsEven(const ExtendedSignedIntImpl<ET, is_builtin_integer>& x) {
  return x.IsEven();
}

template <typename ET, bool is_builtin_integer>
SL int IsOdd(const ExtendedSignedIntImpl<ET, is_builtin_integer>& x) {
  return x.IsOdd();
}

template <typename ET, bool is_builtin_integer>
SL unsigned int LowerBits(
    const ExtendedSignedIntImpl<ET, is_builtin_integer>& x) {
  return x.LowerBits();
}

template <typename ET, bool is_builtin_integer>
SL ExtendedSignedIntImpl<ET, is_builtin_integer> Abs(
    const ExtendedSignedIntImpl<ET, is_builtin_integer>& x) {
  return x;
}

template <typename ET, bool is_builtin_integer>
SL ExtendedSignedIntImpl<ET, is_builtin_integer> FAbs(
    const ExtendedSignedIntImpl<ET, is_builtin_integer>& x) {
  return x;
}

template <typename ET, bool is_builtin_integer>
SL int SameParity(const ExtendedSignedIntImpl<ET, is_builtin_integer>& l,
                  const ExtendedSignedIntImpl<ET, is_builtin_integer>& r) {
  return SameParity(l.LowerBits(), r.LowerBits());
}

template <typename ET, bool is_builtin_integer>
SL std::tuple<ExtendedSignedIntImpl<ET, is_builtin_integer>,
              ExtendedSignedIntImpl<ET, is_builtin_integer>>
Div(const ExtendedSignedIntImpl<ET, is_builtin_integer>& l,
    const ExtendedSignedIntImpl<ET, is_builtin_integer>& r) {
  ExtendedSignedIntImpl<ET, is_builtin_integer> remain;
  ExtendedSignedIntImpl<ET, is_builtin_integer> d(l);
  ExtendedSignedIntImpl<ET, is_builtin_integer>::DivideInplace(d, r, remain);
  return {d, remain};
}

template <typename T, typename ET, bool is_builtin_integer>
SL T ToInt(const ExtendedSignedIntImpl<ET, is_builtin_integer>& x) {
  return x.template ToInt<T>();
}

template <typename T, typename ET, bool is_builtin_integer>
SL T ToFloat(const ExtendedSignedIntImpl<ET, is_builtin_integer>& x) {
  return x.template ToFloat<T>();
}

template <typename ET, bool is_builtin_integer>
SL std::string ToString(
    const ExtendedSignedIntImpl<ET, is_builtin_integer>& x) {
  return x.ToString();
}

template <typename ET, bool is_builtin_integer>
SL std::string to_string(
    const ExtendedSignedIntImpl<ET, is_builtin_integer>& x) {
  return ToString(x);
}

template <typename ET, bool is_builtin_integer, typename T2>
SL REQUIRES((pe::is_builtin_integer_v<T2>))
    RETURN(ExtendedSignedIntImpl<ET, is_builtin_integer>)
        Power(ExtendedSignedIntImpl<ET, is_builtin_integer> x, T2 n) {
  PE_ASSERT(n >= 0);
  ExtendedSignedIntImpl<ET, is_builtin_integer> ret = 1;
  for (; n > 0; n >>= 1) {
    if (n & 1) ret *= x;
    if (n > 1) x *= x;
  }
  return ret;
}

template <typename ET, bool is_builtin_integer, typename T2>
SL REQUIRES((pe::is_builtin_integer_v<T2>))
    RETURN(ExtendedSignedIntImpl<ET, is_builtin_integer>)
        PowerMod(ExtendedSignedIntImpl<ET, is_builtin_integer> x, T2 n,
                 const ExtendedSignedIntImpl<ET, is_builtin_integer>& mod) {
  PE_ASSERT(n >= 0);
  ExtendedSignedIntImpl<ET, is_builtin_integer> ret = 1;
  for (; n > 0; n >>= 1) {
    if (n & 1) ret = ret * x % mod;
    if (n > 1) x = x * x % mod;
  }
  return ret;
}

template <typename ET, bool is_builtin_integer, typename T2, typename T3>
SL REQUIRES((pe::is_builtin_integer_v<T2> && pe::is_builtin_integer_v<T3>))
    RETURN(ExtendedSignedIntImpl<ET, is_builtin_integer>)
        PowerMod(ExtendedSignedIntImpl<ET, is_builtin_integer> x, T2 n,
                 T3 mod) {
  PE_ASSERT(n >= 0);
  ExtendedSignedIntImpl<ET, is_builtin_integer> ret = 1;
  for (; n > 0; n >>= 1) {
    if (n & 1) ret = ret * x % mod;
    if (n > 1) x = x * x % mod;
  }
  return ret;
}

template <typename ET>
using ExtendedSignedInt = ExtendedSignedIntImpl<typename ExtractET<ET>::type,
                                                is_builtin_integer_v<ET>>;

#if PE_HAS_CPP20
static_assert(PeNumberUtil<ExtendedSignedInt<uint64>>);
#if PE_HAS_INT128
static_assert(PeNumberUtil<ExtendedSignedInt<uint128>>);
#endif
#endif
}  // namespace pe
#endif