#line 1 "include/boost/charconv/detail/dragonbox/floff.hpp"
// Copyright 2020-2022 Junekey Jeon
//
// The contents of this file may be used under the terms of
// the Apache License v2.0 with LLVM Exceptions.
//
//    (See accompanying file LICENSE-Apache or copy at
//     https://llvm.org/foundation/relicensing/LICENSE.txt)
//
// Alternatively, the contents of this file may be used under the terms of
// the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE-Boost or copy at
//     https://www.boost.org/LICENSE_1_0.txt)
//
// Unless required by applicable law or agreed to in writing, this software
// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.
//
// Some parts are copied from Dragonbox project.
//
// Copyright 2023 Matt Borland
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_CHARCONV_DETAIL_FLOFF
#define BOOST_CHARCONV_DETAIL_FLOFF

#include <boost/charconv/detail/config.hpp>
#include <boost/charconv/detail/bit_layouts.hpp>
#include <boost/charconv/detail/emulated128.hpp>
#include <boost/charconv/detail/dragonbox/dragonbox_common.hpp>
#include <boost/charconv/detail/to_chars_result.hpp>
#include <boost/charconv/chars_format.hpp>
#include <boost/core/bit.hpp>
#include <type_traits>
#include <limits>
#include <cstdint>
#include <cstring>
#include <cstddef>
#include <climits>

#ifdef BOOST_MSVC
# pragma warning(push)
# pragma warning(disable: 4127) // Extensive use of BOOST_IF_CONSTEXPR emits warnings under C++11 and 14
# pragma warning(disable: 4554) // parentheses are used be warning is still emitted
#endif

namespace boost { namespace charconv { namespace detail {

#ifdef BOOST_MSVC
# pragma warning(push)
# pragma warning(disable: 4702) // use of BOOST_IF_CONSTEXPR can result in unreachable code if max_blocks is 3
                                // Other older compilers will emit warnings if the unreachable code is wrapped
                                // in an else block (e.g. no return statment)
#endif

template <std::size_t max_blocks>
struct fixed_point_calculator 
{
    static_assert(1 < max_blocks, "Max blocks must be greater than 1");

    // Multiply multiplier to the fractional blocks and take the resulting integer part.
    // The fractional blocks are updated.
    template <typename MultiplierType>
    BOOST_FORCEINLINE static MultiplierType generate(MultiplierType multiplier,
                                                     std::uint64_t* blocks_ptr,
                                                     std::size_t number_of_blocks) noexcept
    {
        BOOST_CHARCONV_ASSERT(0 < number_of_blocks && number_of_blocks <= max_blocks);

        BOOST_IF_CONSTEXPR (max_blocks == 3)
        {
            uint128 mul_result;
            std::uint64_t carry = 0;

            switch (number_of_blocks) 
            {
            case 3:
                mul_result = umul128(blocks_ptr[2], multiplier);
                blocks_ptr[2] = mul_result.low;
                carry = mul_result.high;
                BOOST_FALLTHROUGH;

            case 2:
                mul_result = umul128(blocks_ptr[1], multiplier);
                mul_result += carry;
                blocks_ptr[1] = mul_result.low;
                carry = mul_result.high;
                BOOST_FALLTHROUGH;

            case 1:
                mul_result = umul128(blocks_ptr[0], multiplier);
                mul_result += carry;
                blocks_ptr[0] = mul_result.low;
                return mul_result.high;

            default:
                BOOST_UNREACHABLE_RETURN(carry); // NOLINT : Macro for unreachable can expand to be empty
            }
        }

        auto mul_result = umul128(blocks_ptr[number_of_blocks - 1], multiplier);
        blocks_ptr[number_of_blocks - 1] = mul_result.low;
        auto carry = mul_result.high;
        for (std::size_t i = 1; i < number_of_blocks; ++i) 
        {
            mul_result = umul128(blocks_ptr[number_of_blocks - i - 1], multiplier);
            mul_result += carry;
            blocks_ptr[number_of_blocks - i - 1] = mul_result.low;
            carry = mul_result.high;
        }

        return MultiplierType(carry);
    }

    // Multiply multiplier to the fractional blocks and discard the resulting integer part.
    // The fractional blocks are updated.
    template <typename MultiplierType>
    BOOST_FORCEINLINE static void discard_upper(MultiplierType multiplier,
                                                std::uint64_t* blocks_ptr,
                                                std::size_t number_of_blocks) noexcept 
    {
        BOOST_CHARCONV_ASSERT(0 < number_of_blocks && number_of_blocks <= max_blocks);

        blocks_ptr[0] *= multiplier;
        if (number_of_blocks > 1) 
        {
            BOOST_IF_CONSTEXPR (max_blocks == 3) 
            {
                uint128 mul_result;
                std::uint64_t carry = 0;

                if (number_of_blocks > 2)
                {
                    mul_result = umul128(multiplier, blocks_ptr[2]);
                    blocks_ptr[2] = mul_result.low;
                    carry = mul_result.high;
                }

                mul_result = umul128(multiplier, blocks_ptr[1]);
                mul_result += carry;
                blocks_ptr[1] = mul_result.low;
                blocks_ptr[0] += mul_result.high;
            }
            else 
            {
                auto mul_result = umul128(multiplier, blocks_ptr[number_of_blocks - 1]);
                blocks_ptr[number_of_blocks - 1] = mul_result.low;
                auto carry = mul_result.high;

                for (std::size_t i = 2; i < number_of_blocks; ++i)
                {
                    mul_result = umul128(multiplier, blocks_ptr[number_of_blocks - i]);
                    mul_result += carry;
                    blocks_ptr[number_of_blocks - i] = mul_result.low;
                    carry = mul_result.high;
                }

                blocks_ptr[0] += carry;
            }
        }
    }

    // Multiply multiplier to the fractional blocks and take the resulting integer part.
    // Don't care about what happens to the fractional blocks.
    template <typename MultiplierType>
    BOOST_FORCEINLINE static MultiplierType
    generate_and_discard_lower(MultiplierType multiplier, std::uint64_t* blocks_ptr,
                                std::size_t number_of_blocks) noexcept 
    {
        BOOST_CHARCONV_ASSERT(0 < number_of_blocks && number_of_blocks <= max_blocks);

        BOOST_IF_CONSTEXPR (max_blocks == 3) 
        {
            uint128 mul_result;
            std::uint64_t carry = 0;

            switch (number_of_blocks) 
            {
            case 3:
                mul_result = umul128(blocks_ptr[2], static_cast<std::uint64_t>(multiplier));
                carry = mul_result.high;
                BOOST_FALLTHROUGH;

            case 2:
                mul_result = umul128(blocks_ptr[1], static_cast<std::uint64_t>(multiplier));
                mul_result += carry;
                carry = mul_result.high;
                BOOST_FALLTHROUGH;

            case 1:
                mul_result = umul128(blocks_ptr[0], static_cast<std::uint64_t>(multiplier));
                mul_result += carry;
                return static_cast<MultiplierType>(mul_result.high);

            default:
                BOOST_UNREACHABLE_RETURN(carry); // NOLINT
            }
        }

        auto mul_result = umul128(blocks_ptr[number_of_blocks - 1], static_cast<std::uint64_t>(multiplier));
        auto carry = mul_result.high;
        for (std::size_t i = 1; i < number_of_blocks; ++i)
        {
            mul_result = umul128(blocks_ptr[number_of_blocks - i - 1], static_cast<std::uint64_t>(multiplier));
            mul_result += carry;
            carry = mul_result.high;
        }

        return static_cast<MultiplierType>(carry);
    }
};

#ifdef BOOST_MSVC
# pragma warning(pop)
#endif

template <bool b>
struct additional_static_data_holder_impl
{
    static constexpr char radix_100_table[] = {
        '0', '0', '0', '1', '0', '2', '0', '3', '0', '4', //
        '0', '5', '0', '6', '0', '7', '0', '8', '0', '9', //
        '1', '0', '1', '1', '1', '2', '1', '3', '1', '4', //
        '1', '5', '1', '6', '1', '7', '1', '8', '1', '9', //
        '2', '0', '2', '1', '2', '2', '2', '3', '2', '4', //
        '2', '5', '2', '6', '2', '7', '2', '8', '2', '9', //
        '3', '0', '3', '1', '3', '2', '3', '3', '3', '4', //
        '3', '5', '3', '6', '3', '7', '3', '8', '3', '9', //
        '4', '0', '4', '1', '4', '2', '4', '3', '4', '4', //
        '4', '5', '4', '6', '4', '7', '4', '8', '4', '9', //
        '5', '0', '5', '1', '5', '2', '5', '3', '5', '4', //
        '5', '5', '5', '6', '5', '7', '5', '8', '5', '9', //
        '6', '0', '6', '1', '6', '2', '6', '3', '6', '4', //
        '6', '5', '6', '6', '6', '7', '6', '8', '6', '9', //
        '7', '0', '7', '1', '7', '2', '7', '3', '7', '4', //
        '7', '5', '7', '6', '7', '7', '7', '8', '7', '9', //
        '8', '0', '8', '1', '8', '2', '8', '3', '8', '4', //
        '8', '5', '8', '6', '8', '7', '8', '8', '8', '9', //
        '9', '0', '9', '1', '9', '2', '9', '3', '9', '4', //
        '9', '5', '9', '6', '9', '7', '9', '8', '9', '9'  //
    };

    static constexpr std::uint32_t fractional_part_rounding_thresholds32[] = {
        UINT32_C(2576980378), UINT32_C(2190433321), UINT32_C(2151778616), UINT32_C(2147913145),
        UINT32_C(2147526598), UINT32_C(2147487943), UINT32_C(2147484078), UINT32_C(2147483691)
    };

    static constexpr std::uint64_t fractional_part_rounding_thresholds64[] = {
        UINT64_C(11068046444225730970), UINT64_C(9407839477591871325), UINT64_C(9241818780928485360),
        UINT64_C(9225216711262146764),  UINT64_C(9223556504295512904), UINT64_C(9223390483598849518),
        UINT64_C(9223373881529183179),  UINT64_C(9223372221322216546), UINT64_C(9223372055301519882),
        UINT64_C(9223372038699450216),  UINT64_C(9223372037039243249), UINT64_C(9223372036873222553),
        UINT64_C(9223372036856620483),  UINT64_C(9223372036854960276), UINT64_C(9223372036854794255),
        UINT64_C(9223372036854777653),  UINT64_C(9223372036854775993), UINT64_C(9223372036854775827)
    };
};

#if defined(BOOST_NO_CXX17_INLINE_VARIABLES) && (!defined(BOOST_MSVC) || BOOST_MSVC != 1900)

template <bool b> constexpr char additional_static_data_holder_impl<b>::radix_100_table[];
template <bool b> constexpr std::uint32_t additional_static_data_holder_impl<b>::fractional_part_rounding_thresholds32[];
template <bool b> constexpr std::uint64_t additional_static_data_holder_impl<b>::fractional_part_rounding_thresholds64[];

#endif

using additional_static_data_holder = additional_static_data_holder_impl<true>;

struct compute_mul_result 
{
    std::uint64_t result;
    bool is_integer;
};

// Load the necessary bits into blocks_ptr and then return the number of cache blocks
// loaded. The most significant block is loaded into blocks_ptr[0].
template <typename ExtendedCache, bool zero_out, 
          typename CacheBlockType = typename std::decay<decltype(ExtendedCache::cache[0])>::type,
          typename std::enable_if<(ExtendedCache::constant_block_count), bool>::type = true>
inline std::uint8_t cache_block_count_helper(CacheBlockType*, int, int, std::uint32_t) noexcept 
{
    return static_cast<std::uint8_t>(ExtendedCache::max_cache_blocks);
}

template <typename ExtendedCache, bool zero_out,
          typename CacheBlockType = typename std::decay<decltype(ExtendedCache::cache[0])>::type,
          typename std::enable_if<!(ExtendedCache::constant_block_count), bool>::type = true>
inline std::uint8_t cache_block_count_helper(CacheBlockType*, int e, int, std::uint32_t multiplier_index) noexcept 
{
    const auto mul_info = ExtendedCache::multiplier_index_info_table[multiplier_index];

    const auto cache_block_count_index =
                mul_info.cache_block_count_index_offset +
                static_cast<std::uint32_t>(e - ExtendedCache::e_min) / ExtendedCache::collapse_factor -
                ExtendedCache::cache_block_count_offset_base;

    BOOST_IF_CONSTEXPR (ExtendedCache::max_cache_blocks < 3)
    {
        // 1-bit packing.
        return static_cast<std::uint8_t>(
                    (ExtendedCache::cache_block_counts[cache_block_count_index /
                                                        8] >>
                    (cache_block_count_index % 8)) &
                    0x1) +
                1;
    }
    else BOOST_IF_CONSTEXPR (ExtendedCache::max_cache_blocks < 4)
    {
        // 2-bit packing.
        return static_cast<std::uint8_t>(
            (ExtendedCache::cache_block_counts[cache_block_count_index / 4] >>
                (2 * (cache_block_count_index % 4))) &
            0x3);
    }
    else 
    {
        // 4-bit packing.
        return std::uint8_t(
            (ExtendedCache::cache_block_counts[cache_block_count_index / 2] >>
                (4 * (cache_block_count_index % 2))) &
            0xf);
    }
}

template <typename ExtendedCache, bool zero_out,
          typename CacheBlockType = typename std::decay<decltype(ExtendedCache::cache[0])>::type>
BOOST_FORCEINLINE std::uint8_t load_extended_cache(CacheBlockType* blocks_ptr, int e, int k,
                                                   std::uint32_t multiplier_index) noexcept 
{
    BOOST_IF_CONSTEXPR (zero_out)
    {
        std::memset(blocks_ptr, 0, sizeof(CacheBlockType) * ExtendedCache::max_cache_blocks);
    }

    const auto mul_info = ExtendedCache::multiplier_index_info_table[multiplier_index];

    std::uint32_t number_of_leading_zero_blocks;
    std::uint32_t first_cache_block_index;
    std::uint32_t bit_offset;
    std::uint32_t excessive_bits_to_left;
    std::uint32_t excessive_bits_to_right;
    std::uint8_t  cache_block_count = cache_block_count_helper<ExtendedCache, zero_out, CacheBlockType>(blocks_ptr, e, k, multiplier_index);

    // The request window starting/ending positions.
    auto start_bit_index = static_cast<int>(mul_info.cache_bit_index_offset) + e - ExtendedCache::cache_bit_index_offset_base;
    auto end_bit_index = start_bit_index + cache_block_count * static_cast<int>(ExtendedCache::cache_bits_unit);

    // The source window starting/ending positions.
    const auto src_start_bit_index = static_cast<int>(mul_info.first_cache_bit_index);
    const auto src_end_bit_index = static_cast<int>(ExtendedCache::multiplier_index_info_table[multiplier_index + 1].first_cache_bit_index);

    // If the request window goes further than the left boundary of the source window,
    if (start_bit_index < src_start_bit_index)
    {
        number_of_leading_zero_blocks =
            static_cast<std::uint32_t>(src_start_bit_index - start_bit_index) /
            static_cast<std::uint32_t>(ExtendedCache::cache_bits_unit);
        excessive_bits_to_left = static_cast<std::uint32_t>(src_start_bit_index - start_bit_index) %
                                    static_cast<std::uint32_t>(ExtendedCache::cache_bits_unit);

        BOOST_IF_CONSTEXPR (!zero_out)
        {
            std::memset(blocks_ptr, 0, number_of_leading_zero_blocks * sizeof(CacheBlockType));
        }

        start_bit_index += static_cast<int>(number_of_leading_zero_blocks * ExtendedCache::cache_bits_unit);

        const auto src_start_block_index =
            static_cast<int>(static_cast<std::uint32_t>(src_start_bit_index) /
                static_cast<std::uint32_t>(ExtendedCache::cache_bits_unit));
        
        const auto src_start_block_bit_index =
            src_start_block_index * static_cast<int>(ExtendedCache::cache_bits_unit);

        first_cache_block_index = static_cast<std::uint32_t>(src_start_block_index);

        if (start_bit_index < src_start_block_bit_index)
        {
            auto shift_amount = src_start_block_bit_index - start_bit_index;
            BOOST_CHARCONV_ASSERT(shift_amount >= 0 && shift_amount < static_cast<int>(ExtendedCache::cache_bits_unit));

            blocks_ptr[number_of_leading_zero_blocks] =
                ((ExtendedCache::cache[src_start_block_index] >> shift_amount) &
                    (CacheBlockType(CacheBlockType(0) - CacheBlockType(1)) >>
                    excessive_bits_to_left));

            ++number_of_leading_zero_blocks;
            bit_offset = static_cast<std::uint32_t>(static_cast<int>(ExtendedCache::cache_bits_unit) - shift_amount);
            excessive_bits_to_left = 0;
        }
        else 
        {
            bit_offset = static_cast<std::uint32_t>(start_bit_index - src_start_block_bit_index);
        }
    }
    else 
    {
        number_of_leading_zero_blocks = 0;
        first_cache_block_index =
            static_cast<std::uint32_t>(start_bit_index) / static_cast<std::uint32_t>(ExtendedCache::cache_bits_unit);
        bit_offset =
            static_cast<std::uint32_t>(start_bit_index) % static_cast<std::uint32_t>(ExtendedCache::cache_bits_unit);
        excessive_bits_to_left = 0;
    }

    // If the request window goes further than the right boundary of the source window,
    if (end_bit_index > src_end_bit_index)
    {
        const std::uint8_t number_of_trailing_zero_blocks =
            static_cast<std::uint8_t>(end_bit_index - src_end_bit_index) / ExtendedCache::cache_bits_unit;
        excessive_bits_to_right = static_cast<std::uint32_t>(end_bit_index - src_end_bit_index) %
                                    static_cast<std::uint32_t>(ExtendedCache::cache_bits_unit);

        cache_block_count -= number_of_trailing_zero_blocks;
    }
    else
    {
        excessive_bits_to_right = 0;
    }

    // Load blocks.
    const auto number_of_blocks_to_load = cache_block_count - number_of_leading_zero_blocks;
    auto* const dst_ptr = blocks_ptr + number_of_leading_zero_blocks;
    if (bit_offset == 0)
    {
        BOOST_IF_CONSTEXPR (ExtendedCache::max_cache_blocks == 3)
        {
            switch (number_of_blocks_to_load)
            {
            case 3:
                std::memcpy(dst_ptr, ExtendedCache::cache + first_cache_block_index, 3 * sizeof(CacheBlockType));
                break;
            case 2:
                std::memcpy(dst_ptr, ExtendedCache::cache + first_cache_block_index, 2 * sizeof(CacheBlockType));
                break;
            case 1:
                std::memcpy(dst_ptr, ExtendedCache::cache + first_cache_block_index, 1 * sizeof(CacheBlockType));
                break;
            case 0:
                break;
            default:
                BOOST_UNREACHABLE_RETURN(dst_ptr); // NOLINT
            }
        }
        else 
        {
            std::memcpy(dst_ptr, ExtendedCache::cache + first_cache_block_index, number_of_blocks_to_load * sizeof(CacheBlockType));
        }
    }
    else 
    {
        BOOST_IF_CONSTEXPR (ExtendedCache::max_cache_blocks == 3)
        {
            switch (number_of_blocks_to_load)
            {
            case 3:
                *(dst_ptr + 2) =
                    (ExtendedCache::cache[first_cache_block_index + 2] << bit_offset) |
                    (ExtendedCache::cache[first_cache_block_index + 3] >>
                        (ExtendedCache::cache_bits_unit - bit_offset));
                BOOST_FALLTHROUGH;
            case 2:
                *(dst_ptr + 1) =
                    (ExtendedCache::cache[first_cache_block_index + 1] << bit_offset) |
                    (ExtendedCache::cache[first_cache_block_index + 2] >>
                        (ExtendedCache::cache_bits_unit - bit_offset));
                BOOST_FALLTHROUGH;
            case 1:
                *dst_ptr = (ExtendedCache::cache[first_cache_block_index] << bit_offset) |
                            (ExtendedCache::cache[first_cache_block_index + 1] >>
                            (ExtendedCache::cache_bits_unit - bit_offset));
            case 0:
                break;
            default:
                BOOST_UNREACHABLE_RETURN(dst_ptr); // NOLINT
            }
        }
        else 
        {
            for (std::uint8_t i = 0; i < number_of_blocks_to_load; ++i)
            {
                *(dst_ptr + i) =
                    (ExtendedCache::cache[first_cache_block_index + i] << bit_offset) |
                    (ExtendedCache::cache[first_cache_block_index + i + 1] >>
                        (ExtendedCache::cache_bits_unit - bit_offset));
            }
        }
    }
    
    // Remove possible flooding bits from adjacent entries.
    *dst_ptr &= (CacheBlockType(CacheBlockType(0) - CacheBlockType(1)) >> excessive_bits_to_left);

    blocks_ptr[cache_block_count - 1] &= (CacheBlockType(CacheBlockType(0) - CacheBlockType(1)) << excessive_bits_to_right);

    // To compute ceil(2^Q * x / D), we need to check if
    // 2^Q * x / D = 2^(Q + e + k - eta - 1) * 5^(k - eta) is an integer or not.
    if (k < ExtendedCache::segment_length ||
        e + k + static_cast<int>(cache_block_count * ExtendedCache::cache_bits_unit) -
                static_cast<int>(excessive_bits_to_right) <
            ExtendedCache::segment_length + 1) {
        blocks_ptr[cache_block_count - 1] += (CacheBlockType(1) << excessive_bits_to_right);
        BOOST_CHARCONV_ASSERT(blocks_ptr[cache_block_count - 1] != 0);
    }

    return cache_block_count;
}

template <bool constant_block_count, std::uint8_t max_cache_blocks>
struct cache_block_count_t;

template <std::uint8_t max_cache_blocks>
struct cache_block_count_t<false, max_cache_blocks>
{
    std::uint8_t value;
    
