path: root/AK/FloatingPointStringConversions.cpp

/*
 * Copyright (c) 2022, David Tuin <davidot@serenityos.org>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#include <AK/CharacterTypes.h>
#include <AK/FloatingPointStringConversions.h>
#include <AK/Format.h>
#include <AK/ScopeGuard.h>
#include <AK/StringView.h>
#include <AK/UFixedBigInt.h>
#include <AK/UFixedBigIntDivision.h>

namespace AK {

// This entire algorithm is an implementation of the paper: Number Parsing at a Gigabyte per Second
// by Daniel Lemire, available at https://arxiv.org/abs/2101.11408 and an implementation
// at https://github.com/fastfloat/fast_float
// There is also a perhaps more easily understandable explanation
// at https://nigeltao.github.io/blog/2020/eisel-lemire.html

template<typename T>
concept ParseableFloatingPoint = IsFloatingPoint<T> && (sizeof(T) == sizeof(u32) || sizeof(T) == sizeof(u64));

template<ParseableFloatingPoint T>
struct FloatingPointInfo {
    static_assert(sizeof(T) == sizeof(u64) || sizeof(T) == sizeof(u32));
    using SameSizeUnsigned = Conditional<sizeof(T) == sizeof(u64), u64, u32>;

    // Implementing just this gives all the other bit sizes and mask immediately.
    static constexpr inline i32 mantissa_bits()
    {
        if constexpr (sizeof(T) == sizeof(u64))
            return 52;

        return 23;
    }

    static constexpr inline i32 exponent_bits()
    {
        return sizeof(T) * 8u - 1u - mantissa_bits();
    }

    static constexpr inline i32 exponent_bias()
    {
        return (1 << (exponent_bits() - 1)) - 1;
    }

    static constexpr inline i32 minimum_exponent()
    {
        return -exponent_bias();
    }

    static constexpr inline i32 infinity_exponent()
    {
        static_assert(exponent_bits() < 31);
        return (1 << exponent_bits()) - 1;
    }

    static constexpr inline i32 sign_bit_index()
    {
        return sizeof(T) * 8 - 1;
    }

    static constexpr inline SameSizeUnsigned sign_mask()
    {
        return SameSizeUnsigned { 1 } << sign_bit_index();
    }

    static constexpr inline SameSizeUnsigned mantissa_mask()
    {
        return (SameSizeUnsigned { 1 } << mantissa_bits()) - 1;
    }

    static constexpr inline SameSizeUnsigned exponent_mask()
    {
        return SameSizeUnsigned { infinity_exponent() } << mantissa_bits();
    }

    static constexpr inline i32 max_exponent_round_to_even()
    {
        if constexpr (sizeof(T) == sizeof(u64))
            return 23;

        return 10;
    }

    static constexpr inline i32 min_exponent_round_to_even()
    {
        if constexpr (sizeof(T) == sizeof(u64))
            return -4;

        return -17;
    }

    static constexpr inline size_t max_possible_digits_needed_for_parsing()
    {
        if constexpr (sizeof(T) == sizeof(u64))
            return 769;

        return 114;
    }

    static constexpr inline i32 max_power_of_10()
    {
        if constexpr (sizeof(T) == sizeof(u64))
            return 308;

        return 38;
    }

    static constexpr inline i32 min_power_of_10()
    {
        // Closest double value to zero is xe-324 and since we have at most 19 digits
        // we know that -324 -19 = -343 so exponent below that must be zero (for double)
        if constexpr (sizeof(T) == sizeof(u64))
            return -342;

        return -65;
    }

    static constexpr inline i32 max_exact_power_of_10()
    {
        // These are the largest power of 10 representable in T
        // So all powers of 10*i less than or equal to this should be the exact
        // values, be careful as they can be above "safe integer" limits.

        if constexpr (sizeof(T) == sizeof(u64))
            return 22;

        return 10;
    }

    static constexpr inline T power_of_ten(i32 exponent)
    {
        VERIFY(exponent <= max_exact_power_of_10());
        VERIFY(exponent >= 0);
        return m_powers_of_ten_stored[exponent];
    }

    template<u32 MaxPower>
    static constexpr inline Array<T, MaxPower + 1> compute_powers_of_ten()
    {
        // All these values are guaranteed to be exact all powers of MaxPower is the
        Array<T, MaxPower + 1> values {};

        values[0] = T(1.0);
        T ten = T(10.);

        for (u32 i = 1; i <= MaxPower; ++i)
            values[i] = values[i - 1] * ten;

        return values;
    }

    static constexpr auto m_powers_of_ten_stored = compute_powers_of_ten<max_exact_power_of_10()>();
};

template<typename T>
using BitSizedUnsignedForFloatingPoint = typename FloatingPointInfo<T>::SameSizeUnsigned;

struct BasicParseResult {
    u64 mantissa = 0;
    i64 exponent = 0;
    bool valid = false;
    bool negative = false;
    bool more_than_19_digits_with_overflow = false;
    char const* last_parsed { nullptr };
    StringView whole_part;
    StringView fractional_part;
};

static constexpr auto max_representable_power_of_ten_in_u64 = 19;
static_assert(1e19 <= static_cast<double>(NumericLimits<u64>::max()));
static_assert(1e20 >= static_cast<double>(NumericLimits<u64>::max()));

#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
#    error Float parsing currently assumes little endian, this fact is only used in fast parsing of 8 digits at a time \
           you _should_ only need to change read eight_digits to make this big endian compatible.
#endif
constexpr u64 read_eight_digits(char const* string)
{
    u64 val;
    __builtin_memcpy(&val, string, sizeof(val));
    return val;
}

constexpr static bool has_eight_digits(u64 value)
{
    // The ascii digits 0-9 are hex 0x30 - 0x39

    // If x is within that range then y := x + 0x46 is 0x76 to 0x7f
    //    z := x - 0x30 is 0x00 - 0x09
    //    y | z = 0x7t where t is in the range 0 - f so doing & 0x80 gives 0

    // However if a character x is below 0x30 then x - 0x30 underflows setting
    // the 0x80 bit of the next digit meaning & 0x80 will never be 0.

    // Similarly if a character x is above 0x39 then x + 0x46 gives at least
    // 0x80 thus & 0x80 will not be zero.

    return (((value + 0x4646464646464646) | (value - 0x3030303030303030)) & 0x8080808080808080) == 0;
}

constexpr static u32 eight_digits_to_value(u64 value)
{
    // THIS DOES ABSOLUTELY ASSUME has_eight_digits is true

    // This trick is based on https://johnnylee-sde.github.io/Fast-numeric-string-to-int/
    // FIXME: fast_float uses a slightly different version, but that is far harder
    //        to understand and does not seem to improve performance substantially.
    //        See https://github.com/fastfloat/fast_float/pull/28

    // First convert the digits to their respectively numbers (0x30 -> 0x00 etc.)
    value -= 0x3030303030303030;

    // Because of little endian the first number will in fact be the least significant
    // bits of value i.e. "12345678" -> 0x0807060504030201
    // This means that we need to shift/multiply each digit with 8 - the byte it is in
    // So the eight need to go down, and the 01 need to be multiplied with 10000000

    // We effectively multiply by 10 and then shift those values to the right (2^8 = 256)
    // We then shift the values back down, this leads to 4 digits pairs in the 2 byte parts
    // The values between are "garbage" which we will ignore
    value = (value * (256 * 10 + 1)) >> 8;
    // So with our example this gives 0x$$4e$$38$$22$$0c, where $$ is garbage/ignored
    // In decimal this gives              78  56  34  12

    // Now we keep performing the same trick twice more
    // First * 100 and shift of 16 (2^16 = 65536) and then shift back
    value = ((value & 0x00FF00FF00FF00FF) * (65536 * 100 + 1)) >> 16;

    // Again with our example this gives 0x$$$$162e$$$$04d2
    //                                         5678    1234

    // And finally with * 10000 and shift of 32 (2^32 = 4294967296)
    value = ((value & 0x0000FFFF0000FFFF) * (4294967296 * 10000 + 1)) >> 32;

    // With the example this gives 0x$$$$$$$$00bc614e
    //                                       12345678
    // Now we just truncate to the lower part
    return u32(value);
}

template<typename IsDoneCallback, typename Has8CharsLeftCallback>
static BasicParseResult parse_numbers(char const* start, IsDoneCallback is_done, Has8CharsLeftCallback has_eight_chars_to_read)
{
    char const* ptr = start;
    BasicParseResult result {};

    if (start == nullptr || is_done(ptr))
        return result;

    if (*ptr == '-' || *ptr == '+') {
        result.negative = *ptr == '-';
        ++ptr;

        if (is_done(ptr) || (!is_ascii_digit(*ptr) && *ptr != '.'))
            return result;
    }

    auto const fast_parse_decimal = [&](auto& value) {
        while (has_eight_chars_to_read(ptr) && has_eight_digits(read_eight_digits(ptr))) {
            value = 100'000'000 * value + eight_digits_to_value(read_eight_digits(ptr));
            ptr += 8;
        }

        while (!is_done(ptr) && is_ascii_digit(*ptr)) {
            value = 10 * value + (*ptr - '0');
            ++ptr;
        }
    };

    u64 mantissa = 0;
    auto const* whole_part_start = ptr;
    fast_parse_decimal(mantissa);
    auto const* whole_part_end = ptr;
    auto digits_found = whole_part_end - whole_part_start;
    result.whole_part = StringView(whole_part_start, digits_found);

    i64 exponent = 0;
    auto const* start_of_fractional_part = ptr;
    if (!is_done(ptr) && *ptr == '.') {
        ++ptr;
        ++start_of_fractional_part;
        fast_parse_decimal(mantissa);

        // We parsed x digits after the dot so need to multiply with 10^-x
        exponent = -(ptr - start_of_fractional_part);
    }
    result.fractional_part = StringView(start_of_fractional_part, ptr - start_of_fractional_part);
    digits_found += -exponent;

    // If both the part
    if (digits_found == 0)
        return result;

    i64 explicit_exponent = 0;

    // We do this in a lambda to easily be able to get out of parsing the exponent
    // and resetting the final character read to before the 'e'.
    [&] {
        if (is_done(ptr))
            return;
        if (*ptr != 'e' && *ptr != 'E')
            return;

        auto* pointer_before_e = ptr;
        ArmedScopeGuard reset_ptr { [&] { ptr = pointer_before_e; } };
        ++ptr;

        if (is_done(ptr))
            return;

        bool negative_exponent = false;
        if (*ptr == '-' || *ptr == '+') {
            negative_exponent = *ptr == '-';
            ++ptr;

            if (is_done(ptr))
                return;
        }

        if (!is_ascii_digit(*ptr))
            return;

        // Now we must have an optional sign and at least one digit so we
        // will not reset
        reset_ptr.disarm();

        while (!is_done(ptr) && is_ascii_digit(*ptr)) {
            // A massive exponent is not really a problem as this would
            // require a lot of characters so we would fallback on precise
            // parsing anyway (this is already 268435456 digits or 10 megabytes of digits)
            if (explicit_exponent < 0x10'000'000)
                explicit_exponent = 10 * explicit_exponent + (*ptr - '0');

            ++ptr;
        }

        explicit_exponent = negative_exponent ? -explicit_exponent : explicit_exponent;
        exponent += explicit_exponent;
    }();

    result.valid = true;
    result.last_parsed = ptr;

    if (digits_found > max_representable_power_of_ten_in_u64) {
        // There could be overflow but because we just count the digits it could be leading zeros
        auto const* leading_digit = whole_part_start;
        while (!is_done(leading_digit) && (*leading_digit == '0' || *leading_digit == '.')) {
            if (*leading_digit == '0')
                --digits_found;

            ++leading_digit;
        }

        if (digits_found > max_representable_power_of_ten_in_u64) {
            // FIXME: We just removed leading zeros, we might be able to skip these easily again.
            // If removing the leading zeros does not help we reparse and keep just the significant digits
            result.more_than_19_digits_with_overflow = true;

            mantissa = 0;
            constexpr i64 smallest_nineteen_digit_number = { 1000000000000000000 };
            char const* reparse_ptr = whole_part_start;

            constexpr i64 smallest_eleven_digit_number = { 10000000000 };
            while (mantissa < smallest_eleven_digit_number && (whole_part_end - reparse_ptr) >= 8) {
                mantissa = 100'000'000 * mantissa + eight_digits_to_value(read_eight_digits(reparse_ptr));
                reparse_ptr += 8;
            }

            while (mantissa < smallest_nineteen_digit_number && reparse_ptr != whole_part_end) {
                mantissa = 10 * mantissa + (*reparse_ptr - '0');
                ++reparse_ptr;
            }

            if (mantissa >= smallest_nineteen_digit_number) {
                // We still needed to parse (whole_part_end - reparse_ptr) digits so scale the exponent
                exponent = explicit_exponent + (whole_part_end - reparse_ptr);
            } else {
                reparse_ptr = start_of_fractional_part;
                char const* fractional_end = result.fractional_part.characters_without_null_termination() + result.fractional_part.length();

                while (mantissa < smallest_eleven_digit_number && (fractional_end - reparse_ptr) >= 8) {
                    mantissa = 100'000'000 * mantissa + eight_digits_to_value(read_eight_digits(reparse_ptr));
                    reparse_ptr += 8;
                }

                while (mantissa < smallest_nineteen_digit_number && reparse_ptr != fractional_end) {
                    mantissa = 10 * mantissa + (*reparse_ptr - '0');
                    ++reparse_ptr;
                }

                // Again we might be truncating fractional number so scale the exponent with that
                // However here need to subtract 1 from the exponent for every fractional digit
                exponent = explicit_exponent - (reparse_ptr - start_of_fractional_part);
            }
        }
    }

    result.mantissa = mantissa;
    result.exponent = exponent;
    return result;
}

constexpr static u128 compute_power_of_five(i64 exponent)
{
    constexpr u4096 bit128 = u4096 { 1u } << 127u;
    constexpr u4096 bit129 = u4096 { 1u } << 128u;

    VERIFY(exponent <= 308);
    VERIFY(exponent >= -342);

    if (exponent >= 0) {
        u4096 base { 1u };
        for (auto i = 0u; i < exponent; ++i) {
            base *= 5u;
        }

        while (base < bit128)
            base <<= 1u;
        while (base >= bit129)
            base >>= 1u;

        return u128 { base };
    }

    exponent *= -1;
    if (exponent <= 27) {
        u4096 base { 1u };
        for (auto i = 0u; i < exponent; ++i) {
            base *= 5u;
        }

        auto z = 4096 - base.clz();

        auto b = z + 127;
        u4096 base2 { 1u };
        for (auto i = 0u; i < b; ++i) {
            base2 *= 2u;
        }

        base2 /= base;
        base2 += 1u;

        return u128 { base2 };
    }

    VERIFY(exponent <= 342);
    VERIFY(exponent >= 28);

    u4096 base { 1u };
    for (auto i = 0u; i < exponent; ++i) {
        base *= 5u;
    }

    auto z = 4096 - base.clz();

    auto b = 2 * z + 128;

    u4096 base2 { 1u };
    for (auto i = 0u; i < b; ++i) {
        base2 *= 2u;
    }

    base2 /= base;
    base2 += 1u;

    while (base2 >= bit129)
        base2 >>= 1u;

    return u128 { base2 };
}

static constexpr i64 lowest_exponent = -342;
static constexpr i64 highest_exponent = 308;

constexpr auto pre_compute_table()
{
    // Computing this entire table at compile time is slow and hits constexpr
    // limits, so we just compute a (the simplest) value to make sure the
    // function is used. This table can thus be generated with the function
    // `u128 compute_power_of_five(i64 exponent)` above.
    AK::Array<u128, highest_exponent - lowest_exponent + 1> values = {
        u128 { 0x113faa2906a13b3fULL, 0xeef453d6923bd65aULL },
        u128 { 0x4ac7ca59a424c507ULL, 0x9558b4661b6565f8ULL },
        u128 { 0x5d79bcf00d2df649ULL, 0xbaaee17fa23ebf76ULL },
        u128 { 0xf4d82c2c107973dcULL, 0xe95a99df8ace6f53ULL },
        u128 { 0x79071b9b8a4be869ULL, 0x91d8a02bb6c10594ULL },
        u128 { 0x9748e2826cdee284ULL, 0xb64ec836a47146f9ULL },
        u128 { 0xfd1b1b2308169b25ULL, 0xe3e27a444d8d98b7ULL },
        u128 { 0xfe30f0f5e50e20f7ULL, 0x8e6d8c6ab0787f72ULL },
        u128 { 0xbdbd2d335e51a935ULL, 0xb208ef855c969f4fULL },
        u128 { 0xad2c788035e61382ULL, 0xde8b2b66b3bc4723ULL },
        u128 { 0x4c3bcb5021afcc31ULL, 0x8b16fb203055ac76ULL },
        u128 { 0xdf4abe242a1bbf3dULL, 0xaddcb9e83c6b1793ULL },
        u128 { 0xd71d6dad34a2af0dULL, 0xd953e8624b85dd78ULL },
        u128 { 0x8672648c40e5ad68ULL, 0x87d4713d6f33aa6bULL },
        u128 { 0x680efdaf511f18c2ULL, 0xa9c98d8ccb009506ULL },
        u128 { 0x212bd1b2566def2ULL, 0xd43bf0effdc0ba48ULL },
        u128 { 0x14bb630f7604b57ULL, 0x84a57695fe98746dULL },
        u128 { 0x419ea3bd35385e2dULL, 0xa5ced43b7e3e9188ULL },
        u128 { 0x52064cac828675b9ULL, 0xcf42894a5dce35eaULL },
        u128 { 0x7343efebd1940993ULL, 0x818995ce7aa0e1b2ULL },
        u128 { 0x1014ebe6c5f90bf8ULL, 0xa1ebfb4219491a1fULL },
        u128 { 0xd41a26e077774ef6ULL, 0xca66fa129f9b60a6ULL },
        u128 { 0x8920b098955522b4ULL, 0xfd00b897478238d0ULL },
        u128 { 0x55b46e5f5d5535b0ULL, 0x9e20735e8cb16382ULL },
        u128 { 0xeb2189f734aa831dULL, 0xc5a890362fddbc62ULL },
        u128 { 0xa5e9ec7501d523e4ULL, 0xf712b443bbd52b7bULL },
        u128 { 0x47b233c92125366eULL, 0x9a6bb0aa55653b2dULL },
        u128 { 0x999ec0bb696e840aULL, 0xc1069cd4eabe89f8ULL },
        u128 { 0xc00670ea43ca250dULL, 0xf148440a256e2c76ULL },
        u128 { 0x380406926a5e5728ULL, 0x96cd2a865764dbcaULL },
        u128 { 0xc605083704f5ecf2ULL, 0xbc807527ed3e12bcULL },
        u128 { 0xf7864a44c633682eULL, 0xeba09271e88d976bULL },
        u128 { 0x7ab3ee6afbe0211dULL, 0x93445b8731587ea3ULL },
        u128 { 0x5960ea05bad82964ULL, 0xb8157268fdae9e4cULL },
        u128 { 0x6fb92487298e33bdULL, 0xe61acf033d1a45dfULL },
        u128 { 0xa5d3b6d479f8e056ULL, 0x8fd0c16206306babULL },
        u128 { 0x8f48a4899877186cULL, 0xb3c4f1ba87bc8696ULL },
        u128 { 0x331acdabfe94de87ULL, 0xe0b62e2929aba83cULL },
        u128 { 0x9ff0c08b7f1d0b14ULL, 0x8c71dcd9ba0b4925ULL },
        u128 { 0x7ecf0ae5ee44dd9ULL, 0xaf8e5410288e1b6fULL },
        u128 { 0xc9e82cd9f69d6150ULL, 0xdb71e91432b1a24aULL },
        u128 { 0xbe311c083a225cd2ULL, 0x892731ac9faf056eULL },
        u128 { 0x6dbd630a48aaf406ULL, 0xab70fe17c79ac6caULL },
        u128 { 0x92cbbccdad5b108ULL, 0xd64d3d9db981787dULL },
        u128 { 0x25bbf56008c58ea5ULL, 0x85f0468293f0eb4eULL },
        u128 { 0xaf2af2b80af6f24eULL, 0xa76c582338ed2621ULL },
        u128 { 0x1af5af660db4aee1ULL, 0xd1476e2c07286faaULL },
        u128 { 0x50d98d9fc890ed4dULL, 0x82cca4db847945caULL },
        u128 { 0xe50ff107bab528a0ULL, 0xa37fce126597973cULL },
        u128 { 0x1e53ed49a96272c8ULL, 0xcc5fc196fefd7d0cULL },
        u128 { 0x25e8e89c13bb0f7aULL, 0xff77b1fcbebcdc4fULL },
        u128 { 0x77b191618c54e9acULL, 0x9faacf3df73609b1ULL },
        u128 { 0xd59df5b9ef6a2417ULL, 0xc795830d75038c1dULL },
        u128 { 0x4b0573286b44ad1dULL, 0xf97ae3d0d2446f25ULL },
        u128 { 0x4ee367f9430aec32ULL, 0x9becce62836ac577ULL },
        u128 { 0x229c41f793cda73fULL, 0xc2e801fb244576d5ULL },
        u128 { 0x6b43527578c1110fULL, 0xf3a20279ed56d48aULL },
        u128 { 0x830a13896b78aaa9ULL, 0x9845418c345644d6ULL },
        u128 { 0x23cc986bc656d553ULL, 0xbe5691ef416bd60cULL },
        u128 { 0x2cbfbe86b7ec8aa8ULL, 0xedec366b11c6cb8fULL },
        u128 { 0x7bf7d71432f3d6a9ULL, 0x94b3a202eb1c3f39ULL },
        u128 { 0xdaf5ccd93fb0cc53ULL, 0xb9e08a83a5e34f07ULL },
        u128 { 0xd1b3400f8f9cff68ULL, 0xe858ad248f5c22c9ULL },
        u128 { 0x23100809b9c21fa1ULL, 0x91376c36d99995beULL },
        u128 { 0xabd40a0c2832a78aULL, 0xb58547448ffffb2dULL },
        u128 { 0x16c90c8f323f516cULL, 0xe2e69915b3fff9f9ULL },
        u128 { 0xae3da7d97f6792e3ULL, 0x8dd01fad907ffc3bULL },
        u128 { 0x99cd11cfdf41779cULL, 0xb1442798f49ffb4aULL },
        u128 { 0x40405643d711d583ULL, 0xdd95317f31c7fa1dULL },
        u128 { 0x482835ea666b2572ULL, 0x8a7d3eef7f1cfc52ULL },
        u128 { 0xda3243650005eecfULL, 0xad1c8eab5ee43b66ULL },
        u128 { 0x90bed43e40076a82ULL, 0xd863b256369d4a40ULL },
        u128 { 0x5a7744a6e804a291ULL, 0x873e4f75e2224e68ULL },
        u128 { 0x711515d0a205cb36ULL, 0xa90de3535aaae202ULL },
        u128 { 0xd5a5b44ca873e03ULL, 0xd3515c2831559a83ULL },
        u128 { 0xe858790afe9486c2ULL, 0x8412d9991ed58091ULL },
        u128 { 0x626e974dbe39a872ULL, 0xa5178fff668ae0b6ULL },
        u128 { 0xfb0a3d212dc8128fULL, 0xce5d73ff402d98e3ULL },
        u128 { 0x7ce66634bc9d0b99ULL, 0x80fa687f881c7f8eULL },
        u128 { 0x1c1fffc1ebc44e80ULL, 0xa139029f6a239f72ULL },
        u128 { 0xa327ffb266b56220ULL, 0xc987434744ac874eULL },
        u128 { 0x4bf1ff9f0062baa8ULL, 0xfbe9141915d7a922ULL },
        u128 { 0x6f773fc3603db4a9ULL, 0x9d71ac8fada6c9b5ULL },
        u128 { 0xcb550fb4384d21d3ULL, 0xc4ce17b399107c22ULL },
        u128 { 0x7e2a53a146606a48ULL, 0xf6019da07f549b2bULL },
        u128 { 0x2eda7444cbfc426dULL, 0x99c102844f94e0fbULL },
        u128 { 0xfa911155fefb5308ULL, 0xc0314325637a1939ULL },
        u128 { 0x793555ab7eba27caULL, 0xf03d93eebc589f88ULL },
        u128 { 0x4bc1558b2f3458deULL, 0x96267c7535b763b5ULL },
        u128 { 0x9eb1aaedfb016f16ULL, 0xbbb01b9283253ca2ULL },
        u128 { 0x465e15a979c1cadcULL, 0xea9c227723ee8bcbULL },
        u128 { 0xbfacd89ec191ec9ULL, 0x92a1958a7675175fULL },
        u128 { 0xcef980ec671f667bULL, 0xb749faed14125d36ULL },
        u128 { 0x82b7e12780e7401aULL, 0xe51c79a85916f484ULL },
        u128 { 0xd1b2ecb8b0908810ULL, 0x8f31cc0937ae58d2ULL },
        u128 { 0x861fa7e6dcb4aa15ULL, 0xb2fe3f0b8599ef07ULL },
        u128 { 0x67a791e093e1d49aULL, 0xdfbdcece67006ac9ULL },
        u128 { 0xe0c8bb2c5c6d24e0ULL, 0x8bd6a141006042bdULL },
        u128 { 0x58fae9f773886e18ULL, 0xaecc49914078536dULL },
        u128 { 0xaf39a475506a899eULL, 0xda7f5bf590966848ULL },
        u128 { 0x6d8406c952429603ULL, 0x888f99797a5e012dULL },
        u128 { 0xc8e5087ba6d33b83ULL, 0xaab37fd7d8f58178ULL },
        u128 { 0xfb1e4a9a90880a64ULL, 0xd5605fcdcf32e1d6ULL },
        u128 { 0x5cf2eea09a55067fULL, 0x855c3be0a17fcd26ULL },
        u128 { 0xf42faa48c0ea481eULL, 0xa6b34ad8c9dfc06fULL },
        u128 { 0xf13b94daf124da26ULL, 0xd0601d8efc57b08bULL },
        u128 { 0x76c53d08d6b70858ULL, 0x823c12795db6ce57ULL },
        u128 { 0x54768c4b0c64ca6eULL, 0xa2cb1717b52481edULL },
        u128 { 0xa9942f5dcf7dfd09ULL, 0xcb7ddcdda26da268ULL },
        u128 { 0xd3f93b35435d7c4cULL, 0xfe5d54150b090b02ULL },
        u128 { 0xc47bc5014a1a6dafULL, 0x9efa548d26e5a6e1ULL },
        u128 { 0x359ab6419ca1091bULL, 0xc6b8e9b0709f109aULL },
        u128 { 0xc30163d203c94b62ULL, 0xf867241c8cc6d4c0ULL },
        u128 { 0x79e0de63425dcf1dULL, 0x9b407691d7fc44f8ULL },
        u128 { 0x985915fc12f542e4ULL, 0xc21094364dfb5636ULL },
        u128 { 0x3e6f5b7b17b2939dULL, 0xf294b943e17a2bc4ULL },
        u128 { 0xa705992ceecf9c42ULL, 0x979cf3ca6cec5b5aULL },
        u128 { 0x50c6ff782a838353ULL, 0xbd8430bd08277231ULL },
        u128 { 0xa4f8bf5635246428ULL, 0xece53cec4a314ebdULL },
        u128 { 0x871b7795e136be99ULL, 0x940f4613ae5ed136ULL },
        u128 { 0x28e2557b59846e3fULL, 0xb913179899f68584ULL },
        u128 { 0x331aeada2fe589cfULL, 0xe757dd7ec07426e5ULL },
        u128 { 0x3ff0d2c85def7621ULL, 0x9096ea6f3848984fULL },
        u128 { 0xfed077a756b53a9ULL, 0xb4bca50b065abe63ULL },
        u128 { 0xd3e8495912c62894ULL, 0xe1ebce4dc7f16dfbULL },
        u128 { 0x64712dd7abbbd95cULL, 0x8d3360f09cf6e4bdULL },
        u128 { 0xbd8d794d96aacfb3ULL, 0xb080392cc4349decULL },
        u128 { 0xecf0d7a0fc5583a0ULL, 0xdca04777f541c567ULL },
        u128 { 0xf41686c49db57244ULL, 0x89e42caaf9491b60ULL },
        u128 { 0x311c2875c522ced5ULL, 0xac5d37d5b79b6239ULL },
        u128 { 0x7d633293366b828bULL, 0xd77485cb25823ac7ULL },
        u128 { 0xae5dff9c02033197ULL, 0x86a8d39ef77164bcULL },
        u128 { 0xd9f57f830283fdfcULL, 0xa8530886b54dbdebULL },
        u128 { 0xd072df63c324fd7bULL, 0xd267caa862a12d66ULL },
        u128 { 0x4247cb9e59f71e6dULL, 0x8380dea93da4bc60ULL },
        u128 { 0x52d9be85f074e608ULL, 0xa46116538d0deb78ULL },
        u128 { 0x67902e276c921f8bULL, 0xcd795be870516656ULL },
        u128 { 0xba1cd8a3db53b6ULL, 0x806bd9714632dff6ULL },
        u128 { 0x80e8a40eccd228a4ULL, 0xa086cfcd97bf97f3ULL },
        u128 { 0x6122cd128006b2cdULL, 0xc8a883c0fdaf7df0ULL },
        u128 { 0x796b805720085f81ULL, 0xfad2a4b13d1b5d6cULL },
        u128 { 0xcbe3303674053bb0ULL, 0x9cc3a6eec6311a63ULL },
        u128 { 0xbedbfc4411068a9cULL, 0xc3f490aa77bd60fcULL },
        u128 { 0xee92fb5515482d44ULL, 0xf4f1b4d515acb93bULL },
        u128 { 0x751bdd152d4d1c4aULL, 0x991711052d8bf3c5ULL },
        u128 { 0xd262d45a78a0635dULL, 0xbf5cd54678eef0b6ULL },
        u128 { 0x86fb897116c87c34ULL, 0xef340a98172aace4ULL },
        u128 { 0xd45d35e6ae3d4da0ULL, 0x9580869f0e7aac0eULL },
        u128 { 0x8974836059cca109ULL, 0xbae0a846d2195712ULL },
        u128 { 0x2bd1a438703fc94bULL, 0xe998d258869facd7ULL },
        u128 { 0x7b6306a34627ddcfULL, 0x91ff83775423cc06ULL },
        u128 { 0x1a3bc84c17b1d542ULL, 0xb67f6455292cbf08ULL },
        u128 { 0x20caba5f1d9e4a93ULL, 0xe41f3d6a7377eecaULL },
        u128 { 0x547eb47b7282ee9cULL, 0x8e938662882af53eULL },
        u128 { 0xe99e619a4f23aa43ULL, 0xb23867fb2a35b28dULL },
        u128 { 0x6405fa00e2ec94d4ULL, 0xdec681f9f4c31f31ULL },
        u128 { 0xde83bc408dd3dd04ULL, 0x8b3c113c38f9f37eULL },
        u128 { 0x9624ab50b148d445ULL, 0xae0b158b4738705eULL },
        u128 { 0x3badd624dd9b0957ULL, 0xd98ddaee19068c76ULL },
        u128 { 0xe54ca5d70a80e5d6ULL, 0x87f8a8d4cfa417c9ULL },
        u128 { 0x5e9fcf4ccd211f4cULL, 0xa9f6d30a038d1dbcULL },
        u128 { 0x7647c3200069671fULL, 0xd47487cc8470652bULL },
        u128 { 0x29ecd9f40041e073ULL, 0x84c8d4dfd2c63f3bULL },
        u128 { 0xf468107100525890ULL, 0xa5fb0a17c777cf09ULL },
        u128 { 0x7182148d4066eeb4ULL, 0xcf79cc9db955c2ccULL },
        u128 { 0xc6f14cd848405530ULL, 0x81ac1fe293d599bfULL },
        u128 { 0xb8ada00e5a506a7cULL, 0xa21727db38cb002fULL },
        u128 { 0xa6d90811f0e4851cULL, 0xca9cf1d206fdc03bULL },
        u128 { 0x908f4a166d1da663ULL, 0xfd442e4688bd304aULL },
        u128 { 0x9a598e4e043287feULL, 0x9e4a9cec15763e2eULL },
        u128 { 0x40eff1e1853f29fdULL, 0xc5dd44271ad3cdbaULL },
        u128 { 0xd12bee59e68ef47cULL, 0xf7549530e188c128ULL },
        u128 { 0x82bb74f8301958ceULL, 0x9a94dd3e8cf578b9ULL },
        u128 { 0xe36a52363c1faf01ULL, 0xc13a148e3032d6e7ULL },
        u128 { 0xdc44e6c3cb279ac1ULL, 0xf18899b1bc3f8ca1ULL },
        u128 { 0x29ab103a5ef8c0b9ULL, 0x96f5600f15a7b7e5ULL },
        u128 { 0x7415d448f6b6f0e7ULL, 0xbcb2b812db11a5deULL },
        u128 { 0x111b495b3464ad21ULL, 0xebdf661791d60f56ULL },
        u128 { 0xcab10dd900beec34ULL, 0x936b9fcebb25c995ULL },
        u128 { 0x3d5d514f40eea742ULL, 0xb84687c269ef3bfbULL },
        u128 { 0xcb4a5a3112a5112ULL, 0xe65829b3046b0afaULL },
        u128 { 0x47f0e785eaba72abULL, 0x8ff71a0fe2c2e6dcULL },
        u128 { 0x59ed216765690f56ULL, 0xb3f4e093db73a093ULL },
        u128 { 0x306869c13ec3532cULL, 0xe0f218b8d25088b8ULL },
        u128 { 0x1e414218c73a13fbULL, 0x8c974f7383725573ULL },
        u128 { 0xe5d1929ef90898faULL, 0xafbd2350644eeacfULL },
        u128 { 0xdf45f746b74abf39ULL, 0xdbac6c247d62a583ULL },
        u128 { 0x6b8bba8c328eb783ULL, 0x894bc396ce5da772ULL },
        u128 { 0x66ea92f3f326564ULL, 0xab9eb47c81f5114fULL },
        u128 { 0xc80a537b0efefebdULL, 0xd686619ba27255a2ULL },
        u128 { 0xbd06742ce95f5f36ULL, 0x8613fd0145877585ULL },
        u128 { 0x2c48113823b73704ULL, 0xa798fc4196e952e7ULL },
        u128 { 0xf75a15862ca504c5ULL, 0xd17f3b51fca3a7a0ULL },
        u128 { 0x9a984d73dbe722fbULL, 0x82ef85133de648c4ULL },
        u128 { 0xc13e60d0d2e0ebbaULL, 0xa3ab66580d5fdaf5ULL },
        u128 { 0x318df905079926a8ULL, 0xcc963fee10b7d1b3ULL },
        u128 { 0xfdf17746497f7052ULL, 0xffbbcfe994e5c61fULL },
        u128 { 0xfeb6ea8bedefa633ULL, 0x9fd561f1fd0f9bd3ULL },
        u128 { 0xfe64a52ee96b8fc0ULL, 0xc7caba6e7c5382c8ULL },
        u128 { 0x3dfdce7aa3c673b0ULL, 0xf9bd690a1b68637bULL },
        u128 { 0x6bea10ca65c084eULL, 0x9c1661a651213e2dULL },
        u128 { 0x486e494fcff30a62ULL, 0xc31bfa0fe5698db8ULL },
        u128 { 0x5a89dba3c3efccfaULL, 0xf3e2f893dec3f126ULL },
        u128 { 0xf89629465a75e01cULL, 0x986ddb5c6b3a76b7ULL },
        u128 { 0xf6bbb397f1135823ULL, 0xbe89523386091465ULL },
        u128 { 0x746aa07ded582e2cULL, 0xee2ba6c0678b597fULL },
        u128 { 0xa8c2a44eb4571cdcULL, 0x94db483840b717efULL },
        u128 { 0x92f34d62616ce413ULL, 0xba121a4650e4ddebULL },
        u128 { 0x77b020baf9c81d17ULL, 0xe896a0d7e51e1566ULL },
        u128 { 0xace1474dc1d122eULL, 0x915e2486ef32cd60ULL },
        u128 { 0xd819992132456baULL, 0xb5b5ada8aaff80b8ULL },
        u128 { 0x10e1fff697ed6c69ULL, 0xe3231912d5bf60e6ULL },
        u128 { 0xca8d3ffa1ef463c1ULL, 0x8df5efabc5979c8fULL },
        u128 { 0xbd308ff8a6b17cb2ULL, 0xb1736b96b6fd83b3ULL },
        u128 { 0xac7cb3f6d05ddbdeULL, 0xddd0467c64bce4a0ULL },
        u128 { 0x6bcdf07a423aa96bULL, 0x8aa22c0dbef60ee4ULL },
        u128 { 0x86c16c98d2c953c6ULL, 0xad4ab7112eb3929dULL },
        u128 { 0xe871c7bf077ba8b7ULL, 0xd89d64d57a607744ULL },
        u128 { 0x11471cd764ad4972ULL, 0x87625f056c7c4a8bULL },
        u128 { 0xd598e40d3dd89bcfULL, 0xa93af6c6c79b5d2dULL },
        u128 { 0x4aff1d108d4ec2c3ULL, 0xd389b47879823479ULL },
        u128 { 0xcedf722a585139baULL, 0x843610cb4bf160cbULL },
        u128 { 0xc2974eb4ee658828ULL, 0xa54394fe1eedb8feULL },
        u128 { 0x733d226229feea32ULL, 0xce947a3da6a9273eULL },
        u128 { 0x806357d5a3f525fULL, 0x811ccc668829b887ULL },
        u128 { 0xca07c2dcb0cf26f7ULL, 0xa163ff802a3426a8ULL },
        u128 { 0xfc89b393dd02f0b5ULL, 0xc9bcff6034c13052ULL },
        u128 { 0xbbac2078d443ace2ULL, 0xfc2c3f3841f17c67ULL },
        u128 { 0xd54b944b84aa4c0dULL, 0x9d9ba7832936edc0ULL },
        u128 { 0xa9e795e65d4df11ULL, 0xc5029163f384a931ULL },
        u128 { 0x4d4617b5ff4a16d5ULL, 0xf64335bcf065d37dULL },
        u128 { 0x504bced1bf8e4e45ULL, 0x99ea0196163fa42eULL },
        u128 { 0xe45ec2862f71e1d6ULL, 0xc06481fb9bcf8d39ULL },
        u128 { 0x5d767327bb4e5a4cULL, 0xf07da27a82c37088ULL },
        u128 { 0x3a6a07f8d510f86fULL, 0x964e858c91ba2655ULL },
        u128 { 0x890489f70a55368bULL, 0xbbe226efb628afeaULL },
        u128 { 0x2b45ac74ccea842eULL, 0xeadab0aba3b2dbe5ULL },
        u128 { 0x3b0b8bc90012929dULL, 0x92c8ae6b464fc96fULL },
        u128 { 0x9ce6ebb40173744ULL, 0xb77ada0617e3bbcbULL },
        u128 { 0xcc420a6a101d0515ULL, 0xe55990879ddcaabdULL },
        u128 { 0x9fa946824a12232dULL, 0x8f57fa54c2a9eab6ULL },
        u128 { 0x47939822dc96abf9ULL, 0xb32df8e9f3546564ULL },
        u128 { 0x59787e2b93bc56f7ULL, 0xdff9772470297ebdULL },
        u128 { 0x57eb4edb3c55b65aULL, 0x8bfbea76c619ef36ULL },
        u128 { 0xede622920b6b23f1ULL, 0xaefae51477a06b03ULL },
        u128 { 0xe95fab368e45ecedULL, 0xdab99e59958885c4ULL },
        u128 { 0x11dbcb0218ebb414ULL, 0x88b402f7fd75539bULL },
        u128 { 0xd652bdc29f26a119ULL, 0xaae103b5fcd2a881ULL },
        u128 { 0x4be76d3346f0495fULL, 0xd59944a37c0752a2ULL },
        u128 { 0x6f70a4400c562ddbULL, 0x857fcae62d8493a5ULL },
        u128 { 0xcb4ccd500f6bb952ULL, 0xa6dfbd9fb8e5b88eULL },
        u128 { 0x7e2000a41346a7a7ULL, 0xd097ad07a71f26b2ULL },
        u128 { 0x8ed400668c0c28c8ULL, 0x825ecc24c873782fULL },
        u128 { 0x728900802f0f32faULL, 0xa2f67f2dfa90563bULL },
        u128 { 0x4f2b40a03ad2ffb9ULL, 0xcbb41ef979346bcaULL },
        u128 { 0xe2f610c84987bfa8ULL, 0xfea126b7d78186bcULL },
        u128 { 0xdd9ca7d2df4d7c9ULL, 0x9f24b832e6b0f436ULL },
        u128 { 0x91503d1c79720dbbULL, 0xc6ede63fa05d3143ULL },
        u128 { 0x75a44c6397ce912aULL, 0xf8a95fcf88747d94ULL },
        u128 { 0xc986afbe3ee11abaULL, 0x9b69dbe1b548ce7cULL },
        u128 { 0xfbe85badce996168ULL, 0xc24452da229b021bULL },
        u128 { 0xfae27299423fb9c3ULL, 0xf2d56790ab41c2a2ULL },
        u128 { 0xdccd879fc967d41aULL, 0x97c560ba6b0919a5ULL },
        u128 { 0x5400e987bbc1c920ULL, 0xbdb6b8e905cb600fULL },
        u128 { 0x290123e9aab23b68ULL, 0xed246723473e3813ULL },
        u128 { 0xf9a0b6720aaf6521ULL, 0x9436c0760c86e30bULL },
        u128 { 0xf808e40e8d5b3e69ULL, 0xb94470938fa89bceULL },
        u128 { 0xb60b1d1230b20e04ULL, 0xe7958cb87392c2c2ULL },
        u128 { 0xb1c6f22b5e6f48c2ULL, 0x90bd77f3483bb9b9ULL },
        u128 { 0x1e38aeb6360b1af3ULL, 0xb4ecd5f01a4aa828ULL },
        u128 { 0x25c6da63c38de1b0ULL, 0xe2280b6c20dd5232ULL },
        u128 { 0x579c487e5a38ad0eULL, 0x8d590723948a535fULL },
        u128 { 0x2d835a9df0c6d851ULL, 0xb0af48ec79ace837ULL },
        u128 { 0xf8e431456cf88e65ULL, 0xdcdb1b2798182244ULL },
        u128 { 0x1b8e9ecb641b58ffULL, 0x8a08f0f8bf0f156bULL },
        u128 { 0xe272467e3d222f3fULL, 0xac8b2d36eed2dac5ULL },
        u128 { 0x5b0ed81dcc6abb0fULL, 0xd7adf884aa879177ULL },
        u128 { 0x98e947129fc2b4e9ULL, 0x86ccbb52ea94baeaULL },
        u128 { 0x3f2398d747b36224ULL, 0xa87fea27a539e9a5ULL },
        u128 { 0x8eec7f0d19a03aadULL, 0xd29fe4b18e88640eULL },
        u128 { 0x1953cf68300424acULL, 0x83a3eeeef9153e89ULL },
        u128 { 0x5fa8c3423c052dd7ULL, 0xa48ceaaab75a8e2bULL },
        u128 { 0x3792f412cb06794dULL, 0xcdb02555653131b6ULL },
        u128 { 0xe2bbd88bbee40bd0ULL, 0x808e17555f3ebf11ULL },
        u128 { 0x5b6aceaeae9d0ec4ULL, 0xa0b19d2ab70e6ed6ULL },
        u128 { 0xf245825a5a445275ULL, 0xc8de047564d20a8bULL },
        u128 { 0xeed6e2f0f0d56712ULL, 0xfb158592be068d2eULL },
        u128 { 0x55464dd69685606bULL, 0x9ced737bb6c4183dULL },
        u128 { 0xaa97e14c3c26b886ULL, 0xc428d05aa4751e4cULL },
        u128 { 0xd53dd99f4b3066a8ULL, 0xf53304714d9265dfULL },
        u128 { 0xe546a8038efe4029ULL, 0x993fe2c6d07b7fabULL },
        u128 { 0xde98520472bdd033ULL, 0xbf8fdb78849a5f96ULL },
        u128 { 0x963e66858f6d4440ULL, 0xef73d256a5c0f77cULL },
        u128 { 0xdde7001379a44aa8ULL, 0x95a8637627989aadULL },
        u128 { 0x5560c018580d5d52ULL, 0xbb127c53b17ec159ULL },
        u128 { 0xaab8f01e6e10b4a6ULL, 0xe9d71b689dde71afULL },
        u128 { 0xcab3961304ca70e8ULL, 0x9226712162ab070dULL },
        u128 { 0x3d607b97c5fd0d22ULL, 0xb6b00d69bb55c8d1ULL },
        u128 { 0x8cb89a7db77c506aULL, 0xe45c10c42a2b3b05ULL },
        u128 { 0x77f3608e92adb242ULL, 0x8eb98a7a9a5b04e3ULL },
        u128 { 0x55f038b237591ed3ULL, 0xb267ed1940f1c61cULL },
        u128 { 0x6b6c46dec52f6688ULL, 0xdf01e85f912e37a3ULL },
        u128 { 0x2323ac4b3b3da015ULL, 0x8b61313bbabce2c6ULL },
        u128 { 0xabec975e0a0d081aULL, 0xae397d8aa96c1b77ULL },
        u128 { 0x96e7bd358c904a21ULL, 0xd9c7dced53c72255ULL },
        u128 { 0x7e50d64177da2e54ULL, 0x881cea14545c7575ULL },
        u128 { 0xdde50bd1d5d0b9e9ULL, 0xaa242499697392d2ULL },
        u128 { 0x955e4ec64b44e864ULL, 0xd4ad2dbfc3d07787ULL },
        u128 { 0xbd5af13bef0b113eULL, 0x84ec3c97da624ab4ULL },
        u128 { 0xecb1ad8aeacdd58eULL, 0xa6274bbdd0fadd61ULL },
        u128 { 0x67de18eda5814af2ULL, 0xcfb11ead453994baULL },
        u128 { 0x80eacf948770ced7ULL, 0x81ceb32c4b43fcf4ULL },
        u128 { 0xa1258379a94d028dULL, 0xa2425ff75e14fc31ULL },
        u128 { 0x96ee45813a04330ULL, 0xcad2f7f5359a3b3eULL },
        u128 { 0x8bca9d6e188853fcULL, 0xfd87b5f28300ca0dULL },
        u128 { 0x775ea264cf55347eULL, 0x9e74d1b791e07e48ULL },
        u128 { 0x95364afe032a819eULL, 0xc612062576589ddaULL },
        u128 { 0x3a83ddbd83f52205ULL, 0xf79687aed3eec551ULL },
        u128 { 0xc4926a9672793543ULL, 0x9abe14cd44753b52ULL },
        u128 { 0x75b7053c0f178294ULL, 0xc16d9a0095928a27ULL },
        u128 { 0x5324c68b12dd6339ULL, 0xf1c90080baf72cb1ULL },
        u128 { 0xd3f6fc16ebca5e04ULL, 0x971da05074da7beeULL },
        u128 { 0x88f4bb1ca6bcf585ULL, 0xbce5086492111aeaULL },
        u128 { 0x2b31e9e3d06c32e6ULL, 0xec1e4a7db69561a5ULL },
        u128 { 0x3aff322e62439fd0ULL, 0x9392ee8e921d5d07ULL },
        u128 { 0x9befeb9fad487c3ULL, 0xb877aa3236a4b449ULL },
        u128 { 0x4c2ebe687989a9b4ULL, 0xe69594bec44de15bULL },
        u128 { 0xf9d37014bf60a11ULL, 0x901d7cf73ab0acd9ULL },
        u128 { 0x538484c19ef38c95ULL, 0xb424dc35095cd80fULL },
        u128 { 0x2865a5f206b06fbaULL, 0xe12e13424bb40e13ULL },
        u128 { 0xf93f87b7442e45d4ULL, 0x8cbccc096f5088cbULL },
        u128 { 0xf78f69a51539d749ULL, 0xafebff0bcb24aafeULL },
        u128 { 0xb573440e5a884d1cULL, 0xdbe6fecebdedd5beULL },
        u128 { 0x31680a88f8953031ULL, 0x89705f4136b4a597ULL },
        u128 { 0xfdc20d2b36ba7c3eULL, 0xabcc77118461cefcULL },
        u128 { 0x3d32907604691b4dULL, 0xd6bf94d5e57a42bcULL },
        u128 { 0xa63f9a49c2c1b110ULL, 0x8637bd05af6c69b5ULL },
        u128 { 0xfcf80dc33721d54ULL, 0xa7c5ac471b478423ULL },
        u128 { 0xd3c36113404ea4a9ULL, 0xd1b71758e219652bULL },
        u128 { 0x645a1cac083126eaULL, 0x83126e978d4fdf3bULL },
        u128 { 0x3d70a3d70a3d70a4ULL, 0xa3d70a3d70a3d70aULL },
        u128 { 0xcccccccccccccccdULL, 0xccccccccccccccccULL },
        compute_power_of_five(0),
        u128 { 0x0ULL, 0xa000000000000000ULL },
        u128 { 0x0ULL, 0xc800000000000000ULL },
        u128 { 0x0ULL, 0xfa00000000000000ULL },
        u128 { 0x0ULL, 0x9c40000000000000ULL },
        u128 { 0x0ULL, 0xc350000000000000ULL },
        u128 { 0x0ULL, 0xf424000000000000ULL },
        u128 { 0x0ULL, 0x9896800000000000ULL },
        u128 { 0x0ULL, 0xbebc200000000000ULL },
        u128 { 0x0ULL, 0xee6b280000000000ULL },
        u128 { 0x0ULL, 0x9502f90000000000ULL },
        u128 { 0x0ULL, 0xba43b74000000000ULL },
        u128 { 0x0ULL, 0xe8d4a51000000000ULL },
        u128 { 0x0ULL, 0x9184e72a00000000ULL },
        u128 { 0x0ULL, 0xb5e620f480000000ULL },
        u128 { 0x0ULL, 0xe35fa931a0000000ULL },
        u128 { 0x0ULL, 0x8e1bc9bf04000000ULL },
        u128 { 0x0ULL, 0xb1a2bc2ec5000000ULL },
        u128 { 0x0ULL, 0xde0b6b3a76400000ULL },
        u128 { 0x0ULL, 0x8ac7230489e80000ULL },
        u128 { 0x0ULL, 0xad78ebc5ac620000ULL },
        u128 { 0x0ULL, 0xd8d726b7177a8000ULL },
        u128 { 0x0ULL, 0x878678326eac9000ULL },
        u128 { 0x0ULL, 0xa968163f0a57b400ULL },
        u128 { 0x0ULL, 0xd3c21bcecceda100ULL },
        u128 { 0x0ULL, 0x84595161401484a0ULL },
        u128 { 0x0ULL, 0xa56fa5b99019a5c8ULL },
        u128 { 0x0ULL, 0xcecb8f27f4200f3aULL },
        u128 { 0x4000000000000000ULL, 0x813f3978f8940984ULL },
        u128 { 0x5000000000000000ULL, 0xa18f07d736b90be5ULL },
        u128 { 0xa400000000000000ULL, 0xc9f2c9cd04674edeULL },
        u128 { 0x4d00000000000000ULL, 0xfc6f7c4045812296ULL },
        u128 { 0xf020000000000000ULL, 0x9dc5ada82b70b59dULL },
        u128 { 0x6c28000000000000ULL, 0xc5371912364ce305ULL },
        u128 { 0xc732000000000000ULL, 0xf684df56c3e01bc6ULL },
        u128 { 0x3c7f400000000000ULL, 0x9a130b963a6c115cULL },
        u128 { 0x4b9f100000000000ULL, 0xc097ce7bc90715b3ULL },
        u128 { 0x1e86d40000000000ULL, 0xf0bdc21abb48db20ULL },
        u128 { 0x1314448000000000ULL, 0x96769950b50d88f4ULL },
        u128 { 0x17d955a000000000ULL, 0xbc143fa4e250eb31ULL },
        u128 { 0x5dcfab0800000000ULL, 0xeb194f8e1ae525fdULL },
        u128 { 0x5aa1cae500000000ULL, 0x92efd1b8d0cf37beULL },
        u128 { 0xf14a3d9e40000000ULL, 0xb7abc627050305adULL },
        u128 { 0x6d9ccd05d0000000ULL, 0xe596b7b0c643c719ULL },
        u128 { 0xe4820023a2000000ULL, 0x8f7e32ce7bea5c6fULL },
        u128 { 0xdda2802c8a800000ULL, 0xb35dbf821ae4f38bULL },
        u128 { 0xd50b2037ad200000ULL, 0xe0352f62a19e306eULL },
        u128 { 0x4526f422cc340000ULL, 0x8c213d9da502de45ULL },
        u128 { 0x9670b12b7f410000ULL, 0xaf298d050e4395d6ULL },
        u128 { 0x3c0cdd765f114000ULL, 0xdaf3f04651d47b4cULL },
        u128 { 0xa5880a69fb6ac800ULL, 0x88d8762bf324cd0fULL },
        u128 { 0x8eea0d047a457a00ULL, 0xab0e93b6efee0053ULL },
        u128 { 0x72a4904598d6d880ULL, 0xd5d238a4abe98068ULL },
        u128 { 0x47a6da2b7f864750ULL, 0x85a36366eb71f041ULL },
        u128 { 0x999090b65f67d924ULL, 0xa70c3c40a64e6c51ULL },
        u128 { 0xfff4b4e3f741cf6dULL, 0xd0cf4b50cfe20765ULL },
        u128 { 0xbff8f10e7a8921a4ULL, 0x82818f1281ed449fULL },
        u128 { 0xaff72d52192b6a0dULL, 0xa321f2d7226895c7ULL },
        u128 { 0x9bf4f8a69f764490ULL, 0xcbea6f8ceb02bb39ULL },
        u128 { 0x2f236d04753d5b4ULL, 0xfee50b7025c36a08ULL },
        u128 { 0x1d762422c946590ULL, 0x9f4f2726179a2245ULL },
        u128 { 0x424d3ad2b7b97ef5ULL, 0xc722f0ef9d80aad6ULL },
        u128 { 0xd2e0898765a7deb2ULL, 0xf8ebad2b84e0d58bULL },
        u128 { 0x63cc55f49f88eb2fULL, 0x9b934c3b330c8577ULL },
        u128 { 0x3cbf6b71c76b25fbULL, 0xc2781f49ffcfa6d5ULL },
        u128 { 0x8bef464e3945ef7aULL, 0xf316271c7fc3908aULL },
        u128 { 0x97758bf0e3cbb5acULL, 0x97edd871cfda3a56ULL },
        u128 { 0x3d52eeed1cbea317ULL, 0xbde94e8e43d0c8ecULL },
        u128 { 0x4ca7aaa863ee4bddULL, 0xed63a231d4c4fb27ULL },
        u128 { 0x8fe8caa93e74ef6aULL, 0x945e455f24fb1cf8ULL },
        u128 { 0xb3e2fd538e122b44ULL, 0xb975d6b6ee39e436ULL },
        u128 { 0x60dbbca87196b616ULL, 0xe7d34c64a9c85d44ULL },
        u128 { 0xbc8955e946fe31cdULL, 0x90e40fbeea1d3a4aULL },
        u128 { 0x6babab6398bdbe41ULL, 0xb51d13aea4a488ddULL },
        u128 { 0xc696963c7eed2dd1ULL, 0xe264589a4dcdab14ULL },
        u128 { 0xfc1e1de5cf543ca2ULL, 0x8d7eb76070a08aecULL },
        u128 { 0x3b25a55f43294bcbULL, 0xb0de65388cc8ada8ULL },
        u128 { 0x49ef0eb713f39ebeULL, 0xdd15fe86affad912ULL },
        u128 { 0x6e3569326c784337ULL, 0x8a2dbf142dfcc7abULL },
        u128 { 0x49c2c37f07965404ULL, 0xacb92ed9397bf996ULL },
        u128 { 0xdc33745ec97be906ULL, 0xd7e77a8f87daf7fbULL },
        u128 { 0x69a028bb3ded71a3ULL, 0x86f0ac99b4e8dafdULL },
        u128 { 0xc40832ea0d68ce0cULL, 0xa8acd7c0222311bcULL },
        u128 { 0xf50a3fa490c30190ULL, 0xd2d80db02aabd62bULL },
        u128 { 0x792667c6da79e0faULL, 0x83c7088e1aab65dbULL },
        u128 { 0x577001b891185938ULL, 0xa4b8cab1a1563f52ULL },
        u128 { 0xed4c0226b55e6f86ULL, 0xcde6fd5e09abcf26ULL },
        u128 { 0x544f8158315b05b4ULL, 0x80b05e5ac60b6178ULL },
        u128 { 0x696361ae3db1c721ULL, 0xa0dc75f1778e39d6ULL },
        u128 { 0x3bc3a19cd1e38e9ULL, 0xc913936dd571c84cULL },
        u128 { 0x4ab48a04065c723ULL, 0xfb5878494ace3a5fULL },
        u128 { 0x62eb0d64283f9c76ULL, 0x9d174b2dcec0e47bULL },
        u128 { 0x3ba5d0bd324f8394ULL, 0xc45d1df942711d9aULL },
        u128 { 0xca8f44ec7ee36479ULL, 0xf5746577930d6500ULL },
        u128 { 0x7e998b13cf4e1ecbULL, 0x9968bf6abbe85f20ULL },
        u128 { 0x9e3fedd8c321a67eULL, 0xbfc2ef456ae276e8ULL },
        u128 { 0xc5cfe94ef3ea101eULL, 0xefb3ab16c59b14a2ULL },
        u128 { 0xbba1f1d158724a12ULL, 0x95d04aee3b80ece5ULL },
        u128 { 0x2a8a6e45ae8edc97ULL, 0xbb445da9ca61281fULL },
        u128 { 0xf52d09d71a3293bdULL, 0xea1575143cf97226ULL },
        u128 { 0x593c2626705f9c56ULL, 0x924d692ca61be758ULL },
        u128 { 0x6f8b2fb00c77836cULL, 0xb6e0c377cfa2e12eULL },
        u128 { 0xb6dfb9c0f956447ULL, 0xe498f455c38b997aULL },
        u128 { 0x4724bd4189bd5eacULL, 0x8edf98b59a373fecULL },
        u128 { 0x58edec91ec2cb657ULL, 0xb2977ee300c50fe7ULL },
        u128 { 0x2f2967b66737e3edULL, 0xdf3d5e9bc0f653e1ULL },
        u128 { 0xbd79e0d20082ee74ULL, 0x8b865b215899f46cULL },
        u128 { 0xecd8590680a3aa11ULL, 0xae67f1e9aec07187ULL },
        u128 { 0xe80e6f4820cc9495ULL, 0xda01ee641a708de9ULL },
        u128 { 0x3109058d147fdcddULL, 0x884134fe908658b2ULL },
        u128 { 0xbd4b46f0599fd415ULL, 0xaa51823e34a7eedeULL },
        u128 { 0x6c9e18ac7007c91aULL, 0xd4e5e2cdc1d1ea96ULL },
        u128 { 0x3e2cf6bc604ddb0ULL, 0x850fadc09923329eULL },
        u128 { 0x84db8346b786151cULL, 0xa6539930bf6bff45ULL },
        u128 { 0xe612641865679a63ULL, 0xcfe87f7cef46ff16ULL },
        u128 { 0x4fcb7e8f3f60c07eULL, 0x81f14fae158c5f6eULL },
        u128 { 0xe3be5e330f38f09dULL, 0xa26da3999aef7749ULL },
        u128 { 0x5cadf5bfd3072cc5ULL, 0xcb090c8001ab551cULL },
        u128 { 0x73d9732fc7c8f7f6ULL, 0xfdcb4fa002162a63ULL },
        u128 { 0x2867e7fddcdd9afaULL, 0x9e9f11c4014dda7eULL },
        u128 { 0xb281e1fd541501b8ULL, 0xc646d63501a1511dULL },
        u128 { 0x1f225a7ca91a4226ULL, 0xf7d88bc24209a565ULL },
        u128 { 0x3375788de9b06958ULL, 0x9ae757596946075fULL },
        u128 { 0x52d6b1641c83aeULL, 0xc1a12d2fc3978937ULL },
        u128 { 0xc0678c5dbd23a49aULL, 0xf209787bb47d6b84ULL },
        u128 { 0xf840b7ba963646e0ULL, 0x9745eb4d50ce6332ULL },
        u128 { 0xb650e5a93bc3d898ULL, 0xbd176620a501fbffULL },
        u128 { 0xa3e51f138ab4cebeULL, 0xec5d3fa8ce427affULL },
        u128 { 0xc66f336c36b10137ULL, 0x93ba47c980e98cdfULL },
        u128 { 0xb80b0047445d4184ULL, 0xb8a8d9bbe123f017ULL },
        u128 { 0xa60dc059157491e5ULL, 0xe6d3102ad96cec1dULL },
        u128 { 0x87c89837ad68db2fULL, 0x9043ea1ac7e41392ULL },
        u128 { 0x29babe4598c311fbULL, 0xb454e4a179dd1877ULL },
        u128 { 0xf4296dd6fef3d67aULL, 0xe16a1dc9d8545e94ULL },
        u128 { 0x1899e4a65f58660cULL, 0x8ce2529e2734bb1dULL },
        u128 { 0x5ec05dcff72e7f8fULL, 0xb01ae745b101e9e4ULL },
        u128 { 0x76707543f4fa1f73ULL, 0xdc21a1171d42645dULL },
        u128 { 0x6a06494a791c53a8ULL, 0x899504ae72497ebaULL },
        u128 { 0x487db9d17636892ULL, 0xabfa45da0edbde69ULL },
        u128 { 0x45a9d2845d3c42b6ULL, 0xd6f8d7509292d603ULL },
        u128 { 0xb8a2392ba45a9b2ULL, 0x865b86925b9bc5c2ULL },
        u128 { 0x8e6cac7768d7141eULL, 0xa7f26836f282b732ULL },
        u128 { 0x3207d795430cd926ULL, 0xd1ef0244af2364ffULL },
        u128 { 0x7f44e6bd49e807b8ULL, 0x8335616aed761f1fULL },
        u128 { 0x5f16206c9c6209a6ULL, 0xa402b9c5a8d3a6e7ULL },
        u128 { 0x36dba887c37a8c0fULL, 0xcd036837130890a1ULL },
        u128 { 0xc2494954da2c9789ULL, 0x802221226be55a64ULL },
        u128 { 0xf2db9baa10b7bd6cULL, 0xa02aa96b06deb0fdULL },
        u128 { 0x6f92829494e5acc7ULL, 0xc83553c5c8965d3dULL },
        u128 { 0xcb772339ba1f17f9ULL, 0xfa42a8b73abbf48cULL },
        u128 { 0xff2a760414536efbULL, 0x9c69a97284b578d7ULL },
        u128 { 0xfef5138519684abaULL, 0xc38413cf25e2d70dULL },
        u128 { 0x7eb258665fc25d69ULL, 0xf46518c2ef5b8cd1ULL },
        u128 { 0xef2f773ffbd97a61ULL, 0x98bf2f79d5993802ULL },
        u128 { 0xaafb550ffacfd8faULL, 0xbeeefb584aff8603ULL },
        u128 { 0x95ba2a53f983cf38ULL, 0xeeaaba2e5dbf6784ULL },
        u128 { 0xdd945a747bf26183ULL, 0x952ab45cfa97a0b2ULL },
        u128 { 0x94f971119aeef9e4ULL, 0xba756174393d88dfULL },
        u128 { 0x7a37cd5601aab85dULL, 0xe912b9d1478ceb17ULL },
        u128 { 0xac62e055c10ab33aULL, 0x91abb422ccb812eeULL },
        u128 { 0x577b986b314d6009ULL, 0xb616a12b7fe617aaULL },
        u128 { 0xed5a7e85fda0b80bULL, 0xe39c49765fdf9d94ULL },
        u128 { 0x14588f13be847307ULL, 0x8e41ade9fbebc27dULL },
        u128 { 0x596eb2d8ae258fc8ULL, 0xb1d219647ae6b31cULL },
        u128 { 0x6fca5f8ed9aef3bbULL, 0xde469fbd99a05fe3ULL },
        u128 { 0x25de7bb9480d5854ULL, 0x8aec23d680043beeULL },
        u128 { 0xaf561aa79a10ae6aULL, 0xada72ccc20054ae9ULL },
        u128 { 0x1b2ba1518094da04ULL, 0xd910f7ff28069da4ULL },
        u128 { 0x90fb44d2f05d0842ULL, 0x87aa9aff79042286ULL },
        u128 { 0x353a1607ac744a53ULL, 0xa99541bf57452b28ULL },
        u128 { 0x42889b8997915ce8ULL, 0xd3fa922f2d1675f2ULL },
        u128 { 0x69956135febada11ULL, 0x847c9b5d7c2e09b7ULL },
        u128 { 0x43fab9837e699095ULL, 0xa59bc234db398c25ULL },
        u128 { 0x94f967e45e03f4bbULL, 0xcf02b2c21207ef2eULL },
        u128 { 0x1d1be0eebac278f5ULL, 0x8161afb94b44f57dULL },
        u128 { 0x6462d92a69731732ULL, 0xa1ba1ba79e1632dcULL },
        u128 { 0x7d7b8f7503cfdcfeULL, 0xca28a291859bbf93ULL },
        u128 { 0x5cda735244c3d43eULL, 0xfcb2cb35e702af78ULL },
        u128 { 0x3a0888136afa64a7ULL, 0x9defbf01b061adabULL },
        u128 { 0x88aaa1845b8fdd0ULL, 0xc56baec21c7a1916ULL },
        u128 { 0x8aad549e57273d45ULL, 0xf6c69a72a3989f5bULL },
        u128 { 0x36ac54e2f678864bULL, 0x9a3c2087a63f6399ULL },
        u128 { 0x84576a1bb416a7ddULL, 0xc0cb28a98fcf3c7fULL },
        u128 { 0x656d44a2a11c51d5ULL, 0xf0fdf2d3f3c30b9fULL },
        u128 { 0x9f644ae5a4b1b325ULL, 0x969eb7c47859e743ULL },
        u128 { 0x873d5d9f0dde1feeULL, 0xbc4665b596706114ULL },
        u128 { 0xa90cb506d155a7eaULL, 0xeb57ff22fc0c7959ULL },
        u128 { 0x9a7f12442d588f2ULL, 0x9316ff75dd87cbd8ULL },
        u128 { 0xc11ed6d538aeb2fULL, 0xb7dcbf5354e9beceULL },
        u128 { 0x8f1668c8a86da5faULL, 0xe5d3ef282a242e81ULL },
        u128 { 0xf96e017d694487bcULL, 0x8fa475791a569d10ULL },
        u128 { 0x37c981dcc395a9acULL, 0xb38d92d760ec4455ULL },
        u128 { 0x85bbe253f47b1417ULL, 0xe070f78d3927556aULL },
        u128 { 0x93956d7478ccec8eULL, 0x8c469ab843b89562ULL },
        u128 { 0x387ac8d1970027b2ULL, 0xaf58416654a6babbULL },
        u128 { 0x6997b05fcc0319eULL, 0xdb2e51bfe9d0696aULL },
        u128 { 0x441fece3bdf81f03ULL, 0x88fcf317f22241e2ULL },
        u128 { 0xd527e81cad7626c3ULL, 0xab3c2fddeeaad25aULL },
        u128 { 0x8a71e223d8d3b074ULL, 0xd60b3bd56a5586f1ULL },
        u128 { 0xf6872d5667844e49ULL, 0x85c7056562757456ULL },
        u128 { 0xb428f8ac016561dbULL, 0xa738c6bebb12d16cULL },
        u128 { 0xe13336d701beba52ULL, 0xd106f86e69d785c7ULL },
        u128 { 0xecc0024661173473ULL, 0x82a45b450226b39cULL },
        u128 { 0x27f002d7f95d0190ULL, 0xa34d721642b06084ULL },
        u128 { 0x31ec038df7b441f4ULL, 0xcc20ce9bd35c78a5ULL },
        u128 { 0x7e67047175a15271ULL, 0xff290242c83396ceULL },
        u128 { 0xf0062c6e984d386ULL, 0x9f79a169bd203e41ULL },
        u128 { 0x52c07b78a3e60868ULL, 0xc75809c42c684dd1ULL },
        u128 { 0xa7709a56ccdf8a82ULL, 0xf92e0c3537826145ULL },
        u128 { 0x88a66076400bb691ULL, 0x9bbcc7a142b17ccbULL },
        u128 { 0x6acff893d00ea435ULL, 0xc2abf989935ddbfeULL },
        u128 { 0x583f6b8c4124d43ULL, 0xf356f7ebf83552feULL },
        u128 { 0xc3727a337a8b704aULL, 0x98165af37b2153deULL },
        u128 { 0x744f18c0592e4c5cULL, 0xbe1bf1b059e9a8d6ULL },
        u128 { 0x1162def06f79df73ULL, 0xeda2ee1c7064130cULL },
        u128 { 0x8addcb5645ac2ba8ULL, 0x9485d4d1c63e8be7ULL },
        u128 { 0x6d953e2bd7173692ULL, 0xb9a74a0637ce2ee1ULL },
        u128 { 0xc8fa8db6ccdd0437ULL, 0xe8111c87c5c1ba99ULL },
        u128 { 0x1d9c9892400a22a2ULL, 0x910ab1d4db9914a0ULL },
        u128 { 0x2503beb6d00cab4bULL, 0xb54d5e4a127f59c8ULL },
        u128 { 0x2e44ae64840fd61dULL, 0xe2a0b5dc971f303aULL },
        u128 { 0x5ceaecfed289e5d2ULL, 0x8da471a9de737e24ULL },
        u128 { 0x7425a83e872c5f47ULL, 0xb10d8e1456105dadULL },
        u128 { 0xd12f124e28f77719ULL, 0xdd50f1996b947518ULL },
        u128 { 0x82bd6b70d99aaa6fULL, 0x8a5296ffe33cc92fULL },
        u128 { 0x636cc64d1001550bULL, 0xace73cbfdc0bfb7bULL },
        u128 { 0x3c47f7e05401aa4eULL, 0xd8210befd30efa5aULL },
        u128 { 0x65acfaec34810a71ULL, 0x8714a775e3e95c78ULL },
        u128 { 0x7f1839a741a14d0dULL, 0xa8d9d1535ce3b396ULL },
        u128 { 0x1ede48111209a050ULL, 0xd31045a8341ca07cULL },
        u128 { 0x934aed0aab460432ULL, 0x83ea2b892091e44dULL },
        u128 { 0xf81da84d5617853fULL, 0xa4e4b66b68b65d60ULL },
        u128 { 0x36251260ab9d668eULL, 0xce1de40642e3f4b9ULL },
        u128 { 0xc1d72b7c6b426019ULL, 0x80d2ae83e9ce78f3ULL },
        u128 { 0xb24cf65b8612f81fULL, 0xa1075a24e4421730ULL },
        u128 { 0xdee033f26797b627ULL, 0xc94930ae1d529cfcULL },
        u128 { 0x169840ef017da3b1ULL, 0xfb9b7cd9a4a7443cULL },
        u128 { 0x8e1f289560ee864eULL, 0x9d412e0806e88aa5ULL },
        u128 { 0xf1a6f2bab92a27e2ULL, 0xc491798a08a2ad4eULL },
        u128 { 0xae10af696774b1dbULL, 0xf5b5d7ec8acb58a2ULL },
        u128 { 0xacca6da1e0a8ef29ULL, 0x9991a6f3d6bf1765ULL },
        u128 { 0x17fd090a58d32af3ULL, 0xbff610b0cc6edd3fULL },
        u128 { 0xddfc4b4cef07f5b0ULL, 0xeff394dcff8a948eULL },
        u128 { 0x4abdaf101564f98eULL, 0x95f83d0a1fb69cd9ULL },
        u128 { 0x9d6d1ad41abe37f1ULL, 0xbb764c4ca7a4440fULL },
        u128 { 0x84c86189216dc5edULL, 0xea53df5fd18d5513ULL },
        u128 { 0x32fd3cf5b4e49bb4ULL, 0x92746b9be2f8552cULL },
        u128 { 0x3fbc8c33221dc2a1ULL, 0xb7118682dbb66a77ULL },
        u128 { 0xfabaf3feaa5334aULL, 0xe4d5e82392a40515ULL },
        u128 { 0x29cb4d87f2a7400eULL, 0x8f05b1163ba6832dULL },
        u128 { 0x743e20e9ef511012ULL, 0xb2c71d5bca9023f8ULL },
        u128 { 0x914da9246b255416ULL, 0xdf78e4b2bd342cf6ULL },
        u128 { 0x1ad089b6c2f7548eULL, 0x8bab8eefb6409c1aULL },
        u128 { 0xa184ac2473b529b1ULL, 0xae9672aba3d0c320ULL },
        u128 { 0xc9e5d72d90a2741eULL, 0xda3c0f568cc4f3e8ULL },
        u128 { 0x7e2fa67c7a658892ULL, 0x8865899617fb1871ULL },
        u128 { 0xddbb901b98feeab7ULL, 0xaa7eebfb9df9de8dULL },
        u128 { 0x552a74227f3ea565ULL, 0xd51ea6fa85785631ULL },
        u128 { 0xd53a88958f87275fULL, 0x8533285c936b35deULL },
        u128 { 0x8a892abaf368f137ULL, 0xa67ff273b8460356ULL },
        u128 { 0x2d2b7569b0432d85ULL, 0xd01fef10a657842cULL },
        u128 { 0x9c3b29620e29fc73ULL, 0x8213f56a67f6b29bULL },
        u128 { 0x8349f3ba91b47b8fULL, 0xa298f2c501f45f42ULL },
        u128 { 0x241c70a936219a73ULL, 0xcb3f2f7642717713ULL },
        u128 { 0xed238cd383aa0110ULL, 0xfe0efb53d30dd4d7ULL },
        u128 { 0xf4363804324a40aaULL, 0x9ec95d1463e8a506ULL },
        u128 { 0xb143c6053edcd0d5ULL, 0xc67bb4597ce2ce48ULL },
        u128 { 0xdd94b7868e94050aULL, 0xf81aa16fdc1b81daULL },
        u128 { 0xca7cf2b4191c8326ULL, 0x9b10a4e5e9913128ULL },
        u128 { 0xfd1c2f611f63a3f0ULL, 0xc1d4ce1f63f57d72ULL },
        u128 { 0xbc633b39673c8cecULL, 0xf24a01a73cf2dccfULL },
        u128 { 0xd5be0503e085d813ULL, 0x976e41088617ca01ULL },
        u128 { 0x4b2d8644d8a74e18ULL, 0xbd49d14aa79dbc82ULL },
        u128 { 0xddf8e7d60ed1219eULL, 0xec9c459d51852ba2ULL },
        u128 { 0xcabb90e5c942b503ULL, 0x93e1ab8252f33b45ULL },
        u128 { 0x3d6a751f3b936243ULL, 0xb8da1662e7b00a17ULL },
        u128 { 0xcc512670a783ad4ULL, 0xe7109bfba19c0c9dULL },
        u128 { 0x27fb2b80668b24c5ULL, 0x906a617d450187e2ULL },
        u128 { 0xb1f9f660802dedf6ULL, 0xb484f9dc9641e9daULL },
        u128 { 0x5e7873f8a0396973ULL, 0xe1a63853bbd26451ULL },
        u128 { 0xdb0b487b6423e1e8ULL, 0x8d07e33455637eb2ULL },
        u128 { 0x91ce1a9a3d2cda62ULL, 0xb049dc016abc5e5fULL },
        u128 { 0x7641a140cc7810fbULL, 0xdc5c5301c56b75f7ULL },
        u128 { 0xa9e904c87fcb0a9dULL, 0x89b9b3e11b6329baULL },
        u128 { 0x546345fa9fbdcd44ULL, 0xac2820d9623bf429ULL },
        u128 { 0xa97c177947ad4095ULL, 0xd732290fbacaf133ULL },
        u128 { 0x49ed8eabcccc485dULL, 0x867f59a9d4bed6c0ULL },
        u128 { 0x5c68f256bfff5a74ULL, 0xa81f301449ee8c70ULL },
        u128 { 0x73832eec6fff3111ULL, 0xd226fc195c6a2f8cULL },
        u128 { 0xc831fd53c5ff7eabULL, 0x83585d8fd9c25db7ULL },
        u128 { 0xba3e7ca8b77f5e55ULL, 0xa42e74f3d032f525ULL },
        u128 { 0x28ce1bd2e55f35ebULL, 0xcd3a1230c43fb26fULL },
        u128 { 0x7980d163cf5b81b3ULL, 0x80444b5e7aa7cf85ULL },
        u128 { 0xd7e105bcc332621fULL, 0xa0555e361951c366ULL },
        u128 { 0x8dd9472bf3fefaa7ULL, 0xc86ab5c39fa63440ULL },
        u128 { 0xb14f98f6f0feb951ULL, 0xfa856334878fc150ULL },
        u128 { 0x6ed1bf9a569f33d3ULL, 0x9c935e00d4b9d8d2ULL },
        u128 { 0xa862f80ec4700c8ULL, 0xc3b8358109e84f07ULL },
        u128 { 0xcd27bb612758c0faULL, 0xf4a642e14c6262c8ULL },
        u128 { 0x8038d51cb897789cULL, 0x98e7e9cccfbd7dbdULL },
        u128 { 0xe0470a63e6bd56c3ULL, 0xbf21e44003acdd2cULL },
        u128 { 0x1858ccfce06cac74ULL, 0xeeea5d5004981478ULL },
        u128 { 0xf37801e0c43ebc8ULL, 0x95527a5202df0ccbULL },
        u128 { 0xd30560258f54e6baULL, 0xbaa718e68396cffdULL },
        u128 { 0x47c6b82ef32a2069ULL, 0xe950df20247c83fdULL },
        u128 { 0x4cdc331d57fa5441ULL, 0x91d28b7416cdd27eULL },
        u128 { 0xe0133fe4adf8e952ULL, 0xb6472e511c81471dULL },
        u128 { 0x58180fddd97723a6ULL, 0xe3d8f9e563a198e5ULL },
        u128 { 0x570f09eaa7ea7648ULL, 0x8e679c2f5e44ff8fULL },
    };
    return values;
}

static constexpr auto pre_computed_powers_of_five = pre_compute_table();

static constexpr u128 power_of_five(i64 exponent)
{
    return pre_computed_powers_of_five[exponent - lowest_exponent];
}

struct FloatingPointBuilder {
    u64 mantissa = 0;
    // This exponent is power of 2 and with the bias already added.
    i32 exponent = 0;

    static constexpr i32 invalid_exponent_offset = 32768;

    static FloatingPointBuilder zero()
    {
        return { 0, 0 };
    }

    template<typename T>
    static FloatingPointBuilder infinity()
    {
        return { 0, FloatingPointInfo<T>::infinity_exponent() };
    }

    template<typename T>
    static FloatingPointBuilder nan()
    {
        return { 1ull << (FloatingPointInfo<T>::mantissa_bits() - 1), FloatingPointInfo<T>::infinity_exponent() };
    }

    template<typename T>
    static FloatingPointBuilder from_value(T value)
    {
        using BitDetails = FloatingPointInfo<T>;
        auto bits = bit_cast<typename BitDetails::SameSizeUnsigned>(value);
        // we ignore negative

        FloatingPointBuilder result;
        i32 bias = BitDetails::mantissa_bits() + BitDetails::exponent_bias();
        if ((bits & BitDetails::exponent_mask()) == 0) {
            // 0 exponent -> denormal (or zero)
            result.exponent = 1 - bias;
            // Denormal so _DON'T_ add the implicit 1
            result.mantissa = bits & BitDetails::mantissa_mask();
        } else {
            result.exponent = (bits & BitDetails::exponent_mask()) >> BitDetails::mantissa_bits();
            result.exponent -= bias;
            result.mantissa = (bits & BitDetails::mantissa_mask()) | (1ull << BitDetails::mantissa_bits());
        }

        return result;
    }

    template<typename T>
    T to_value(bool is_negative) const
    {
        if constexpr (IsSame<double, T>) {
            VERIFY((mantissa & 0xffe0'0000'0000'0000) == 0);
            VERIFY((mantissa & 0xfff0'0000'0000'0000) == 0 || exponent == 1);
            VERIFY((exponent & ~(0x7ff)) == 0);
        } else {
            static_assert(IsSame<float, T>);
            VERIFY((mantissa & 0xff00'0000) == 0);
            VERIFY((mantissa & 0xff80'0000) == 0 || exponent == 1);
            VERIFY((exponent & ~(0xff)) == 0);
        }

        using BitSizedUnsigened = BitSizedUnsignedForFloatingPoint<T>;

        BitSizedUnsigened raw_bits = mantissa;
        raw_bits |= BitSizedUnsigened(exponent) << FloatingPointInfo<T>::mantissa_bits();
        raw_bits |= BitSizedUnsigened(is_negative) << FloatingPointInfo<T>::sign_bit_index();
        return bit_cast<T>(raw_bits);
    }
};

template<typename T>
static FloatingPointBuilder parse_arbitrarily_long_floating_point(BasicParseResult& result, FloatingPointBuilder initial);

static i32 decimal_exponent_to_binary_exponent(i32 exponent)
{
    return ((((152170 + 65536) * exponent) >> 16) + 63);
}

static u128 multiply(u64 a, u64 b)
{
    return UFixedBigInt<64>(a).wide_multiply(b);
}

template<unsigned Precision>
u128 multiplication_approximation(u64 value, i32 exponent)
{
    auto z = power_of_five(exponent);

    static_assert(Precision < 64);
    constexpr u64 mask = NumericLimits<u64>::max() >> Precision;

    auto lower_result = multiply(z.high(), value);

    if ((lower_result.high() & mask) == mask) {
        auto upper_result = multiply(z.low(), value);
        lower_result += upper_result.high();
    }

    return lower_result;
}

template<typename T>
static FloatingPointBuilder not_enough_precision_binary_to_decimal(i64 exponent, u64 mantissa, int leading_zeros)
{
    using FloatingPointRepr = FloatingPointInfo<T>;
    i32 did_not_have_upper_bit = static_cast<i32>(mantissa >> 63) ^ 1;
    FloatingPointBuilder answer;
    answer.mantissa = mantissa << did_not_have_upper_bit;

    i32 bias = FloatingPointRepr::mantissa_bits() + FloatingPointRepr::exponent_bias();
    answer.exponent = decimal_exponent_to_binary_exponent(static_cast<i32>(exponent)) - leading_zeros - did_not_have_upper_bit - 62 + bias;
    // Make it negative to show we need more precision.
    answer.exponent -= FloatingPointBuilder::invalid_exponent_offset;
    VERIFY(answer.exponent < 0);
    return answer;
}

template<typename T>
static FloatingPointBuilder fallback_binary_to_decimal(u64 mantissa, i64 exponent)
{
    // We should have caught huge exponents already
    VERIFY(exponent >= -400 && exponent <= 400);

    // Perform the initial steps of binary_to_decimal.
    auto w = mantissa;
    auto leading_zeros = count_leading_zeroes(mantissa);
    w <<= leading_zeros;

    auto product = multiplication_approximation<FloatingPointInfo<T>::mantissa_bits() + 3>(w, exponent);

    return not_enough_precision_binary_to_decimal<T>(exponent, product.high(), leading_zeros);
}

template<typename T>
static FloatingPointBuilder binary_to_decimal(u64 mantissa, i64 exponent)
{
    using FloatingPointRepr = FloatingPointInfo<T>;

    if (mantissa == 0 || exponent < FloatingPointRepr::min_power_of_10())
        return FloatingPointBuilder::zero();

    // Max double value which isn't negative is xe308
    if (exponent > FloatingPointRepr::max_power_of_10())
        return FloatingPointBuilder::infinity<T>();

    auto w = mantissa;
    // Normalize the decimal significand w by shifting it so that w ∈ [2^63, 2^64)
    auto leading_zeros = count_leading_zeroes(mantissa);
    w <<= leading_zeros;

    // We need at least mantissa bits + 1 for the implicit bit + 1 for the implicit 0 top bit and one extra for rounding
    u128 approximation_of_product_with_power_of_five = multiplication_approximation<FloatingPointRepr::mantissa_bits() + 3>(w, exponent);

    // The paper (and code of fastfloat/fast_float as of writing) mention that the low part
    // of approximation_of_product_with_power_of_five can be 2^64 - 1 here in which case we need more
    // precision if the exponent lies outside of [-27, 55]. However the authors of the paper have
    // shown that this case cannot actually occur. See https://github.com/fastfloat/fast_float/issues/146#issuecomment-1262527329

    u8 upperbit = approximation_of_product_with_power_of_five.high() >> 63;
    auto real_mantissa = approximation_of_product_with_power_of_five.high() >> (upperbit + 64 - FloatingPointRepr::mantissa_bits() - 3);

    // We immediately normalize the exponent to 0 - max else we have to add the bias in most following calculations
    i32 power_of_two_with_bias = decimal_exponent_to_binary_exponent(exponent) - leading_zeros + upperbit + FloatingPointRepr::exponent_bias();

    if (power_of_two_with_bias <= 0) {
        // If the exponent is less than the bias we might have a denormal on our hands
        // A denormal is a float with exponent zero, which means it doesn't have the implicit
        // 1 at the top of the mantissa.

        // If the top bit would be below the bottom of the mantissa we have to round to zero
        if (power_of_two_with_bias <= -63)
            return FloatingPointBuilder::zero();

        // Otherwise, we have to shift the mantissa to be a denormal
        auto s = -power_of_two_with_bias + 1;
        real_mantissa = real_mantissa >> s;

        // And then round ties to even
        real_mantissa += real_mantissa & 1;
        real_mantissa >>= 1;

        // Check for subnormal by checking if the 53th bit of the mantissa it set in which case exponent is 1 not 0
        // It is only a real subnormal if the top bit isn't set
        power_of_two_with_bias = real_mantissa < (1ull << FloatingPointRepr::mantissa_bits()) ? 0 : 1;

        return { real_mantissa, power_of_two_with_bias };
    }

    if (approximation_of_product_with_power_of_five.low() <= 1 && (real_mantissa & 0b11) == 0b01
        && exponent >= FloatingPointRepr::min_exponent_round_to_even()
        && exponent <= FloatingPointRepr::max_exponent_round_to_even()) {
        // If the lowest bit is set but the one above it isn't this is a value exactly halfway
        // between two floating points
        // if (z ÷ 264 )/m is a power of two then m ← m − 1

        // effectively all discard bits from z.high are 0
        if (approximation_of_product_with_power_of_five.high() == (real_mantissa << (upperbit + 64 - FloatingPointRepr::mantissa_bits() - 3))) {
            real_mantissa &= ~u64(1);
        }
    }

    real_mantissa += real_mantissa & 1;
    real_mantissa >>= 1;

    // If we overflowed the mantissa round up the exponent
    if (real_mantissa >= (2ull << FloatingPointRepr::mantissa_bits())) {
        real_mantissa = 1ull << FloatingPointRepr::mantissa_bits();
        ++power_of_two_with_bias;
    }

    real_mantissa &= ~(1ull << FloatingPointRepr::mantissa_bits());

    // We might have rounded exponent up to infinity
    if (power_of_two_with_bias >= FloatingPointRepr::infinity_exponent())
        return FloatingPointBuilder::infinity<T>();

    return {
        real_mantissa, power_of_two_with_bias
    };
}

static constexpr u64 multiply_with_carry(u64 x, u64 y, u64& carry)
{
    u128 result = (u128 { x } * y) + carry;
    carry = result.high();
    return result.low();
}

static constexpr u64 add_with_overflow(u64 x, u64 y, bool& did_overflow)
{
    u64 value;
    did_overflow = __builtin_add_overflow(x, y, &value);
    return value;
}

class MinimalBigInt {
public:
    MinimalBigInt() = default;
    MinimalBigInt(u64 value)
    {
        append(value);
    }

    static MinimalBigInt from_decimal_floating_point(BasicParseResult const& parse_result, size_t& digits_parsed, size_t max_total_digits)
    {
        size_t current_word_counter = 0;
        // 10**19 is the biggest power of ten which fits in 64 bit
        constexpr size_t max_word_counter = max_representable_power_of_ten_in_u64;

        u64 current_word = 0;

        enum AddDigitResult {
            DidNotHitMaxDigits,
            HitMaxDigits,
        };

        auto does_truncate_non_zero = [](char const* parse_head, char const* parse_end) {
            while (parse_end - parse_head >= 8) {
                static_assert('0' == 0x30);

                if (read_eight_digits(parse_head) != 0x3030303030303030)
                    return true;

                parse_head += 8;
            }

            while (parse_head != parse_end) {
                if (*parse_head != '0')
                    return true;

                ++parse_head;
            }

            return false;
        };

        MinimalBigInt value;
        auto add_digits = [&](StringView digits, bool check_fraction_for_truncation = false) {
            char const* parse_head = digits.characters_without_null_termination();
            char const* parse_end = digits.characters_without_null_termination() + digits.length();

            if (digits_parsed == 0) {
                // Skip all leading zeros as long as we haven't hit a non zero
                while (parse_head != parse_end && *parse_head == '0')
                    ++parse_head;
            }

            while (parse_head != parse_end) {
                while (max_word_counter - current_word_counter >= 8
                    && parse_end - parse_head >= 8
                    && max_total_digits - digits_parsed >= 8) {

                    current_word = current_word * 100'000'000 + eight_digits_to_value(read_eight_digits(parse_head));

                    digits_parsed += 8;
                    current_word_counter += 8;
                    parse_head += 8;
                }

                while (current_word_counter < max_word_counter
                    && parse_head != parse_end
                    && digits_parsed < max_total_digits) {

                    current_word = current_word * 10 + (*parse_head - '0');

                    ++digits_parsed;
                    ++current_word_counter;
                    ++parse_head;
                }

                if (digits_parsed == max_total_digits) {
                    // Check if we are leaving behind any non zero
                    bool truncated = does_truncate_non_zero(parse_head, parse_end);
                    if (auto fraction = parse_result.fractional_part; check_fraction_for_truncation && !fraction.is_empty())
                        truncated = truncated || does_truncate_non_zero(fraction.characters_without_null_termination(), fraction.characters_without_null_termination() + fraction.length());

                    // If we truncated we just pretend there is another 1 after the already parsed digits

                    if (truncated && current_word_counter != max_word_counter) {
                        // If it still fits in the current add it there, this saves a wide multiply
                        current_word = current_word * 10 + 1;
                        ++current_word_counter;
                        truncated = false;
                    }
                    value.add_digits(current_word, current_word_counter);

                    // If it didn't fit just do * 10 + 1
                    if (truncated)
                        value.add_digits(1, 1);

                    return HitMaxDigits;
                } else {
                    value.add_digits(current_word, current_word_counter);
                    current_word = 0;
                    current_word_counter = 0;
                }
            }

            return DidNotHitMaxDigits;
        };

        if (add_digits(parse_result.whole_part, true) == HitMaxDigits)
            return value;

        add_digits(parse_result.fractional_part);

        return value;
    }

    u64 top_64_bits(bool& has_truncated_bits) const
    {
        if (m_used_length == 0)
            return 0;

        // Top word should be non-zero
        VERIFY(m_words[m_used_length - 1] != 0);

        auto leading_zeros = count_leading_zeroes(m_words[m_used_length - 1]);
        if (m_used_length == 1)
            return m_words[0] << leading_zeros;

        for (size_t i = 0; i < m_used_length - 2; i++) {
            if (m_words[i] != 0) {
                has_truncated_bits = true;
                break;
            }
        }

        if (leading_zeros == 0) {
            // Shift of 64+ is undefined so this has to be a separate case
            has_truncated_bits |= m_words[m_used_length - 2] != 0;
            return m_words[m_used_length - 1] << leading_zeros;
        }

        auto bits_from_second = 64 - leading_zeros;
        has_truncated_bits |= (m_words[m_used_length - 2] << leading_zeros) != 0;
        return (m_words[m_used_length - 1] << leading_zeros) | (m_words[m_used_length - 2] >> bits_from_second);
    }

    i32 size_in_bits() const
    {
        if (m_used_length == 0)
            return 0;
        // This is guaranteed to be at most max_size_in_words * 64 so not above i32 max
        return static_cast<i32>(64 * (m_used_length)-count_leading_zeroes(m_words[m_used_length - 1]));
    }

    void multiply_with_power_of_10(u32 exponent)
    {
        multiply_with_power_of_5(exponent);
        multiply_with_power_of_2(exponent);
    }

    void multiply_with_power_of_5(u32 exponent)
    {
        // FIXME: We might be able to store a bigger power of 5 but this would
        //        require a wide multiply, so perhaps using u4096 would be
        //        better to get wide multiply and not duplicate logic.
        static constexpr Array<u64, 28> power_of_5 = {
            1ul,
            5ul,
            25ul,
            125ul,
            625ul,
            3125ul,
            15625ul,
            78125ul,
            390625ul,
            1953125ul,
            9765625ul,
            48828125ul,
            244140625ul,
            1220703125ul,
            6103515625ul,
            30517578125ul,
            152587890625ul,
            762939453125ul,
            3814697265625ul,
            19073486328125ul,
            95367431640625ul,
            476837158203125ul,
            2384185791015625ul,
            11920928955078125ul,
            59604644775390625ul,
            298023223876953125ul,
            1490116119384765625ul,
            7450580596923828125ul,
        };

        static constexpr u32 max_step = power_of_5.size() - 1;
        static constexpr u64 max_power = power_of_5[max_step];

        while (exponent >= max_step) {
            multiply_with_small(max_power);
            exponent -= max_step;
        }

        if (exponent > 0)
            multiply_with_small(power_of_5[exponent]);
    }

    void multiply_with_power_of_2(u32 exponent)
    {
        // It's cheaper to shift bits first since that creates at most 1 new word
        shift_bits(exponent % 64);
        shift_words(exponent / 64);
    }

    enum class CompareResult {
        Equal,
        GreaterThan,
        LessThan
    };

    CompareResult compare_to(MinimalBigInt const& other) const
    {
        if (m_used_length > other.m_used_length)
            return CompareResult::GreaterThan;

        if (m_used_length < other.m_used_length)
            return CompareResult::LessThan;

        // Now we know it's the same size
        for (size_t i = m_used_length; i > 0; --i) {
            auto our_word = m_words[i - 1];
            auto their_word = other.m_words[i - 1];

            if (our_word > their_word)
                return CompareResult::GreaterThan;
            if (their_word > our_word)
                return CompareResult::LessThan;
        }

        return CompareResult::Equal;
    }

private:
    void shift_words(u32 amount)
    {
        if (amount == 0)
            return;

        VERIFY(amount + m_used_length <= max_words_needed);

        for (size_t i = m_used_length + amount - 1; i > amount - 1; --i)
            m_words[i] = m_words[i - amount];

        for (size_t i = 0; i < amount; ++i)
            m_words[i] = 0;

        m_used_length += amount;
    }

    void shift_bits(u32 amount)
    {
        if (amount == 0)
            return;

        VERIFY(amount < 64);

        u32 inverse = 64 - amount;
        u64 last_word = 0;

        for (size_t i = 0; i < m_used_length; ++i) {
            u64 word = m_words[i];
            m_words[i] = (word << amount) | (last_word >> inverse);
            last_word = word;
        }

        u64 carry = last_word >> inverse;
        if (carry != 0)
            append(carry);
    }

    static constexpr Array<u64, 20> powers_of_ten_uint64 = {
        1UL, 10UL, 100UL, 1000UL, 10000UL, 100000UL, 1000000UL, 10000000UL, 100000000UL,
        1000000000UL, 10000000000UL, 100000000000UL, 1000000000000UL, 10000000000000UL,
        100000000000000UL, 1000000000000000UL, 10000000000000000UL, 100000000000000000UL,
        1000000000000000000UL, 10000000000000000000UL
    };

    void multiply_with_small(u64 value)
    {
        u64 carry = 0;
        for (size_t i = 0; i < m_used_length; ++i)
            m_words[i] = multiply_with_carry(m_words[i], value, carry);

        if (carry != 0)
            append(carry);
    }

    void add_small(u64 value)
    {
        bool overflow;
        size_t index = 0;
        while (value != 0 && index < m_used_length) {
            m_words[index] = add_with_overflow(m_words[index], value, overflow);

            value = overflow ? 1 : 0;
            ++index;
        }

        if (value != 0)
            append(value);
    }

    void add_digits(u64 value, size_t digits_for_value)
    {
        VERIFY(digits_for_value < powers_of_ten_uint64.size());

        multiply_with_small(powers_of_ten_uint64[digits_for_value]);
        add_small(value);
    }

    void append(u64 word)
    {
        VERIFY(m_used_length <= max_words_needed);
        m_words[m_used_length] = word;
        ++m_used_length;
    }

    // The max valid words we might need are log2(10^(769 + 342)), max digits + max exponent
    static constexpr size_t max_words_needed = 58;

    size_t m_used_length = 0;

    // FIXME: This is an array just to avoid allocations, but the max size is only needed for
    //        massive amount of digits, so a smaller vector would work for most cases.
    Array<u64, max_words_needed> m_words {};
};

static bool round_nearest_tie_even(FloatingPointBuilder& value, bool did_truncate_bits, i32 shift)
{
    VERIFY(shift == 11 || shift == 40);
    u64 mask = (1ull << shift) - 1;
    u64 halfway = 1ull << (shift - 1);

    u64 truncated_bits = value.mantissa & mask;
    bool is_halfway = truncated_bits == halfway;
    bool is_above = truncated_bits > halfway;

    value.mantissa >>= shift;
    value.exponent += shift;

    bool is_odd = (value.mantissa & 1) == 1;
    return is_above || (is_halfway && did_truncate_bits) || (is_halfway && is_odd);
}

template<typename T, typename Callback>
static void round(FloatingPointBuilder& value, Callback&& should_round_up)
{
    using FloatingRepr = FloatingPointInfo<T>;

    i32 mantissa_shift = 64 - FloatingRepr::mantissa_bits() - 1;
    if (-value.exponent >= mantissa_shift) {
        // This is a denormal so we have to shift????
        mantissa_shift = min(-value.exponent + 1, 64);
        if (should_round_up(value, mantissa_shift))
            ++value.mantissa;

        value.exponent = (value.mantissa < (1ull << FloatingRepr::mantissa_bits())) ? 0 : 1;
        return;
    }

    if (should_round_up(value, mantissa_shift))
        ++value.mantissa;

    // Mantissa might have been rounded so if it overflowed increase the exponent
    if (value.mantissa >= (2ull << FloatingRepr::mantissa_bits())) {
        value.mantissa = 0;
        ++value.exponent;
    } else {
        // Clear the implicit top bit
        value.mantissa &= ~(1ull << FloatingRepr::mantissa_bits());
    }

    // If we also overflowed the exponent make it infinity!
    if (value.exponent >= FloatingRepr::infinity_exponent()) {
        value.exponent = FloatingRepr::infinity_exponent();
        value.mantissa = 0;
    }
}

template<typename T>
static FloatingPointBuilder build_positive_double(MinimalBigInt& mantissa, i32 exponent)
{
    mantissa.multiply_with_power_of_10(exponent);

    FloatingPointBuilder result {};
    bool should_round_up_ties = false;
    // First we get the 64 most significant bits WARNING not masked to real mantissa yet
    result.mantissa = mantissa.top_64_bits(should_round_up_ties);

    i32 bias = FloatingPointInfo<T>::mantissa_bits() + FloatingPointInfo<T>::exponent_bias();
    result.exponent = mantissa.size_in_bits() - 64 + bias;

    round<T>(result, [should_round_up_ties](FloatingPointBuilder& value, i32 shift) {
        return round_nearest_tie_even(value, should_round_up_ties, shift);
    });
    return result;
}

template<ParseableFloatingPoint T>
static FloatingPointBuilder build_negative_exponent_double(MinimalBigInt& mantissa, i32 exponent, FloatingPointBuilder initial)
{
    VERIFY(exponent < 0);

    // Building a fraction from a big integer is harder to understand
    // But fundamentely we have mantissa * 10^-e and so divide by 5^f

    auto parts_copy = initial;
    round<T>(parts_copy, [](FloatingPointBuilder& value, i32 shift) {
        if (shift == 64)
            value.mantissa = 0;
        else
            value.mantissa >>= shift;

        value.exponent += shift;

        return false;
    });

    T rounded_down_double_value = parts_copy.template to_value<T>(false);
    auto exact_halfway_builder = FloatingPointBuilder::from_value(rounded_down_double_value);
    // halfway is exactly just the next bit 1 (rest implicit zeros)
    exact_halfway_builder.mantissa <<= 1;
    exact_halfway_builder.mantissa += 1;
    --exact_halfway_builder.exponent;

    MinimalBigInt rounded_down_full_mantissa { exact_halfway_builder.mantissa };

    // Scale halfway up with 5**(-e)
    if (u32 power_of_5 = -exponent; power_of_5 != 0)
        rounded_down_full_mantissa.multiply_with_power_of_5(power_of_5);

    i32 power_of_2 = exact_halfway_builder.exponent - exponent;
    if (power_of_2 > 0) {
        // halfway has lower exponent scale up to real exponent
        rounded_down_full_mantissa.multiply_with_power_of_2(power_of_2);
    } else if (power_of_2 < 0) {
        // halfway has higher exponent scale original mantissa up to real halfway
        mantissa.multiply_with_power_of_2(-power_of_2);
    }

    auto compared_to_halfway = mantissa.compare_to(rounded_down_full_mantissa);

    round<T>(initial, [compared_to_halfway](FloatingPointBuilder& value, i32 shift) {
        if (shift == 64) {
            value.mantissa = 0;
        } else {
            value.mantissa >>= shift;
        }
        value.exponent += shift;

        if (compared_to_halfway == MinimalBigInt::CompareResult::GreaterThan)
            return true;
        if (compared_to_halfway == MinimalBigInt::CompareResult::LessThan)
            return false;

        return (value.mantissa & 1) == 1;
    });

    return initial;
}

template<typename T>
static FloatingPointBuilder parse_arbitrarily_long_floating_point(BasicParseResult& result, FloatingPointBuilder initial)
{
    VERIFY(initial.exponent < 0);
    initial.exponent += FloatingPointBuilder::invalid_exponent_offset;

    VERIFY(result.exponent >= NumericLimits<i32>::min() && result.exponent <= NumericLimits<i32>::max());
    i32 exponent = static_cast<i32>(result.exponent);
    {
        u64 mantissa_copy = result.mantissa;

        while (mantissa_copy >= 10000) {
            mantissa_copy /= 10000;
            exponent += 4;
        }

        while (mantissa_copy >= 10) {
            mantissa_copy /= 10;
            ++exponent;
        }
    }

    size_t digits = 0;

    constexpr auto max_digits_to_parse = FloatingPointInfo<T>::max_possible_digits_needed_for_parsing();

    // Reparse mantissa into big int
    auto mantissa = MinimalBigInt::from_decimal_floating_point(result, digits, max_digits_to_parse);

    VERIFY(digits <= 1024);

    exponent += 1 - static_cast<i32>(digits);

    if (exponent >= 0)
        return build_positive_double<T>(mantissa, exponent);

    return build_negative_exponent_double<T>(mantissa, exponent, initial);
}

template<FloatingPoint T>
T parse_result_to_value(BasicParseResult& parse_result)
{
    using FloatingPointRepr = FloatingPointInfo<T>;

    if (parse_result.mantissa <= u64(2) << FloatingPointRepr::mantissa_bits()
        && parse_result.exponent >= -FloatingPointRepr::max_exact_power_of_10() && parse_result.exponent <= FloatingPointRepr::max_exact_power_of_10()
        && !parse_result.more_than_19_digits_with_overflow) {

        T value = parse_result.mantissa;
        VERIFY(u64(value) == parse_result.mantissa);

        if (parse_result.exponent < 0)
            value = value / FloatingPointRepr::power_of_ten(-parse_result.exponent);
        else
            value = value * FloatingPointRepr::power_of_ten(parse_result.exponent);

        if (parse_result.negative)
            value = -value;

        return value;
    }

    auto floating_point_parts = binary_to_decimal<T>(parse_result.mantissa, parse_result.exponent);
    if (parse_result.more_than_19_digits_with_overflow && floating_point_parts.exponent >= 0) {
        auto rounded_up_double_build = binary_to_decimal<T>(parse_result.mantissa + 1, parse_result.exponent);
        if (floating_point_parts.mantissa != rounded_up_double_build.mantissa || floating_point_parts.exponent != rounded_up_double_build.exponent) {
            floating_point_parts = fallback_binary_to_decimal<T>(parse_result.mantissa, parse_result.exponent);
            VERIFY(floating_point_parts.exponent < 0);
        }
    }

    if (floating_point_parts.exponent < 0) {
        // Invalid have to parse perfectly
        floating_point_parts = parse_arbitrarily_long_floating_point<T>(parse_result, floating_point_parts);
    }

    return floating_point_parts.template to_value<T>(parse_result.negative);
}

template<FloatingPoint T>
constexpr FloatingPointParseResults<T> parse_result_to_full_result(BasicParseResult parse_result)
{
    if (!parse_result.valid)
        return { nullptr, FloatingPointError::NoOrInvalidInput, __builtin_nan("") };

    FloatingPointParseResults<T> full_result {};
    full_result.end_ptr = parse_result.last_parsed;

    // We special case this to be able to differentiate between 0 and values rounded down to 0
    if (parse_result.mantissa == 0) {
        full_result.value = parse_result.negative ? -0. : 0.;
        return full_result;
    }

    full_result.value = parse_result_to_value<T>(parse_result);

    // The only way we can get infinity is from rounding up/down to it.
    if (__builtin_isinf(full_result.value))
        full_result.error = FloatingPointError::OutOfRange;
    else if (full_result.value == T(0.))
        full_result.error = FloatingPointError::RoundedDownToZero;

    return full_result;
}

template<FloatingPoint T>
FloatingPointParseResults<T> parse_first_floating_point(char const* start, char const* end)
{
    auto parse_result = parse_numbers(
        start,
        [end](char const* head) { return head == end; },
        [end](char const* head) { return head - end >= 8; });

    return parse_result_to_full_result<T>(parse_result);
}

template FloatingPointParseResults<double> parse_first_floating_point(char const* start, char const* end);

template FloatingPointParseResults<float> parse_first_floating_point(char const* start, char const* end);

template<FloatingPoint T>
FloatingPointParseResults<T> parse_first_floating_point_until_zero_character(char const* start)
{
    auto parse_result = parse_numbers(
        start,
        [](char const* head) { return *head == '\0'; },
        [](char const*) { return false; });

    return parse_result_to_full_result<T>(parse_result);
}

template FloatingPointParseResults<double> parse_first_floating_point_until_zero_character(char const* start);

template FloatingPointParseResults<float> parse_first_floating_point_until_zero_character(char const* start);

template<FloatingPoint T>
Optional<T> parse_floating_point_completely(char const* start, char const* end)
{
    auto parse_result = parse_numbers(
        start,
        [end](char const* head) { return head == end; },
        [end](char const* head) { return head - end >= 8; });

    if (!parse_result.valid || parse_result.last_parsed != end)
        return {};

    return parse_result_to_value<T>(parse_result);
}

template Optional<double> parse_floating_point_completely(char const* start, char const* end);

template Optional<float> parse_floating_point_completely(char const* start, char const* end);

struct HexFloatParseResult {
    bool is_negative = false;
    bool valid = false;
    char const* last_parsed = nullptr;
    u64 mantissa = 0;
    i64 exponent = 0;
};

static HexFloatParseResult parse_hexfloat(char const* start)
{
    HexFloatParseResult result {};
    if (start == nullptr || *start == '\0')
        return result;

    char const* parse_head = start;
    bool any_digits = false;
    bool truncated_non_zero = false;

    if (*parse_head == '-') {
        result.is_negative = true;
        ++parse_head;

        if (*parse_head == '\0' || (!is_ascii_hex_digit(*parse_head) && *parse_head != floating_point_decimal_separator))
            return result;
    } else if (*parse_head == '+') {
        ++parse_head;

        if (*parse_head == '\0' || (!is_ascii_hex_digit(*parse_head) && *parse_head != floating_point_decimal_separator))
            return result;
    }
    if (*parse_head == '0' && (*(parse_head + 1) != '\0') && (*(parse_head + 1) == 'x' || *(parse_head + 1) == 'X')) {
        // Skip potential 0[xX], we have to do this here since the sign comes at the front
        parse_head += 2;
    }

    auto add_mantissa_digit = [&] {
        any_digits = true;

        // We assume you already checked this is actually a digit
        auto digit = parse_ascii_hex_digit(*parse_head);

        // Because the power of sixteen is just scaling of power of two we don't
        // need to keep all the remaining digits beyond the first 52 bits, just because
        // it's easy we store the first 16 digits. However for rounding we do need to parse
        // all the digits and keep track if we see any non zero one.
        if (result.mantissa < (1ull << 60)) {
            result.mantissa = (result.mantissa * 16) + digit;
            return true;
        }

        if (digit != 0)
            truncated_non_zero = true;

        return false;
    };

    while (*parse_head != '\0' && is_ascii_hex_digit(*parse_head)) {
        add_mantissa_digit();

        ++parse_head;
    }

    if (*parse_head != '\0' && *parse_head == floating_point_decimal_separator) {
        ++parse_head;
        i64 digits_after_separator = 0;
        while (*parse_head != '\0' && is_ascii_hex_digit(*parse_head)) {
            // Track how many characters we actually read into the mantissa
            digits_after_separator += add_mantissa_digit() ? 1 : 0;

            ++parse_head;
        }

        // We parsed x digits after the dot so need to multiply with 2^(-x * 4)
        // Since every digit is 4 bits
        result.exponent = -digits_after_separator * 4;
    }

    if (!any_digits)
        return result;

    if (*parse_head != '\0' && (*parse_head == 'p' || *parse_head == 'P')) {
        [&] {
            auto const* head_before_p = parse_head;
            ArmedScopeGuard reset_ptr { [&] { parse_head = head_before_p; } };
            ++parse_head;

            if (*parse_head == '\0')
                return;

            bool exponent_is_negative = false;
            i64 explicit_exponent = 0;

            if (*parse_head == '-' || *parse_head == '+') {
                exponent_is_negative = *parse_head == '-';
                ++parse_head;
                if (*parse_head == '\0')
                    return;
            }

            if (!is_ascii_digit(*parse_head))
                return;

            // We have at least one digit (with optional preceding sign) so we will not reset
            reset_ptr.disarm();

            while (*parse_head != '\0' && is_ascii_digit(*parse_head)) {
                // If we hit exponent overflow the number is so huge we are in trouble anyway, see
                // a comment in parse_numbers.
                if (explicit_exponent < 0x10000000)
                    explicit_exponent = 10 * explicit_exponent + (*parse_head - '0');
                ++parse_head;
            }

            if (exponent_is_negative)
                explicit_exponent = -explicit_exponent;

            result.exponent += explicit_exponent;
        }();
    }

    result.valid = true;

    // Round up exactly halfway with truncated non zeros, but don't if it would cascade up
    if (truncated_non_zero && (result.mantissa & 0xF) != 0xF) {
        VERIFY(result.mantissa >= 0x1000'0000'0000'0000);
        result.mantissa |= 1;
    }

    result.last_parsed = parse_head;

    return result;
}

template<FloatingPoint T>
static FloatingPointBuilder build_hex_float(HexFloatParseResult& parse_result)
{
    using FloatingPointRepr = FloatingPointInfo<T>;
    VERIFY(parse_result.mantissa != 0);

    if (parse_result.exponent >= FloatingPointRepr::infinity_exponent())
        return FloatingPointBuilder::infinity<T>();

    auto leading_zeros = count_leading_zeroes(parse_result.mantissa);
    u64 normalized_mantissa = parse_result.mantissa << leading_zeros;

    // No need to multiply with some power of 5 here the exponent is already a power of 2.

    u8 upperbit = normalized_mantissa >> 63;
    FloatingPointBuilder parts;
    parts.mantissa = normalized_mantissa >> (upperbit + 64 - FloatingPointRepr::mantissa_bits() - 3);

    parts.exponent = parse_result.exponent + upperbit - leading_zeros + FloatingPointRepr::exponent_bias() + 62;

    if (parts.exponent <= 0) {
        // subnormal
        if (-parts.exponent + 1 >= 64) {
            parts.mantissa = 0;
            parts.exponent = 0;
            return parts;
        }

        parts.mantissa >>= -parts.exponent + 1;
        parts.mantissa += parts.mantissa & 1;
        parts.mantissa >>= 1;

        if (parts.mantissa < (1ull << FloatingPointRepr::mantissa_bits())) {
            parts.exponent = 0;
        } else {
            parts.exponent = 1;
        }

        return parts;
    }

    // Here we don't have to only do this halfway check for some exponents
    if ((parts.mantissa & 0b11) == 0b01) {
        // effectively all discard bits from z.high are 0
        if (normalized_mantissa == (parts.mantissa << (upperbit + 64 - FloatingPointRepr::mantissa_bits() - 3)))
            parts.mantissa &= ~u64(1);
    }

    parts.mantissa += parts.mantissa & 1;
    parts.mantissa >>= 1;

    if (parts.mantissa >= (2ull << FloatingPointRepr::mantissa_bits())) {
        parts.mantissa = 1ull << FloatingPointRepr::mantissa_bits();
        ++parts.exponent;
    }

    parts.mantissa &= ~(1ull << FloatingPointRepr::mantissa_bits());

    if (parts.exponent >= FloatingPointRepr::infinity_exponent()) {
        parts.mantissa = 0;
        parts.exponent = FloatingPointRepr::infinity_exponent();
    }

    return parts;
}

template<FloatingPoint T>
FloatingPointParseResults<T> parse_first_hexfloat_until_zero_character(char const* start)
{
    using FloatingPointRepr = FloatingPointInfo<T>;
    auto parse_result = parse_hexfloat(start);

    if (!parse_result.valid)
        return { nullptr, FloatingPointError::NoOrInvalidInput, __builtin_nan("") };

    FloatingPointParseResults<T> full_result {};
    full_result.end_ptr = parse_result.last_parsed;

    // We special case this to be able to differentiate between 0 and values rounded down to 0

    if (parse_result.mantissa == 0) {
        full_result.value = 0.;
        return full_result;
    }

    auto result = build_hex_float<T>(parse_result);
    full_result.value = result.template to_value<T>(parse_result.is_negative);

    if (result.exponent == FloatingPointRepr::infinity_exponent()) {
        VERIFY(result.mantissa == 0);
        full_result.error = FloatingPointError::OutOfRange;
    } else if (result.mantissa == 0 && result.exponent == 0) {
        full_result.error = FloatingPointError::RoundedDownToZero;
    }

    return full_result;
}

template FloatingPointParseResults<double> parse_first_hexfloat_until_zero_character(char const* start);

template FloatingPointParseResults<float> parse_first_hexfloat_until_zero_character(char const* start);

}