DCHECK_GT(precision, 0);

DCHECK_LE(precision, 38);

return BasicDecimal128::Abs(*this) < ScaleMultipliers[precision];

uint128_t() {}

uint128_t(uint64_t hi, uint64_t lo) : val_((static_cast<__uint128_t>(hi) << 64) | lo) {}

explicit uint128_t(const BasicDecimal128& decimal) {

val_ = (static_cast<__uint128_t>(decimal.high_bits()) << 64) | decimal.low_bits();

}

explicit uint128_t(uint64_t value) : val_(value) {}

uint64_t hi() { return val_ >> 64; }

uint64_t lo() { return val_ & kInt64Mask; }

uint128_t& operator+=(const uint128_t& other) {

val_ += other.val_;

return *this;

}

uint128_t& operator*=(const uint128_t& other) {

val_ *= other.val_;

return *this;

}

__uint128_t val_;

// Perform multiplication on two 64 bit words x and y into a 128 bit result

// by splitting up x and y into 32 bit high/low bit components,

// allowing us to represent the multiplication as

// x * y = x_lo * y_lo + x_hi * y_lo * 2^32 + y_hi * x_lo * 2^32

// + x_hi * y_hi * 2^64

//

// Now, consider the final output as lo_lo || lo_hi || hi_lo || hi_hi

// Therefore,

// lo_lo is (x_lo * y_lo)_lo,

// lo_hi is ((x_lo * y_lo)_hi + (x_hi * y_lo)_lo + (x_lo * y_hi)_lo)_lo,

// hi_lo is ((x_hi * y_hi)_lo + (x_hi * y_lo)_hi + (x_lo * y_hi)_hi)_hi,

// hi_hi is (x_hi * y_hi)_hi

const uint64_t x_lo = x & kInt32Mask;

const uint64_t y_lo = y & kInt32Mask;

const uint64_t x_hi = x >> 32;

const uint64_t y_hi = y >> 32;

const uint64_t t = x_lo * y_lo;

const uint64_t t_lo = t & kInt32Mask;

const uint64_t t_hi = t >> 32;

const uint64_t u = x_hi * y_lo + t_hi;

const uint64_t u_lo = u & kInt32Mask;

const uint64_t u_hi = u >> 32;

const uint64_t v = x_lo * y_hi + u_lo;

const uint64_t v_hi = v >> 32;

*hi = x_hi * y_hi + u_hi + v_hi;

*lo = (v << 32) + t_lo;

uint128_t() {}

uint128_t(uint64_t hi, uint64_t lo) : hi_(hi), lo_(lo) {}

explicit uint128_t(const BasicDecimal128& decimal) {

hi_ = decimal.high_bits();

lo_ = decimal.low_bits();

}

uint64_t hi() const { return hi_; }

uint64_t lo() const { return lo_; }

uint128_t& operator+=(const uint128_t& other) {

// To deduce the carry bit, we perform "65 bit" addition on the low bits and

// seeing if the resulting high bit is 1. This is accomplished by shifting the

// low bits to the right by 1 (chopping off the lowest bit), then adding 1 if the

// result of adding the two chopped bits would have produced a carry.

uint64_t carry = (((lo_ & other.lo_) & 1) + (lo_ >> 1) + (other.lo_ >> 1)) >> 63;

hi_ += other.hi_ + carry;

lo_ += other.lo_;

return *this;

}

uint128_t& operator*=(const uint128_t& other) {

uint128_t r;

ExtendAndMultiply(lo_, other.lo_, &r.hi_, &r.lo_);

r.hi_ += (hi_ * other.lo_) + (lo_ * other.hi_);

*this = r;

return *this;

}

uint64_t hi_;

uint64_t lo_;

const std::array<uint64_t, N>& rh,