    operator std::uint8_t() const noexcept { return value; } // NOLINT : implicit conversions are ok for block count
    cache_block_count_t& operator=(std::uint8_t new_value) noexcept
    {
        value = new_value;
        return *this;
    }
};

template <std::uint8_t max_cache_blocks>
struct cache_block_count_t<true, max_cache_blocks>
{
    static constexpr std::uint8_t value = max_cache_blocks;
    operator std::uint8_t() const noexcept { return value; } // NOLINT : implicit conversions are ok for block count
    cache_block_count_t& operator=(std::uint8_t) noexcept
    {
        // Don't do anything.
        return *this;
    }
};

template <unsigned n>
struct uconst
{
    constexpr uconst() {}; // NOLINT : Clang 3.x does not support = default
    static constexpr unsigned value = n;
};

BOOST_INLINE_VARIABLE constexpr uconst<0>  uconst0;
BOOST_INLINE_VARIABLE constexpr uconst<1>  uconst1;
BOOST_INLINE_VARIABLE constexpr uconst<6>  uconst6;
BOOST_INLINE_VARIABLE constexpr uconst<9>  uconst9;
BOOST_INLINE_VARIABLE constexpr uconst<14> uconst14;
BOOST_INLINE_VARIABLE constexpr uconst<16> uconst16;

#ifdef __clang__
#  pragma clang diagnostic push
#  pragma clang diagnostic ignored "-Wsign-conversion"
#elif defined(__GNUC__)
#  pragma GCC diagnostic push
#  pragma GCC diagnostic ignored "-Wsign-conversion"
#elif defined(BOOST_MSVC)
#  pragma warning(push)
#  pragma warning(disable: 4365 4267)
#endif

template <unsigned digits, bool dummy = (digits <= 9)>
struct uint_with_known_number_of_digits;

template <unsigned digits_>
struct uint_with_known_number_of_digits<digits_, true> 
{
    static constexpr auto digits = digits_;
    std::uint32_t value;
};

template <unsigned digits_>
struct uint_with_known_number_of_digits<digits_, false>
{
    static constexpr auto digits = digits_;
    std::uint64_t value;
};

template <typename HasFurtherDigits, typename... Args, typename std::enable_if<std::is_same<HasFurtherDigits, bool>::value, bool>::type = true>
static BOOST_FORCEINLINE bool check_rounding_condition_inside_subsegment(
    std::uint32_t current_digits, std::uint32_t fractional_part,
    int remaining_digits_in_the_current_subsegment, HasFurtherDigits has_further_digits,
    Args...) noexcept 
{
    if (fractional_part >= additional_static_data_holder::fractional_part_rounding_thresholds32[remaining_digits_in_the_current_subsegment - 1])
    {
        return true;
    }

    return ((fractional_part >> 31) & ((current_digits & 1) | has_further_digits)) != 0;
}

template <typename HasFurtherDigits, typename... Args,
          typename std::enable_if<!std::is_same<HasFurtherDigits, bool>::value, bool>::type = true>
static BOOST_FORCEINLINE bool check_rounding_condition_inside_subsegment(
    std::uint32_t current_digits, std::uint32_t fractional_part,
    int remaining_digits_in_the_current_subsegment, HasFurtherDigits has_further_digits,
    Args... args) noexcept 
{
    if (fractional_part >= additional_static_data_holder::fractional_part_rounding_thresholds32[remaining_digits_in_the_current_subsegment - 1]) 
    {
        return true;
    }
    
    return fractional_part >= 0x80000000 && ((current_digits & 1) != 0 || has_further_digits(args...));
}

template <typename HasFurtherDigits, typename... Args,
          typename std::enable_if<std::is_same<HasFurtherDigits, bool>::value, bool>::type = true>
static BOOST_FORCEINLINE bool check_rounding_condition_with_next_bit(std::uint32_t current_digits, bool next_bit,
                                                                     HasFurtherDigits has_further_digits, Args...) noexcept 
{
    if (!next_bit) 
    {
        return false;
    }

    return ((current_digits & 1) | has_further_digits) != 0;
}

template <typename HasFurtherDigits, typename... Args,
          typename std::enable_if<!std::is_same<HasFurtherDigits, bool>::value, bool>::type = true>
static BOOST_FORCEINLINE bool check_rounding_condition_with_next_bit(std::uint32_t current_digits, bool next_bit,
                                                                     HasFurtherDigits has_further_digits, Args... args) noexcept 
{
    if (!next_bit) 
    {
        return false;
    }

    return (current_digits & 1) != 0 || has_further_digits(args...);
}

template <typename UintWithKnownDigits, typename HasFurtherDigits, typename... Args, 
          typename std::enable_if<std::is_same<HasFurtherDigits, bool>::value, bool>::type = true>
static BOOST_FORCEINLINE bool check_rounding_condition_subsegment_boundary_with_next_subsegment(
    std::uint32_t current_digits, UintWithKnownDigits next_subsegment,
    HasFurtherDigits has_further_digits, Args...) noexcept 
{
    if (next_subsegment.value > power_of_10[decltype(next_subsegment)::digits] / 2)
    {
        return true;
    }

    return next_subsegment.value == power_of_10[decltype(next_subsegment)::digits] / 2 && 
                                    ((current_digits & 1) | has_further_digits) != 0;
}

template <typename UintWithKnownDigits, typename HasFurtherDigits, typename... Args, 
          typename std::enable_if<!std::is_same<HasFurtherDigits, bool>::value, bool>::type = true>
static BOOST_FORCEINLINE bool check_rounding_condition_subsegment_boundary_with_next_subsegment(
    std::uint32_t current_digits, UintWithKnownDigits next_subsegment,
    HasFurtherDigits has_further_digits, Args... args) noexcept 
{
    if (next_subsegment.value > power_of_10[decltype(next_subsegment)::digits] / 2) 
    {
        return true;
    }

    return next_subsegment.value == power_of_10[decltype(next_subsegment)::digits] / 2 &&
                                    ((current_digits & 1) != 0 || has_further_digits(args...));
}

#ifdef __clang__
#  pragma clang diagnostic pop
#elif defined(__GNUC__)
#  pragma GCC diagnostic pop
#elif defined(BOOST_MSVC)
#  pragma warning(pop)
#endif

#ifdef BOOST_MSVC
# pragma warning(push)
# pragma warning(disable: 4307) // MSVC 14.1 emits warnings for uint64_t constants
#endif

namespace has_further_digits_impl {
template <int k_right_threshold, int additional_neg_exp_of_2>
bool no_neg_k_can_be_integer(int k, int exp2_base) noexcept 
{
    return k < k_right_threshold || exp2_base + k < additional_neg_exp_of_2;
}

template <int k_left_threshold, int k_right_threshold, int additional_neg_exp_of_2, int min_neg_exp_of_5, typename SignificandType>
bool only_one_neg_k_can_be_integer(int k, int exp2_base, SignificandType significand) noexcept
{
    // Supposed to be k - additional_neg_exp_of_5_v < -min_neg_exp_of_5 || ...
    if (k < k_left_threshold || exp2_base + k < additional_neg_exp_of_2) 
    {
        return true;
    }
    // Supposed to be k - additional_neg_exp_of_5_v >= 0.
    if (k >= k_right_threshold) 
    {
        return false;
    }

    BOOST_CXX14_CONSTEXPR std::uint64_t mod_inv = compute_power(UINT64_C(0xcccccccccccccccd), static_cast<unsigned>(min_neg_exp_of_5));
    BOOST_CXX14_CONSTEXPR std::uint64_t max_quot = UINT64_C(0xffffffffffffffff) / compute_power(UINT64_C(5), static_cast<unsigned>(min_neg_exp_of_5));

    return (significand * mod_inv) > max_quot;
}

template <int k_left_threshold, int k_middle_threshold, int k_right_threshold,
            int additional_neg_exp_of_2, int min_neg_exp_of_5, int segment_length,
            typename SignificandType>
bool only_two_neg_k_can_be_integer(int k, int exp2_base,
                                    SignificandType significand) noexcept {
    // Supposed to be k - additional_neg_exp_of_5_v < -min_neg_exp_of_5 - segment_length
    // || ...
    if (k < k_left_threshold || exp2_base + k < additional_neg_exp_of_2) {
        return true;
    }
    // Supposed to be k - additional_neg_exp_of_5_v >= 0.
    if (k >= k_right_threshold) {
        return false;
    }

    if (k >= k_middle_threshold) {
        BOOST_CXX14_CONSTEXPR std::uint64_t mod_inv =
            compute_power(UINT64_C(0xcccccccccccccccd), static_cast<unsigned>(min_neg_exp_of_5));
        BOOST_CXX14_CONSTEXPR std::uint64_t max_quot =
            UINT64_C(0xffffffffffffffff) /
            compute_power(UINT64_C(5), static_cast<unsigned>(min_neg_exp_of_5));

        return (significand * mod_inv) > max_quot;
    }
    else {
        BOOST_CXX14_CONSTEXPR std::uint64_t mod_inv = compute_power(
            UINT64_C(0xcccccccccccccccd), static_cast<unsigned>(min_neg_exp_of_5 + segment_length));
        BOOST_CXX14_CONSTEXPR std::uint64_t max_quot =
            UINT64_C(0xffffffffffffffff) /
            compute_power(UINT64_C(5),
                            static_cast<unsigned>(min_neg_exp_of_5 + segment_length));

        return (significand * mod_inv) > max_quot;
    }
}
} // Namespace has_further_digits_impl

#ifdef BOOST_MSVC
#pragma warning(pop)
#endif

inline void print_1_digit(std::uint32_t n, char* buffer) noexcept 
{
    *buffer = char('0' + n);
}

inline void print_2_digits(std::uint32_t n, char* buffer) noexcept
{
    std::memcpy(buffer, additional_static_data_holder::radix_100_table + n * 2, 2);
}

inline void print_6_digits(std::uint32_t n, char* buffer) noexcept 
{
    // 429497 = ceil(2^32/10^4)
    auto prod = (n * UINT64_C(429497)) + 1;
    print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
    
    for (int i = 0; i < 2; ++i) 
    {
        prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
        print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer + 2 + i * 2);
    }
}

inline void print_7_digits(std::uint32_t n, char* buffer) noexcept 
{
    // 17592187 = ceil(2^(32+12)/10^6)
    auto prod = ((n * UINT64_C(17592187)) >> 12) + 1;
    print_1_digit(static_cast<std::uint32_t>(prod >> 32), buffer);
    
    for (int i = 0; i < 3; ++i)
    {
        prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
        print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer + 1 + i * 2);
    }
}

inline void print_8_digits(std::uint32_t n, char* buffer) noexcept
{
    // 140737489 = ceil(2^(32+15)/10^6)
    auto prod = ((n * UINT64_C(140737489)) >> 15) + 1;
    print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
    
    for (int i = 0; i < 3; ++i) 
    {
        prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
        print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer + 2 + i * 2);
    }
}

inline void print_9_digits(std::uint32_t n, char* buffer) noexcept
{
    // 1441151881 = ceil(2^(32+25)/10^8)
    auto prod = ((n * UINT64_C(1441151881)) >> 25) + 1;
    print_1_digit(static_cast<std::uint32_t>(prod >> 32), buffer);
    
    for (int i = 0; i < 4; ++i) 
    {
        prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
        print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer + 1 + i * 2);
    }
}

struct main_cache_full 
{
    template <typename FloatFormat>
    static constexpr typename main_cache_holder::cache_entry_type get_cache(int k) noexcept
    {
        return main_cache_holder::cache[std::size_t(k - main_cache_holder::min_k)];
    }
};

struct main_cache_compressed 
{
    template <typename FloatFormat>
    static BOOST_CHARCONV_CXX14_CONSTEXPR typename main_cache_holder::cache_entry_type get_cache(int k) noexcept
    {
        BOOST_CHARCONV_ASSERT(k >= main_cache_holder::min_k && k <= main_cache_holder::max_k);

        BOOST_IF_CONSTEXPR (std::is_same<FloatFormat, ieee754_binary64>::value) 
        {
            // Compute the base index.
            const auto cache_index =
                static_cast<int>(static_cast<std::uint32_t>(k - main_cache_holder::min_k) /
                    compressed_cache_detail::compression_ratio);

            const auto kb = cache_index * compressed_cache_detail::compression_ratio +
                            main_cache_holder::min_k;

            const auto offset = k - kb;

            // Get the base cache.
            const auto base_cache = compressed_cache_detail::cache_holder_t::table[cache_index];

            if (offset == 0)
            {
                return base_cache;
            }
            else 
            {

                // Compute the required amount of bit-shift.
                const auto alpha = log::floor_log2_pow10(kb + offset) - log::floor_log2_pow10(kb) - offset;
                BOOST_CHARCONV_ASSERT(alpha > 0 && alpha < 64);

                // Try to recover the real cache.
                const auto pow5 = compressed_cache_detail::pow5_holder_t::table[offset];
                auto recovered_cache = umul128(base_cache.high, pow5);
                const auto middle_low = umul128(base_cache.low, pow5);

                recovered_cache += middle_low.high;

                const auto high_to_middle = recovered_cache.high << (64 - alpha);
                const auto middle_to_low = recovered_cache.low << (64 - alpha);

                recovered_cache = uint128{(recovered_cache.low >> alpha) | high_to_middle, ((middle_low.low >> alpha) | middle_to_low)};

                BOOST_CHARCONV_ASSERT(recovered_cache.low + 1 != 0);
                recovered_cache = uint128(recovered_cache.high, recovered_cache.low + 1);

                return recovered_cache;
            }
        }
        else
        {
            // Just use the full cache for anything other than binary64
            return main_cache_holder::cache[std::size_t(k - main_cache_holder::min_k)];
        }
    }
};

