xref: /arkcompiler/ets_runtime/ecmascript/js_bigint.cpp

68 JSHandle<BigInt> BigInt::CreateUint64MaxBigInt(JSThread *thread)
70     JSHandle<BigInt> bigint = CreateBigint(thread, 3); // 3:The number of digits in an object of type BigInt
71     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
74     bigint->SetDigit(2, 1); // 2:The number of digits in an object of type BigInt
78 JSHandle<BigInt> BigInt::CreateInt64MaxBigInt(JSThread *thread)
80     JSHandle<BigInt> bigint = CreateBigint(thread, 2); // 2:The number of digits in an object of type BigInt
81     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
87 JSHandle<BigInt> BigInt::GetUint64MaxBigInt(JSThread *thread)
89     return JSHandle<BigInt>::Cast(thread->GlobalConstants()->GetHandledUint64MaxBigInt());
92 JSHandle<BigInt> BigInt::GetInt64MaxBigInt(JSThread *thread)
94     return JSHandle<BigInt>::Cast(thread->GlobalConstants()->GetHandledInt64MaxBigInt());
97 JSHandle<BigInt> BigIntHelper::SetBigInt(JSThread *thread, const CString &numStr, uint32_t currentRadix)
105     if (currentRadix != BigInt::BINARY) {
106         binaryStr = Conversion(numStr.substr(flag), BigInt::BINARY, currentRadix);
111     JSHandle<BigInt> bigint;
113     size_t len = binaryStrLen / BigInt::DATEBITS;
114     size_t mod = binaryStrLen % BigInt::DATEBITS;
118         bigint = BigInt::CreateBigint(thread, len);
119         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
123         bigint = BigInt::CreateBigint(thread, len);
124         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
139         for (size_t j = 0; j < BigInt::DATEBITS && i < binaryStrLen; ++j, ++i) {
149 JSHandle<BigInt> BigIntHelper::RightTruncate(JSThread *thread, JSHandle<BigInt> x)
169         return BigInt::Int32ToBigInt(thread, 0);
172         return BigInt::Copy(thread, x, index + 1);
176 CString BigIntHelper::GetBinary(const BigInt *bigint)
181     int strLen = BigInt::DATEBITS * len;
185         int bityLen = BigInt::DATEBITS;
197 JSHandle<BigInt> BigInt::CreateBigint(JSThread *thread, uint32_t length)
200         JSHandle<BigInt> bigint(thread, JSTaggedValue::Exception());
201         THROW_RANGE_ERROR_AND_RETURN(thread, "Maximum BigInt size exceeded", bigint);
204     JSHandle<BigInt> bigint = factory->NewBigInt(length);
209 bool BigInt::Equal(const JSTaggedValue &x, const JSTaggedValue &y)
211     BigInt* xVal = BigInt::Cast(x.GetTaggedObject());
212     BigInt* yVal = BigInt::Cast(y.GetTaggedObject());
216 bool BigInt::Equal(const BigInt *x, const BigInt *y)
232 bool BigInt::SameValue(const JSTaggedValue &x, const JSTaggedValue &y)
238 bool BigInt::SameValueZero(const JSTaggedValue &x, const JSTaggedValue &y)
243 JSHandle<BigInt> BigInt::BitwiseOp(JSThread *thread, Operate op, JSHandle<BigInt> x, JSHandle<BigInt> y)
256     JSHandle<BigInt> bigint = BigInt::CreateBigint(thread, maxLen);
257     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
282 JSHandle<BigInt> OneIsNegativeAND(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y)
284     JSHandle<BigInt> yVal = BigInt::BitwiseSubOne(thread, y, y->GetLength());
285     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
292     JSHandle<BigInt> newBigint = BigInt::CreateBigint(thread, xLength);
293     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
307 // 6.1.6.2.20 BigInt::bitwiseAND ( x, y )
308 JSHandle<BigInt> BigInt::BitwiseAND(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y)
312         JSHandle<BigInt> xVal = BitwiseSubOne(thread, x, x->GetLength());
313         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
314         JSHandle<BigInt> yVal = BitwiseSubOne(thread, y, y->GetLength());
315         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
316         JSHandle<BigInt> temp = BitwiseOp(thread, Operate::OR, xVal, yVal);
317         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
318         JSHandle<BigInt> res = BitwiseAddOne(thread, temp);
319         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
333 JSHandle<BigInt> OneIsNegativeXOR(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y)
335     JSHandle<BigInt> yVal = BigInt::BitwiseSubOne(thread, y, y->GetLength());
336     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
337     JSHandle<BigInt> temp = BigInt::BitwiseOp(thread, Operate::XOR, x, yVal);
338     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
339     JSHandle<BigInt> res = BigInt::BitwiseAddOne(thread, temp);
340     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
344 // 6.1.6.2.21 BigInt::bitwiseOR ( x, y )
345 JSHandle<BigInt> BigInt::BitwiseXOR(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y)
349         JSHandle<BigInt> xVal = BitwiseSubOne(thread, x, x->GetLength());
350         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
351         JSHandle<BigInt> yVal = BitwiseSubOne(thread, y, y->GetLength());
352         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
366 JSHandle<BigInt> BigInt::BitwiseSubOne(JSThread *thread, JSHandle<BigInt> bigint, uint32_t maxLen)
371     JSHandle<BigInt> newBigint = BigInt::CreateBigint(thread, maxLen);
372     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
384 JSHandle<BigInt> BigInt::BitwiseAddOne(JSThread *thread, JSHandle<BigInt> bigint)
399     JSHandle<BigInt> newBigint = BigInt::CreateBigint(thread, newLength);
400     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
414 JSHandle<BigInt> OneIsNegativeOR(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y)
421     JSHandle<BigInt> yVal = BigInt::BitwiseSubOne(thread, y, maxLen);
422     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
428     JSHandle<BigInt> newBigint = BigInt::CreateBigint(thread, yLength);
429     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
440     JSHandle<BigInt> temp = BigIntHelper::RightTruncate(thread, newBigint);
441     JSHandle<BigInt> res = BigInt::BitwiseAddOne(thread, temp);
442     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
447 // 6.1.6.2.22 BigInt::bitwiseOR ( x, y )
448 JSHandle<BigInt> BigInt::BitwiseOR(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y)
455         JSHandle<BigInt> xVal = BitwiseSubOne(thread, x, maxLen);
456         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
457         JSHandle<BigInt> yVal = BitwiseSubOne(thread, y, yLen);
458         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
459         JSHandle<BigInt> temp = BitwiseOp(thread, Operate::AND, xVal, yVal);
460         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
461         JSHandle<BigInt> res = BitwiseAddOne(thread, temp);
462         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
477 // 6.1.6.2.23 BigInt::toString ( x )
478 JSHandle<EcmaString> BigInt::ToString(JSThread *thread, JSHandle<BigInt> bigint, uint32_t conversionToRadix)
485 CString BigInt::ToStdString(uint32_t conversionToRadix) const
495 JSTaggedValue BigInt::NumberToBigInt(JSThread *thread, JSHandle<JSTaggedValue> number)
498         THROW_RANGE_ERROR_AND_RETURN(thread, "The number cannot be converted to a BigInt because it is not an integer",
508 JSTaggedValue BigInt::DoubleToBigInt(JSThread *thread, double num)
520     JSHandle<BigInt> bigint = CreateBigint(thread, mayNeedLen);
546 JSHandle<BigInt> BigInt::Int32ToBigInt(JSThread *thread, const int &number)
548     JSHandle<BigInt> bigint = CreateBigint(thread, 1);
549     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
562 JSHandle<BigInt> BigInt::Uint32ToBigInt(JSThread *thread, const uint32_t &number)
564     JSHandle<BigInt> bigint = CreateBigint(thread, 1);
565     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
570 JSHandle<BigInt> BigInt::Int64ToBigInt(JSThread *thread, const int64_t &number)
579     JSHandle<BigInt> bigint = Uint64ToBigInt(thread, value);
580     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
585 JSHandle<BigInt> BigInt::Uint64ToBigInt(JSThread *thread, const uint64_t &number)
587     JSHandle<BigInt> bigint = CreateBigint(thread, 2); // 2 : one int64_t bits need two uint32_t bits
588     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
596 uint64_t BigInt::ToUint64()
599     ASSERT(len <= 2); // The maximum length of the BigInt data is less or equal 2
613 int64_t BigInt::ToInt64()
618 void BigInt::BigIntToInt64(JSThread *thread, JSHandle<JSTaggedValue> bigint, int64_t *cValue, bool *lossless)
626         JSHandle<BigInt> bigInt64(thread, JSTaggedValue::ToBigInt64(thread, bigint));
631     JSHandle<BigInt> bigInt64(thread, JSTaggedValue::ToBigInt64(thread, bigint));
641 void BigInt::BigIntToUint64(JSThread *thread, JSHandle<JSTaggedValue> bigint, uint64_t *cValue, bool *lossless)
649         JSHandle<BigInt> bigInt64(thread, JSTaggedValue::ToBigUint64(thread, bigint));
654     JSHandle<BigInt> bigUint64(thread, JSTaggedValue::ToBigUint64(thread, bigint));
664 JSHandle<BigInt> BigInt::CreateBigWords(JSThread *thread, bool sign, uint32_t size, const uint64_t *words)
673         JSHandle<BigInt> bigint(thread, JSTaggedValue::Exception());
674         THROW_RANGE_ERROR_AND_RETURN(thread, "Maximum BigInt size exceeded", bigint);
676     JSHandle<BigInt> bigint = CreateBigint(thread, needLen);
677     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
688 JSHandle<BigInt> BigInt::Add(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y)
718 JSHandle<BigInt> BigInt::Subtract(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y)
750 JSHandle<BigInt> BigInt::BigintAdd(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y, bool resultSign)
755     JSHandle<BigInt> bigint = BigInt::CreateBigint(thread, x->GetLength() + 1);
756     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
788 JSHandle<BigInt> BigInt::BigintSub(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y, bool resultSign)
790     JSHandle<BigInt> bigint = BigInt::CreateBigint(thread, x->GetLength());
791     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
813 JSHandle<BigInt> BigInt::BigintAddOne(JSThread *thread, JSHandle<BigInt> x)
815     JSHandle<BigInt> temp = Int32ToBigInt(thread, 1);
816     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
820 JSHandle<BigInt> BigInt::BigintSubOne(JSThread *thread, JSHandle<BigInt> x)
822     JSHandle<BigInt> temp = Int32ToBigInt(thread, 1);
823     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
837 ComparisonResult BigInt::Compare(const JSTaggedValue &x, const JSTaggedValue &y)
839     BigInt* xVal = BigInt::Cast(x.GetTaggedObject());
840     BigInt* yVal = BigInt::Cast(y.GetTaggedObject());
844 ComparisonResult BigInt::Compare(const BigInt *x, const BigInt *y)
858 bool BigInt::LessThan(const JSTaggedValue &x, const JSTaggedValue &y)
863 bool BigInt::LessThan(const BigInt *x, const BigInt *y)
870 JSHandle<BigInt> BigInt::SignedRightShift(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y)
882 JSHandle<BigInt> BigInt::ReturnIfRightShiftOverMax(JSThread *thread, bool sign)
890 void BigInt::RightShift(JSHandle<BigInt> bigint, JSHandle<BigInt> x, uint32_t digitMove, uint32_t bitsMove)
910 void BigInt::JudgeRoundDown(JSHandle<BigInt> x, uint32_t digitMove, uint32_t bitsMove, uint32_t &needLen,
936 JSHandle<BigInt> BigInt::RightShiftHelper(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y)
955     JSHandle<BigInt> bigint = CreateBigint(thread, needLen);
956     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
969 JSHandle<BigInt> BigInt::LeftShift(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y)
978 JSHandle<BigInt> BigInt::LeftShiftHelper(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y)
989     JSHandle<BigInt> bigint = CreateBigint(thread, needLen);
990     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
1015 JSTaggedValue BigInt::UnsignedRightShift(JSThread *thread)
1017     THROW_TYPE_ERROR_AND_RETURN(thread, "BigInt have no unsigned right shift, use >> instead",
1021 JSHandle<BigInt> BigInt::Copy(JSThread *thread, JSHandle<BigInt> x, uint32_t len)
1024     JSHandle<BigInt> newBig = CreateBigint(thread, len);
1025     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
1031 JSHandle<BigInt> BigInt::UnaryMinus(JSThread *thread, JSHandle<BigInt> x)
1036     JSHandle<BigInt> y = Copy(thread, x, x->GetLength());
1041 // 6.1.6.2.2   BigInt::bitwiseNOT ( x )
1042 JSHandle<BigInt> BigInt::BitwiseNOT(JSThread *thread, JSHandle<BigInt> x)
1046     JSHandle<BigInt> result = BigintAddOne(thread, x);
1047     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
1056 JSHandle<BigInt> BigInt::Exponentiate(JSThread *thread, JSHandle<BigInt> base, JSHandle<BigInt> exponent)
1059         JSHandle<BigInt> bigint(thread, JSTaggedValue::Exception());
1072             return BigInt::UnaryMinus(thread, base);
1078         JSHandle<BigInt> bigint(thread, JSTaggedValue::Exception());
1079         THROW_RANGE_ERROR_AND_RETURN(thread, "Maximum BigInt size exceeded", bigint);
1084         JSHandle<BigInt> bigint = CreateBigint(thread, needLength);
1085         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
1093     JSMutableHandle<BigInt> result(thread, JSTaggedValue::Null());
1094     JSMutableHandle<BigInt> temp(thread, base);
1100         temp.Update(BigInt::Multiply(thread, temp, temp));
1101         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
1106                 result.Update(BigInt::Multiply(thread, result, temp));
1107                 RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
1115 std::tuple<uint32_t, uint32_t> BigInt::Mul(uint32_t x, uint32_t y)
1135 JSHandle<BigInt> BigInt::Multiply(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y)
1144     JSHandle<BigInt> bigint = BigInt::CreateBigint(thread, needLength);
1145     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
1202 ComparisonResult BigInt::AbsolutelyCompare(const BigInt *x, const BigInt *y)
1224 uint32_t BigInt::DivideAndRemainder(uint32_t highBit, uint32_t lowBit, uint32_t divisor, uint32_t& remainder)
1273 JSHandle<BigInt> BigInt::FormatLeftShift(JSThread *thread, uint32_t shift, JSHandle<BigInt> bigint, bool neeedAddOne)
1283     JSHandle<BigInt> result = CreateBigint(thread, needLen);
1284     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
1304 void BigInt::UnformattedRightShift(JSHandle<BigInt> bigint, uint32_t shift)
1309 bool BigInt::SpecialMultiplyAndSub(JSHandle<BigInt> u, JSHandle<BigInt> v, uint32_t q, JSHandle<BigInt> qv,
1344 uint32_t BigInt::SpecialAdd(JSHandle<BigInt> u, JSHandle<BigInt> v, uint32_t pos)
1357 uint32_t BigInt::ImproveAccuracy(uint32_t vHighest, uint32_t vHighestNext, uint32_t UHighest,
1376 JSHandle<BigInt> BigInt::DivideAndRemainderWithBigintDivisor(JSThread *thread, JSHandle<BigInt> dividend,
1377                                                              JSHandle<BigInt> divisor,
1378                                                              JSMutableHandle<BigInt> &remainder)
1383     JSMutableHandle<BigInt> quotient(thread, JSTaggedValue::Null());
1386         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
1392     JSHandle<BigInt> v = FormatLeftShift(thread, leadingZeros, divisor, false);
1393     JSHandle<BigInt> u = FormatLeftShift(thread, leadingZeros, dividend, true);
1395     JSHandle<BigInt> qv = CreateBigint(thread, divisorLen + 1);
1396     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
1433 JSHandle<BigInt> BigInt::DivideAndRemainderWithUint32Divisor(JSThread *thread, JSHandle<BigInt> dividend,
1434                                                              uint32_t divisor, JSMutableHandle<BigInt> &remainder)
1437     JSMutableHandle<BigInt> quotient(thread, JSTaggedValue::Null());
1445         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
1455 JSHandle<BigInt> BigInt::Divide(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y)
1458         JSHandle<BigInt> bigint(thread, JSTaggedValue::Exception());
1462     JSMutableHandle<BigInt> quotient(thread, JSTaggedValue::Null());
1480     JSMutableHandle<BigInt> remainder(thread, JSTaggedValue::Null());
1486         JSHandle<BigInt> newBigint = DivideAndRemainderWithBigintDivisor(thread, x, y, remainder);
1487         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
1495 JSHandle<BigInt> BigInt::Remainder(JSThread *thread, JSHandle<BigInt> n, JSHandle<BigInt> d)
1498         JSHandle<BigInt> bigint(thread, JSTaggedValue::Exception());
1508     JSMutableHandle<BigInt> remainder(thread, JSTaggedValue::Undefined());
1515         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
1522 JSHandle<BigInt> BigInt::FloorMod(JSThread *thread, JSHandle<BigInt> leftVal, JSHandle<BigInt> rightVal)
1524     JSHandle<BigInt> remainder = Remainder(thread, leftVal, rightVal);
1525     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
1532 JSTaggedValue BigInt::AsUintN(JSThread *thread, JSTaggedNumber &bits, JSHandle<BigInt> bigint)
1543     JSHandle<BigInt> exponent = Uint64ToBigInt(thread, bit);
1544     JSHandle<BigInt> base = Int64ToBigInt(thread, 2); // 2 : base value
1548     JSHandle<BigInt> tValue = Exponentiate(thread, base, exponent);
1553 JSTaggedValue BigInt::AsintN(JSThread *thread, JSTaggedNumber &bits, JSHandle<BigInt> bigint)
1564     JSHandle<BigInt> exp = Int64ToBigInt(thread, bit);
1565     JSHandle<BigInt> exponent = Int64ToBigInt(thread, bit - 1);
1566     JSHandle<BigInt> base = Int64ToBigInt(thread, 2); // 2 : base value
1570     JSHandle<BigInt> tValue = Exponentiate(thread, base, exp);
1572     JSHandle<BigInt> modValue = FloorMod(thread, bigint, tValue);
1573     JSHandle<BigInt> resValue = Exponentiate(thread, base, exponent);
1609 JSTaggedNumber BigInt::BigIntToNumber(JSHandle<BigInt> bigint)
1618     int bigintBitLen = static_cast<int>(bigintLen * BigInt::DATEBITS - leadingZeros);
1625     int needMoveBit = static_cast<int>(leadingZeros + BigInt::DATEBITS + 1);
1640     if (static_cast<uint32_t>(remainMantissaBits) >= BigInt::DATEBITS) {
1641         mantissa |= (static_cast<uint64_t>(digit) << (remainMantissaBits - BigInt::DATEBITS));
1642         remainMantissaBits -= BigInt::DATEBITS;
1647         mantissa |= (static_cast<uint64_t>(digit) >> (BigInt::DATEBITS - remainMantissaBits));
1648         remainMantissaBits -= BigInt::DATEBITS;
1663         remainDigitBits = BigInt::DATEBITS;
1680 static int CompareToBitsLen(JSHandle<BigInt> bigint, int numBitLen, int &leadingZeros)
1686     int bigintBitLen = static_cast<int>(bigintLen * BigInt::DATEBITS) - leadingZeros;
1698 ComparisonResult BigInt::CompareWithNumber(JSHandle<BigInt> bigint, JSHandle<JSTaggedValue> number)
1755             leftover = mantissaSize - BigInt::DATEBITS + leadingZeros + 1;
1765             leftover -= BigInt::DATEBITS;
1766             doubleNum = static_cast<uint32_t>(mantissa >> BigInt::DATEBITS);
1767             mantissa = mantissa << BigInt::DATEBITS;
1774             leftover -= BigInt::DATEBITS;

Indexes created Thu Nov 07 10:32:03 CST 2024