std::array<uint64_t, N>* result) {

const auto lh_le = bit_util::little_endian::Make(lh);

const auto rh_le = bit_util::little_endian::Make(rh);

auto result_le = bit_util::little_endian::Make(result);

for (int j = 0; j < N; ++j) {

uint64_t carry = 0;

for (int i = 0; i < N - j; ++i) {

uint128_t tmp(lh_le[i]);

tmp *= uint128_t(rh_le[j]);

tmp += uint128_t(result_le[i + j]);

tmp += uint128_t(carry);

result_le[i + j] = tmp.lo();

carry = tmp.hi();

}

}

uint32_t* result_array) {

const auto value_array_le = bit_util::little_endian::Make(value_array);

int64_t next_index = 0;

// 1st loop to find out 1st non-negative value in input

int64_t i = N - 1;

for (; i >= 0; i--) {

if (value_array_le[i] != 0) {

if (value_array_le[i] <= std::numeric_limits<uint32_t>::max()) {

result_array[next_index++] = static_cast<uint32_t>(value_array_le[i]);

i--;

}

break;

}

}

// 2nd loop to fill in the rest of the array.

for (int64_t j = i; j >= 0; j--) {

result_array[next_index++] = static_cast<uint32_t>(value_array_le[j] >> 32);

result_array[next_index++] = static_cast<uint32_t>(value_array_le[j]);

}

return next_index;

bool& was_negative) {

BasicDecimal128 abs_value = BasicDecimal128::Abs(value);

was_negative = value.high_bits() < 0;

uint64_t high = static_cast<uint64_t>(abs_value.high_bits());

uint64_t low = abs_value.low_bits();

// FillInArray(std::array<uint64_t, N>& value_array, uint32_t* result_array) is not

// called here as the following code has better performance, to avoid regression on

// BasicDecimal128 Division.

if (high != 0) {

if (high > std::numeric_limits<uint32_t>::max()) {

array[0] = static_cast<uint32_t>(high >> 32);

array[1] = static_cast<uint32_t>(high);

array[2] = static_cast<uint32_t>(low >> 32);

array[3] = static_cast<uint32_t>(low);

return 4;

}

array[0] = static_cast<uint32_t>(high);

array[1] = static_cast<uint32_t>(low >> 32);

array[2] = static_cast<uint32_t>(low);

return 3;

}

if (low > std::numeric_limits<uint32_t>::max()) {

array[0] = static_cast<uint32_t>(low >> 32);

array[1] = static_cast<uint32_t>(low);

return 2;

}

if (low == 0) {

return 0;

}

array[0] = static_cast<uint32_t>(low);

return 1;

bool& was_negative) {

BasicDecimal256 positive_value = value;

was_negative = false;

if (positive_value.IsNegative()) {

positive_value.Negate();

was_negative = true;

}

return FillInArray<4>(positive_value.native_endian_array(), array);

if (length > 0 && bits != 0) {

for (int64_t i = 0; i < length - 1; ++i) {

array[i] = (array[i] << bits) | (array[i + 1] >> (32 - bits));

}

array[length - 1] <<= bits;

}

if (length > 0 && bits != 0) {

for (int64_t i = length - 1; i > 0; --i) {

array[i] = (array[i] >> bits) | (array[i - 1] << (32 - bits));

}

array[0] >>= bits;

}

bool dividend_was_negative,

bool divisor_was_negative) {

if (dividend_was_negative != divisor_was_negative) {

result->Negate();

}

if (dividend_was_negative) {

remainder->Negate();

}

const uint32_t* array, int64_t length) {

for (int64_t i = length - 2 * N - 1; i >= 0; i--) {

if (array[i] != 0) {

return DecimalStatus::kOverflow;

}

}

int64_t next_index = length - 1;

size_t i = 0;

auto result_array_le = bit_util::little_endian::Make(result_array);

for (; i < N && next_index >= 0; i++) {

uint64_t lower_bits = array[next_index--];

result_array_le[i] =

(next_index < 0)

? lower_bits

: ((static_cast<uint64_t>(array[next_index--]) << 32) + lower_bits);

}

for (; i < N; i++) {

result_array_le[i] = 0;

}

return DecimalStatus::kSuccess;

int64_t length) {

std::array<uint64_t, 2> result_array;

auto status = BuildFromArray(&result_array, array, length);

if (status != DecimalStatus::kSuccess) {

return status;

}

const auto result_array_le = bit_util::little_endian::Make(result_array);

*value = {static_cast<int64_t>(result_array_le[1]), result_array_le[0]};

return DecimalStatus::kSuccess;

int64_t length) {

std::array<uint64_t, 4> result_array;

auto status = BuildFromArray(&result_array, array, length);

if (status != DecimalStatus::kSuccess) {

return status;

}

*value = result_array;

return DecimalStatus::kSuccess;

int64_t dividend_length, uint32_t divisor,

DecimalClass* remainder,

bool dividend_was_negative,

bool divisor_was_negative,

DecimalClass* result) {

uint64_t r = 0;

constexpr int64_t kDecimalArrayLength = DecimalClass::kBitWidth / sizeof(uint32_t) + 1;

uint32_t result_array[kDecimalArrayLength];

for (int64_t j = 0; j < dividend_length; j++) {

r <<= 32;

r += dividend[j];

result_array[j] = static_cast<uint32_t>(r / divisor);

r %= divisor;

}

auto status = BuildFromArray(result, result_array, dividend_length);

if (status != DecimalStatus::kSuccess) {

return status;

}

*remainder = static_cast<int64_t>(r);

FixDivisionSigns(result, remainder, dividend_was_negative, divisor_was_negative);

return DecimalStatus::kSuccess;

const DecimalClass& divisor,

DecimalClass* result, DecimalClass* remainder) {

constexpr int64_t kDecimalArrayLength = DecimalClass::kBitWidth / sizeof(uint32_t);

// Split the dividend and divisor into integer pieces so that we can

// work on them.

uint32_t dividend_array[kDecimalArrayLength + 1];

uint32_t divisor_array[kDecimalArrayLength];

bool dividend_was_negative;

bool divisor_was_negative;

// leave an extra zero before the dividend

dividend_array[0] = 0;

int64_t dividend_length =

FillInArray(dividend, dividend_array + 1, dividend_was_negative) + 1;

int64_t divisor_length = FillInArray(divisor, divisor_array, divisor_was_negative);

// Handle some of the easy cases.

if (dividend_length <= divisor_length) {

*remainder = dividend;

*result = 0;

return DecimalStatus::kSuccess;

}

if (divisor_length == 0) {

return DecimalStatus::kDivideByZero;

}

if (divisor_length == 1) {

return SingleDivide(dividend_array, dividend_length, divisor_array[0], remainder,

dividend_was_negative, divisor_was_negative, result);

}

int64_t result_length = dividend_length - divisor_length;

uint32_t result_array[kDecimalArrayLength];

DCHECK_LE(result_length, kDecimalArrayLength);

// Normalize by shifting both by a multiple of 2 so that

// the digit guessing is better. The requirement is that

// divisor_array[0] is greater than 2**31.

int64_t normalize_bits = bit_util::CountLeadingZeros(divisor_array[0]);

ShiftArrayLeft(divisor_array, divisor_length, normalize_bits);

ShiftArrayLeft(dividend_array, dividend_length, normalize_bits);

// compute each digit in the result

for (int64_t j = 0; j < result_length; ++j) {

// Guess the next digit. At worst it is two too large

uint32_t guess = std::numeric_limits<uint32_t>::max();

const auto high_dividend =

static_cast<uint64_t>(dividend_array[j]) << 32 | dividend_array[j + 1];

if (dividend_array[j] != divisor_array[0]) {

guess = static_cast<uint32_t>(high_dividend / divisor_array[0]);

}

// catch all of the cases where guess is two too large and most of the

// cases where it is one too large

auto rhat = static_cast<uint32_t>(high_dividend -

guess * static_cast<uint64_t>(divisor_array[0]));

while (static_cast<uint64_t>(divisor_array[1]) * guess >

(static_cast<uint64_t>(rhat) << 32) + dividend_array[j + 2]) {

--guess;

rhat += divisor_array[0];

if (static_cast<uint64_t>(rhat) < divisor_array[0]) {

break;

}

}

// subtract off the guess * divisor from the dividend

uint64_t mult = 0;

for (int64_t i = divisor_length - 1; i >= 0; --i) {

mult += static_cast<uint64_t>(guess) * divisor_array[i];

uint32_t prev = dividend_array[j + i + 1];

dividend_array[j + i + 1] -= static_cast<uint32_t>(mult);

mult >>= 32;

if (dividend_array[j + i + 1] > prev) {

++mult;

}

}

uint32_t prev = dividend_array[j];

dividend_array[j] -= static_cast<uint32_t>(mult);

// if guess was too big, we add back divisor

if (dividend_array[j] > prev) {

--guess;

uint32_t carry = 0;

for (int64_t i = divisor_length - 1; i >= 0; --i) {

const auto sum =

static_cast<uint64_t>(divisor_array[i]) + dividend_array[j + i + 1] + carry;

dividend_array[j + i + 1] = static_cast<uint32_t>(sum);

carry = static_cast<uint32_t>(sum >> 32);

}

dividend_array[j] += carry;

}

result_array[j] = guess;

}

// denormalize the remainder

ShiftArrayRight(dividend_array, dividend_length, normalize_bits);

// return result and remainder

auto status = BuildFromArray(result, result_array, result_length);

if (status != DecimalStatus::kSuccess) {

return status;

}

status = BuildFromArray(remainder, dividend_array, dividend_length);

if (status != DecimalStatus::kSuccess) {

return status;

}

FixDivisionSigns(result, remainder, dividend_was_negative, divisor_was_negative);

return DecimalStatus::kSuccess;

BasicDecimal128* result,

BasicDecimal128* remainder) const {

return DecimalDivide(*this, divisor, result, remainder);