template <bool b>
struct extended_cache_long_impl
{
    static constexpr std::size_t max_cache_blocks = 3;
    static constexpr std::size_t cache_bits_unit = 64;
    static constexpr int segment_length = 22;
    static constexpr bool constant_block_count = true;
    static constexpr int e_min = -1074;
    static constexpr int k_min = -272;
    static constexpr int cache_bit_index_offset_base = 977;
    static constexpr std::uint64_t cache[] = {
        0xa37fce126597973c, 0xe50ff107bab528a0, 0x8f1ba3f17395a391, 0xd56bdc876cdb4648,
        0x6ca000bdd9e33bd4, 0x23cf34bbf983f78b, 0x8737d87296e93f5d, 0xa2824ba6d9df301d,
        0x8ce3eccf7cfb42ab, 0xe5ecdc0b78109f00, 0xa620c9995c9c5c3a, 0xa0f79c97ac210943,
        0x64dfb5636985915f, 0xc12f542e4c7ea6ee, 0x34de81232784ea17, 0xd0cbde7fac4643f2,
        0x5d9400de8fef7552, 0x81214f68696d9af2, 0xb7d0e0a2ccaccf20, 0x5c4ed9243f16193d,
        0xf71838486e60b926, 0x48892047ec1a8bf4, 0x14ff2faa9c32befa, 0x666fbaa24ddbb8e9,
        0x436682c807652a58, 0xed98ddaee19068c7, 0x63badd624dd9b095, 0x72dbb637d5b77493,
        0xd01998fb8d9e8861, 0xacb39418dce017b9, 0x8db8f2f13eed81cf, 0xfd699fbb7d0a737a,
        0x011cd67160923d91, 0x9a66fd7732c14d98, 0x235857d065a52d18, 0x895288951dab0d8e,
        0x59041cb66e4f0e68, 0x5e7c68240249e750, 0x8881a2a6ab00987b, 0x5fc8c32c863aaeac,
        0x3bafbe662a7f81a8, 0xd47692705ae76b64, 0xeb1cc7d99143fb53, 0xcf8be24f7b0fc499,
        0x6a276e8f0fbf33eb, 0x63b2d61966fa7243, 0x0970327d2cc58011, 0x43ff09410ec24aae,
        0x0bdb6f345ea1851d, 0x409c37132c5836ff, 0xf3150f74a6190324, 0x5c358d6c07453d23,
        0x7207012ad7846ba7, 0x61ad5d0772604733, 0x19a20a6e21c2018d, 0x5f568fd497ef18b2,
        0xeda5815eed00749f, 0x029531461bc483d8, 0xb8789d7784875911, 0x6fc40572236f2ba5,
        0x9c2a50a76ace3168, 0xbf4815c2bea56741, 0xf84e8f2fe9b211f5, 0x689033182d2ea7ed,
        0x5bcb3a3230a68f47, 0xa848403d116805ef, 0xfaeaa73623b79604, 0x31d76828d2181b64,
        0x7c4eabddc7dd634b, 0xc2b13231eeff6fda, 0x8094743db32bf251, 0x2df07391bde052d2,
        0xffd9bdbf321ad8ae, 0x06b2c6d1cf6cf742, 0xf32a54ce1598fe8f, 0x1cc2e3082d28897e,
        0x0485f2e46b488584, 0xe3f6965b145a49cb, 0x406eaa1217aefe69, 0x0777373638de456b,
        0xcde91853b592212b, 0x3faf7b46d7f79c18, 0x558d83afb7127381, 0x5f490259c7957aeb,
        0x76e6540e246d73cc, 0x5098a935a866dc75, 0xc50d9c29002d9e73, 0xcc8f8252faac0b7f,
        0xb759afb688f8251d, 0x6a2934d3036c85d3, 0x570eb3ce4c86407f, 0x036f2b68794754af,
        0x57661a5d6993fe2c, 0x6d07b7fabe546a80, 0x38efe4029259743c, 0x548f417ebaa61c6c,
        0xb0c31fa64a3fcc9e, 0x7dab825964fb7100, 0xd0c92ae8207d6f22, 0xf1e38a8a9c541144,
        0x2139951c68d0385b, 0x9d9e22c42f139287, 0x4fea4d670876b800, 0x35f293a9a62252d4,
        0x4b606b26f1922c5c, 0x8e5660b37505cb11, 0x868138391855da81, 0x6e95f6c9b45c7aa2,
        0x425ff75e14fc31a1, 0x258379a94d028d18, 0xdf2ccd1fe00a03b6, 0x398471c1ff970f83,
        0x8c36b2214a3db8e7, 0x431dd42c3fe7f4fb, 0xb09bcf0fffb5b849, 0xc47dd13da60fb5a1,
        0x8fdad56516fe9d75, 0xc317e1025a7e1c63, 0x9ddcb98cbb384fda, 0x80adccda993bf70e,
        0x667f1622e4052ae4, 0xa41598d58f777363, 0x704b93d675808501, 0xaf046d3fd448aaf3,
        0x1dc4611873bf3f70, 0x834acdae9f0f4f53, 0x4f5d60585a5f1c1a, 0x3ced1b4be0d415c1,
        0x5d57f4de8ec12376, 0x51c0e7e72f799542, 0x46f7604940e6a510, 0x1a546a0f9345ed75,
        0x0df4097cab773ca2, 0x72b122774e4029e6, 0xae4a55b99aebd424, 0x04163a291bad2fa3,
        0x86ad58be322a49aa, 0x98f051614696e839, 0x64d08f241fc4ec58, 0xae41f23dca90dd5d,
        0x68bbd62f5af3107a, 0x7025f39ef241c56c, 0xd2e7c72fa9be33ac, 0x0aece66fd3e29a7d,
        0xd91241cebf3bd47c, 0x3ed7bfdee19ba2f6, 0x4bdf483194c7444e, 0xc99d83c931e8ab87,
        0x1732f416dbf7381f, 0x2ac88e244de13b96, 0x2cab688bd86c8bf8, 0x9f209787bb47d6b8,
        0x4c0678c5dbd23a49, 0xa0612c3c5ce15e55, 0x4dccc6ca29b3e9df, 0x0dc079c918022212,
        0x26be55a64c249495, 0x4da2c9789dd268b0, 0xe975528c76435158, 0xa6cb8a4d2356f9cf,
        0xdcafd2279c77d987, 0xaa9aff7904228690, 0xfb44d2f05d0842fb, 0x118fc9c217a1d2b2,
        0x04b3d9686f55b572, 0xbd9cb3625ef1cfc3, 0x2eba0e25e938e6c3, 0x1f48eaf234ad3a21,
        0xf2dc02fad2890f79, 0xace340325d4a7f9b, 0xe9e051f540b239dc, 0x221091f05abb8687,
        0x7e08deb014db8afe, 0x4711e1e9d9a094cc, 0x0b2d79bd90a9ef61, 0xb93d19bd45b82515,
        0x45e9e31d63c1afe1, 0x2c5f0a596005c216, 0xe687cc2331b14a12, 0x51963a2412b6f60c,
        0x91aeb77c8fe68eaa, 0xd6e18e8cc6841d68, 0x9391085cc2c933d9, 0x6e184be07e68df49,
        0x4fe4e52edb0dce60, 0x6cda31e8617f0ca2, 0xf8b9374fda7e7c95, 0x8032c603725e774d,
        0x222b6aa27e007612, 0xf7b7f47cf096afad, 0xe6a9fbafee77e77a, 0x3776ee406e63fbaa,
        0xde147932fcf78be6, 0x2ab9e031ffaa071e, 0x2169ad0e8a9b1256, 0xe33358135938b76a,
        0xcaec07e7a5373835, 0xef2863090a97c3ec, 0x6ccfb95f69c3adcc, 0x173e00da427cee4b,
        0x20f4ed58fcfb3040, 0x16f6fb326a60c32c, 0x2968fa04270ed545, 0x70673adfac0eabc4,
        0x6ff3c9364ff4e873, 0xde09ed35f13325d3, 0x2396e863b18c500f, 0xe22d253cc031e3ff,
        0x756d97a61247798d, 0xc9fc8d937e43c880, 0x0759ba59c08e14c7, 0xcd7aad86a4a45810,
        0x9f91c21c571dbe84, 0xd52d936f44abe8a3, 0xd5b48c100959d9d0, 0xb6cc856b3adc93b6,
        0x7aea8f8e067d2c8d, 0x04bc177f7b4287a6, 0xe3fcda36fa3b3342, 0xeaeb442e15d45095,
        0x2f4dd1ca5e89b18b, 0x602368385bb19cb1, 0x4bdfc434d3028181, 0x0b5a92cb80ac8150,
        0xb95953a97b1578ab, 0x46e6a18b01781b92, 0xdfd31585f38d7433, 0x0b1084b96009370b,
        0x9a81808e52462ba3, 0xff83368ace4af235, 0xb4e5d8a647e05e95, 0xf848cfc90df4b231,
        0x9919c68cf3576038, 0x1e89dad8a6790435, 0x7ac9361379139511, 0x7b5f9b6b937a7760,
        0x6e42e395fde0c1f7, 0x430cef1679799f8f, 0x0ad21cc1b4828074, 0x8982577d0ea42349,
        0xb1aca6185a7d0d0d, 0x4085c6db106c3d74, 0xba6f7a86e728a418, 0x0325a28758a974d2,
        0x57ea317f731817ed, 0xbd1e8e00b215a6eb, 0xb39f323742948e87, 0x9f9b0f873784cef4,
        0xa8c83d26585c5377, 0x837ba337bfcf893c, 0x0a7eeca62a23b805, 0xba4925a9e7f7346f,
        0xa574eebb90c8da6d, 0x5db7ff0e8d0b8d2d, 0x1562834c52c048d8, 0x0b2e577a853bcafc,
        0xdecef97a3524ff97, 0xeec053c8fd537066, 0xeaf2b1df83d600e4, 0x5be8b9ab7717eccf,
        0x05905b91ecbba038, 0xabacba5b373029ed, 0x22fb2283c0ee1267, 0x9c32b2ec3634c580,
        0x5186c586b6e5611c, 0x71eb0de5e91bb0a0, 0x89e969b42975ef08, 0x2ba0958bc44e322f,
        0x626d033cb828ba7d, 0xe5fbb65c7776509d, 0xb1403ae51ae9bc82, 0x5d773f0d9753a966,
        0x4a06feadd4ec8585, 0xda58a710fccd7b76, 0x6061ba4cd3d80d59, 0xf4824f5cfa2ba71c,
        0xfce622bba0ece756, 0x7d9c738486bc6842, 0x5f629d33c99db969, 0x855ff7c9b79362e6,
        0x892188a87c7de231, 0x85fea7caf30e2b5e, 0xbefeb221543782c5, 0x769ca33d280842f6,
        0x3974ebaf71353e52, 0xed0577283980f0cb, 0x7c37d689ab6b0662, 0x5037aeffcd3db52d,
        0x11bb0a5f64fbdcb5, 0xf5fd5aa5f2b7e974, 0xe1aa07ba7074367b, 0x4b5c14aa1c6a0d28,
        0xe9fc8c9c36f73953, 0x2609ad2cd0f99b76, 0x8d4f1d6bb589844f, 0xde09f066714fa909,
        0xe004c5d7adad3747, 0xd5ac81a94dfdefe3, 0xfd3e0083658a13c2, 0xf5512f25dd6e39a7,
        0xeb7204042ffa181d, 0x046d9254242d06e3, 0x91a5ca94f8706fab, 0xf5c58cc57af63c98,
        0x04e7ff1e23474908, 0xe4a9bec5c5818324, 0x1edfb105cc3084dd, 0x82431ec76e72a87a,
        0xe0b215be32c51083, 0x0d9942e3b5245098, 0xa49f1aad5723fd7e, 0xad45edba25a4bde8,
        0x241f0adc0cd56771, 0xf09bf2de59df3274, 0x090db856bbc020f2, 0x6aa4efb2d2ecb9bb,
        0xc6be4224ba04c233, 0x557a1760bde90850, 0x23090117938cb921, 0xcbec34da23f3e9c2,
        0xdfe2d55daad85c54, 0xa7932be700067f48, 0xfb7874535e2d76a4, 0x5161ba088056e74f,
        0xc275a8435be6cdb2, 0x05fcb771cab5aa15, 0x7f18a4382c9565a8, 0x4244c2cb833d6710,
        0x884e2b7a4a3db4d0, 0x08ded459d3edf2c2, 0x1616df531fee90cd, 0x9531c65800a97aaa,
        0x881ba77ab7e5d63a, 0x606d27428df4edd3, 0x294063ed78e305c7, 0x7de2b12f8a8cceb5,
        0xe6b01cc54a494437, 0x0cdecbe5ac90907c, 0xb88496c657d3e644, 0xf3eecf996f9c6b13,
        0x24aad7949edcde03, 0x304ca88ebfeaa534, 0x7b68a7bd3ef1916b, 0x3cc307a784d9060c,
        0x5dca03f19b213efd, 0xa380539c235f80c3, 0xf39756fc01d75bd7, 0x39ac6c7281739adb,
        0x4b606dc4aa036fda, 0x97126cd02a23b97c, 0x98c1e6906230aead, 0xe12d0f696a6bbc36,
        0x657a202bb6a89a33, 0x6421a07bda47e13d, 0x8d9d21b3c6b1dbee, 0x1f110f3744f13e0d,
        0x04d86fccb6e77ee8, 0x8c92852d9c9c14b3, 0x56be3cef19b19446, 0x57ceef0e2ebcbcf7,
        0x230a9328be0144bf, 0x3c1949b98a92aebc, 0x7ed2db80a62003f2, 0x84e609d13c7594f4,
        0xf8e81b9a9f35b4e8, 0xc2982fde1a087e4b, 0x84b0713cb3b18147, 0x3582530578d1ff08,
        0x0e5b6538cd61fce4, 0x46867abf4b6e72bc, 0x4fe9652832325e89, 0x7d141d065654745f,
        0x9bd5c0479188a53d, 0x4ccd47925108c00b, 0xfd3f6c8d961d47e3, 0x9c5c18a96093d2ad,
        0xa7d91bf008a358c3, 0x3ea3e5629f977d55, 0x80f0fed6a5f06003, 0x21f390e377ee4d68,
        0x73ed055ec082526b, 0x28482600c10f6ce2, 0x2bff1aaf94c11fe9, 0xde29cb7a943801b8,
        0x045b0493dd35af0e, 0xaeae25ff7a431c16, 0x78c9d3348f5364b7, 0xf973d1af84bc2476,
        0x4d2303e11baf18f3, 0xacebdb3fe5efbc7b, 0xd274a5cf5be50678, 0x2d60c40fdf53ac67,
        0x109592b606139855, 0x612f472a9c09925f, 0x701a035ccd4e7ab0, 0xac881f0db121a709,
        0xe1ed47438368366d, 0xde2faff8eeb2810a, 0x8eb2188044342ef9, 0x0e3c1aa7b6851548,
        0x7ce94a6ba4fd843f, 0x0da503676ee5ebb2, 0xf3bc7bb2cb8669e8, 0xd4b9e44de392fe64,
        0x81e470ebf207fdea, 0xdd53b09d49a0e5b5, 0xf78e23167a350d5a, 0x706470fc2d84423b,
        0x816ee82b19a29476, 0x35a9d218ba7cd4a1, 0xf590f12fb09b3fe3, 0x5e574140b302f8b7,
        0x6cb237a2021f77c3, 0x30a29037231a861e, 0xff4bb07af553a606, 0x831412ee2690d92c,
        0xf6d2d725ef14ff67, 0x2f79f810928a40ff, 0x2857d91ea9b04f71, 0xd063066f0ed78f3c,
        0xbf4b8dbc8a34017d, 0x6230f319f8b1f9c4, 0x061b0e25d8899834, 0x4071de32ef7ff0bf,
        0xbc546a0793fcfcd3, 0xd5881f5d968cf898, 0x0e21c0674cdda190, 0x0000000000000000};

    struct multiplier_index_info 
    {
        std::uint16_t first_cache_bit_index;
        std::uint16_t cache_bit_index_offset;
    };

    static constexpr multiplier_index_info multiplier_index_info_table[] = {
        {0, 0},         {171, 244},     {419, 565},     {740, 959},     {1135, 1427},
        {1604, 1969},   {2141, 2579},   {2750, 3261},   {3434, 4019},   {4191, 4849},
        {5019, 5750},   {5924, 6728},   {6904, 7781},   {7922, 8872},   {8993, 10016},
        {9026, 10122},  {9110, 10279},  {9245, 10487},  {9431, 10746},  {9668, 11056},
        {9956, 11418},  {10296, 11831}, {10687, 12295}, {11129, 12810}, {11622, 13376},
        {12166, 13993}, {12761, 14661}, {13407, 15380}, {14104, 16150}, {14852, 16902},
        {15582, 17627}, {16285, 18332}, {16968, 19019}, {17633, 19683}, {18275, 20326},
        {18896, 20947}, {19495, 21546}, {20072, 22122}, {20626, 22669}, {21151, 23202},
        {21662, 23713}, {22151, 24202}, {22618, 24669}, {23063, 25114}, {23486, 25535},
        {23885, 25936}, {24264, 26313}, {24619, 26670}, {24954, 27004}, {25266, 27316},
        {25556, 27603}, {25821, 27870}, {26066, 28117}, {26291, 28340}, {26492, 28543},
        {26673, 28723}, {26831, 28881}, {26967, 29018}, {27082, 29133}, {27175, 29225},
        {27245, 29296}, {27294, 29344}, {27320, 29370}, {27324, 0}};
};

#if defined(BOOST_NO_CXX17_INLINE_VARIABLES) && (!defined(BOOST_MSVC) || BOOST_MSVC != 1900)

template <bool b> constexpr std::size_t extended_cache_long_impl<b>::max_cache_blocks;
template <bool b> constexpr std::size_t extended_cache_long_impl<b>::cache_bits_unit;
template <bool b> constexpr int extended_cache_long_impl<b>::segment_length;
template <bool b> constexpr bool extended_cache_long_impl<b>::constant_block_count;
template <bool b> constexpr int extended_cache_long_impl<b>::e_min;
template <bool b> constexpr int extended_cache_long_impl<b>::k_min;
template <bool b> constexpr int extended_cache_long_impl<b>::cache_bit_index_offset_base;
template <bool b> constexpr std::uint64_t extended_cache_long_impl<b>::cache[];
template <bool b> constexpr typename extended_cache_long_impl<b>::multiplier_index_info extended_cache_long_impl<b>::multiplier_index_info_table[];

#endif

using extended_cache_long = extended_cache_long_impl<true>;

struct extended_cache_compact 
{
    static constexpr std::size_t max_cache_blocks = 6;
    static constexpr std::size_t cache_bits_unit = 64;
    static constexpr int segment_length = 80;
    static constexpr bool constant_block_count = false;
    static constexpr int collapse_factor = 64;
    static constexpr int e_min = -1074;
    static constexpr int k_min = -211;
    static constexpr int cache_bit_index_offset_base = 967;
    static constexpr int cache_block_count_offset_base = 27;

    static constexpr std::uint64_t cache[] = {
        0x9faacf3df73609b1, 0x77b191618c54e9ac, 0xcbc0fe19cae9528c, 0x8164d034592c3d4e,
        0x04c42d46c9d7a229, 0x7ee39007a5bc8cc3, 0x5469cf7bb8b25e57, 0x2effce010198cb81,
        0x642eb5bc0d8169e0, 0x91356aed1f5cd514, 0xe1c8f30156868b8c, 0xd1201a2b857f5cc5,
        0x15c07ee55715eff8, 0x8530360cd386f94f, 0xeb706c10ea02c329, 0x3cb22680f921f59e,
        0x3231912d5bf60e61, 0x0e1fff697ed6c695, 0xa8bed97c2f3b63fc, 0xda96e93c07538a6d,
        0xc1c4e34ccd6fdbc5, 0x85c09fd1d0f79834, 0x485f3a5d03622bba, 0xe640b09cca5b9d50,
        0x19a80913a40927a9, 0x4d82d751a5cf886d, 0x325c9cd793b9977b, 0x4896c18501fb9e0c,
        0xa9993bfdf3ea7275, 0xcb7d257a3ee7c9d8, 0xcbf8fdb78849a5f9, 0x6de98520472bdd03,
        0x36efd14b69b311de, 0x694fa387dcf3e78f, 0xdccfbfc61d1662ef, 0xbe3a4d4104fb75a2,
        0x289ccaebae5c6d2d, 0x436915952987fa63, 0x830446728505ab75, 0x3ad8772923e4e0c0,
        0xca946600436f3894, 0x0faae7895e3885f0, 0xadf6b773b1ebf8e0, 0x52473dd5e8218647,
        0x5e6b5121ca3b747c, 0x217399923cd80bc0, 0x0a56ced144bb2f9f, 0xb856e82eea863c1f,
        0x5cdae42f9562104d, 0x3fa421962c8c4241, 0x63451ff73769a3d2, 0xb0895649e11affd6,
        0xe5dd7be415e5d3ef, 0x282a242e818f1668, 0xc8a86da5faf0b5cc, 0xf5176ecc7cbb19db,
        0x2a9a282e49b4da0e, 0x59e22f9ed2cb3a4b, 0xc010afa26505a7e7, 0xee47b3ab83a99c3e,
        0xc7eafae5fa385ec2, 0x3ec747e06293a148, 0x4b8a8260baf424a7, 0x63079a1ac7709a4e,
        0x7fd0cd567aa4a0fa, 0x6909d0e0cfc6ce8d, 0xe0c965770d1491dd, 0xa6d4449e3a3e13ea,
        0x73e06d2253c6b584, 0x9f95a4b69679998d, 0x0cc8cc76a8234060, 0xd3da311bb4fc0aae,
        0x670614382f45f33c, 0x21f68425f4189fbf, 0x557ce28d58d9a8bd, 0x1f16d908907d0a0e,
        0x929415f993b9a2c2, 0x95e0878748988052, 0xc4a104701f794a31, 0xe7d2d2b0c3c31b19,
        0x1e6a68d5574b3d9d, 0x5727ec70c7681154, 0xe4b2adae8ac5259e, 0x1cefff5ed639205f,
        0xf9410ba5daeb3af5, 0x21b0ad30acb4b8d2, 0xd324604028bf6fac, 0x349a5d2dc4bdc6e0,
        0xc77223714aff22d9, 0x5b18ce4aabb5b369, 0xb8a6d609b15ecab7, 0x2111dbce86023643,
        0x2a5717a571b96b6c, 0x8039783af28427bf, 0x5bbadd6a1a3fb931, 0xe8564a7a3e3ff2dc,
        0xd0868939e541158e, 0xc57d0b8a8af06dde, 0xf1706d329def96c1, 0xbe74f435713bb7d5,
        0x8dcdaef5bfb0242c, 0x73b5a1c8c8ec33c7, 0x4ab726d9dac95550, 0x210cf3b3ddfa00ae,
        0x559d5e65eefbfa04, 0xe5d1f67c5f9de0ec, 0x6ad4699ea2d0efd6, 0x9590c0f05024f29a,
        0x917d5715e6e20913, 0xb13124a40bffe5ba, 0x5248ce22e40406e5, 0xb844b16596551ded,
        0xad4c4c5140496c58, 0x458562ae335689b6, 0x269441e13a195ad3, 0x7a5e32a8baf53ea8,
        0x6d1469edb474b5f6, 0xe87b554829f6ee5b, 0xbf824a42bae3bdef, 0xed12ec6937744feb,
        0x2ca544e624e048f9, 0x1bab8d5ee0c61285, 0x8863eaef018d32d9, 0x98f37ac46669f7ea,
        0xa9a0573cb5501b2b, 0xf25c3a8e08a5694d, 0x42355a8000000000, 0x0000000000000000};

    struct multiplier_index_info 
    {
        std::uint16_t first_cache_bit_index;
        std::uint16_t cache_bit_index_offset;
        std::uint16_t cache_block_count_index_offset;
    };

    static constexpr multiplier_index_info multiplier_index_info_table[] = {
        {0, 0, 0},          {377, 643, 9},      {1020, 1551, 22},  {1924, 2721, 39},
        {3046, 4109, 60},   {3114, 4443, 70},   {3368, 4962, 84},  {3807, 5667, 98},
        {4432, 6473, 111},  {5158, 7199, 123},  {5804, 7845, 134}, {6370, 8411, 143},
        {6856, 8896, 151},  {7261, 9302, 158},  {7587, 9628, 164}, {7833, 9874, 168},
        {7999, 10039, 171}, {8084, 10124, 173}, {8089, 0, 0}};

    static constexpr std::uint8_t cache_block_counts[] = {
        0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66,
        0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x56, 0x34, 0x12, 0x66,
        0x66, 0x45, 0x23, 0x61, 0x66, 0x66, 0x66, 0x45, 0x23, 0x61, 0x66, 0x66, 0x66,
        0x56, 0x34, 0x12, 0x66, 0x66, 0x66, 0x56, 0x34, 0x12, 0x66, 0x66, 0x66, 0x45,
        0x23, 0x61, 0x66, 0x56, 0x34, 0x12, 0x66, 0x56, 0x34, 0x12, 0x66, 0x45, 0x23,
        0x61, 0x45, 0x23, 0x41, 0x23, 0x31, 0x12, 0x12, 0x01};
};

#ifdef BOOST_CXX17_INLINE_VARIABLES

constexpr std::size_t extended_cache_compact::max_cache_blocks;
constexpr std::size_t extended_cache_compact::cache_bits_unit;
constexpr int extended_cache_compact::segment_length;
constexpr bool extended_cache_compact::constant_block_count;
constexpr int extended_cache_compact::collapse_factor;
constexpr int extended_cache_compact::e_min;
constexpr int extended_cache_compact::k_min;
constexpr int extended_cache_compact::cache_bit_index_offset_base;
constexpr int extended_cache_compact::cache_block_count_offset_base;
constexpr extended_cache_compact::multiplier_index_info extended_cache_compact::multiplier_index_info_table[];
constexpr std::uint8_t extended_cache_compact::cache_block_counts[];

#endif

struct extended_cache_super_compact 
{
    static constexpr std::size_t max_cache_blocks = 15;
    static constexpr std::size_t cache_bits_unit = 64;
    static constexpr int segment_length = 252;
    static constexpr bool constant_block_count = false;
    static constexpr int collapse_factor = 128;
    static constexpr int e_min = -1074;
    static constexpr int k_min = -65;
    static constexpr int cache_bit_index_offset_base = 1054;
    static constexpr int cache_block_count_offset_base = 10;

    static constexpr std::uint64_t cache[] = {
        0xf712b443bbd52b7b, 0xa5e9ec7501d523e4, 0x6f99ee8b281c132a, 0x1c7262e905287f33,
        0xbf4f71a69f411989, 0xe95fb0bf35d5c518, 0x00d875ffe81c1457, 0x31f0fcb03c200323,
        0x6f64d6af592895a0, 0x45c073ee14c78fb0, 0x8744404cbdba226c, 0x8dbe2386885f0c74,
        0x279b6693e94ab813, 0x6df0a4a86ccbb52e, 0xa94baea98e947129, 0xfc2b4e9bb4cbe9a4,
        0x73bbc273e753c4ad, 0xc70c8ff8c19c1059, 0xb7da754b6db8b578, 0x5214cf7f2274988c,
        0x39b5c4db3b36b321, 0xda6f355441d9f234, 0x01ab018d850bd7e2, 0x36517c3f140b3bcf,
        0xd0e52375d8d125a7, 0xaf9709f49f3b8404, 0x022dd12dd219aa3f, 0x46e2ecebe43f459e,
        0xa428ebddeecd6636, 0x3a7d11bff7e2a722, 0xd35d40e9d3b97c7d, 0x60ef65c4478901f1,
        0x945301feb0da841a, 0x2028c054ab187f51, 0xbe94b1f686a8b684, 0x09c13fdc1c4868c9,
        0xf2325ac2bf88a4ce, 0x92980d8fa53b6888, 0x8f6e17c7572a3359, 0x2964c5bfdd7761f2,
        0xf60269fc4910b562, 0x3ca164c4a2183ab0, 0x13f4f9e5a06a95c9, 0xf75022e39380598a,
        0x0d3f3c870002ab76, 0x24a4beb4780b78ef, 0x17a59a8f5696d625, 0x0ad76de884cb489d,
        0x559d3d0681553d6a, 0x813dcf205788af76, 0xf42f9c3ad707bf72, 0x770d63ceb129026c,
        0xa604d413fc14c7c2, 0x3cfc19e01239c784, 0xec7ef19965cedd56, 0x7303dcb3b300b6fd,
        0x118059e1139c0f3c, 0x97097186308c91f7, 0x2ad91d77379dce42, 0xad396c61acbe15ec,
        0x728518461b5722b6, 0xb85c5bb1ed805ecd, 0x816abc04592a4974, 0x1866b17c7cfbd0d0,
        0x0000000000000000};

    struct multiplier_index_info 
    {
        std::uint16_t first_cache_bit_index;
        std::uint16_t cache_bit_index_offset;
        std::uint16_t cache_block_count_index_offset;
    };

    static constexpr multiplier_index_info multiplier_index_info_table[] = {
        {0, 0, 0},        {860, 1698, 13},  {2506, 4181, 29}, {2941, 5069, 36},
        {3577, 5705, 41}, {3961, 6088, 44}, {4092, 0, 0}};

    static constexpr std::uint8_t cache_block_counts[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xee,
                                                            0xee, 0xee, 0xee, 0xee, 0xac, 0x68,
                                                            0x24, 0x8a, 0x46, 0x62, 0x24, 0x13};
};

#ifdef BOOST_CXX17_INLINE_VARIABLES

constexpr std::size_t extended_cache_super_compact::max_cache_blocks;
constexpr std::size_t extended_cache_super_compact::cache_bits_unit;
constexpr int extended_cache_super_compact::segment_length;
constexpr bool extended_cache_super_compact::constant_block_count;
constexpr int extended_cache_super_compact::collapse_factor;
constexpr int extended_cache_super_compact::e_min;
constexpr int extended_cache_super_compact::k_min;
constexpr int extended_cache_super_compact::cache_bit_index_offset_base;
constexpr int extended_cache_super_compact::cache_block_count_offset_base;
constexpr std::uint64_t extended_cache_super_compact::cache[];
constexpr extended_cache_super_compact::multiplier_index_info extended_cache_super_compact::multiplier_index_info_table[];
constexpr std::uint8_t extended_cache_super_compact::cache_block_counts[];

#endif

#ifdef BOOST_MSVC
# pragma warning(push)
# pragma warning(disable: 4100) // MSVC 14.0 warning of unused formal parameter is incorrect
#endif

template <unsigned v1, unsigned v2, typename ExtendedCache>
bool has_further_digits(std::uint64_t significand, int exp2_base, int& k, boost::charconv::detail::uconst<v1> additional_neg_exp_of_2_c, boost::charconv::detail::uconst<v2> additional_neg_exp_of_10_c) noexcept
{
    constexpr auto additional_neg_exp_of_2_v = static_cast<int>(decltype(additional_neg_exp_of_2_c)::value +
                                               decltype(additional_neg_exp_of_10_c)::value);
    
    constexpr auto additional_neg_exp_of_5_v = static_cast<int>(decltype(additional_neg_exp_of_10_c)::value);

    constexpr auto min_neg_exp_of_5 = (-ExtendedCache::k_min + additional_neg_exp_of_5_v) % ExtendedCache::segment_length;

    // k >= k_right_threshold iff k - k1 >= 0.
    static_assert(additional_neg_exp_of_5_v + ExtendedCache::segment_length >= 1 + ExtendedCache::k_min, 
    "additional_neg_exp_of_5_v + ExtendedCache::segment_length >= 1 + ExtendedCache::k_min");

    constexpr auto k_right_threshold = ExtendedCache::k_min + 
    ((additional_neg_exp_of_5_v + ExtendedCache::segment_length - 1 -
            ExtendedCache::k_min) /
            ExtendedCache::segment_length) *
            ExtendedCache::segment_length;

    // When the smallest absolute value of negative exponent for 5 is too big,
    // so whenever the exponent for 5 is negative, the result cannot be an
    // integer.
    BOOST_IF_CONSTEXPR (min_neg_exp_of_5 > 23)
    {
        return boost::charconv::detail::has_further_digits_impl::no_neg_k_can_be_integer<
            k_right_threshold, additional_neg_exp_of_2_v>(k, exp2_base);
    }
    // When the smallest absolute value of negative exponent for 5 is big enough, so
    // the only negative exponent for 5 that allows the result to be an integer is the
    // smallest one.
    else BOOST_IF_CONSTEXPR (min_neg_exp_of_5 + ExtendedCache::segment_length > 23)
    {
        // k < k_left_threshold iff k - k1 < -min_neg_exp_of_5.
        static_assert(additional_neg_exp_of_5_v + ExtendedCache::segment_length >= min_neg_exp_of_5 + 1 + ExtendedCache::k_min,
        "additional_neg_exp_of_5_v + ExtendedCache::segment_length >= min_neg_exp_of_5 + 1 + ExtendedCache::k_min");

        constexpr auto k_left_threshold =
            ExtendedCache::k_min +
            ((additional_neg_exp_of_5_v - min_neg_exp_of_5 +
                ExtendedCache::segment_length - 1 - ExtendedCache::k_min) /
                ExtendedCache::segment_length) *
                ExtendedCache::segment_length;

        return boost::charconv::detail::has_further_digits_impl::only_one_neg_k_can_be_integer<
            k_left_threshold, k_right_threshold, additional_neg_exp_of_2_v,
            min_neg_exp_of_5>(k, exp2_base, significand);
    }
    // When the smallest absolute value of negative exponent for 5 is big enough, so
    // the only negative exponents for 5 that allows the result to be an integer are the
    // smallest one and the next smallest one.
    else
    {
        static_assert(min_neg_exp_of_5 + 2 * ExtendedCache::segment_length > 23,
                        "min_neg_exp_of_5 + 2 * ExtendedCache::segment_length > 23");

        constexpr auto k_left_threshold =
            ExtendedCache::k_min +
            ((additional_neg_exp_of_5_v - min_neg_exp_of_5 - 1 - ExtendedCache::k_min) /
                ExtendedCache::segment_length) *
                ExtendedCache::segment_length;

        constexpr auto k_middle_threshold =
            ExtendedCache::k_min +
            ((additional_neg_exp_of_5_v - min_neg_exp_of_5 +
                ExtendedCache::segment_length - 1 - ExtendedCache::k_min) /
                ExtendedCache::segment_length) *
                ExtendedCache::segment_length;

        return boost::charconv::detail::has_further_digits_impl::only_two_neg_k_can_be_integer<
            k_left_threshold, k_middle_threshold, k_right_threshold,
            additional_neg_exp_of_2_v, min_neg_exp_of_5, ExtendedCache::segment_length>(
            k, exp2_base, significand);
    }
}

template <unsigned v1, unsigned v2, typename ExtendedCache>
inline bool has_further_digits(std::uint64_t significand, int exp2_base, int& k)
{
    boost::charconv::detail::uconst<v1> additional_neg_exp_of_2_c;
    boost::charconv::detail::uconst<v2> additional_neg_exp_of_10_c;

    return has_further_digits<v1, v2, ExtendedCache>(significand, exp2_base, k, additional_neg_exp_of_2_c, additional_neg_exp_of_10_c);
}

template <unsigned additional_neg_exp_of_2, unsigned additional_neg_exp_of_10, typename ExtendedCache>
bool compute_has_further_digits(unsigned remaining_subsegment_pairs, std::uint64_t significand, int exp2_base, int& k) noexcept
{
    #define BOOST_CHARCONV_252_HAS_FURTHER_DIGITS(n)                                                        \
    case n:                                                                                            \
        return has_further_digits<additional_neg_exp_of_2, additional_neg_exp_of_10 + (n - 1) * 18, ExtendedCache>(significand, exp2_base, k)                                             
                                    switch (remaining_subsegment_pairs) {
                                        BOOST_CHARCONV_252_HAS_FURTHER_DIGITS(1);
                                        BOOST_CHARCONV_252_HAS_FURTHER_DIGITS(2);
                                        BOOST_CHARCONV_252_HAS_FURTHER_DIGITS(3);
                                        BOOST_CHARCONV_252_HAS_FURTHER_DIGITS(4);
                                        BOOST_CHARCONV_252_HAS_FURTHER_DIGITS(5);
                                        BOOST_CHARCONV_252_HAS_FURTHER_DIGITS(6);
                                        BOOST_CHARCONV_252_HAS_FURTHER_DIGITS(7);
                                        BOOST_CHARCONV_252_HAS_FURTHER_DIGITS(8);
                                        BOOST_CHARCONV_252_HAS_FURTHER_DIGITS(9);
                                        BOOST_CHARCONV_252_HAS_FURTHER_DIGITS(10);
                                        BOOST_CHARCONV_252_HAS_FURTHER_DIGITS(11);
                                        BOOST_CHARCONV_252_HAS_FURTHER_DIGITS(12);
                                        BOOST_CHARCONV_252_HAS_FURTHER_DIGITS(13);
                                        BOOST_CHARCONV_252_HAS_FURTHER_DIGITS(14);

                                    default:
                                        BOOST_UNREACHABLE_RETURN(remaining_subsegment_pairs); // NOLINT
                                    }
    #undef BOOST_CHARCONV_252_HAS_FURTHER_DIGITS

    BOOST_UNREACHABLE_RETURN(false); // NOLINT
}

#ifdef BOOST_MSVC
# pragma warning(pop)
#endif

// Print 0.000...0 where precision is the number of 0's after the decimal dot.
inline to_chars_result print_zero_fixed(char* buffer, std::size_t buffer_size, const int precision) noexcept
{
    // No trailing decimal dot.
    if (precision == 0)
    {
        *buffer = '0';
        return {buffer + 1, std::errc()};
    }

    if (buffer_size < static_cast<std::size_t>(precision) + 2U)
    {
        return {buffer + buffer_size, std::errc::value_too_large};
    }

    std::memcpy(buffer, "0.", 2); // NOLINT : Specifically not null-terminating
    std::memset(buffer + 2, '0', static_cast<std::size_t>(precision)); // NOLINT : Specifically not null-terminating
    return {buffer + 2 + precision, std::errc()};
}

// precision means the number of decimal significand digits minus 1.
// Assumes round-to-nearest, tie-to-even rounding.
template <typename MainCache = main_cache_full, typename ExtendedCache>
BOOST_CHARCONV_SAFEBUFFERS to_chars_result floff(const double x, int precision, char* first, char* last,
                                                 boost::charconv::chars_format fmt) noexcept
{
    if (first >= last)
    {
        return {last, std::errc::value_too_large};
    }

    auto buffer_size = static_cast<std::size_t>(last - first);
    auto buffer = first;

    BOOST_CHARCONV_ASSERT(precision >= 0);
    using namespace detail;

    std::uint64_t br = default_float_traits<double>::float_to_carrier(x);
    bool is_negative = ((br >> 63) != 0);
    br <<= 1;
    int e = static_cast<int>(br >> (ieee754_binary64::significand_bits + 1));
    auto significand = (br & ((UINT64_C(1) << (ieee754_binary64::significand_bits + 1)) - 1)); // shifted by 1-bit.

    if (is_negative)
    {
        *buffer = '-';
        ++buffer;
        --buffer_size;

        if (buffer_size == 0)
        {
            return {buffer, std::errc::value_too_large};
        }
    }

    // Infinities or NaN
    if (e == ((UINT32_C(1) << ieee754_binary64::exponent_bits) - 1)) 
    {
        if (significand == 0)
        {
            constexpr std::size_t inf_chars = 3;

            if (buffer_size < inf_chars)
            {
                return {last, std::errc::value_too_large};
            }

            std::memcpy(buffer, "inf", inf_chars); // NOLINT : Specifically not null-terminating
            return {buffer + inf_chars, std::errc()};
        }
        else 
        {
            // Significand values for NaN by type
            // qNaN = 4503599627370496
            // sNaN = 2251799813685248
            //
            if (significand == UINT64_C(4503599627370496))
            {
                if (!is_negative)
                {
                    constexpr std::size_t nan_chars = 3;

                    if (buffer_size < nan_chars)
                    {
                        return {last, std::errc::value_too_large};
                    }

                    std::memcpy(buffer, "nan", nan_chars); // NOLINT : Specifically not null-terminating
                    return {buffer + nan_chars, std::errc()};
                }
                else
                {
                    constexpr std::size_t neg_nan_chars = 8;

                    if (buffer_size < neg_nan_chars)
                    {
                        return {last, std::errc::value_too_large};
                    }

                    std::memcpy(buffer, "nan(ind)", neg_nan_chars); // NOLINT : Specifically not null-terminating
                    return {buffer + neg_nan_chars, std::errc()};
                }
            }
            else
            {
                constexpr std::size_t snan_chars = 9;

                if (buffer_size < snan_chars)
                {
                    return {last, std::errc::value_too_large};
                }

                std::memcpy(buffer, "nan(snan)", snan_chars); // NOLINT : Specifically not null-terminating
                return {buffer + snan_chars, std::errc()};
            }
        }
    }
    else
    {
        // Normal numbers.
        if (e != 0)
        {
            significand |= (decltype(significand)(1) << (ieee754_binary64::significand_bits + 1));
            e += (ieee754_binary64::exponent_bias - ieee754_binary64::significand_bits);
        }
        // Subnormal numbers.
        else 
        {
            // Zero
            if (significand == 0) 
            {
                if (fmt == boost::charconv::chars_format::general)
                {
                    // For the case of chars_format::general, 0 is always printed as 0.
                    *buffer = '0';
                    return {buffer + 1, std::errc()};
                }
                else if (fmt == boost::charconv::chars_format::fixed)
                {
                    return print_zero_fixed(buffer, buffer_size, precision);
                }
                // For the case of chars_format::scientific, print as many 0's as requested after the decimal dot, and then print e+00.
                if (precision == 0) 
                {
                    constexpr std::size_t zero_chars = 5;

                    if (buffer_size < zero_chars)
                    {
                        return {last, std::errc::value_too_large};
                    }

                    std::memcpy(buffer, "0e+00", zero_chars);
                    return {buffer + zero_chars, std::errc()};
                }
                else 
                {
                    if (buffer_size < static_cast<std::size_t>(precision) + 6U)
                    {
                        return {last, std::errc::value_too_large};
                    }

                    std::memcpy(buffer, "0.", 2); // NOLINT : Specifically not null-terminating
                    std::memset(buffer + 2, '0', static_cast<std::size_t>(precision)); // NOLINT : Specifically not null-terminating
                    std::memcpy(buffer + 2 + precision, "e+00", 4); // NOLINT : Specifically not null-terminating
                    return {buffer + precision + 6, std::errc()};
                }
            }
            // Nonzero
            e = ieee754_binary64::min_exponent - ieee754_binary64::significand_bits;
        }
    }

    constexpr int kappa = 2;
    int k = kappa - log::floor_log10_pow2(e);
    std::uint32_t current_digits {};
    char* const buffer_starting_pos = buffer;
    char* decimal_dot_pos = buffer; // decimal_dot_pos == buffer_starting_pos indicates that there should be no decimal dot.
    int decimal_exponent_normalized {};

    // Number of digits to be printed.
    int remaining_digits {};

    /////////////////////////////////////////////////////////////////////////////////////////////////
    /// Phase 1 - Print the first digit segment computed with the Dragonbox table.
    /////////////////////////////////////////////////////////////////////////////////////////////////

    {
        // Compute the first digit segment.
        const auto main_cache = MainCache::template get_cache<ieee754_binary64>(k);
        const int beta = e + log::floor_log2_pow10(k);

        // Integer check is okay for binary64.
        //auto [first_segment, has_more_segments] 
        compute_mul_result segments = [&] {
            const auto r = umul192_upper128(significand << beta, main_cache);
            return compute_mul_result{r.high, r.low == 0};
        }();

        auto first_segment = segments.result;
        auto has_more_segments = !segments.is_integer;

        // The first segment can be up to 19 digits. It is in fact always of either 18 or 19
        // digits except when the input is a subnormal number. For subnormal numbers, the
        // smallest possible value of the first segment is 10^kappa, so it is of at least
        // kappa+1 digits (i.e., 3 in this case).

        int first_segment_length = 19;
        auto first_segment_aligned = first_segment; // Aligned to have 19 digits.
        while (first_segment_aligned < UINT64_C(10000000000000000))
        {
            first_segment_aligned *= 100;
            first_segment_length -= 2;
        }
        if (first_segment_aligned < UINT64_C(1000000000000000000))
        {
            first_segment_aligned *= 10;
            first_segment_length -= 1;
        }
        // The decimal exponent when written as X.XXXX.... x 10^XX.
        decimal_exponent_normalized = first_segment_length - k - 1;

        // Figure out the correct value of remaining_digits.
        if (fmt == boost::charconv::chars_format::scientific)
        {
            remaining_digits = precision + 1;
            int exponent_print_length =
                decimal_exponent_normalized >= 100 ? 5 :
                decimal_exponent_normalized <= -100 ? 6 :
                decimal_exponent_normalized >= 0 ? 4 : 5;

            // No trailing decimal dot.
            auto minimum_required_buffer_size =
                static_cast<std::size_t>(remaining_digits + exponent_print_length + (precision != 0 ? 1 : 0));
            if (buffer_size < minimum_required_buffer_size)
            {
                return {last, std::errc::value_too_large};
            }

            if (precision != 0)
            {
                // Reserve a place for the decimal dot.
                *buffer = '0';
                ++buffer;
                ++decimal_dot_pos;
            }
        }
        else if (fmt == boost::charconv::chars_format::fixed)
        {
            if (decimal_exponent_normalized >= 0)
            {
                remaining_digits = precision + decimal_exponent_normalized + 1;
                
                // No trailing decimal dot.
                auto minimum_required_buffer_size =
                    static_cast<std::size_t>(remaining_digits + (precision != 0 ? 1 : 0));

                // We need one more space if the rounding changes the exponent,
                // but since we don't know at this point if that will actually happen, handle such a case later.

                if (buffer_size < minimum_required_buffer_size)
                {
                    return {last, std::errc::value_too_large};
                }

                if (precision != 0)
                {
                    // Reserve a place for the decimal dot.
                    *buffer = '0';
                    ++buffer;
                    decimal_dot_pos += decimal_exponent_normalized + 1;
                }
            }
            else
            {
                int number_of_leading_zeros = -decimal_exponent_normalized - 1;

                // When there are more than precision number of leading zeros,
                // all the digits we need to print are 0.
                if (number_of_leading_zeros > precision)
                {
                    return print_zero_fixed(buffer, buffer_size, precision);
                }
                // When the number of leading zeros is exactly precision,
                // then we might need to print 1 at the last digit due to rounding.
                if (number_of_leading_zeros == precision)
                {
                    // Since the last digit before rounding is 0,
                    // according to the "round-to-nearest, tie-to-even" rule, we round-up
                    // if and only if the input is strictly larger than the midpoint.
                    bool round_up = (first_segment_aligned + (has_more_segments ? 1 : 0)) > UINT64_C(5000000000000000000);
                    if (!round_up)
                    {
                        return print_zero_fixed(buffer, buffer_size, precision);
                    }

                    // No trailing decimal dot.
                    if (precision == 0)
                    {
                        *buffer = '1';
                        return {buffer + 1, std::errc()};
                    }

                    if (buffer_size < static_cast<std::size_t>(precision) + 2U)
                    {
                        return {buffer + buffer_size, std::errc::value_too_large};
                    }

                    std::memcpy(buffer, "0.", 2); // NOLINT : Specifically not null-terminating
                    std::memset(buffer + 2, '0', static_cast<std::size_t>(precision - 1)); // NOLINT : Specifically not null-terminating
                    buffer[1 + precision] = '1';
                    return {buffer + 2 + precision, std::errc()};
                }

                remaining_digits = precision - number_of_leading_zeros;
                
                // Always have decimal dot.
                BOOST_CHARCONV_ASSERT(precision > 0);
                auto minimum_required_buffer_size = static_cast<std::size_t>(precision + 2);
                if (buffer_size < minimum_required_buffer_size)
                {
                    return {last, std::errc::value_too_large};
                }

                // Print leading zeros.
                std::memset(buffer, '0', static_cast<std::size_t>(number_of_leading_zeros + 2));
                buffer += number_of_leading_zeros + 2;
                ++decimal_dot_pos;
            }
        }
        else
        {
            // fmt == boost::charconv::chars_format::general
            if (precision == 0)
            {
                // For general format, precision = 0 is interpreted as precision = 1.
                precision = 1;
            }
            remaining_digits = precision;

            // Use scientific format if decimal_exponent_normalized <= -6 or decimal_exponent_normalized >= precision.
            // Use fixed format if -4 <= decimal_exponent_normalized <= precision - 2.
            // If decimal_exponent_normalized == -5, use fixed format if and only if the rounding increases the exponent.
            // If decimal_exponent_normalized == precision - 1, use scientific format if and only if the rounding increases the exponent.
            // Since we cannot reliably decide which format to use, necessary corrections will be made in the last phase.

            // We may end up not printing the decimal dot if fixed format is chosen, but reserve a place anyway.
            *buffer = '0';
            ++buffer;
            decimal_dot_pos += (0 < decimal_exponent_normalized && decimal_exponent_normalized < precision)
                                ? decimal_exponent_normalized + 1 : 1;
        }

        if (remaining_digits <= 2) 
        {
            uint128 prod;
            std::uint64_t fractional_part64;
            std::uint64_t fractional_part_rounding_threshold64;

            // Convert to fixed-point form with 64/32-bit boundary for the fractional part.

            if (remaining_digits == 1)
            {
                prod = umul128(first_segment_aligned, UINT64_C(1329227995784915873));
                // ceil(2^63 + 2^64/10^18)
                fractional_part_rounding_threshold64 = additional_static_data_holder::fractional_part_rounding_thresholds64[17];
            }
            else
            {
                prod = umul128(first_segment_aligned, UINT64_C(13292279957849158730));
                // ceil(2^63 + 2^64/10^17)
                fractional_part_rounding_threshold64 = additional_static_data_holder::
                    fractional_part_rounding_thresholds64[16];
            }
            fractional_part64 = (prod.low >> 56) | (prod.high << 8);
            current_digits = static_cast<std::uint32_t>(prod.high >> 56);

            // Perform rounding, print the digit, and return.
            if (remaining_digits == 1)
            {
                if (fractional_part64 >= fractional_part_rounding_threshold64 ||
                    ((fractional_part64 >> 63) & (has_more_segments | (current_digits & 1))) != 0) 
                {
                    goto round_up_one_digit;
                }

                print_1_digit(current_digits, buffer);
                ++buffer;
            }
            else 
            {
                if (fractional_part64 >= fractional_part_rounding_threshold64 ||
                    ((fractional_part64 >> 63) & (has_more_segments | (current_digits & 1))) != 0)
                {
                    goto round_up_two_digits;
                }

                print_2_digits(current_digits, buffer);
                buffer += 2;
            }

            goto insert_decimal_dot;
        } // remaining_digits <= 2

        // At this point, there are at least 3 digits to print.
        // We split the segment into three chunks, each consisting of 9 digits, 8 digits,
        // and 2 digits.

        // MSVC doesn't know how to do Grandlund-Montgomery for large 64-bit integers.
        // 7922816251426433760 = ceil(2^96/10^10) = floor(2^96*(10^9/(10^19 - 1)))
        const auto first_subsegment =
            static_cast<std::uint32_t>(umul128_upper64(first_segment, UINT64_C(7922816251426433760)) >> 32);

        const auto second_third_subsegments =
            first_segment - first_subsegment * UINT64_C(10000000000);

        BOOST_CHARCONV_ASSERT(first_subsegment < UINT64_C(1000000000));
        BOOST_CHARCONV_ASSERT(second_third_subsegments < UINT64_C(10000000000));

        int remaining_digits_in_the_current_subsegment;
        std::uint64_t prod; // holds intermediate values for digit generation.

        // Print the first subsegment.
        if (first_subsegment != 0)
        {
            // 9 digits (19 digits in total).
            if (first_subsegment >= 100000000) 
            {
                // 1441151882 = ceil(2^57 / 10^8) + 1
                prod = first_subsegment * UINT64_C(1441151882);
                prod >>= 25;
                remaining_digits_in_the_current_subsegment = 8;
            }
            // 7 or 8 digits (17 or 18 digits in total).
            else if (first_subsegment >= 1000000)
            {
                // 281474978 = ceil(2^48 / 10^6) + 1
                prod = first_subsegment * UINT64_C(281474978);
                prod >>= 16;
                remaining_digits_in_the_current_subsegment = 6;
            }
            // 5 or 6 digits (15 or 16 digits in total).
            else if (first_subsegment >= 10000)
            {
                // 429497 = ceil(2^32 / 10^4)
                prod = first_subsegment * UINT64_C(429497);
                remaining_digits_in_the_current_subsegment = 4;
            }
            // 3 or 4 digits (13 or 14 digits in total).
            else if (first_subsegment >= 100)
            {
                // 42949673 = ceil(2^32 / 10^2)
                prod = first_subsegment * UINT64_C(42949673);
                remaining_digits_in_the_current_subsegment = 2;
            }
            // 1 or 2 digits (11 or 12 digits in total).
            else
            {
                prod = std::uint64_t(first_subsegment) << 32;
                remaining_digits_in_the_current_subsegment = 0;
            }

            const auto initial_digits = static_cast<std::uint32_t>(prod >> 32);

            buffer -= (initial_digits < 10 && buffer != first ? 1 : 0);
            remaining_digits -= (2 - (initial_digits < 10 ? 1 : 0));

            // Avoid the situation where we have a leading 0 that we don't need
            // Typically used to account for inserting a decimal, but we know
            // we won't need that in the 0 precision case
            if (precision == 0 && initial_digits < 10)
            {
                print_1_digit(initial_digits, buffer);
                ++buffer;
            }
            else
            {
                print_2_digits(initial_digits, buffer);
                buffer += 2;
            }

            if (remaining_digits > remaining_digits_in_the_current_subsegment) 
            {
                remaining_digits -= remaining_digits_in_the_current_subsegment;
                
                for (; remaining_digits_in_the_current_subsegment > 0; remaining_digits_in_the_current_subsegment -= 2) 
                {
                    // Write next two digits.
                    prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                    print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
                    buffer += 2;
                }
            }
            else 
            {
                for (int i = 0; i < (remaining_digits - 1) / 2; ++i) 
                {
                    // Write next two digits.
                    prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                    print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
                    buffer += 2;
                }

                // Distinguish two cases of rounding.
                if (remaining_digits_in_the_current_subsegment > remaining_digits)
                {
                    if ((remaining_digits & 1) != 0) 
                    {
                        prod = static_cast<std::uint32_t>(prod) * UINT64_C(10);
                    }
                    else 
                    {
                        prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                    }
                    
                    current_digits = static_cast<std::uint32_t>(prod >> 32);

                    if (check_rounding_condition_inside_subsegment(
                            current_digits, static_cast<std::uint32_t>(prod),
                            remaining_digits_in_the_current_subsegment - remaining_digits,
                            second_third_subsegments != 0 || has_more_segments)) 
                    {
                        goto round_up;
                    }

                    goto print_last_digits;
                }
                else 
                {
                    prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                    current_digits = static_cast<std::uint32_t>(prod >> 32);

                    if (check_rounding_condition_subsegment_boundary_with_next_subsegment(
                            current_digits,
                            uint_with_known_number_of_digits<10>{second_third_subsegments},
                            has_more_segments)) 
                    {
                        goto round_up_two_digits;
                    }

                    goto print_last_two_digits;
                }
            }
        }

        // Print the second subsegment.
        // The second subsegment cannot be zero even for subnormal numbers.

        if (remaining_digits <= 2) 
        {
            // In this case the first subsegment must be nonzero.

            if (remaining_digits == 1) 
            {
                const auto prod128 = umul128(second_third_subsegments, UINT64_C(18446744074));

                current_digits = static_cast<std::uint32_t>(prod128.high);
                const auto fractional_part64 = prod128.low + 1;
                // 18446744074 is even, so prod.low cannot be equal to 2^64 - 1.
                BOOST_CHARCONV_ASSERT(fractional_part64 != 0);

                if (fractional_part64 >= additional_static_data_holder::fractional_part_rounding_thresholds64[8] ||
                    ((fractional_part64 >> 63) & (has_more_segments | (current_digits & 1))) != 0) 
                {
                    goto round_up_one_digit;
                }

                goto print_last_one_digit;
            } // remaining_digits == 1
            else 
            {
                const auto prod128 = umul128(second_third_subsegments, UINT64_C(184467440738));

                current_digits = static_cast<std::uint32_t>(prod128.high);
                const auto fractional_part64 = prod128.low + 1;
                // 184467440738 is even, so prod.low cannot be equal to 2^64 - 1.
                BOOST_CHARCONV_ASSERT(fractional_part64 != 0);

                if (fractional_part64 >= additional_static_data_holder::fractional_part_rounding_thresholds64[7] ||
                    ((fractional_part64 >> 63) & (has_more_segments | (current_digits & 1))) != 0) 
                {
                    goto round_up_two_digits;
                }

                goto print_last_two_digits;
            }
        } // remaining_digits <= 2

        // Compilers are not aware of how to leverage the maximum value of
        // second_third_subsegments to find out a better magic number which allows us to
        // eliminate an additional shift.
        // 184467440737095517 = ceil(2^64/100) < floor(2^64*(10^8/(10^10 - 1))).
        const auto second_subsegment = static_cast<std::uint32_t>(
            umul128_upper64(second_third_subsegments, UINT64_C(184467440737095517)));

        // Since the final result is of 2 digits, we can do the computation in 32-bits.
        const auto third_subsegment =
            static_cast<std::uint32_t>(second_third_subsegments) - second_subsegment * 100;

        BOOST_CHARCONV_ASSERT(second_subsegment < 100000000);
        BOOST_CHARCONV_ASSERT(third_subsegment < 100);

        {
            std::uint32_t initial_digits;
            if (first_subsegment != 0) 
            {
                prod = ((second_subsegment * UINT64_C(281474977)) >> 16) + 1;
                remaining_digits_in_the_current_subsegment = 6;

                initial_digits = static_cast<std::uint32_t>(prod >> 32);
                remaining_digits -= 2;
            }
            else 
            {
                // 7 or 8 digits (9 or 10 digits in total).
                if (second_subsegment >= 1000000) 
                {
                    prod = (second_subsegment * UINT64_C(281474978)) >> 16;
                    remaining_digits_in_the_current_subsegment = 6;
                }
                // 5 or 6 digits (7 or 8 digits in total).
                else if (second_subsegment >= 10000)
                {
                    prod = second_subsegment * UINT64_C(429497);
                    remaining_digits_in_the_current_subsegment = 4;
                }
                // 3 or 4 digits (5 or 6 digits in total).
                else if (second_subsegment >= 100)
                {
                    prod = second_subsegment * UINT64_C(42949673);
                    remaining_digits_in_the_current_subsegment = 2;
                }
                // 1 or 2 digits (3 or 4 digits in total).
                else
                {
                    prod = std::uint64_t(second_subsegment) << 32;
                    remaining_digits_in_the_current_subsegment = 0;
                }

                initial_digits = static_cast<std::uint32_t>(prod >> 32);
                buffer -= (initial_digits < 10 ? 1 : 0);
                remaining_digits -= (2 - (initial_digits < 10 ? 1 : 0));
            }

            print_2_digits(initial_digits, buffer);
            buffer += 2;

            if (remaining_digits > remaining_digits_in_the_current_subsegment)
            {
                remaining_digits -= remaining_digits_in_the_current_subsegment;
                for (; remaining_digits_in_the_current_subsegment > 0; remaining_digits_in_the_current_subsegment -= 2) 
                {
                    // Write next two digits.
                    prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                    print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
                    buffer += 2;
                }
            }
            else 
            {
                for (int i = 0; i < (remaining_digits - 1) / 2; ++i) 
                {
                    // Write next two digits.
                    prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                    print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
                    buffer += 2;
                }

                // Distinguish two cases of rounding.
                if (remaining_digits_in_the_current_subsegment > remaining_digits) 
                {
                    if ((remaining_digits & 1) != 0) 
                    {
                        prod = static_cast<std::uint32_t>(prod) * UINT64_C(10);
                    }
                    else 
                    {
                        prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                    }
                    current_digits = static_cast<std::uint32_t>(prod >> 32);

                    if (check_rounding_condition_inside_subsegment(
                            current_digits, static_cast<std::uint32_t>(prod),
                            remaining_digits_in_the_current_subsegment - remaining_digits,
                            third_subsegment != 0 || has_more_segments)) 
                    {
                        goto round_up;
                    }

                    goto print_last_digits;
                }
                else 
                {
                    prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                    current_digits = static_cast<std::uint32_t>(prod >> 32);

                    if (check_rounding_condition_subsegment_boundary_with_next_subsegment(
                            current_digits,
                            uint_with_known_number_of_digits<2>{third_subsegment},
                            has_more_segments)) 
                    {
                        goto round_up_two_digits;
                    }

                    goto print_last_two_digits;
                }
            }
        }

        // Print the third subsegment.
        {
            if (remaining_digits > 2) 
            {
                print_2_digits(third_subsegment, buffer);
                buffer += 2;
                remaining_digits -= 2;

                // If there is no more segment, then fill remaining digits with 0's and return.
                if (!has_more_segments) 
                {
                    goto fill_remaining_digits_with_0s;
                }
            }
            else if (remaining_digits == 1) 
            {
                prod = third_subsegment * UINT64_C(429496730);
                current_digits = static_cast<std::uint32_t>(prod >> 32);

                if (check_rounding_condition_inside_subsegment(
                        current_digits, static_cast<std::uint32_t>(prod), 1, has_more_segments)) 
                {
                    goto round_up_one_digit;
                }

                goto print_last_one_digit;
            }
            else 
            {
                // remaining_digits == 2.
                // If there is no more segment, then print the current two digits and return.
                if (!has_more_segments)
                {
                    print_2_digits(third_subsegment, buffer);
                    buffer += 2;
                    goto insert_decimal_dot;
                }

                // Otherwise, for performing the rounding, we have to wait until the next
                // segment becomes available. This state can be detected afterward by
                // inspecting if remaining_digits == 0.
                remaining_digits = 0;
                current_digits = third_subsegment;
            }
        }
    }

    /////////////////////////////////////////////////////////////////////////////////////////////////
    /// Phase 2 - Print further digit segments computed with the extended cache table.
    /////////////////////////////////////////////////////////////////////////////////////////////////

    {
        auto multiplier_index =
            static_cast<std::uint32_t>(k + ExtendedCache::segment_length - ExtendedCache::k_min) /
            static_cast<std::uint32_t>(ExtendedCache::segment_length);

        int digits_in_the_second_segment;
        {
            const auto new_k =
                ExtendedCache::k_min + static_cast<int>(multiplier_index) * ExtendedCache::segment_length;
            digits_in_the_second_segment = new_k - k;
            k = new_k;
        }

        const auto exp2_base = e + boost::core::countr_zero(significand);

        using cache_block_type = typename std::decay<decltype(ExtendedCache::cache[0])>::type;
        
        cache_block_type blocks[ExtendedCache::max_cache_blocks];
        cache_block_count_t<ExtendedCache::constant_block_count, ExtendedCache::max_cache_blocks> cache_block_count;

        // Deal with the second segment. The second segment is special because it can have
        // overlapping digits with the first segment. Note that we cannot just move the buffer
        // pointer backward and print the whole segment from there, because it may contain
        // leading zeros.
        {
            cache_block_count =
                load_extended_cache<ExtendedCache, ExtendedCache::constant_block_count>(
                    blocks, e, k, multiplier_index);

            // Compute nm mod 2^Q.
            fixed_point_calculator<ExtendedCache::max_cache_blocks>::discard_upper(significand, blocks, cache_block_count);

            BOOST_CHARCONV_IF_CONSTEXPR (ExtendedCache::segment_length == 22)
            {
                // No rounding, continue.
                if (remaining_digits > digits_in_the_second_segment)
                {
                    remaining_digits -= digits_in_the_second_segment;

                    if (digits_in_the_second_segment <= 2)
                    {
                        BOOST_CHARCONV_ASSERT(digits_in_the_second_segment != 0);

                        fixed_point_calculator<ExtendedCache::max_cache_blocks>::discard_upper(
                            power_of_10[19], blocks, cache_block_count);

                        auto subsegment =
                            fixed_point_calculator<ExtendedCache::max_cache_blocks>::
                                generate_and_discard_lower(power_of_10[3], blocks,
                                                            cache_block_count);

                        if (digits_in_the_second_segment == 1)
                        {
                            auto prod = subsegment * UINT64_C(429496730);
                            prod = static_cast<std::uint32_t>(prod) * UINT64_C(10);
                            print_1_digit(static_cast<std::uint32_t>(prod >> 32), buffer);
                            ++buffer;
                        }
                        else 
                        {
                            auto prod = subsegment * UINT64_C(42949673);
                            prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                            print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
                            buffer += 2;
                        }
                    } // digits_in_the_second_segment <= 2
                    else if (digits_in_the_second_segment <= 16)
                    {
                        BOOST_CHARCONV_ASSERT(22 - digits_in_the_second_segment <= 19);
                        
                        fixed_point_calculator<ExtendedCache::max_cache_blocks>::discard_upper(
                            compute_power(UINT64_C(10), 22 - digits_in_the_second_segment),
                            blocks, cache_block_count);

                        // When there are at most 9 digits, we can store them in 32-bits.
                        if (digits_in_the_second_segment <= 9) 
                        {
                            // The number of overlapping digits is in the range 13 ~ 19.
                            const auto subsegment =
                                fixed_point_calculator<ExtendedCache::max_cache_blocks>::
                                    generate_and_discard_lower(power_of_10[9], blocks,
                                                                cache_block_count);

                            std::uint64_t prod;
                            if ((digits_in_the_second_segment & 1) != 0)
                            {
                                prod = ((subsegment * UINT64_C(720575941)) >> 24) + 1;
                                print_1_digit(static_cast<std::uint32_t>(prod >> 32), buffer);
                                ++buffer;
                            }
                            else
                            {
                                prod = ((subsegment * UINT64_C(450359963)) >> 20) + 1;
                                print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
                                buffer += 2;
                            }

                            for (; digits_in_the_second_segment > 2; digits_in_the_second_segment -= 2)
                            {
                                prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                                print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
                                buffer += 2;
                            }
                        } // digits_in_the_second_segment <= 9
                        else 
                        {
                            // The number of digits in the segment is in the range 10 ~ 16.
                            const auto first_second_subsegments =
                                fixed_point_calculator<ExtendedCache::max_cache_blocks>::
                                    generate_and_discard_lower(power_of_10[16], blocks,
                                                                cache_block_count);

                            // The first segment is of 8 digits, and the second segment is of
                            // 2 ~ 8 digits.
                            // ceil(2^(64+14)/10^8) = 3022314549036573
                            // = floor(2^(64+14)*(10^8/(10^16 - 1)))
                            const auto first_subsegment =
                                static_cast<std::uint32_t>(umul128_upper64(first_second_subsegments,
                                                                        UINT64_C(3022314549036573)) >>
                                                14);
                            const auto second_subsegment =
                                static_cast<std::uint32_t>(first_second_subsegments) -
                                UINT32_C(100000000) * first_subsegment;

                            // Print the first subsegment.
                            print_8_digits(first_subsegment, buffer);
                            buffer += 8;

                            // Print the second subsegment.
                            // There are at least 2 digits in the second subsegment.
                            auto prod = ((second_subsegment * UINT64_C(140737489)) >> 15) + 1;
                            print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
                            buffer += 2;
                            digits_in_the_second_segment -= 10;

                            for (; digits_in_the_second_segment > 1; digits_in_the_second_segment -= 2)
                            {
                                prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                                print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
                                buffer += 2;
                            }

                            if (digits_in_the_second_segment != 0)
                            {
                                prod = static_cast<std::uint32_t>(prod) * UINT64_C(10);
                                print_1_digit(static_cast<std::uint32_t>(prod >> 32), buffer);
                                ++buffer;
                            }
                        }
                    } // digits_in_the_second_segment <= 16
                    else 
                    {
                        // The number of digits in the segment is in the range 17 ~ 22.
                        const auto first_subsegment =
                            fixed_point_calculator<ExtendedCache::max_cache_blocks>::generate(
                                power_of_10[6], blocks, cache_block_count);

                        const auto second_third_subsegments =
                            fixed_point_calculator<ExtendedCache::max_cache_blocks>::
                                generate_and_discard_lower(power_of_10[16], blocks,
                                                            cache_block_count);

                        // ceil(2^(64+14)/10^8) = 3022314549036573
                        // = floor(2^(64+14)*(10^8/(10^16 - 1)))
                        const auto second_subsegment =
                            static_cast<std::uint32_t>(umul128_upper64(second_third_subsegments,
                                                                    UINT64_C(3022314549036573)) >>
                                            14);
                        const auto third_subsegment = static_cast<std::uint32_t>(second_third_subsegments) -
                                                        UINT32_C(100000000) * second_subsegment;

                        // Print the first subsegment (1 ~ 6 digits).
                        std::uint64_t prod {};
                        auto remaining_digits_in_the_current_subsegment =
                            digits_in_the_second_segment - 16;

                        switch (remaining_digits_in_the_current_subsegment)
                        {
                        case 1:
                            prod = first_subsegment * UINT64_C(429496730);
                            goto second_segment22_more_than_16_digits_first_subsegment_no_rounding_odd_remaining;

                        case 2:
                            prod = first_subsegment * UINT64_C(42949673);
                            goto second_segment22_more_than_16_digits_first_subsegment_no_rounding_even_remaining;

                        case 3:
                            prod = first_subsegment * UINT64_C(4294968);
                            goto second_segment22_more_than_16_digits_first_subsegment_no_rounding_odd_remaining;

                        case 4:
                            prod = first_subsegment * UINT64_C(429497);
                            goto second_segment22_more_than_16_digits_first_subsegment_no_rounding_even_remaining;

                        case 5:
                            prod = ((first_subsegment * UINT64_C(687195)) >> 4) + 1;
                            goto second_segment22_more_than_16_digits_first_subsegment_no_rounding_odd_remaining;

                        case 6:
                            prod = first_subsegment * UINT64_C(429497);
                            print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
                            buffer += 2;
                            remaining_digits_in_the_current_subsegment = 4;
                            goto second_segment22_more_than_16_digits_first_subsegment_no_rounding_even_remaining;

                        default:
                            BOOST_UNREACHABLE_RETURN(prod); // NOLINT
                        }

                    second_segment22_more_than_16_digits_first_subsegment_no_rounding_odd_remaining
                        :
                        prod = static_cast<std::uint32_t>(prod) * UINT64_C(10);
                        print_1_digit(static_cast<std::uint32_t>(prod >> 32), buffer);
                        ++buffer;

                    second_segment22_more_than_16_digits_first_subsegment_no_rounding_even_remaining
                        :
                        for (; remaining_digits_in_the_current_subsegment > 1;
                                remaining_digits_in_the_current_subsegment -= 2)
                        {
                            prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                            print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
                            buffer += 2;
                        }

                        // Print the second and third subsegments (8 digits each).
                        print_8_digits(second_subsegment, buffer);
                        print_8_digits(third_subsegment, buffer + 8);
                        buffer += 16;
                    }
                } // remaining_digits > digits_in_the_second_segment

                // Perform rounding and return.
                else
                {
                    if (digits_in_the_second_segment <= 2)
                    {
                        fixed_point_calculator<ExtendedCache::max_cache_blocks>::discard_upper(
                            power_of_10[19], blocks, cache_block_count);

                        // Get one more bit for potential rounding on the segment boundary.
                        auto subsegment =
                            fixed_point_calculator<ExtendedCache::max_cache_blocks>::
                                generate_and_discard_lower(2000, blocks, cache_block_count);

                        bool segment_boundary_rounding_bit = ((subsegment & 1) != 0);
                        subsegment >>= 1;

                        if (digits_in_the_second_segment == 2)
                        {
                            // Convert subsegment into fixed-point fractional form where the
                            // integer part is of one digit. The integer part is ignored.
                            // 42949673 = ceil(2^32/10^2)
                            auto prod = static_cast<std::uint64_t>(subsegment) * UINT64_C(42949673);

                            if (remaining_digits == 1)
                            {
                                prod = static_cast<std::uint32_t>(prod) * UINT64_C(10);
                                current_digits = static_cast<std::uint32_t>(prod >> 32);
                                const bool has_further_digits_v = has_further_digits<1, 0, ExtendedCache>(significand, exp2_base, k, uconst1, uconst0);
                                if (check_rounding_condition_inside_subsegment(current_digits, static_cast<std::uint32_t>(prod), 1, has_further_digits_v))
                                {
                                    goto round_up_one_digit;
                                }
                                goto print_last_one_digit;
                            }

                            prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                            const auto next_digits = static_cast<std::uint32_t>(prod >> 32);

                            if (remaining_digits == 0)
                            {
                                if (check_rounding_condition_subsegment_boundary_with_next_subsegment(
                                        current_digits,
                                        uint_with_known_number_of_digits<2>{next_digits},
                                        has_further_digits<1, 0, ExtendedCache>(significand, exp2_base, k, uconst1, uconst0))) 
                                {
                                    goto round_up_two_digits;
                                }
                                goto print_last_two_digits;
                            }

                            current_digits = next_digits;
                            BOOST_CHARCONV_ASSERT(remaining_digits == 2);
                        }
                        else
                        {
                            BOOST_CHARCONV_ASSERT(digits_in_the_second_segment == 1);
                            // Convert subsegment into fixed-point fractional form where the
                            // integer part is of two digits. The integer part is ignored.
                            // 429496730 = ceil(2^32/10^1)
                            auto prod = static_cast<std::uint64_t>(subsegment) * UINT64_C(429496730);
                            prod = static_cast<std::uint32_t>(prod) * UINT64_C(10);
                            const auto next_digits = static_cast<std::uint32_t>(prod >> 32);

                            if (remaining_digits == 0) 
                            {
                                if (check_rounding_condition_subsegment_boundary_with_next_subsegment(
                                        current_digits,
                                        uint_with_known_number_of_digits<1>{next_digits},
                                        has_further_digits<1, 0, ExtendedCache>(significand, exp2_base, k, uconst1, uconst0)))
                                {
                                    goto round_up_two_digits;
                                }
                                goto print_last_two_digits;
                            }

                            current_digits = next_digits;
                            BOOST_CHARCONV_ASSERT(remaining_digits == 1);
                        }

                        if (check_rounding_condition_with_next_bit(
                                current_digits, segment_boundary_rounding_bit,
                                has_further_digits<0, 0, ExtendedCache>(significand, exp2_base, k, uconst0, uconst0))) 
                        {
                            goto round_up;
                        }

                        goto print_last_digits;
                    } // digits_in_the_second_segment <= 2

                    // When there are at most 9 digits in the segment.
                    if (digits_in_the_second_segment <= 9)
                    {
                        // Throw away all overlapping digits.
                        BOOST_CHARCONV_ASSERT(22 - digits_in_the_second_segment <= 19);

                        fixed_point_calculator<ExtendedCache::max_cache_blocks>::discard_upper(
                            compute_power(UINT64_C(10), 22 - digits_in_the_second_segment),
                            blocks, cache_block_count);

                        // Get one more bit for potential rounding on the segment boundary.
                        auto segment = fixed_point_calculator<ExtendedCache::max_cache_blocks>::
                            generate_and_discard_lower(power_of_10[9] << 1, blocks,
                                                        cache_block_count);

                        std::uint64_t prod;
                        digits_in_the_second_segment -= remaining_digits;

                        if ((remaining_digits & 1) != 0)
                        {
                            prod = ((segment * UINT64_C(1441151881)) >> 26) + 1;
                            current_digits = static_cast<std::uint32_t>(prod >> 32);

                            if (remaining_digits == 1)
                            {
                                goto second_segment22_at_most_9_digits_rounding;
                            }

                            print_1_digit(current_digits, buffer);
                            ++buffer;
                        }
                        else 
                        {
                            prod = ((segment * UINT64_C(1801439851)) >> 23) + 1;
                            const auto next_digits = static_cast<std::uint32_t>(prod >> 32);

                            if (remaining_digits == 0)
                            {
                                if (check_rounding_condition_subsegment_boundary_with_next_subsegment(
                                        current_digits,
                                        uint_with_known_number_of_digits<2>{next_digits}, [&] {
                                            return static_cast<std::uint32_t>(prod) >=
                                                        (additional_static_data_holder::
                                                            fractional_part_rounding_thresholds32[digits_in_the_second_segment - 3] & UINT32_C(0x7fffffff))
                                                    || has_further_digits<1, 0, ExtendedCache>(significand, exp2_base, k, uconst1, uconst0);
                                        })) 
                                {
                                    goto round_up_two_digits;
                                }
                                goto print_last_two_digits;
                            }
                            else if (remaining_digits == 2)
                            {
                                current_digits = next_digits;
                                goto second_segment22_at_most_9_digits_rounding;
                            }

                            print_2_digits(next_digits, buffer);
                            buffer += 2;
                        }

                        BOOST_CHARCONV_ASSERT(remaining_digits >= 3);

                        for (int i = 0; i < (remaining_digits - 3) / 2; ++i)
                        {
                            prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                            print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
                            buffer += 2;
                        }

                        if (digits_in_the_second_segment != 0) 
                        {
                            prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                            current_digits = static_cast<std::uint32_t>(prod >> 32);
                            remaining_digits = 0;

                        second_segment22_at_most_9_digits_rounding:
                            if (check_rounding_condition_inside_subsegment(
                                    current_digits, static_cast<std::uint32_t>(prod),
                                    digits_in_the_second_segment, has_further_digits<1, 0, ExtendedCache>(significand, exp2_base, k, uconst1,
                                    uconst0))) 
                            {
                                goto round_up;
                            }

                            goto print_last_digits;
                        }
                        else
                        {
                            prod = static_cast<std::uint32_t>(prod) * UINT64_C(200);
                            current_digits = static_cast<std::uint32_t>(prod >> 32);
                            const auto segment_boundary_rounding_bit = (current_digits & 1) != 0;
                            current_digits >>= 1;

                            if (check_rounding_condition_with_next_bit(
                                    current_digits, segment_boundary_rounding_bit,
                                    has_further_digits<0, 1, ExtendedCache>(significand, exp2_base, k, uconst0, uconst1)))
                            {
                                goto round_up_two_digits;
                            }
                            goto print_last_two_digits;
                        }
                    } // digits_in_the_second_segment <= 9

                    // first_second_subsegments is of 1 ~ 13 digits, and third_subsegment is
                    // of 9 digits.
                    // Get one more bit for potential rounding condition check.
                    auto first_second_subsegments =
                        fixed_point_calculator<ExtendedCache::max_cache_blocks>::generate(
                            power_of_10[13] << 1, blocks, cache_block_count);
                    
                    bool first_bit_of_third_subsegment = ((first_second_subsegments & 1) != 0);
                    first_second_subsegments >>= 1;

                    // Compilers are not aware of how to leverage the maximum value of
                    // first_second_subsegments to find out a better magic number which
                    // allows us to eliminate an additional shift.
                    // 1844674407371 = ceil(2^64/10^7) = floor(2^64*(10^6/(10^13 - 1))).
                    const auto first_subsegment =
                        static_cast<std::uint32_t>(boost::charconv::detail::umul128_upper64(
                            first_second_subsegments, 1844674407371));

                    const auto second_subsegment =
                        static_cast<std::uint32_t>(first_second_subsegments) - 10000000 * first_subsegment;

                    int digits_in_the_second_subsegment;

                    // Print the first subsegment (0 ~ 6 digits) if exists.
                    if (digits_in_the_second_segment > 16)
                    {
                        std::uint64_t prod;
                        int remaining_digits_in_the_current_subsegment = digits_in_the_second_segment - 16;

                        // No rounding, continue.
                        if (remaining_digits > remaining_digits_in_the_current_subsegment)
                        {
                            remaining_digits -= remaining_digits_in_the_current_subsegment;

                            // There is no overlap in the second subsegment.
                            digits_in_the_second_subsegment = 7;

                            // When there is no overlapping digit.
                            if (remaining_digits_in_the_current_subsegment == 6)
                            {
                                prod = (first_subsegment * UINT64_C(429497)) + 1;
                                print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
                                buffer += 2;
                                remaining_digits_in_the_current_subsegment -= 2;
                            }
                            // If there are overlapping digits, move all overlapping digits
                            // into the integer part.
                            else 
                            {
                                prod = ((first_subsegment * UINT64_C(687195)) >> 4) + 1;
                                prod *= compute_power(UINT64_C(10), 5 - remaining_digits_in_the_current_subsegment);

                                if ((remaining_digits_in_the_current_subsegment & 1) != 0) 
                                {
                                    prod = static_cast<std::uint32_t>(prod) * UINT64_C(10);
                                    print_1_digit(static_cast<std::uint32_t>(prod >> 32), buffer);
                                    ++buffer;
                                }
                            }

                            for (; remaining_digits_in_the_current_subsegment > 1; remaining_digits_in_the_current_subsegment -= 2) 
                            {
                                prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                                print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
                                buffer += 2;
                            }
                        }
                        // The first subsegment is the last subsegment to print.
                        else
                        {
                            if ((remaining_digits & 1) != 0)
                            {
                                prod = ((first_subsegment * UINT64_C(687195)) >> 4) + 1;

                                // If there are overlapping digits, move all overlapping digits
                                // into the integer part and then get the next digit.
                                if (remaining_digits_in_the_current_subsegment < 6)
                                {
                                    prod *= compute_power(UINT64_C(10), 5 - remaining_digits_in_the_current_subsegment);
                                    prod = static_cast<std::uint32_t>(prod) * UINT64_C(10);
                                }
                                current_digits = static_cast<std::uint32_t>(prod >> 32);
                                remaining_digits_in_the_current_subsegment -= remaining_digits;

                                if (remaining_digits == 1) 
                                {
                                    goto second_segment22_more_than_9_digits_first_subsegment_rounding;
                                }

                                print_1_digit(current_digits, buffer);
                                ++buffer;
                            }
                            else 
                            {
                                // When there is no overlapping digit.
                                if (remaining_digits_in_the_current_subsegment == 6) 
                                {
                                    if (remaining_digits == 0)
                                    {
                                        if (check_rounding_condition_subsegment_boundary_with_next_subsegment(
                                                current_digits,
                                                uint_with_known_number_of_digits<6>{
                                                    first_subsegment},
                                                has_further_digits<1, 16, ExtendedCache>(significand, exp2_base, k, uconst1, uconst16)))
                                        {
                                            goto round_up_two_digits;
                                        }
                                        goto print_last_two_digits;
                                    }

                                    prod = (first_subsegment * UINT64_C(429497)) + 1;
                                }
                                // Otherwise, convert the subsegment into a fixed-point
                                // fraction form, move all overlapping digits into the
                                // integer part, and then extract the next two digits.
                                else 
                                {
                                    prod = ((first_subsegment * UINT64_C(687195)) >> 4) + 1;
                                    prod *= compute_power(UINT64_C(10), 5 - remaining_digits_in_the_current_subsegment);

                                    if (remaining_digits == 0)
                                    {
                                        goto second_segment22_more_than_9_digits_first_subsegment_rounding_inside_subsegment;
                                    }

                                    prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                                }
                                current_digits = static_cast<std::uint32_t>(prod >> 32);
                                remaining_digits_in_the_current_subsegment -= remaining_digits;

                                if (remaining_digits == 2)
                                {
                                    goto second_segment22_more_than_9_digits_first_subsegment_rounding;
                                }

                                print_2_digits(current_digits, buffer);
                                buffer += 2;
                            }

                            BOOST_CHARCONV_ASSERT(remaining_digits >= 3);

                            if (remaining_digits > 4)
                            {
                                prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                                print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
                                buffer += 2;
                            }

                            prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                            current_digits = static_cast<std::uint32_t>(prod >> 32);
                            remaining_digits = 0;

                        second_segment22_more_than_9_digits_first_subsegment_rounding:
                            if (remaining_digits_in_the_current_subsegment == 0) 
                            {
                                if (check_rounding_condition_subsegment_boundary_with_next_subsegment(
                                        current_digits,
                                        uint_with_known_number_of_digits<7>{second_subsegment},
                                        has_further_digits<1, 9, ExtendedCache>(significand, exp2_base, k, uconst1, uconst9))) 
                                {
                                    goto round_up;
                                }
                            }
                            else 
                            {
                            second_segment22_more_than_9_digits_first_subsegment_rounding_inside_subsegment
                                :
                                if (check_rounding_condition_inside_subsegment(
                                        current_digits, static_cast<std::uint32_t>(prod),
                                        remaining_digits_in_the_current_subsegment,
                                        has_further_digits<1, 16, ExtendedCache>(significand, exp2_base, k, uconst1, uconst16)))
                                {
                                    goto round_up;
                                }
                            }
                            goto print_last_digits;
                        }
                    }
                    else
                    {
                        digits_in_the_second_subsegment = digits_in_the_second_segment - 9;
                    }

                    // Print the second subsegment (1 ~ 7 digits).
                    {
                        // No rounding, continue.
                        if (remaining_digits > digits_in_the_second_subsegment) 
                        {
                            auto prod = ((second_subsegment * UINT64_C(17592187)) >> 12) + 1;
                            remaining_digits -= digits_in_the_second_subsegment;

                            // When there is no overlapping digit.
                            if (digits_in_the_second_subsegment == 7)
                            {
                                print_1_digit(static_cast<std::uint32_t>(prod >> 32), buffer);
                                ++buffer;
                            }
                            // If there are overlapping digits, move all overlapping digits
                            // into the integer part.
                            else
                            {
                                prod *= compute_power(UINT64_C(10),
                                                        6 - digits_in_the_second_subsegment);

                                if ((digits_in_the_second_subsegment & 1) != 0)
                                {
                                    prod = static_cast<std::uint32_t>(prod) * UINT64_C(10);
                                    print_1_digit(static_cast<std::uint32_t>(prod >> 32), buffer);
                                    ++buffer;
                                }
                            }

                            for (; digits_in_the_second_subsegment > 1; digits_in_the_second_subsegment -= 2)
                            {
                                prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                                print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
                                buffer += 2;
                            }
                        }
                        // The second subsegment is the last subsegment to print.
                        else
                        {
                            std::uint64_t prod;

                            if ((remaining_digits & 1) != 0)
                            {
                                prod = ((second_subsegment * UINT64_C(17592187)) >> 12) + 1;

                                // If there are overlapping digits, move all overlapping digits
                                // into the integer part and then get the next digit.
                                if (digits_in_the_second_subsegment < 7) 
                                {
                                    prod *= compute_power(UINT64_C(10), 6 - digits_in_the_second_subsegment);
                                    prod = static_cast<std::uint32_t>(prod) * UINT64_C(10);
                                }
                                current_digits = static_cast<std::uint32_t>(prod >> 32);
                                digits_in_the_second_subsegment -= remaining_digits;

                                if (remaining_digits == 1)
                                {
                                    goto second_segment22_more_than_9_digits_second_subsegment_rounding;
                                }

                                print_1_digit(current_digits, buffer);
                                ++buffer;
                            }
                            else
                            {
                                // When there is no overlapping digit.
                                if (digits_in_the_second_subsegment == 7)
                                {
                                    if (remaining_digits == 0)
                                    {
                                        if (check_rounding_condition_subsegment_boundary_with_next_subsegment(
                                                current_digits,
                                                uint_with_known_number_of_digits<7>{
                                                    second_subsegment},
                                                has_further_digits<1, 9, ExtendedCache>(significand, exp2_base, k, uconst1, uconst9)))
                                        {
                                            goto round_up_two_digits;
                                        }
                                        goto print_last_two_digits;
                                    }

                                    prod = ((second_subsegment * UINT64_C(10995117)) >> 8) + 1;
                                }
                                // Otherwise, convert the subsegment into a fixed-point
                                // fraction form, move all overlapping digits into the
                                // integer part, and then extract the next two digits.
                                else 
                                {
                                    prod = ((second_subsegment * UINT64_C(17592187)) >> 12) + 1;
                                    prod *= compute_power(UINT64_C(10), 6 - digits_in_the_second_subsegment);

                                    if (remaining_digits == 0)
                                    {
                                        goto second_segment22_more_than_9_digits_second_subsegment_rounding_inside_subsegment;
                                    }

                                    prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                                }
                                current_digits = static_cast<std::uint32_t>(prod >> 32);
                                digits_in_the_second_subsegment -= remaining_digits;

                                if (remaining_digits == 2)
                                {
                                    goto second_segment22_more_than_9_digits_second_subsegment_rounding;
                                }

                                print_2_digits(current_digits, buffer);
                                buffer += 2;
                            }

                            BOOST_CHARCONV_ASSERT(remaining_digits >= 3);

                            if (remaining_digits > 4)
                            {
                                prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                                print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
                                buffer += 2;
                            }

                            prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                            current_digits = static_cast<std::uint32_t>(prod >> 32);
                            remaining_digits = 0;

                        second_segment22_more_than_9_digits_second_subsegment_rounding:
                            if (digits_in_the_second_subsegment == 0)
                            {
                                if (check_rounding_condition_with_next_bit(
                                        current_digits, first_bit_of_third_subsegment,
                                        has_further_digits<0, 9, ExtendedCache>(significand, exp2_base, k, uconst0, uconst9)))
                                {
                                    goto round_up;
                                }
                            }
                            else
                            {
                            second_segment22_more_than_9_digits_second_subsegment_rounding_inside_subsegment
                                :
                                if (check_rounding_condition_inside_subsegment(
                                        current_digits, static_cast<std::uint32_t>(prod),
                                        digits_in_the_second_subsegment, has_further_digits<1, 9, ExtendedCache>(significand, exp2_base, k,
                                        uconst1, uconst9)))
                                {
                                    goto round_up;
                                }
                            }
                            goto print_last_digits;
                        }
                    }

                    // Print the third subsegment (9 digits).
                    {
                        // Get one more bit if we need to check rounding conditions on
                        // the segment boundary. We already have shifted by 1-bit in the
                        // computation of first & second subsegments, so here we don't
                        // shift the multiplier.
                        auto third_subsegment =
                            fixed_point_calculator<ExtendedCache::max_cache_blocks>::
                                generate_and_discard_lower(power_of_10[9], blocks,
                                                            cache_block_count);

                        bool segment_boundary_rounding_bit = ((third_subsegment & 1) != 0);
                        third_subsegment >>= 1;
                        third_subsegment += (first_bit_of_third_subsegment ? 500000000 : 0);

                        std::uint64_t prod;
                        if ((remaining_digits & 1) != 0)
                        {
                            prod = ((third_subsegment * UINT64_C(720575941)) >> 24) + 1;
                            current_digits = static_cast<std::uint32_t>(prod >> 32);

                            if (remaining_digits == 1) 
                            {
                                if (check_rounding_condition_inside_subsegment(
                                        current_digits, static_cast<std::uint32_t>(prod), 8,
                                        has_further_digits<1, 0, ExtendedCache>(significand, exp2_base, k, uconst1, uconst0))) 
                                {
                                    goto round_up_one_digit;
                                }
                                goto print_last_one_digit;
                            }

                            print_1_digit(current_digits, buffer);
                            ++buffer;
                        }
                        else 
                        {
                            prod = ((third_subsegment * UINT64_C(450359963)) >> 20) + 1;
                            current_digits = static_cast<std::uint32_t>(prod >> 32);

                            if (remaining_digits == 2) 
                            {
                                goto second_segment22_more_than_9_digits_third_subsegment_rounding;
                            }

                            print_2_digits(current_digits, buffer);
                            buffer += 2;
                        }

                        for (int i = 0; i < (remaining_digits - 3) / 2; ++i)
                        {
                            prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                            print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
                            buffer += 2;
                        }

                        prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                        current_digits = static_cast<std::uint32_t>(prod >> 32);

                        if (remaining_digits < 9)
                        {
                        second_segment22_more_than_9_digits_third_subsegment_rounding:
                            if (check_rounding_condition_inside_subsegment(
                                    current_digits, static_cast<std::uint32_t>(prod), 9 - remaining_digits,
                                    has_further_digits<1, 0, ExtendedCache>(significand, exp2_base, k, uconst1, uconst0)))
                            {
                                goto round_up_two_digits;
                            }
                        }
                        else 
                        {
                            if (check_rounding_condition_with_next_bit(
                                    current_digits, segment_boundary_rounding_bit,
                                    has_further_digits<0, 0, ExtendedCache>(significand, exp2_base, k, uconst0, uconst0))) 
                            {
                                goto round_up_two_digits;
                            }
                        }
                        goto print_last_two_digits;
                    }
                }
            } // ExtendedCache::segment_length == 22

            else BOOST_CHARCONV_IF_CONSTEXPR (ExtendedCache::segment_length == 252)
            {
                int overlapping_digits = 252 - digits_in_the_second_segment;
                int remaining_subsegment_pairs = 14;

                while (overlapping_digits >= 18)
                {
                    fixed_point_calculator<ExtendedCache::max_cache_blocks>::discard_upper(
                        power_of_10[18], blocks, cache_block_count);
                    --remaining_subsegment_pairs;
                    overlapping_digits -= 18;
                }

                auto subsegment_pair = fixed_point_calculator<ExtendedCache::max_cache_blocks>::generate(power_of_10[18] << 1, blocks, cache_block_count);
                auto subsegment_boundary_rounding_bit = (subsegment_pair & 1) != 0;
                subsegment_pair >>= 1;

                // Deal with the first subsegment pair.
                {
                    // Divide it into two 9-digits subsegments.
                    const auto first_part = static_cast<std::uint32_t>(subsegment_pair / power_of_10[9]);
                    const auto second_part = static_cast<std::uint32_t>(subsegment_pair - power_of_10[9] * first_part);

                    auto print_subsegment = [&](std::uint32_t subsegment, int digits_in_the_subsegment)
                    {
                        remaining_digits -= digits_in_the_subsegment;

                        // Move all overlapping digits into the integer part.
                        auto prod = ((subsegment * UINT64_C(720575941)) >> 24) + 1;
                        if (digits_in_the_subsegment < 9) 
                        {
                            prod *= compute_power(UINT32_C(10), 8 - digits_in_the_subsegment);

                            if ((digits_in_the_subsegment & 1) != 0) 
                            {
                                prod = static_cast<std::uint32_t>(prod) * UINT64_C(10);
                                print_1_digit(static_cast<std::uint32_t>(prod >> 32), buffer);
                                ++buffer;
                            }
                        }
                        else 
                        {
                            print_1_digit(static_cast<std::uint32_t>(prod >> 32), buffer);
                            ++buffer;
                        }

                        for (; digits_in_the_subsegment > 1; digits_in_the_subsegment -= 2) 
                        {
                            prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                            print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
                            buffer += 2;
                        }
                    };

                    // When the first part is not completely overlapping with the first segment.
                    int digits_in_the_second_part;
                    if (overlapping_digits < 9) 
                    {
                        int digits_in_the_first_part = 9 - overlapping_digits;

                        // No rounding, continue.
                        if (remaining_digits > digits_in_the_first_part) 
                        {
                            digits_in_the_second_part = 9;
                            print_subsegment(first_part, digits_in_the_first_part);
                        }
                        // Perform rounding and return.
                        else 
                        {
                            // When there is no overlapping digit.
                            std::uint64_t prod;
                            if (digits_in_the_first_part == 9)
                            {
                                if ((remaining_digits & 1) != 0) 
                                {
                                    prod = ((first_part * UINT64_C(720575941)) >> 24) + 1;
                                }
                                else 
                                {
                                    if (remaining_digits == 0) 
                                    {
                                        if (check_rounding_condition_subsegment_boundary_with_next_subsegment(
                                                current_digits,
                                                uint_with_known_number_of_digits<9>{first_part},
                                                compute_has_further_digits<1, 9, ExtendedCache>, remaining_subsegment_pairs, significand, exp2_base, k))
                                        {
                                            goto round_up_two_digits;
                                        }
                                        goto print_last_two_digits;
                                    }

                                    prod = ((first_part * UINT64_C(450359963)) >> 20) + 1;
                                }
                            }
                            else 
                            {
                                prod = ((first_part * UINT64_C(720575941)) >> 24) + 1;
                                prod *= compute_power(UINT32_C(10), 8 - digits_in_the_first_part);

                                if ((remaining_digits & 1) != 0) 
                                {
                                    prod = static_cast<std::uint32_t>(prod) * UINT64_C(10);
                                }
                                else 
                                {
                                    if (remaining_digits == 0) 
                                    {
                                        goto second_segment252_first_subsegment_rounding_inside_subsegment;
                                    }

                                    prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                                }
                            }
                            digits_in_the_first_part -= remaining_digits;
                            current_digits = static_cast<std::uint32_t>(prod >> 32);

                            if (remaining_digits > 2) 
                            {
                                if ((remaining_digits & 1) != 0) 
                                {
                                    print_1_digit(current_digits, buffer);
                                    ++buffer;
                                }
                                else 
                                {
                                    print_2_digits(current_digits, buffer);
                                    buffer += 2;
                                }

                                for (int i = 0; i < (remaining_digits - 3) / 2; ++i)
                                {
                                    prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                                    print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
                                    buffer += 2;
                                }

                                prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                                current_digits = static_cast<std::uint32_t>(prod >> 32);
                                remaining_digits = 0;
                            }

                            if (digits_in_the_first_part != 0)
                            {
                            second_segment252_first_subsegment_rounding_inside_subsegment:
                                if (check_rounding_condition_inside_subsegment(
                                        current_digits, static_cast<std::uint32_t>(prod),
                                        digits_in_the_first_part, compute_has_further_digits<1, 9, ExtendedCache>, remaining_subsegment_pairs, significand, exp2_base, k)) 
                                {
                                    goto round_up;
                                }
                            }
                            else 
                            {
                                if (check_rounding_condition_subsegment_boundary_with_next_subsegment(
                                        current_digits,
                                        uint_with_known_number_of_digits<9>{static_cast<std::uint32_t>(second_part)},
                                        compute_has_further_digits<1, 0, ExtendedCache>, remaining_subsegment_pairs, significand, exp2_base, k))
                                {
                                    goto round_up;
                                }
                            }
                            goto print_last_digits;
                        }
                    }
                    else
                    {
                        digits_in_the_second_part = 18 - overlapping_digits;
                    }

                    // Print the second part.
                    // No rounding, continue.
                    if (remaining_digits > digits_in_the_second_part)
                    {
                        print_subsegment(second_part, digits_in_the_second_part);
                    }
                    // Perform rounding and return.
                    else
                    {
                        // When there is no overlapping digit.
                        std::uint64_t prod;
                        if (digits_in_the_second_part == 9)
                        {
                            if ((remaining_digits & 1) != 0)
                            {
                                prod = ((second_part * UINT64_C(720575941)) >> 24) + 1;
                            }
                            else 
                            {
                                if (remaining_digits == 0)
                                {
                                    if (check_rounding_condition_subsegment_boundary_with_next_subsegment(
                                            current_digits,
                                            uint_with_known_number_of_digits<9>{static_cast<std::uint32_t>(second_part)},
                                            compute_has_further_digits<1, 0, ExtendedCache>, remaining_subsegment_pairs, significand, exp2_base, k)) 
                                    {
                                        goto round_up_two_digits;
                                    }
                                    goto print_last_two_digits;
                                }

                                prod = ((second_part * UINT64_C(450359963)) >> 20) + 1;
                            }
                        }
                        else 
                        {
                            prod = ((second_part * UINT64_C(720575941)) >> 24) + 1;
                            prod *= compute_power(UINT32_C(10), 8 - digits_in_the_second_part);

                            if ((remaining_digits & 1) != 0)
                            {
                                prod = static_cast<std::uint32_t>(prod) * UINT64_C(10);
                            }
                            else 
                            {
                                if (remaining_digits == 0) 
                                {
                                    goto second_segment252_second_subsegment_rounding_inside_subsegment;
                                }

                                prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                            }
                        }
                        digits_in_the_second_part -= remaining_digits;
                        current_digits = static_cast<std::uint32_t>(prod >> 32);

                        if (remaining_digits > 2)
                        {
                            if ((remaining_digits & 1) != 0) 
                            {
                                print_1_digit(current_digits, buffer);
                                ++buffer;
                            }
                            else 
                            {
                                print_2_digits(current_digits, buffer);
                                buffer += 2;
                            }

                            for (int i = 0; i < (remaining_digits - 3) / 2; ++i)
                            {
                                prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                                print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
                                buffer += 2;
                            }

                            prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                            current_digits = static_cast<std::uint32_t>(prod >> 32);
                            remaining_digits = 0;
                        }

                        if (digits_in_the_second_part != 0)
                        {
                        second_segment252_second_subsegment_rounding_inside_subsegment:
                            if (check_rounding_condition_inside_subsegment(
                                    current_digits, static_cast<std::uint32_t>(prod),
                                    digits_in_the_second_part, compute_has_further_digits<1, 0, ExtendedCache>, remaining_subsegment_pairs, significand, exp2_base, k))
                            {
                                goto round_up;
                            }
                        }
                        else 
                        {
                            if (check_rounding_condition_with_next_bit(
                                    current_digits, subsegment_boundary_rounding_bit,
                                    compute_has_further_digits<0, 0, ExtendedCache>, remaining_subsegment_pairs, significand, exp2_base, k))
                            {
                                goto round_up;
                            }
                        }
                        goto print_last_digits;
                    }
                }

                // Remaining subsegment pairs do not have overlapping digits.
                --remaining_subsegment_pairs;
                for (; remaining_subsegment_pairs > 0; --remaining_subsegment_pairs) 
                {
                    subsegment_pair = fixed_point_calculator<ExtendedCache::max_cache_blocks>::generate(power_of_10[18], blocks, cache_block_count);

                    subsegment_pair += (subsegment_boundary_rounding_bit ? power_of_10[18] : 0);
                    subsegment_boundary_rounding_bit = (subsegment_pair & 1) != 0;
                    subsegment_pair >>= 1;

                    const auto first_part = static_cast<std::uint32_t>(subsegment_pair / power_of_10[9]);
                    const auto second_part = static_cast<std::uint32_t>(subsegment_pair - power_of_10[9] * first_part);

                    // The first part can be printed without rounding.
                    if (remaining_digits > 9)
                    {
                        print_9_digits(first_part, buffer);

                        // The second part also can be printed without rounding.
                        if (remaining_digits > 18) 
                        {
                            print_9_digits(second_part, buffer + 9);
                        }
                        // Otherwise, perform rounding and return.
                        else
                        {
                            buffer += 9;
                            remaining_digits -= 9;

                            std::uint64_t prod;
                            int remaining_digits_in_the_current_subsegment = 9 - remaining_digits;

                            if ((remaining_digits & 1) != 0)
                            {
                                prod = ((second_part * UINT64_C(720575941)) >> 24) + 1;
                                current_digits = static_cast<std::uint32_t>(prod >> 32);

                                if (remaining_digits == 1)
                                {
                                    goto second_segment252_loop_second_subsegment_rounding;
                                }

                                print_1_digit(current_digits, buffer);
                                ++buffer;
                            }
                            else
                            {
                                prod = ((second_part * UINT64_C(450359963)) >> 20) + 1;
                                current_digits = static_cast<std::uint32_t>(prod >> 32);

                                if (remaining_digits == 2)
                                {
                                    goto second_segment252_loop_second_subsegment_rounding;
                                }

                                print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
                                buffer += 2;
                            }

                            for (int i = 0; i < (remaining_digits - 3) / 2; ++i)
                            {
                                prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                                print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
                                buffer += 2;
                            }

                            prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                            current_digits = static_cast<std::uint32_t>(prod >> 32);
                            remaining_digits = 0;

                            if (remaining_digits_in_the_current_subsegment != 0) 
                            {
                            second_segment252_loop_second_subsegment_rounding:
                                if (check_rounding_condition_inside_subsegment(
                                        current_digits, static_cast<std::uint32_t>(prod),
                                        remaining_digits_in_the_current_subsegment,
                                        compute_has_further_digits<1, 0, ExtendedCache>, remaining_subsegment_pairs, significand, exp2_base, k))
                                {
                                    goto round_up;
                                }
                                goto print_last_digits;
                            }
                            else 
                            {
                                if (check_rounding_condition_with_next_bit(
                                        current_digits, subsegment_boundary_rounding_bit,
                                        compute_has_further_digits<0, 0, ExtendedCache>, remaining_subsegment_pairs, significand, exp2_base, k))
                                {
                                    goto round_up_two_digits;
                                }
                                goto print_last_two_digits;
                            }
                        }
                    }
                    // Otherwise, perform rounding and return.
                    else
                    {
                        std::uint64_t prod;
                        int remaining_digits_in_the_current_subsegment = 9 - remaining_digits;
                        if ((remaining_digits & 1) != 0) 
                        {
                            prod = ((first_part * UINT64_C(720575941)) >> 24) + 1;
                            current_digits = static_cast<std::uint32_t>(prod >> 32);

                            if (remaining_digits == 1) 
                            {
                                goto second_segment252_loop_first_subsegment_rounding;
                            }

                            print_1_digit(current_digits, buffer);
                            ++buffer;
                        }
                        else
                        {
                            prod = ((first_part * UINT64_C(450359963)) >> 20) + 1;
                            current_digits = static_cast<std::uint32_t>(prod >> 32);

                            if (remaining_digits == 2)
                            {
                                goto second_segment252_loop_first_subsegment_rounding;
                            }

                            print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
                            buffer += 2;
                        }

                        for (int i = 0; i < (remaining_digits - 3) / 2; ++i)
                        {
                            prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                            print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
                            buffer += 2;
                        }

                        prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                        current_digits = static_cast<std::uint32_t>(prod >> 32);
                        remaining_digits = 0;

                        if (remaining_digits_in_the_current_subsegment != 0)
                        {
                        second_segment252_loop_first_subsegment_rounding:
                            if (check_rounding_condition_inside_subsegment(
                                    current_digits, static_cast<std::uint32_t>(prod),
                                    remaining_digits_in_the_current_subsegment,
                                    compute_has_further_digits<1, 9, ExtendedCache>, remaining_subsegment_pairs, significand, exp2_base, k))
                            {
                                goto round_up;
                            }
                            goto print_last_digits;
                        }
                        else
                        {
                            if (check_rounding_condition_subsegment_boundary_with_next_subsegment(
                                    current_digits,
                                    uint_with_known_number_of_digits<9>{static_cast<std::uint32_t>(second_part)},
                                    compute_has_further_digits<1, 9, ExtendedCache>, remaining_subsegment_pairs, significand, exp2_base, k))
                            {
                                goto round_up_two_digits;
                            }
                            goto print_last_two_digits;
                        }
                    }

                    buffer += 18;
                    remaining_digits -= 18;
                }
            } // ExtendedCache::segment_length == 252
        }

        // Print all remaining segments.
        while (has_further_digits<1, 0, ExtendedCache>(significand, exp2_base, k, uconst1, uconst0))
        {
            // Get new segment.
            ++multiplier_index;
            k += ExtendedCache::segment_length;

            cache_block_count = load_extended_cache<ExtendedCache, ExtendedCache::constant_block_count>(blocks, e, k, multiplier_index);

            // Compute nm mod 2^Q.
            fixed_point_calculator<ExtendedCache::max_cache_blocks>::discard_upper(significand, blocks, cache_block_count);

            BOOST_CHARCONV_IF_CONSTEXPR (ExtendedCache::segment_length == 22)
            {
                // When at least two subsegments left.
                if (remaining_digits > 16) 
                {
                    std::uint64_t first_second_subsegments = fixed_point_calculator<ExtendedCache::max_cache_blocks>::generate(power_of_10[16], blocks, cache_block_count);

                    const auto first_subsegment =
                        static_cast<std::uint32_t>(boost::charconv::detail::umul128_upper64(first_second_subsegments, UINT64_C(3022314549036573)) >> 14);
                    
                    const std::uint32_t second_subsegment = static_cast<std::uint32_t>(first_second_subsegments) - UINT32_C(100000000) * first_subsegment;

                    print_8_digits(first_subsegment, buffer);
                    print_8_digits(second_subsegment, buffer + 8);

                    // When more segments left.
                    if (remaining_digits > 22)
                    {
                        const auto third_subsegment = static_cast<std::uint32_t>(
                            fixed_point_calculator<ExtendedCache::max_cache_blocks>::generate_and_discard_lower(power_of_10[6], blocks,cache_block_count));

                        print_6_digits(third_subsegment, buffer + 16);
                        buffer += 22;
                        remaining_digits -= 22;
                    }
                    // When this is the last segment.
                    else
                    {
                        buffer += 16;
                        remaining_digits -= 16;

                        auto third_subsegment = fixed_point_calculator<ExtendedCache::max_cache_blocks>::
                            generate_and_discard_lower(power_of_10[6] << 1, blocks, cache_block_count);

                        bool segment_boundary_rounding_bit = ((third_subsegment & 1) != 0);
                        third_subsegment >>= 1;

                        std::uint64_t prod;
                        if ((remaining_digits & 1) != 0)
                        {
                            prod = ((third_subsegment * UINT64_C(687195)) >> 4) + 1;
                            current_digits = static_cast<std::uint32_t>(prod >> 32);

                            if (remaining_digits == 1)
                            {
                                if (check_rounding_condition_inside_subsegment(
                                        current_digits, static_cast<std::uint32_t>(prod), 5,
                                        has_further_digits<1, 0, ExtendedCache>(significand, exp2_base, k, uconst1, uconst0))) 
                                {
                                    goto round_up_one_digit;
                                }
                                goto print_last_one_digit;
                            }

                            print_1_digit(current_digits, buffer);
                            ++buffer;
                        }
                        else
                        {
                            prod = (third_subsegment * UINT64_C(429497)) + 1;
                            current_digits = static_cast<std::uint32_t>(prod >> 32);

                            if (remaining_digits == 2)
                            {
                                goto segment_loop22_more_than_16_digits_rounding;
                            }

                            print_2_digits(current_digits, buffer);
                            buffer += 2;
                        }

                        if (remaining_digits > 4)
                        {
                            prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                            print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
                            buffer += 2;

                            if (remaining_digits == 6)
                            {
                                prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                                current_digits = static_cast<std::uint32_t>(prod >> 32);

                                if (check_rounding_condition_with_next_bit(
                                        current_digits, segment_boundary_rounding_bit,
                                        has_further_digits<0, 0, ExtendedCache>(significand, exp2_base, k, uconst0, uconst0)))
                                {
                                    goto round_up_two_digits;
                                }
                                goto print_last_two_digits;
                            }
                        }

                        prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                        current_digits = static_cast<std::uint32_t>(prod >> 32);

                    segment_loop22_more_than_16_digits_rounding:
                        if (check_rounding_condition_inside_subsegment(
                                current_digits, static_cast<std::uint32_t>(prod), 6 - remaining_digits,
                                has_further_digits<1, 0, ExtendedCache>(significand, exp2_base, k, uconst1, uconst0)))
                        {
                            goto round_up_two_digits;
                        }
                        goto print_last_two_digits;
                    }
                }
                // When two subsegments left.
                else if (remaining_digits > 8)
                {
                    // Get one more bit for potential rounding conditions check.
                    auto first_second_subsegments =
                        fixed_point_calculator<ExtendedCache::max_cache_blocks>::
                            generate_and_discard_lower(power_of_10[16] << 1, blocks, cache_block_count);

                    bool first_bit_of_third_subsegment = ((first_second_subsegments & 1) != 0);
                    first_second_subsegments >>= 1;

                    // 3022314549036573 = ceil(2^78/10^8) = floor(2^78*(10^8/(10^16 -
                    // 1))).
                    const auto first_subsegment =
                        static_cast<std::uint32_t>(boost::charconv::detail::umul128_upper64(first_second_subsegments, UINT64_C(3022314549036573)) >> 14);

                    const auto second_subsegment = static_cast<std::uint32_t>(first_second_subsegments) - UINT32_C(100000000) * first_subsegment;

                    print_8_digits(first_subsegment, buffer);
                    buffer += 8;
                    remaining_digits -= 8;

                    // Second subsegment (8 digits).
                    std::uint64_t prod;
                    if ((remaining_digits & 1) != 0)
                    {
                        prod = ((second_subsegment * UINT64_C(112589991)) >> 18) + 1;
                        current_digits = static_cast<std::uint32_t>(prod >> 32);

                        if (remaining_digits == 1)
                        {
                            if (check_rounding_condition_inside_subsegment(
                                    current_digits, static_cast<std::uint32_t>(prod), 7, has_further_digits<1, 6, ExtendedCache>(significand, exp2_base, k,
                                    uconst1, uconst6)))
                            {
                                goto round_up_one_digit;
                            }
                            goto print_last_one_digit;
                        }

                        print_1_digit(current_digits, buffer);
                        ++buffer;
                    }
                    else
                    {
                        prod = ((second_subsegment * UINT64_C(140737489)) >> 15) + 1;
                        current_digits = static_cast<std::uint32_t>(prod >> 32);

                        if (remaining_digits == 2)
                        {
                            goto segment_loop22_more_than_8_digits_rounding;
                        }

                        print_2_digits(current_digits, buffer);
                        buffer += 2;
                    }

                    for (int i = 0; i < (remaining_digits - 3) / 2; ++i)
                    {
                        prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                        print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
                        buffer += 2;
                    }

                    prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                    current_digits = static_cast<std::uint32_t>(prod >> 32);

                    if (remaining_digits < 8)
                    {
                    segment_loop22_more_than_8_digits_rounding:
                        if (check_rounding_condition_inside_subsegment(
                                current_digits, static_cast<std::uint32_t>(prod), 8 - remaining_digits,
                                has_further_digits<1, 6, ExtendedCache>(significand, exp2_base, k, uconst1, uconst6)))
                        {
                            goto round_up_two_digits;
                        }
                    }
                    else {
                        if (check_rounding_condition_with_next_bit(
                                current_digits, first_bit_of_third_subsegment,
                                has_further_digits<0, 6, ExtendedCache>(significand, exp2_base, k, uconst0, uconst6)))
                        {
                            goto round_up_two_digits;
                        }
                    }
                    goto print_last_two_digits;
                }
                // remaining_digits is at most 8.
                else
                {
                    // Get one more bit for potential rounding conditions check.
                    auto first_subsegment =
                        fixed_point_calculator<ExtendedCache::max_cache_blocks>::
                            generate_and_discard_lower(power_of_10[8] << 1, blocks, cache_block_count);

                    bool first_bit_of_second_subsegment = ((first_subsegment & 1) != 0);
                    first_subsegment >>= 1;

                    std::uint64_t prod;
                    if ((remaining_digits & 1) != 0)
                    {
                        prod = ((first_subsegment * UINT64_C(112589991)) >> 18) + 1;
                        current_digits = static_cast<std::uint32_t>(prod >> 32);

                        if (remaining_digits == 1)
                        {
                            if (check_rounding_condition_inside_subsegment(
                                    current_digits, static_cast<std::uint32_t>(prod), 7, has_further_digits<1, 14, ExtendedCache>(significand, exp2_base, k,
                                    uconst1, uconst14)))
                            {
                                goto round_up_one_digit;
                            }
                            goto print_last_one_digit;
                        }

                        print_1_digit(current_digits, buffer);
                        ++buffer;
                    }
                    else
                    {
                        prod = ((first_subsegment * UINT64_C(140737489)) >> 15) + 1;
                        current_digits = static_cast<std::uint32_t>(prod >> 32);

                        if (remaining_digits == 2)
                        {
                            goto segment_loop22_at_most_8_digits_rounding;
                        }

                        print_2_digits(current_digits, buffer);
                        buffer += 2;
                    }

                    for (int i = 0; i < (remaining_digits - 3) / 2; ++i)
                    {
                        prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                        print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
                        buffer += 2;
                    }

                    prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                    current_digits = static_cast<std::uint32_t>(prod >> 32);

                    if (remaining_digits < 8)
                    {
                    segment_loop22_at_most_8_digits_rounding:
                        if (check_rounding_condition_inside_subsegment(
                                current_digits, static_cast<std::uint32_t>(prod), 8 - remaining_digits,
                                has_further_digits<1, 14, ExtendedCache>(significand, exp2_base, k, uconst1, uconst14)))
                        {
                            goto round_up_two_digits;
                        }
                    }
                    else
                    {
                        if (check_rounding_condition_with_next_bit(
                                current_digits, first_bit_of_second_subsegment,
                                has_further_digits<0, 14, ExtendedCache>(significand, exp2_base, k, uconst0, uconst14)))
                        {
                            goto round_up_two_digits;
                        }
                    }
                    goto print_last_two_digits;
                }
            } // ExtendedCache::segment_length == 22
            else if (ExtendedCache::segment_length == 252)
            {
                // Print as many 18-digits subsegment pairs as possible.
                for (int remaining_subsegment_pairs = 14; remaining_subsegment_pairs > 0;
                        --remaining_subsegment_pairs)
                {
                    // No rounding, continue.
                    if (remaining_digits > 18)
                    {
                        const auto subsegment_pair =
                            fixed_point_calculator<ExtendedCache::max_cache_blocks>::generate(power_of_10[18], blocks, cache_block_count);

                        const auto first_part = static_cast<std::uint32_t>(subsegment_pair / power_of_10[9]);
                        const auto second_part = static_cast<std::uint32_t>(subsegment_pair - power_of_10[9] * first_part);

                        print_9_digits(first_part, buffer);
                        print_9_digits(second_part, buffer + 9);
                        buffer += 18;
                        remaining_digits -= 18;
                    }
                    // Final subsegment pair.
                    else
                    {
                        auto last_subsegment_pair =
                            fixed_point_calculator<ExtendedCache::max_cache_blocks>::
                                generate_and_discard_lower(power_of_10[18] << 1, blocks, cache_block_count);

                        const bool subsegment_boundary_rounding_bit = ((last_subsegment_pair & 1) != 0);
                        last_subsegment_pair >>= 1;

                        const auto first_part = static_cast<std::uint32_t>(last_subsegment_pair / power_of_10[9]);
                        const auto second_part = static_cast<std::uint32_t>(last_subsegment_pair) - power_of_10[9] * first_part;

                        if (remaining_digits <= 9)
                        {
                            std::uint64_t prod;

                            if ((remaining_digits & 1) != 0)
                            {
                                prod = ((first_part * UINT64_C(1441151881)) >> 25) + 1;
                                current_digits = static_cast<std::uint32_t>(prod >> 32);

                                if (remaining_digits == 1)
                                {
                                    if (check_rounding_condition_inside_subsegment(
                                            current_digits, static_cast<std::uint32_t>(prod), 8,
                                            compute_has_further_digits<1, 9, ExtendedCache>, remaining_subsegment_pairs, significand, exp2_base, k))
                                    {
                                        goto round_up_one_digit;
                                    }
                                    goto print_last_one_digit;
                                }

                                print_1_digit(current_digits, buffer);
                                ++buffer;
                            }
                            else
                            {
                                prod = ((first_part * UINT64_C(450359963)) >> 20) + 1;
                                current_digits = static_cast<std::uint32_t>(prod >> 32);

                                if (remaining_digits == 2)
                                {
                                    goto segment_loop252_final18_first_part_rounding;
                                }

                                print_2_digits(current_digits, buffer);
                                buffer += 2;
                            }

                            for (int i = 0; i < (remaining_digits - 3) / 2; ++i)
                            {
                                prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                                print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
                                buffer += 2;
                            }

                            prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                            current_digits = static_cast<std::uint32_t>(prod >> 32);

                            if (remaining_digits < 9)
                            {
                            segment_loop252_final18_first_part_rounding:
                                if (check_rounding_condition_inside_subsegment(
                                        current_digits, static_cast<std::uint32_t>(prod),
                                        9 - remaining_digits, compute_has_further_digits<1, 9, ExtendedCache>, remaining_subsegment_pairs, significand, exp2_base, k))
                                {
                                    goto round_up_two_digits;
                                }
                            }
                            else
                            {
                                if (check_rounding_condition_subsegment_boundary_with_next_subsegment(
                                        current_digits,
                                        uint_with_known_number_of_digits<9>{static_cast<std::uint32_t>(second_part)},
                                        compute_has_further_digits<1, 0, ExtendedCache>, remaining_subsegment_pairs, significand, exp2_base, k))
                                {
                                    goto round_up_two_digits;
                                }
                            }
                            goto print_last_two_digits;
                        } // remaining_digits <= 9

                        print_9_digits(first_part, buffer);
                        buffer += 9;
                        remaining_digits -= 9;

                        std::uint64_t prod;

                        if ((remaining_digits & 1) != 0)
                        {
                            prod = ((second_part * UINT64_C(1441151881)) >> 25) + 1;
                            current_digits = static_cast<std::uint32_t>(prod >> 32);

                            if (remaining_digits == 1)
                            {
                                if (check_rounding_condition_inside_subsegment(
                                        current_digits, static_cast<std::uint32_t>(prod), 8,
                                        compute_has_further_digits<1, 0, ExtendedCache>, remaining_subsegment_pairs, significand, exp2_base, k))
                                {
                                    goto round_up_one_digit;
                                }
                                goto print_last_one_digit;
                            }

                            print_1_digit(current_digits, buffer);
                            ++buffer;
                        }
                        else
                        {
                            prod = ((second_part * UINT64_C(450359963)) >> 20) + 1;
                            current_digits = static_cast<std::uint32_t>(prod >> 32);

                            if (remaining_digits == 2)
                            {
                                goto segment_loop252_final18_second_part_rounding;
                            }

                            print_2_digits(current_digits, buffer);
                            buffer += 2;
                        }

                        for (int i = 0; i < (remaining_digits - 3) / 2; ++i)
                        {
                            prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                            print_2_digits(static_cast<std::uint32_t>(prod >> 32), buffer);
                            buffer += 2;
                        }

                        prod = static_cast<std::uint32_t>(prod) * UINT64_C(100);
                        current_digits = static_cast<std::uint32_t>(prod >> 32);

                        if (remaining_digits < 9)
                        {
                        segment_loop252_final18_second_part_rounding:
                            if (check_rounding_condition_inside_subsegment(
                                    current_digits, static_cast<std::uint32_t>(prod), 9 - remaining_digits,
                                    compute_has_further_digits<1, 0, ExtendedCache>, remaining_subsegment_pairs, significand, exp2_base, k))
                            {
                                goto round_up_two_digits;
                            }
                        }
                        else
                        {
                            if (check_rounding_condition_with_next_bit(
                                    current_digits, subsegment_boundary_rounding_bit,
                                    compute_has_further_digits<0, 0, ExtendedCache>, remaining_subsegment_pairs, significand, exp2_base, k))
                            {
                                goto round_up_two_digits;
                            }
                        }
                        goto print_last_two_digits;
                    }
                }
            } // if (ExtendedCache::segment_length == 252)
        }
    }


    /////////////////////////////////////////////////////////////////////////////////////////////////
    /// Phase 3 - Fill remaining digits with 0's, insert decimal dot, print exponent, and
    /// return.
    /////////////////////////////////////////////////////////////////////////////////////////////////

fill_remaining_digits_with_0s:
    // This is probably not needed for the general format, but currently I am not 100% sure.
    // (When fixed format is eventually chosen, we do not remove trailing zeros in the integer part.
    // I am not sure if those trailing zeros are guaranteed to be already printed or not.)
    std::memset(buffer, '0', static_cast<std::size_t>(remaining_digits));
    buffer += remaining_digits;

insert_decimal_dot:
    if (fmt == chars_format::general)
    {
        // Decide between fixed vs scientific.
        if (-4 <= decimal_exponent_normalized && decimal_exponent_normalized < precision)
        {
            // Fixed.
            if (decimal_exponent_normalized >= 0)
            {
                // Insert decimal dot.
                decimal_dot_pos = buffer_starting_pos + decimal_exponent_normalized + 1;
                std::memmove(buffer_starting_pos, buffer_starting_pos + 1,
                             static_cast<std::size_t>(decimal_dot_pos - buffer_starting_pos));
                *decimal_dot_pos = '.';
            }
            else
            {
                // Print leading zeros and insert decimal dot.
                int number_of_leading_zeros = -decimal_exponent_normalized - 1;
                std::memmove(buffer_starting_pos + number_of_leading_zeros + 2, buffer_starting_pos + 1,
                             static_cast<std::size_t>(buffer - buffer_starting_pos - 1));
                std::memcpy(buffer_starting_pos, "0.", 2);
                std::memset(buffer_starting_pos + 2, '0', static_cast<std::size_t>(number_of_leading_zeros));
                buffer += number_of_leading_zeros + 1;
            }
            // Don't print exponent.
            fmt = chars_format::fixed;
        }
        else
        {
            // Scientific.
            // Insert decimal dot.
            *buffer_starting_pos = *(buffer_starting_pos + 1);
            *(buffer_starting_pos + 1) = '.';
        }

        // Remove trailing zeros.
        while (true)
        {
            auto prev = buffer - 1;

            // Remove decimal dot as well if there is no fractional digits.
            if (*prev == '.')
            {
                buffer = prev;
                break;
            }
            else if (*prev != '0')
            {
                break;
            }
            buffer = prev;
        }
    }
    else if (decimal_dot_pos != buffer_starting_pos)
    {
        std::memmove(buffer_starting_pos, buffer_starting_pos + 1,
                     static_cast<std::size_t>(decimal_dot_pos - buffer_starting_pos));
        *decimal_dot_pos = '.';
    }

    if (fmt != chars_format::fixed)
    {
        if (decimal_exponent_normalized >= 0)
        {
            std::memcpy(buffer, "e+", 2); // NOLINT : Specifically not null-terminating
        }
        else
        {
            std::memcpy(buffer, "e-", 2); // NOLINT : Specifically not null-terminating
            decimal_exponent_normalized = -decimal_exponent_normalized;
        }

        buffer += 2;
        if (decimal_exponent_normalized >= 100)
        {
            // d1 = decimal_exponent / 10; d2 = decimal_exponent % 10;
            // 6554 = ceil(2^16 / 10)
            auto prod = static_cast<std::uint32_t>(decimal_exponent_normalized) * UINT32_C(6554);
            auto d1 = prod >> 16;
            prod = static_cast<std::uint16_t>(prod) * UINT16_C(5); // * 10
            auto d2 = prod >> 15;                                  // >> 16
            print_2_digits(d1, buffer);
            print_1_digit(d2, buffer + 2);
            buffer += 3;
        }
        else
        {
            print_2_digits(static_cast<std::uint32_t>(decimal_exponent_normalized), buffer);
            buffer += 2;
        }
    }    

    return {buffer, std::errc()};

round_up:
    if ((remaining_digits & 1) != 0)
    {
    round_up_one_digit:
        if (++current_digits == 10)
        {
            goto round_up_all_9s;
        }

        goto print_last_one_digit;
    }
    else
    {
    round_up_two_digits:
        if (++current_digits == 100)
        {
            goto round_up_all_9s;
        }

        goto print_last_two_digits;
    }

print_last_digits:
    if ((remaining_digits & 1) != 0) 
    {
    print_last_one_digit:
        print_1_digit(current_digits, buffer);
        ++buffer;
    }
    else
    {
    print_last_two_digits:
        print_2_digits(current_digits, buffer);
        buffer += 2;
    }

    goto insert_decimal_dot;

round_up_all_9s:
    char* first_9_pos = buffer;
    buffer += (2 - (remaining_digits & 1));
    
    // Find the starting position of printed digits.
    char* digit_starting_pos = [&] {
        // For negative exponent & fixed format, we already printed leading zeros.
        if (fmt == chars_format::fixed && decimal_exponent_normalized < 0)
        {
            return buffer_starting_pos - decimal_exponent_normalized + 1;
        }
        // We reserved one slot for decimal dot, so the starting position of printed digits
        // is buffer_starting_pos + 1 if we need to print decimal dot.
        return buffer_starting_pos == decimal_dot_pos ? buffer_starting_pos
            : buffer_starting_pos + 1;
    }();
    // Find all preceding 9's.
    if ((first_9_pos - digit_starting_pos) % 2 != 0)
    {
        if (*(first_9_pos - 1) != '9')
        {
            ++*(first_9_pos - 1);
            if ((remaining_digits & 1) != 0)
            {
                *first_9_pos = '0';
            }
            else
            {
                std::memcpy(first_9_pos, "00", 2);
            }
            goto insert_decimal_dot;
        }
        --first_9_pos;
    }
    while (first_9_pos != digit_starting_pos)
    {
        if (std::memcmp(first_9_pos - 2, "99", 2) != 0)
        {
            if (*(first_9_pos - 1) != '9')
            {
                ++*(first_9_pos - 1);
            }
            else
            {
                ++*(first_9_pos - 2);
                *(first_9_pos - 1) = '0';
            }
            std::memset(first_9_pos, '0', static_cast<std::size_t>(buffer - first_9_pos));
            goto insert_decimal_dot;
        }
        first_9_pos -= 2;
    }

    // Every digit we wrote so far are all 9's. In this case, we have to shift the whole thing by 1.
    ++decimal_exponent_normalized;

    if (fmt == chars_format::fixed)
    {
        if (decimal_exponent_normalized > 0)
        {
            // We need to print one more character.
            if (buffer == last)
            {
                return {last, std::errc::value_too_large};
            }
            ++buffer;
            // If we were to print the decimal dot, we have to shift it to right
            // since we now have one more digit in the integer part.
            if (buffer_starting_pos != decimal_dot_pos)
            {
                ++decimal_dot_pos;
            }
        }
        else if (decimal_exponent_normalized == 0)
        {
            // For the case 0.99...9 -> 1.00...0, the rounded digit is one before the first digit written.
            // Note: decimal_exponent_normalized was negative before the increment (++decimal_exponent_normalized),
            //       so we already have printed "00" onto the buffer.
            //       Hence, --digit_starting_pos doesn't go more than the starting position of the buffer.
            --digit_starting_pos;
        }
    }

    // Nolint is applied to the following two calls since we know they are not supposed to be null terminated
    *digit_starting_pos = '1';
    std::memset(digit_starting_pos + 1, '0', static_cast<std::size_t>(buffer - digit_starting_pos - 1)); // NOLINT

    goto insert_decimal_dot;
}

}}} // Namespaces 

#ifdef BOOST_MSVC
# pragma warning(pop)
#endif

#endif // BOOST_CHARCONV_DETAIL_FLOFF
