From e699167d48ac5d95eb9443075664c819350d5484 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Tue, 17 Jan 2023 09:13:43 -0800
Subject: [PATCH 01/63] to_chars integer parser

---
 include/boost/charconv/to_chars.hpp | 79 +++++++++++++++++++++++++++--
 src/to_chars.cpp                    |  6 ---
 2 files changed, 76 insertions(+), 9 deletions(-)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index 5362971..f5b136b 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -7,6 +7,10 @@
 #define BOOST_CHARCONV_TO_CHARS_HPP_INCLUDED
 
 #include <boost/charconv/config.hpp>
+#include <type_traits>
+#include <array>
+#include <cstring>
+#include <cstdio>
 
 namespace boost { namespace charconv {
 
@@ -15,19 +19,88 @@ namespace boost { namespace charconv {
 struct to_chars_result
 {
     char* ptr;
+
+    // Values:
+    // 0 = no error
+    // EINVAL = invalid_argument
+    // ERANGE = result_out_of_range
     int ec;
-    friend bool operator==(const to_chars_result& lhs, const to_chars_result& rhs)
+
+    constexpr friend bool operator==(const to_chars_result& lhs, const to_chars_result& rhs) noexcept
     {
         return lhs.ptr == rhs.ptr && lhs.ec == rhs.ec;
     }
 
-    friend bool operator!=(const to_chars_result& lhs, const to_chars_result& rhs)
+    constexpr friend bool operator!=(const to_chars_result& lhs, const to_chars_result& rhs) noexcept
     {
         return !(lhs == rhs);
     }
 };
 
-BOOST_CHARCONV_DECL to_chars_result to_chars(char* first, char* last, int value, int base = 10);
+namespace detail {
+
+static constexpr std::array<char, 200> radix_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'
+}};
+
+// TODO: Should we do a specialized base 10 algorithm, and then one for the rest? I think yes
+// See: https://jk-jeon.github.io/posts/2022/02/jeaiii-algorithm/
+template <typename Integer>
+BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* last, Integer value)
+{
+    std::snprintf( first, last - first - 1, "%d", value );
+    return { first + std::strlen( first ), 0 };
+}
+
+// All other bases
+template <typename Integer>
+BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* last, Integer value, int base)
+{
+    // Check pre-conditions
+    BOOST_CHARCONV_ASSERT_MSG(base >= 2 && base <= 36, "Base must be between 2 and 36 (inclusive)");
+    if (!(first <= last))
+    {
+        return {last, EINVAL};
+    }
+
+    std::snprintf( first, last - first - 1, "%d", value );
+    return { first + std::strlen( first ), 0 };
+}
+
+} // Namespace detail
+
+template <typename Integer, typename std::enable_if<std::is_integral<Integer>::value, bool>::type = true>
+BOOST_CXX14_CONSTEXPR to_chars_result to_chars(char* first, char* last, Integer value, BOOST_ATTRIBUTE_UNUSED int base = 10) noexcept
+{
+    if (base == 10)
+    {
+        return detail::to_chars_integer_impl(first, last, value);
+    }
+
+    return detail::to_chars_integer_impl(first, last, value, base);
+}
+
+template <>
+BOOST_CXX14_CONSTEXPR to_chars_result to_chars<bool>(char* first, char* last, bool value, int base) noexcept = delete;
 
 } // namespace charconv
 } // namespace boost
diff --git a/src/to_chars.cpp b/src/to_chars.cpp
index ec0e927..dce2a57 100644
--- a/src/to_chars.cpp
+++ b/src/to_chars.cpp
@@ -6,9 +6,3 @@
 #include <boost/charconv/to_chars.hpp>
 #include <cstdio>
 #include <cstring>
-
-boost::charconv::to_chars_result boost::charconv::to_chars(char* first, char* last, int value, int /*base*/)
-{
-    std::snprintf( first, last - first - 1, "%d", value );
-    return { first + std::strlen( first ), 0 };
-}

From e0df5fb2025ed661a48cf4ab5d0240b41eacd01d Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Tue, 17 Jan 2023 09:17:19 -0800
Subject: [PATCH 02/63] Add missing header

[ci skip]
---
 include/boost/charconv/to_chars.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index f5b136b..7e9ca2a 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -11,6 +11,7 @@
 #include <array>
 #include <cstring>
 #include <cstdio>
+#include <cerrno>
 
 namespace boost { namespace charconv {
 

From fa957d7fe8522ad9a3e34f8ff0f338e9043d0317 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Tue, 17 Jan 2023 12:48:50 -0800
Subject: [PATCH 03/63] Add 32-bit base10 decomposition

---
 include/boost/charconv/to_chars.hpp | 53 +++++++++++++++++++++++++----
 1 file changed, 47 insertions(+), 6 deletions(-)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index 7e9ca2a..b7b27a9 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -12,6 +12,7 @@
 #include <cstring>
 #include <cstdio>
 #include <cerrno>
+#include <cstdint>
 
 namespace boost { namespace charconv {
 
@@ -40,7 +41,7 @@ struct to_chars_result
 
 namespace detail {
 
-static constexpr std::array<char, 200> radix_table = {{
+    static constexpr char radix_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',
@@ -61,22 +62,62 @@ static constexpr std::array<char, 200> radix_table = {{
     '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'
-}};
+};
 
 // TODO: Should we do a specialized base 10 algorithm, and then one for the rest? I think yes
 // See: https://jk-jeon.github.io/posts/2022/02/jeaiii-algorithm/
+// https://arxiv.org/abs/2101.11408
+BOOST_CXX14_CONSTEXPR char* decompose32(std::uint32_t value, char* buffer)
+{
+    constexpr auto mask = (static_cast<std::uint64_t>(1) << 57) - 1; // D = 57 so 2^D - 1
+    constexpr auto magic_multiplier = static_cast<std::uint64_t>(1441151881); // floor(2*D / 10*k) where D is 57 and k is 8
+    auto y = value * magic_multiplier;
+
+    for (std::size_t i {}; i < 10; i += 2)
+    {
+        std::memcpy(buffer + i, radix_table + static_cast<std::size_t>(y >> 57) * 2, 2);
+        y &= mask;
+        y *= 100;
+    }
+
+    return buffer + 10;
+}
+
 template <typename Integer>
 BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* last, Integer value)
-{
-    std::snprintf( first, last - first - 1, "%d", value );
+{   
+    char buffer[10] {};
+    
+    if (!(first <= last))
+    {
+        return {last, EINVAL};
+    }
+    
+    // TODO: Only use this for strlen < 10
+    decompose32(value, buffer);
+
+    std::size_t i {};
+    while (buffer[i] == '0')
+    {
+        ++i;
+    }
+
+    for (; i < 10; ++i)
+    {
+        *first = buffer[i];
+        ++first;
+    }
+
+    return {first, 0};
+
+    //std::snprintf( first, last - first - 1, "%d", value );
     return { first + std::strlen( first ), 0 };
 }
 
 // All other bases
 template <typename Integer>
-BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* last, Integer value, int base)
+BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* last, Integer value, int base) noexcept
 {
-    // Check pre-conditions
     BOOST_CHARCONV_ASSERT_MSG(base >= 2 && base <= 36, "Base must be between 2 and 36 (inclusive)");
     if (!(first <= last))
     {

From f5258519d66d1b3271ba8b221e46a246ceb278d0 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Tue, 17 Jan 2023 12:58:03 -0800
Subject: [PATCH 04/63] Replace memcpy and fix warning

---
 include/boost/charconv/to_chars.hpp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index b7b27a9..8c6b0c8 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -75,7 +75,11 @@ BOOST_CXX14_CONSTEXPR char* decompose32(std::uint32_t value, char* buffer)
 
     for (std::size_t i {}; i < 10; i += 2)
     {
-        std::memcpy(buffer + i, radix_table + static_cast<std::size_t>(y >> 57) * 2, 2);
+        // Replaces std::memcpy(buffer + i, radix_table + static_cast<std::size_t>(y >> 57) * 2, 2)
+        // since it would not be constexpr
+        const char* temp = {radix_table + static_cast<std::size_t>(y >> 57) * 2};
+        buffer[i] = temp[0];
+        buffer[i+1] = temp[1];
         y &= mask;
         y *= 100;
     }
@@ -119,6 +123,7 @@ template <typename Integer>
 BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* last, Integer value, int base) noexcept
 {
     BOOST_CHARCONV_ASSERT_MSG(base >= 2 && base <= 36, "Base must be between 2 and 36 (inclusive)");
+    (void)base;
     if (!(first <= last))
     {
         return {last, EINVAL};

From 88d522553f0cfd0df9da97cc9af0c7c6da26c8ce Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Wed, 18 Jan 2023 07:41:43 -0800
Subject: [PATCH 05/63] More efficiently get rid of leading zeros

---
 include/boost/charconv/to_chars.hpp | 17 +++++------------
 1 file changed, 5 insertions(+), 12 deletions(-)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index 8c6b0c8..2c86a63 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -90,6 +90,7 @@ BOOST_CXX14_CONSTEXPR char* decompose32(std::uint32_t value, char* buffer)
 template <typename Integer>
 BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* last, Integer value)
 {   
+    // decompose32 will always return 10 digits (including leading 0s)
     char buffer[10] {};
     
     if (!(first <= last))
@@ -97,7 +98,7 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
         return {last, EINVAL};
     }
     
-    // TODO: Only use this for strlen < 10
+    // TODO: Only use this for strlen <= 10
     decompose32(value, buffer);
 
     std::size_t i {};
@@ -105,17 +106,9 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
     {
         ++i;
     }
+    std::memcpy(first, buffer + i, sizeof(buffer) - i);
 
-    for (; i < 10; ++i)
-    {
-        *first = buffer[i];
-        ++first;
-    }
-
-    return {first, 0};
-
-    //std::snprintf( first, last - first - 1, "%d", value );
-    return { first + std::strlen( first ), 0 };
+    return {first + std::strlen(first), 0};
 }
 
 // All other bases
@@ -136,7 +129,7 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
 } // Namespace detail
 
 template <typename Integer, typename std::enable_if<std::is_integral<Integer>::value, bool>::type = true>
-BOOST_CXX14_CONSTEXPR to_chars_result to_chars(char* first, char* last, Integer value, BOOST_ATTRIBUTE_UNUSED int base = 10) noexcept
+BOOST_CXX14_CONSTEXPR to_chars_result to_chars(char* first, char* last, Integer value, int base = 10) noexcept
 {
     if (base == 10)
     {

From 807c3ea028775e98c9a64eb95a9e16727ecf37c6 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Wed, 18 Jan 2023 10:08:18 -0800
Subject: [PATCH 06/63] Add framework to decompose larger values

---
 include/boost/charconv/to_chars.hpp | 38 ++++++++++++++++++++++-------
 1 file changed, 29 insertions(+), 9 deletions(-)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index 2c86a63..9c693dc 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -9,6 +9,7 @@
 #include <boost/charconv/config.hpp>
 #include <type_traits>
 #include <array>
+#include <limits>
 #include <cstring>
 #include <cstdio>
 #include <cerrno>
@@ -64,7 +65,6 @@ namespace detail {
     '9', '5', '9', '6', '9', '7', '9', '8', '9', '9'
 };
 
-// TODO: Should we do a specialized base 10 algorithm, and then one for the rest? I think yes
 // See: https://jk-jeon.github.io/posts/2022/02/jeaiii-algorithm/
 // https://arxiv.org/abs/2101.11408
 BOOST_CXX14_CONSTEXPR char* decompose32(std::uint32_t value, char* buffer)
@@ -98,16 +98,36 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
         return {last, EINVAL};
     }
     
-    // TODO: Only use this for strlen <= 10
-    decompose32(value, buffer);
-
-    std::size_t i {};
-    while (buffer[i] == '0')
+    // If the type is less than 32 bits we can use this without change
+    // If the type is greater than 32 bits we use a binary search tree to figure out how many digits
+    // are present and then decompose the value into two (or more) std::uint32_t of known length so that we
+    // don't have the issue of removing leading zeros from the least significant digits
+    if (static_cast<std::uint32_t>(value) <= (std::numeric_limits<std::uint32_t>::max)())
     {
-        ++i;
-    }
-    std::memcpy(first, buffer + i, sizeof(buffer) - i);
+        decompose32(value, buffer);
 
+        std::size_t i {};
+        while (buffer[i] == '0')
+        {
+            ++i;
+        }
+        std::memcpy(first, buffer + i, sizeof(buffer) - i);
+    }
+    else if (static_cast<std::uint64_t>(value) <= (std::numeric_limits<std::uint64_t>::max)())
+    {
+
+    }
+    #if 0
+    // unsigned __128 requires 4 shifts
+    // Could just recursivly call the uint64_t twice and then compose 2x 64 bits
+    else if (static_cast<unsigned __int128>(value) <= (std::numeric_limits<unsigned __int128>::max)())
+    #endif
+    else 
+    {
+        BOOST_CHARCONV_ASSERT_MSG(sizeof(Integer) < 1, "Your type is unsupported. Use a built-in integral type");
+    }
+    
+    
     return {first + std::strlen(first), 0};
 }
 

From dea69677ebb863923591340a560bb34585ccbae7 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Wed, 18 Jan 2023 11:36:04 -0800
Subject: [PATCH 07/63] Add binary search trees for 32, 64 and 128 bit types

---
 .../charconv/detail/integer_search_trees.hpp  | 233 ++++++++++++++++++
 include/boost/charconv/to_chars.hpp           |   1 +
 2 files changed, 234 insertions(+)
 create mode 100644 include/boost/charconv/detail/integer_search_trees.hpp

diff --git a/include/boost/charconv/detail/integer_search_trees.hpp b/include/boost/charconv/detail/integer_search_trees.hpp
new file mode 100644
index 0000000..41f23fb
--- /dev/null
+++ b/include/boost/charconv/detail/integer_search_trees.hpp
@@ -0,0 +1,233 @@
+// 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_INTEGER_SEARCH_TREES_HPP
+#define BOOST_CHARCONV_DETAIL_INTEGER_SEARCH_TREES_HPP
+
+// https://stackoverflow.com/questions/1489830/efficient-way-to-determine-number-of-digits-in-an-integer?page=1&tab=scoredesc#tab-top
+// https://graphics.stanford.edu/~seander/bithacks.html
+
+#include "../config.hpp"
+#include <limits>
+#include <array>
+#include <cstdint>
+
+// Generic solution
+template <typename T>
+BOOST_CXX14_CONSTEXPR int num_digits(T x) noexcept
+{
+    int digits = 0;
+
+    while (x)
+    {
+        x /= 10;
+        ++digits;
+    }
+
+    return digits;
+}
+
+template <>
+BOOST_CXX14_CONSTEXPR int num_digits(std::uint32_t x) noexcept
+{
+    if (x >= UINT32_C(10000))
+    {
+        if (x >= UINT32_C(10000000))
+        {
+            if (x >= UINT32_C(100000000))
+            {
+                if (x >= UINT32_C(1000000000))
+                {
+                    return 10;
+                }
+                return 9;
+            }
+            return 8;
+        }
+
+        else if (x >= UINT32_C(100000))
+        {
+            if (x >= UINT32_C(1000000))
+            {
+                return 7;
+            }
+            return 6;
+        }
+        return 5;
+    }
+    else if (x >= UINT32_C(100))
+    {
+        if (x >= UINT32_C(1000))
+        {
+            return 4;
+        }
+        return 3;
+    }
+    else if (x >= UINT32_C(10))
+    {
+        return 2;
+    }
+
+    return 1;
+}
+
+template <>
+BOOST_CXX14_CONSTEXPR int num_digits(std::uint64_t x) noexcept
+{
+    if (x >= UINT64_C(10000000000))
+    {
+        if (x >= UINT64_C(100000000000000))
+        {
+            if (x >= UINT64_C(10000000000000000))
+            {
+                if (x >= UINT64_C(100000000000000000)) 
+                {
+                    if (x >= UINT64_C(1000000000000000000))
+                    {
+                        if (x >= UINT64_C(10000000000000000000))
+                        {
+                            return 20;
+                        }
+                        return 19;
+                    }
+                    return 18;
+                }
+                return 17;
+            }
+            else if (x >= UINT64_C(1000000000000000))
+            {
+                return 16;
+            }
+            return 15;
+        } 
+        if (x >= UINT64_C(1000000000000))
+        {
+            if (x >= UINT64_C(10000000000000))
+            {
+                return 14;
+            }
+            return 13;
+        }
+        if (x >= UINT64_C(100000000000))
+        {
+            return 12;
+        }
+        return 11;
+    }
+    else if (x >= UINT64_C(100000))
+    {
+        if (x >= UINT64_C(10000000))
+        {
+            if (x >= UINT64_C(100000000))
+            {
+                if (x >= UINT64_C(1000000000))
+                {
+                    return 10;
+                }
+                return 9;
+            }
+            return 8;
+        }
+        if (x >= UINT64_C(1000000))
+        {
+            return 7;
+        }
+        return 6;
+    }
+    if (x >= UINT64_C(100))
+    {
+        if (x >= UINT64_C(1000))
+        {
+            if (x >= UINT64_C(10000))
+            {
+                return 5;
+            }
+            return 4;
+        }
+        return 3;
+    }
+    if (x >= UINT64_C(10))
+    {
+        return 2;
+    }
+    return 1;
+}
+
+#ifdef __GLIBCXX_TYPE_INT_N_0
+static constexpr std::array<std::uint64_t, 20> powers_of_10 =
+{{
+    1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000, 10000000000,
+    100000000000, 1000000000000, 10000000000000, 100000000000000, 1000000000000000, 10000000000000000,
+    100000000000000000, 1000000000000000000, 10000000000000000000
+}};
+
+// Assume that if someone is using 128 bit ints they are favoring the top end of the range
+// Max value is 340,282,366,920,938,463,463,374,607,431,768,211,455 (39 digits)
+BOOST_CXX14_CONSTEXPR int num_digits(unsigned __int128 x) noexcept
+{
+    // There is not literal for unsigned __int128 so we need to calculate them using the max value of the
+    // std::uint64_t powers of 10
+    constexpr unsigned __int128 digits_39 = static_cast<unsigned __int128>(powers_of_10[19]) * static_cast<unsigned __int128>(powers_of_10[18]);
+    constexpr unsigned __int128 digits_38 = digits_39 / 10;
+    constexpr unsigned __int128 digits_37 = digits_38 / 10;
+    constexpr unsigned __int128 digits_36 = digits_37 / 10;
+    constexpr unsigned __int128 digits_35 = digits_36 / 10;
+    constexpr unsigned __int128 digits_34 = digits_35 / 10;
+    constexpr unsigned __int128 digits_33 = digits_34 / 10;
+    constexpr unsigned __int128 digits_32 = digits_33 / 10;
+    constexpr unsigned __int128 digits_31 = digits_32 / 10;
+    constexpr unsigned __int128 digits_30 = digits_31 / 10;
+    constexpr unsigned __int128 digits_29 = digits_30 / 10;
+    constexpr unsigned __int128 digits_28 = digits_29 / 10;
+    constexpr unsigned __int128 digits_27 = digits_28 / 10;
+    constexpr unsigned __int128 digits_26 = digits_27 / 10;
+    constexpr unsigned __int128 digits_25 = digits_26 / 10;
+    constexpr unsigned __int128 digits_24 = digits_25 / 10;
+    constexpr unsigned __int128 digits_23 = digits_24 / 10;
+    constexpr unsigned __int128 digits_22 = digits_23 / 10;
+    constexpr unsigned __int128 digits_21 = digits_22 / 10;
+
+    return (x > digits_39) ? 39 :
+           (x > digits_38) ? 38 :
+           (x > digits_37) ? 37 :
+           (x > digits_36) ? 36 :
+           (x > digits_35) ? 35 :
+           (x > digits_34) ? 34 :
+           (x > digits_33) ? 33 :
+           (x > digits_32) ? 32 :
+           (x > digits_31) ? 31 :
+           (x > digits_30) ? 30 :
+           (x > digits_29) ? 29 :
+           (x > digits_28) ? 28 :
+           (x > digits_27) ? 27 :
+           (x > digits_26) ? 26 :
+           (x > digits_25) ? 25 :
+           (x > digits_24) ? 24 :
+           (x > digits_23) ? 23 :
+           (x > digits_22) ? 22 :
+           (x > digits_21) ? 21 :
+           (x > powers_of_10[19]) ? 20 :
+           (x > powers_of_10[18]) ? 19 :
+           (x > powers_of_10[17]) ? 18 :
+           (x > powers_of_10[16]) ? 17 :
+           (x > powers_of_10[15]) ? 16 :
+           (x > powers_of_10[14]) ? 15 :
+           (x > powers_of_10[13]) ? 14 :
+           (x > powers_of_10[12]) ? 13 :
+           (x > powers_of_10[11]) ? 12 :
+           (x > powers_of_10[10]) ? 11 :
+           (x > powers_of_10[9])  ? 10 :
+           (x > powers_of_10[8])  ?  9 :
+           (x > powers_of_10[7])  ?  8 :
+           (x > powers_of_10[6])  ?  7 :
+           (x > powers_of_10[5])  ?  6 :
+           (x > powers_of_10[4])  ?  5 :
+           (x > powers_of_10[3])  ?  4 :
+           (x > powers_of_10[2])  ?  3 :
+           (x > powers_of_10[1])  ?  2 :
+           (x > powers_of_10[0])  ?  1 : 0;
+}
+#endif // 128-bit support
+
+#endif // BOOST_CHARCONV_DETAIL_INTEGER_SEARCH_TREES_HPP
diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index 9c693dc..577745b 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -6,6 +6,7 @@
 #ifndef BOOST_CHARCONV_TO_CHARS_HPP_INCLUDED
 #define BOOST_CHARCONV_TO_CHARS_HPP_INCLUDED
 
+#include <boost/charconv/detail/integer_search_trees.hpp>
 #include <boost/charconv/config.hpp>
 #include <type_traits>
 #include <array>

From e8db8b0bf4e182683f8a7cdbc5664f43688c83cc Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Wed, 18 Jan 2023 11:47:07 -0800
Subject: [PATCH 08/63] Fix init of power_of_10 array

---
 include/boost/charconv/detail/integer_search_trees.hpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/include/boost/charconv/detail/integer_search_trees.hpp b/include/boost/charconv/detail/integer_search_trees.hpp
index 41f23fb..f014567 100644
--- a/include/boost/charconv/detail/integer_search_trees.hpp
+++ b/include/boost/charconv/detail/integer_search_trees.hpp
@@ -157,9 +157,10 @@ BOOST_CXX14_CONSTEXPR int num_digits(std::uint64_t x) noexcept
 #ifdef __GLIBCXX_TYPE_INT_N_0
 static constexpr std::array<std::uint64_t, 20> powers_of_10 =
 {{
-    1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000, 10000000000,
-    100000000000, 1000000000000, 10000000000000, 100000000000000, 1000000000000000, 10000000000000000,
-    100000000000000000, 1000000000000000000, 10000000000000000000
+    UINT64_C(1), UINT64_C(10), UINT64_C(100), UINT64_C(1000), UINT64_C(10000), UINT64_C(100000), UINT64_C(1000000), 
+    UINT64_C(10000000), UINT64_C(100000000), UINT64_C(1000000000), UINT64_C(10000000000), UINT64_C(100000000000), 
+    UINT64_C(1000000000000), UINT64_C(10000000000000), UINT64_C(100000000000000), UINT64_C(1000000000000000), 
+    UINT64_C(10000000000000000), UINT64_C(100000000000000000), UINT64_C(1000000000000000000), UINT64_C(10000000000000000000)
 }};
 
 // Assume that if someone is using 128 bit ints they are favoring the top end of the range

From 0e5fa4c26b40976cc75da17947a3b353691d8637 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Wed, 18 Jan 2023 12:04:59 -0800
Subject: [PATCH 09/63] Replace std::array::operator[] since it is not
 constexpr in C++11

---
 include/boost/charconv/detail/integer_search_trees.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/boost/charconv/detail/integer_search_trees.hpp b/include/boost/charconv/detail/integer_search_trees.hpp
index f014567..3ef1ff4 100644
--- a/include/boost/charconv/detail/integer_search_trees.hpp
+++ b/include/boost/charconv/detail/integer_search_trees.hpp
@@ -169,7 +169,7 @@ BOOST_CXX14_CONSTEXPR int num_digits(unsigned __int128 x) noexcept
 {
     // There is not literal for unsigned __int128 so we need to calculate them using the max value of the
     // std::uint64_t powers of 10
-    constexpr unsigned __int128 digits_39 = static_cast<unsigned __int128>(powers_of_10[19]) * static_cast<unsigned __int128>(powers_of_10[18]);
+    constexpr unsigned __int128 digits_39 = static_cast<unsigned __int128>(UINT64_C(10000000000000000000)) * static_cast<unsigned __int128>(UINT64_C(1000000000000000000));
     constexpr unsigned __int128 digits_38 = digits_39 / 10;
     constexpr unsigned __int128 digits_37 = digits_38 / 10;
     constexpr unsigned __int128 digits_36 = digits_37 / 10;

From 9b350bcdcbca2f97f45c3477401d94e94bef3ab8 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Wed, 18 Jan 2023 13:34:33 -0800
Subject: [PATCH 10/63] Simplify 32-bit impl and improve logic

---
 .../charconv/detail/integer_search_trees.hpp  |  7 ++++++-
 include/boost/charconv/to_chars.hpp           | 21 +++++++++----------
 2 files changed, 16 insertions(+), 12 deletions(-)

diff --git a/include/boost/charconv/detail/integer_search_trees.hpp b/include/boost/charconv/detail/integer_search_trees.hpp
index 3ef1ff4..30250de 100644
--- a/include/boost/charconv/detail/integer_search_trees.hpp
+++ b/include/boost/charconv/detail/integer_search_trees.hpp
@@ -13,6 +13,8 @@
 #include <array>
 #include <cstdint>
 
+namespace boost { namespace charconv { namespace detail {
+
 // Generic solution
 template <typename T>
 BOOST_CXX14_CONSTEXPR int num_digits(T x) noexcept
@@ -169,7 +171,8 @@ BOOST_CXX14_CONSTEXPR int num_digits(unsigned __int128 x) noexcept
 {
     // There is not literal for unsigned __int128 so we need to calculate them using the max value of the
     // std::uint64_t powers of 10
-    constexpr unsigned __int128 digits_39 = static_cast<unsigned __int128>(UINT64_C(10000000000000000000)) * static_cast<unsigned __int128>(UINT64_C(1000000000000000000));
+    constexpr unsigned __int128 digits_39 = static_cast<unsigned __int128>(UINT64_C(10000000000000000000)) * 
+                                            static_cast<unsigned __int128>(UINT64_C(1000000000000000000));
     constexpr unsigned __int128 digits_38 = digits_39 / 10;
     constexpr unsigned __int128 digits_37 = digits_38 / 10;
     constexpr unsigned __int128 digits_36 = digits_37 / 10;
@@ -231,4 +234,6 @@ BOOST_CXX14_CONSTEXPR int num_digits(unsigned __int128 x) noexcept
 }
 #endif // 128-bit support
 
+}}} // Namespace boost::charconv::detail
+
 #endif // BOOST_CHARCONV_DETAIL_INTEGER_SEARCH_TREES_HPP
diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index 577745b..c7048e7 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -90,10 +90,7 @@ BOOST_CXX14_CONSTEXPR char* decompose32(std::uint32_t value, char* buffer)
 
 template <typename Integer>
 BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* last, Integer value)
-{   
-    // decompose32 will always return 10 digits (including leading 0s)
-    char buffer[10] {};
-    
+{       
     if (!(first <= last))
     {
         return {last, EINVAL};
@@ -103,16 +100,18 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
     // If the type is greater than 32 bits we use a binary search tree to figure out how many digits
     // are present and then decompose the value into two (or more) std::uint32_t of known length so that we
     // don't have the issue of removing leading zeros from the least significant digits
-    if (static_cast<std::uint32_t>(value) <= (std::numeric_limits<std::uint32_t>::max)())
+    
+    // TODO: fix this logic for types that could contain values greater than std::uint32_t but don't
+    // and types smaller than which would overflow on casting
+    if (std::numeric_limits<Integer>::digits <= std::numeric_limits<std::uint32_t>::digits ||
+        value <= static_cast<Integer>((std::numeric_limits<std::uint32_t>::max)()))
     {
+        char buffer[10] {};
+        const auto num_sig_chars = num_digits(value);
+
         decompose32(value, buffer);
 
-        std::size_t i {};
-        while (buffer[i] == '0')
-        {
-            ++i;
-        }
-        std::memcpy(first, buffer + i, sizeof(buffer) - i);
+        std::memcpy(first, buffer + (sizeof(buffer) - num_sig_chars), num_sig_chars);
     }
     else if (static_cast<std::uint64_t>(value) <= (std::numeric_limits<std::uint64_t>::max)())
     {

From e55057214a29ad11cc882492cbbae3bb4f89c983 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Thu, 19 Jan 2023 10:24:10 -0800
Subject: [PATCH 11/63] Move buffer and add float stub to keep MSVC happy

---
 include/boost/charconv/to_chars.hpp | 9 ++++++---
 src/to_chars.cpp                    | 7 +++++++
 2 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index c7048e7..e3988fe 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -96,21 +96,21 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
         return {last, EINVAL};
     }
     
+    char buffer[10] {};
     // If the type is less than 32 bits we can use this without change
     // If the type is greater than 32 bits we use a binary search tree to figure out how many digits
     // are present and then decompose the value into two (or more) std::uint32_t of known length so that we
     // don't have the issue of removing leading zeros from the least significant digits
     
-    // TODO: fix this logic for types that could contain values greater than std::uint32_t but don't
-    // and types smaller than which would overflow on casting
     if (std::numeric_limits<Integer>::digits <= std::numeric_limits<std::uint32_t>::digits ||
         value <= static_cast<Integer>((std::numeric_limits<std::uint32_t>::max)()))
     {
-        char buffer[10] {};
         const auto num_sig_chars = num_digits(value);
 
         decompose32(value, buffer);
 
+        // If constant evaluated use unrolled loop
+        // If not constant evaluated use memcpy
         std::memcpy(first, buffer + (sizeof(buffer) - num_sig_chars), num_sig_chars);
     }
     else if (static_cast<std::uint64_t>(value) <= (std::numeric_limits<std::uint64_t>::max)())
@@ -162,6 +162,9 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars(char* first, char* last, Integer
 template <>
 BOOST_CXX14_CONSTEXPR to_chars_result to_chars<bool>(char* first, char* last, bool value, int base) noexcept = delete;
 
+// TODO: Not correct, but need to make MSVC happy while working on integers
+BOOST_CHARCONV_DECL to_chars_result to_chars(char* first, char* last, float value) noexcept;
+
 } // namespace charconv
 } // namespace boost
 
diff --git a/src/to_chars.cpp b/src/to_chars.cpp
index dce2a57..b59936c 100644
--- a/src/to_chars.cpp
+++ b/src/to_chars.cpp
@@ -6,3 +6,10 @@
 #include <boost/charconv/to_chars.hpp>
 #include <cstdio>
 #include <cstring>
+
+
+boost::charconv::to_chars_result boost::charconv::to_chars(char* first, char* last, float value) noexcept
+{
+    std::snprintf(first, last - first - 1, "%f", value);
+    return {first + std::strlen(first), 0};
+}

From 9664ba51720753366f61532b501d4bbfc3e58339 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Thu, 19 Jan 2023 10:47:44 -0800
Subject: [PATCH 12/63] Disable warning C4127

---
 include/boost/charconv/to_chars.hpp | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index e3988fe..809b7c9 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -88,6 +88,11 @@ BOOST_CXX14_CONSTEXPR char* decompose32(std::uint32_t value, char* buffer)
     return buffer + 10;
 }
 
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable: 4127)
+#endif
+
 template <typename Integer>
 BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* last, Integer value)
 {       
@@ -97,11 +102,14 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
     }
     
     char buffer[10] {};
+
     // If the type is less than 32 bits we can use this without change
     // If the type is greater than 32 bits we use a binary search tree to figure out how many digits
     // are present and then decompose the value into two (or more) std::uint32_t of known length so that we
     // don't have the issue of removing leading zeros from the least significant digits
     
+    // Yields: warning C4127: conditional expression is constant becuase first half the expression is constant
+    // but we need to short circuit to avoid UB on the second half
     if (std::numeric_limits<Integer>::digits <= std::numeric_limits<std::uint32_t>::digits ||
         value <= static_cast<Integer>((std::numeric_limits<std::uint32_t>::max)()))
     {
@@ -109,7 +117,7 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
 
         decompose32(value, buffer);
 
-        // If constant evaluated use unrolled loop
+        // TODO: If constant evaluated use unrolled loop
         // If not constant evaluated use memcpy
         std::memcpy(first, buffer + (sizeof(buffer) - num_sig_chars), num_sig_chars);
     }
@@ -131,6 +139,10 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
     return {first + std::strlen(first), 0};
 }
 
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif
+
 // All other bases
 template <typename Integer>
 BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* last, Integer value, int base) noexcept

From 69d09f5d6b4b7fdb9555c8ee651674860a7b3def Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Thu, 19 Jan 2023 11:50:30 -0800
Subject: [PATCH 13/63] Refactor training

---
 include/boost/charconv/to_chars.hpp |  8 ++---
 test/to_chars.cpp                   | 50 ++++++++++++++++++++---------
 2 files changed, 39 insertions(+), 19 deletions(-)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index 809b7c9..6bae33f 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -68,7 +68,7 @@ namespace detail {
 
 // See: https://jk-jeon.github.io/posts/2022/02/jeaiii-algorithm/
 // https://arxiv.org/abs/2101.11408
-BOOST_CXX14_CONSTEXPR char* decompose32(std::uint32_t value, char* buffer)
+BOOST_CXX14_CONSTEXPR char* decompose32(std::uint32_t value, char* buffer) noexcept
 {
     constexpr auto mask = (static_cast<std::uint64_t>(1) << 57) - 1; // D = 57 so 2^D - 1
     constexpr auto magic_multiplier = static_cast<std::uint64_t>(1441151881); // floor(2*D / 10*k) where D is 57 and k is 8
@@ -94,7 +94,7 @@ BOOST_CXX14_CONSTEXPR char* decompose32(std::uint32_t value, char* buffer)
 #endif
 
 template <typename Integer>
-BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* last, Integer value)
+BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* last, Integer value) noexcept
 {       
     if (!(first <= last))
     {
@@ -149,13 +149,13 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
 {
     BOOST_CHARCONV_ASSERT_MSG(base >= 2 && base <= 36, "Base must be between 2 and 36 (inclusive)");
     (void)base;
+    (void)value;
     if (!(first <= last))
     {
         return {last, EINVAL};
     }
 
-    std::snprintf( first, last - first - 1, "%d", value );
-    return { first + std::strlen( first ), 0 };
+    return {first + std::strlen(first), 0};
 }
 
 } // Namespace detail
diff --git a/test/to_chars.cpp b/test/to_chars.cpp
index 8b9a616..95d41f9 100644
--- a/test/to_chars.cpp
+++ b/test/to_chars.cpp
@@ -5,25 +5,45 @@
 
 #include <boost/charconv.hpp>
 #include <boost/core/lightweight_test.hpp>
+#include <type_traits>
 #include <cstring>
+#include <cerrno>
+
+template <typename T>
+void simple_test()
+{
+    char buffer1[64] {};
+    T v = 34;
+    auto r1 = boost::charconv::to_chars(buffer1, buffer1 + sizeof(buffer1) - 1, v);
+    BOOST_TEST_EQ(r1.ec, 0);
+    BOOST_TEST_CSTR_EQ(buffer1, "34");
+
+    boost::charconv::to_chars_result r {r1.ptr, r1.ec};
+    BOOST_TEST(r1 == r);
+
+    char buffer2[64] {};
+    T v2 = 12;
+    auto r2 = boost::charconv::to_chars(buffer2, buffer2 + sizeof(buffer2) - 1, v2);
+    BOOST_TEST(r1 != r2);
+    BOOST_TEST_EQ(r2.ec, 0);
+    BOOST_TEST_CSTR_EQ(buffer2, "12");
+}
 
 int main()
 {
-    char buffer[32] = {};
-
-    int v = 1048576;
-    auto r = boost::charconv::to_chars( buffer, buffer + sizeof( buffer ) - 1, v );
-
-    BOOST_TEST_EQ(r.ec, 0) && BOOST_TEST_CSTR_EQ(buffer, "1048576");
-    BOOST_TEST(r == r);
-
-    boost::charconv::to_chars_result r2 {r.ptr, 0};
-    BOOST_TEST(r == r2);
-
-    char buffer2[32] = {};
-
-    auto r3 = boost::charconv::to_chars(buffer2, buffer2 + sizeof(buffer) - 1, v);
-    BOOST_TEST(r != r3);
+    simple_test<char>();
+    simple_test<signed char>();
+    simple_test<unsigned char>();
+    simple_test<short>();
+    simple_test<unsigned short>();
+    simple_test<int>();
+    simple_test<unsigned>();
+    simple_test<long>();
+    simple_test<unsigned long>();
+    simple_test<long long>();
+    simple_test<unsigned long long>();
+    simple_test<std::int32_t>();
+    simple_test<std::uint64_t>();
 
     return boost::report_errors();
 }

From 37e301d310f883f673effa882221aaaa2d05e235 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Thu, 19 Jan 2023 12:17:07 -0800
Subject: [PATCH 14/63] Fix for warning C4244

---
 include/boost/charconv/to_chars.hpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index 6bae33f..1281f43 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -113,9 +113,10 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
     if (std::numeric_limits<Integer>::digits <= std::numeric_limits<std::uint32_t>::digits ||
         value <= static_cast<Integer>((std::numeric_limits<std::uint32_t>::max)()))
     {
-        const auto num_sig_chars = num_digits(value);
+        const auto converted_value = static_cast<std::uint32_t>(value);
+        const auto num_sig_chars = num_digits(converted_value);
 
-        decompose32(value, buffer);
+        decompose32(converted_value, buffer);
 
         // TODO: If constant evaluated use unrolled loop
         // If not constant evaluated use memcpy

From 6b41bb6e69a811b4d09cdf8033442f499a7f2e1e Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Thu, 19 Jan 2023 13:33:00 -0800
Subject: [PATCH 15/63] Add support for negative numbers

---
 include/boost/charconv/to_chars.hpp | 21 ++++++++++++++++++---
 test/to_chars.cpp                   | 13 +++++++++++++
 2 files changed, 31 insertions(+), 3 deletions(-)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index 1281f43..b4e2cf6 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -96,12 +96,23 @@ BOOST_CXX14_CONSTEXPR char* decompose32(std::uint32_t value, char* buffer) noexc
 template <typename Integer>
 BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* last, Integer value) noexcept
 {       
+    char buffer[10] {};
+    BOOST_ATTRIBUTE_UNUSED bool is_negative = false;
+    
     if (!(first <= last))
     {
         return {last, EINVAL};
     }
-    
-    char buffer[10] {};
+
+    // Strip the sign from the value and apply at the end after parsing if the type is signed
+    BOOST_IF_CONSTEXPR (std::is_signed<Integer>::value)
+    {
+        if (value < 0)
+        {
+            value = -value;
+            is_negative = true;
+        }
+    }
 
     // If the type is less than 32 bits we can use this without change
     // If the type is greater than 32 bits we use a binary search tree to figure out how many digits
@@ -120,6 +131,11 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
 
         // TODO: If constant evaluated use unrolled loop
         // If not constant evaluated use memcpy
+        if (is_negative)
+        {
+            *first++ = '-';
+        }
+            
         std::memcpy(first, buffer + (sizeof(buffer) - num_sig_chars), num_sig_chars);
     }
     else if (static_cast<std::uint64_t>(value) <= (std::numeric_limits<std::uint64_t>::max)())
@@ -136,7 +152,6 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
         BOOST_CHARCONV_ASSERT_MSG(sizeof(Integer) < 1, "Your type is unsupported. Use a built-in integral type");
     }
     
-    
     return {first + std::strlen(first), 0};
 }
 
diff --git a/test/to_chars.cpp b/test/to_chars.cpp
index 95d41f9..b96aeaf 100644
--- a/test/to_chars.cpp
+++ b/test/to_chars.cpp
@@ -9,6 +9,16 @@
 #include <cstring>
 #include <cerrno>
 
+template <typename T>
+void negative_vals_test()
+{
+    char buffer1[10] {};
+    T v = -4321;
+    auto r1 = boost::charconv::to_chars(buffer1, buffer1 + sizeof(buffer1) - 1, v);
+    BOOST_TEST_EQ(r1.ec, 0);
+    BOOST_TEST_CSTR_EQ(buffer1, "-4321");
+}
+
 template <typename T>
 void simple_test()
 {
@@ -45,5 +55,8 @@ int main()
     simple_test<std::int32_t>();
     simple_test<std::uint64_t>();
 
+    negative_vals_test<int>();
+    negative_vals_test<long>();
+
     return boost::report_errors();
 }

From 302e9f5f09fbd5a4bc3f1eeab12c8b45d325cb0c Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Fri, 20 Jan 2023 08:48:35 -0800
Subject: [PATCH 16/63] Workaround for warning C4146

---
 include/boost/charconv/detail/apply_sign.hpp | 29 ++++++++++++++++++++
 include/boost/charconv/from_chars.hpp        | 13 +--------
 include/boost/charconv/to_chars.hpp          |  5 ++--
 3 files changed, 33 insertions(+), 14 deletions(-)
 create mode 100644 include/boost/charconv/detail/apply_sign.hpp

diff --git a/include/boost/charconv/detail/apply_sign.hpp b/include/boost/charconv/detail/apply_sign.hpp
new file mode 100644
index 0000000..244c0bb
--- /dev/null
+++ b/include/boost/charconv/detail/apply_sign.hpp
@@ -0,0 +1,29 @@
+// 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_APPLY_SIGN_HPP
+#define BOOST_CHARCONV_DETAIL_APPLY_SIGN_HPP
+
+// Workaround for warning C4146: unary minus operator applied to unsigned type, result still unsigned
+// Occurs using MSVC with pre-C++17 language standards
+
+#include <type_traits>
+
+namespace boost { namespace charconv { namespace detail {
+
+template <typename Integer, typename std::enable_if<std::is_signed<Integer>::value, bool>::type = true>
+constexpr Integer apply_sign(Integer val) noexcept
+{
+    return -val;
+}
+
+template <typename Integer, typename std::enable_if<std::is_unsigned<Integer>::value, bool>::type = true>
+constexpr Integer apply_sign(Integer val) noexcept
+{
+    return val;
+}
+
+}}} // Namespaces
+
+#endif // BOOST_CHARCONV_DETAIL_APPLY_SIGN_HPP
diff --git a/include/boost/charconv/from_chars.hpp b/include/boost/charconv/from_chars.hpp
index 9e5fcc6..4f8f040 100644
--- a/include/boost/charconv/from_chars.hpp
+++ b/include/boost/charconv/from_chars.hpp
@@ -6,6 +6,7 @@
 #ifndef BOOST_CHARCONV_FROM_CHARS_HPP_INCLUDED
 #define BOOST_CHARCONV_FROM_CHARS_HPP_INCLUDED
 
+#include <boost/charconv/detail/apply_sign.hpp>
 #include <boost/charconv/config.hpp>
 #include <boost/config.hpp>
 #include <type_traits>
@@ -67,18 +68,6 @@ constexpr unsigned char digit_from_char(char val) noexcept
     return uchar_values[static_cast<std::size_t>(val)];
 }
 
-template <typename Integer, typename std::enable_if<std::is_signed<Integer>::value, bool>::type = true>
-constexpr Integer apply_sign(Integer val) noexcept
-{
-    return -val;
-}
-
-template <typename Integer, typename std::enable_if<std::is_unsigned<Integer>::value, bool>::type = true>
-constexpr Integer apply_sign(Integer val) noexcept
-{
-    return val;
-}
-
 template <typename Integer>
 BOOST_CXX14_CONSTEXPR boost::charconv::from_chars_result from_chars_integer_impl(const char* first, const char* last, Integer& value, int base) noexcept
 {
diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index b4e2cf6..1503c29 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -6,6 +6,7 @@
 #ifndef BOOST_CHARCONV_TO_CHARS_HPP_INCLUDED
 #define BOOST_CHARCONV_TO_CHARS_HPP_INCLUDED
 
+#include <boost/charconv/detail/apply_sign.hpp>
 #include <boost/charconv/detail/integer_search_trees.hpp>
 #include <boost/charconv/config.hpp>
 #include <type_traits>
@@ -109,7 +110,7 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
     {
         if (value < 0)
         {
-            value = -value;
+            value = apply_sign(value);
             is_negative = true;
         }
     }
@@ -119,7 +120,7 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
     // are present and then decompose the value into two (or more) std::uint32_t of known length so that we
     // don't have the issue of removing leading zeros from the least significant digits
     
-    // Yields: warning C4127: conditional expression is constant becuase first half the expression is constant
+    // Yields: warning C4127: conditional expression is constant becuase first half of the expression is constant
     // but we need to short circuit to avoid UB on the second half
     if (std::numeric_limits<Integer>::digits <= std::numeric_limits<std::uint32_t>::digits ||
         value <= static_cast<Integer>((std::numeric_limits<std::uint32_t>::max)()))

From fe0260c4075c235017d8bacdd595c0f353c31c3f Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Fri, 20 Jan 2023 09:07:52 -0800
Subject: [PATCH 17/63] Add functions to pack and unpack 64 and 128 bit
 integers

---
 .../charconv/detail/integer_conversion.hpp    | 44 +++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 include/boost/charconv/detail/integer_conversion.hpp

diff --git a/include/boost/charconv/detail/integer_conversion.hpp b/include/boost/charconv/detail/integer_conversion.hpp
new file mode 100644
index 0000000..d262618
--- /dev/null
+++ b/include/boost/charconv/detail/integer_conversion.hpp
@@ -0,0 +1,44 @@
+// 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_CONCATENATE_HPP
+#define BOOST_CHARCONV_DETAIL_CONCATENATE_HPP
+
+#include <boost/charconv/config.hpp>
+#include <utility>
+#include <cstdint>
+
+namespace boost { namespace charconv { namespace detail {
+
+constexpr std::uint64_t pack(std::uint32_t word1, std::uint32_t word2) noexcept
+{
+    return static_cast<std::uint64_t>(word1) << 32 | word2;
+}
+
+BOOST_CXX14_CONSTEXPR std::pair<std::uint32_t, std::uint32_t> unpack(std::uint64_t value)
+{
+    auto x = static_cast<std::uint32_t>(value >> 32);
+    auto y = static_cast<std::uint32_t>(value);
+
+    return std::make_pair(x, y);
+}
+
+#ifdef __GLIBCXX_TYPE_INT_N_0
+constexpr unsigned __int128 pack(std::uint64_t word1, std::uint64_t word2) noexcept
+{
+    return static_cast<unsigned __int128>(word1) << 64 | word2;
+}
+
+BOOST_CXX14_CONSTEXPR std::pair<std::uint64_t, std::uint64_t> unpack(unsigned __int128 value)
+{
+    auto x = static_cast<std::uint64_t>(value >> 64);
+    auto y = static_cast<std::uint64_t>(value);
+
+    return std::make_pair(x, y);
+}
+#endif // defined(__GLIBCXX_TYPE_INT_N_0)
+
+}}} // Namespaces
+
+#endif // BOOST_CHARCONV_DETAIL_CONCATENATE_HPP

From 52feaddc9df2f9510dd9e5414c940911a4440772 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Fri, 20 Jan 2023 10:41:15 -0800
Subject: [PATCH 18/63] 64bit impl framework

---
 .../charconv/detail/integer_conversion.hpp    |  5 ++--
 include/boost/charconv/to_chars.hpp           | 25 ++++++++++++++++++-
 test/to_chars.cpp                             | 13 ++++++++++
 3 files changed, 40 insertions(+), 3 deletions(-)

diff --git a/include/boost/charconv/detail/integer_conversion.hpp b/include/boost/charconv/detail/integer_conversion.hpp
index d262618..093cb6a 100644
--- a/include/boost/charconv/detail/integer_conversion.hpp
+++ b/include/boost/charconv/detail/integer_conversion.hpp
@@ -7,6 +7,7 @@
 
 #include <boost/charconv/config.hpp>
 #include <utility>
+#include <limits>
 #include <cstdint>
 
 namespace boost { namespace charconv { namespace detail {
@@ -18,8 +19,8 @@ constexpr std::uint64_t pack(std::uint32_t word1, std::uint32_t word2) noexcept
 
 BOOST_CXX14_CONSTEXPR std::pair<std::uint32_t, std::uint32_t> unpack(std::uint64_t value)
 {
-    auto x = static_cast<std::uint32_t>(value >> 32);
-    auto y = static_cast<std::uint32_t>(value);
+    auto x = static_cast<std::uint32_t>((value & UINT64_MAX) >> UINT64_C(32));
+    auto y = static_cast<std::uint32_t>(value & UINT32_MAX);
 
     return std::make_pair(x, y);
 }
diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index 1503c29..38ef425 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -8,10 +8,12 @@
 
 #include <boost/charconv/detail/apply_sign.hpp>
 #include <boost/charconv/detail/integer_search_trees.hpp>
+#include <boost/charconv/detail/integer_conversion.hpp>
 #include <boost/charconv/config.hpp>
 #include <type_traits>
 #include <array>
 #include <limits>
+#include <utility>
 #include <cstring>
 #include <cstdio>
 #include <cerrno>
@@ -139,9 +141,30 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
             
         std::memcpy(first, buffer + (sizeof(buffer) - num_sig_chars), num_sig_chars);
     }
-    else if (static_cast<std::uint64_t>(value) <= (std::numeric_limits<std::uint64_t>::max)())
+    else if (std::numeric_limits<Integer>::digits <= std::numeric_limits<std::uint64_t>::digits ||
+             static_cast<std::uint64_t>(value) <= (std::numeric_limits<std::uint64_t>::max)())
     {
+        const auto converted_value = static_cast<std::uint64_t>(value);
+        const auto num_sig_chars = num_digits(converted_value);
 
+        const auto pair_32bit_values = unpack(converted_value);
+        const int first_value_chars = num_digits(converted_value);
+        const int second_value_chars = num_digits(converted_value);
+        
+        // TODO: Remove when done with debugging
+        assert(first_value_chars + second_value_chars <= num_sig_chars);
+
+        decompose32(pair_32bit_values.first, buffer);
+        
+        if (is_negative)
+        {
+            *first++ = '-';
+        }
+
+        std::memcpy(first, buffer + (sizeof(buffer) - first_value_chars), first_value_chars);
+
+        decompose32(pair_32bit_values.second, buffer);
+        std::memcpy(first + first_value_chars, buffer, sizeof(buffer));
     }
     #if 0
     // unsigned __128 requires 4 shifts
diff --git a/test/to_chars.cpp b/test/to_chars.cpp
index b96aeaf..5cc6e3a 100644
--- a/test/to_chars.cpp
+++ b/test/to_chars.cpp
@@ -9,6 +9,16 @@
 #include <cstring>
 #include <cerrno>
 
+template <typename T>
+void sixty_four_bit_tests()
+{
+    char buffer1[64] {};
+    T v1 = -1234;
+    auto r1 = boost::charconv::to_chars(buffer1, buffer1 + sizeof(buffer1) - 1, v1);
+    BOOST_TEST_EQ(r1.ec, 0);
+    BOOST_TEST_CSTR_EQ(buffer1, "-1234");
+}
+
 template <typename T>
 void negative_vals_test()
 {
@@ -58,5 +68,8 @@ int main()
     negative_vals_test<int>();
     negative_vals_test<long>();
 
+    sixty_four_bit_tests<long>();
+    sixty_four_bit_tests<long long>();
+
     return boost::report_errors();
 }

From 4765f06652bda1785f5b355efca61ed30c46a916 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Fri, 20 Jan 2023 11:23:10 -0800
Subject: [PATCH 19/63] Fixes to 64 bit testing

---
 include/boost/charconv/to_chars.hpp | 11 ++++++-----
 test/to_chars.cpp                   |  6 ++++++
 2 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index 38ef425..c0f7279 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -147,14 +147,15 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
         const auto converted_value = static_cast<std::uint64_t>(value);
         const auto num_sig_chars = num_digits(converted_value);
 
-        const auto pair_32bit_values = unpack(converted_value);
-        const int first_value_chars = num_digits(converted_value);
-        const int second_value_chars = num_digits(converted_value);
+        const auto x = static_cast<std::uint32_t>(converted_value / UINT64_C(10000000000));
+        const auto y = static_cast<std::uint32_t>(converted_value % UINT64_C(10000000000));
+        const int first_value_chars = num_digits(x);
+        const int second_value_chars = num_digits(y);
         
         // TODO: Remove when done with debugging
         assert(first_value_chars + second_value_chars <= num_sig_chars);
 
-        decompose32(pair_32bit_values.first, buffer);
+        decompose32(x, buffer);
         
         if (is_negative)
         {
@@ -163,7 +164,7 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
 
         std::memcpy(first, buffer + (sizeof(buffer) - first_value_chars), first_value_chars);
 
-        decompose32(pair_32bit_values.second, buffer);
+        decompose32(y, buffer);
         std::memcpy(first + first_value_chars, buffer, sizeof(buffer));
     }
     #if 0
diff --git a/test/to_chars.cpp b/test/to_chars.cpp
index 5cc6e3a..48ef6c3 100644
--- a/test/to_chars.cpp
+++ b/test/to_chars.cpp
@@ -17,6 +17,12 @@ void sixty_four_bit_tests()
     auto r1 = boost::charconv::to_chars(buffer1, buffer1 + sizeof(buffer1) - 1, v1);
     BOOST_TEST_EQ(r1.ec, 0);
     BOOST_TEST_CSTR_EQ(buffer1, "-1234");
+
+    char buffer2[64] {};
+    T v2 = 1234123412341234;
+    auto r2 = boost::charconv::to_chars(buffer2, buffer2 + sizeof(buffer2) - 1, v2);
+    BOOST_TEST_EQ(r2.ec, 0);
+    BOOST_TEST_CSTR_EQ(buffer2, "1234123412341234");
 }
 
 template <typename T>

From d372d6ab0a447ce2be71fa61b256b503efc32088 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Fri, 20 Jan 2023 12:02:13 -0800
Subject: [PATCH 20/63] Remove unused variables

---
 include/boost/charconv/to_chars.hpp | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index c0f7279..f6a4448 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -145,15 +145,10 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
              static_cast<std::uint64_t>(value) <= (std::numeric_limits<std::uint64_t>::max)())
     {
         const auto converted_value = static_cast<std::uint64_t>(value);
-        const auto num_sig_chars = num_digits(converted_value);
 
         const auto x = static_cast<std::uint32_t>(converted_value / UINT64_C(10000000000));
         const auto y = static_cast<std::uint32_t>(converted_value % UINT64_C(10000000000));
         const int first_value_chars = num_digits(x);
-        const int second_value_chars = num_digits(y);
-        
-        // TODO: Remove when done with debugging
-        assert(first_value_chars + second_value_chars <= num_sig_chars);
 
         decompose32(x, buffer);
         

From 6a9eeacafe18c1b2a2a616265676a59573bc4690 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Fri, 20 Jan 2023 12:27:09 -0800
Subject: [PATCH 21/63] Add edge case tests

---
 test/to_chars.cpp | 30 ++++++++++++++++++++++++++++--
 1 file changed, 28 insertions(+), 2 deletions(-)

diff --git a/test/to_chars.cpp b/test/to_chars.cpp
index 48ef6c3..c7090ff 100644
--- a/test/to_chars.cpp
+++ b/test/to_chars.cpp
@@ -6,6 +6,7 @@
 #include <boost/charconv.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <type_traits>
+#include <limits>
 #include <cstring>
 #include <cerrno>
 
@@ -13,18 +14,42 @@ template <typename T>
 void sixty_four_bit_tests()
 {
     char buffer1[64] {};
-    T v1 = -1234;
+    T v1 = T(-1234);
     auto r1 = boost::charconv::to_chars(buffer1, buffer1 + sizeof(buffer1) - 1, v1);
     BOOST_TEST_EQ(r1.ec, 0);
     BOOST_TEST_CSTR_EQ(buffer1, "-1234");
 
     char buffer2[64] {};
-    T v2 = 1234123412341234;
+    T v2 = T(1234123412341234);
     auto r2 = boost::charconv::to_chars(buffer2, buffer2 + sizeof(buffer2) - 1, v2);
     BOOST_TEST_EQ(r2.ec, 0);
     BOOST_TEST_CSTR_EQ(buffer2, "1234123412341234");
 }
 
+template <>
+void sixty_four_bit_tests<std::uint64_t>()
+{
+    char buffer1[64] {};
+    std::uint64_t v1 = (std::numeric_limits<std::uint64_t>::max)();
+    auto r1 = boost::charconv::to_chars(buffer1, buffer1 + sizeof(buffer1) - 1, v1);
+    BOOST_TEST_EQ(r1.ec, 0);
+    BOOST_TEST_CSTR_EQ(buffer1, "18446744073709551615");
+
+    // Cutting this value in half would overflow a 32 bit unsigned for the back 10 digits
+    char buffer2[64] {};
+    std::uint64_t v2 = UINT64_C(9999999999999999999);
+    auto r2 = boost::charconv::to_chars(buffer2, buffer2 + sizeof(buffer2) - 1, v2);
+    BOOST_TEST_EQ(r2.ec, 0);
+    BOOST_TEST_CSTR_EQ(buffer2, "9999999999999999999");
+
+    // Account for zeros in the back half of the split
+    char buffer3[64] {};
+    std::uint64_t v3 = UINT64_C(10000000000000000000);
+    auto r3 = boost::charconv::to_chars(buffer3, buffer3 + sizeof(buffer3) - 1, v3);
+    BOOST_TEST_EQ(r3.ec, 0);
+    BOOST_TEST_CSTR_EQ(buffer3, "10000000000000000000");
+}
+
 template <typename T>
 void negative_vals_test()
 {
@@ -76,6 +101,7 @@ int main()
 
     sixty_four_bit_tests<long>();
     sixty_four_bit_tests<long long>();
+    sixty_four_bit_tests<std::uint64_t>();
 
     return boost::report_errors();
 }

From 4f46f6a31dcc81964282d46df8aaafaf5ba6e032 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Wed, 25 Jan 2023 13:00:54 -0800
Subject: [PATCH 22/63] Avoid overflow by only using 9 digits per uint32_t

---
 include/boost/charconv/to_chars.hpp | 54 +++++++++++++++++++++++------
 1 file changed, 44 insertions(+), 10 deletions(-)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index f6a4448..43c8cc3 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -144,23 +144,57 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
     else if (std::numeric_limits<Integer>::digits <= std::numeric_limits<std::uint64_t>::digits ||
              static_cast<std::uint64_t>(value) <= (std::numeric_limits<std::uint64_t>::max)())
     {
-        const auto converted_value = static_cast<std::uint64_t>(value);
+        auto converted_value = static_cast<std::uint64_t>(value);
+        const auto converted_value_digits = num_digits(converted_value);
 
-        const auto x = static_cast<std::uint32_t>(converted_value / UINT64_C(10000000000));
-        const auto y = static_cast<std::uint32_t>(converted_value % UINT64_C(10000000000));
-        const int first_value_chars = num_digits(x);
-
-        decompose32(x, buffer);
-        
         if (is_negative)
         {
             *first++ = '-';
         }
 
-        std::memcpy(first, buffer + (sizeof(buffer) - first_value_chars), first_value_chars);
+        // Only store 9 digits in each to avoid overflow
+        if (num_digits(converted_value) <= 18)
+        {
+            const auto x = static_cast<std::uint32_t>(converted_value / UINT64_C(1000000000));
+            const auto y = static_cast<std::uint32_t>(converted_value % UINT64_C(1000000000));
+            const int first_value_chars = num_digits(x);
 
-        decompose32(y, buffer);
-        std::memcpy(first + first_value_chars, buffer, sizeof(buffer));
+            decompose32(x, buffer);
+            std::memcpy(first, buffer + (sizeof(buffer) - first_value_chars), first_value_chars);
+
+            decompose32(y, buffer);
+            std::memcpy(first + first_value_chars, buffer + 1, sizeof(buffer) - 1);
+        }
+        else
+        {
+            const auto x = static_cast<std::uint32_t>(converted_value / UINT64_C(100000000000));
+            converted_value -= x * UINT64_C(100000000000);
+            const auto y = static_cast<std::uint32_t>(converted_value / UINT64_C(100));
+            const auto z = static_cast<std::uint32_t>(converted_value % UINT64_C(100));
+
+            if (converted_value_digits == 19)
+            {
+                decompose32(x, buffer);
+                std::memcpy(first, buffer + 2, sizeof(buffer) - 2);
+
+                decompose32(y, buffer);
+                std::memcpy(first + 8, buffer + 1, sizeof(buffer) - 1);
+            
+                decompose32(z, buffer);
+                std::memcpy(first + 17, buffer + 8, 2);
+            }
+            else // 20
+            {
+                decompose32(x, buffer);
+                std::memcpy(first, buffer + 1, sizeof(buffer) - 1);
+
+                decompose32(y, buffer);
+                std::memcpy(first + 9, buffer + 1, sizeof(buffer) - 1);
+            
+                decompose32(z, buffer);
+                std::memcpy(first + 18, buffer + 8, 2);
+            }
+        }
     }
     #if 0
     // unsigned __128 requires 4 shifts

From ff4b840217cb3d1c7dc0846db998e3c7a87575b6 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Wed, 25 Jan 2023 13:19:26 -0800
Subject: [PATCH 23/63] Fix MSVC casting warnings

---
 test/to_chars.cpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/test/to_chars.cpp b/test/to_chars.cpp
index c7090ff..1d048e2 100644
--- a/test/to_chars.cpp
+++ b/test/to_chars.cpp
@@ -14,13 +14,13 @@ template <typename T>
 void sixty_four_bit_tests()
 {
     char buffer1[64] {};
-    T v1 = T(-1234);
+    T v1 = static_cast<T>(-1234);
     auto r1 = boost::charconv::to_chars(buffer1, buffer1 + sizeof(buffer1) - 1, v1);
     BOOST_TEST_EQ(r1.ec, 0);
     BOOST_TEST_CSTR_EQ(buffer1, "-1234");
 
     char buffer2[64] {};
-    T v2 = T(1234123412341234);
+    T v2 = static_cast<T>(1234123412341234LL);
     auto r2 = boost::charconv::to_chars(buffer2, buffer2 + sizeof(buffer2) - 1, v2);
     BOOST_TEST_EQ(r2.ec, 0);
     BOOST_TEST_CSTR_EQ(buffer2, "1234123412341234");
@@ -99,7 +99,6 @@ int main()
     negative_vals_test<int>();
     negative_vals_test<long>();
 
-    sixty_four_bit_tests<long>();
     sixty_four_bit_tests<long long>();
     sixty_four_bit_tests<std::uint64_t>();
 

From c7b2177145e76d09c39d8153e4c4faec20ff852e Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Thu, 26 Jan 2023 09:21:33 -0800
Subject: [PATCH 24/63] Add framework for is_constant_evaluated

---
 .../charconv/detail/is_constant_evaluated.hpp | 54 +++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 include/boost/charconv/detail/is_constant_evaluated.hpp

diff --git a/include/boost/charconv/detail/is_constant_evaluated.hpp b/include/boost/charconv/detail/is_constant_evaluated.hpp
new file mode 100644
index 0000000..f5f8fe4
--- /dev/null
+++ b/include/boost/charconv/detail/is_constant_evaluated.hpp
@@ -0,0 +1,54 @@
+//  Copyright John Maddock 2011-2021.
+//  Copyright Matt Borland 2023.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_CHARCONV_TOOLS_IS_CONSTANT_EVALUATED_HPP
+#define BOOST_CHARCONV_TOOLS_IS_CONSTANT_EVALUATED_HPP
+
+#include <boost/charconv/config.hpp>
+
+#ifdef __has_include
+# if __has_include(<version>)
+#  include <version>
+#  ifdef __cpp_lib_is_constant_evaluated
+#   include <type_traits>
+#   define BOOST_CHARCONV_HAS_IS_CONSTANT_EVALUATED
+#  endif
+# endif
+#endif
+
+#ifdef __has_builtin
+#  if __has_builtin(__builtin_is_constant_evaluated) && !defined(BOOST_NO_CXX14_CONSTEXPR)
+#    define BOOST_CHARCONV_HAS_BUILTIN_IS_CONSTANT_EVALUATED
+#  endif
+#endif
+
+//
+// MSVC also supports __builtin_is_constant_evaluated if it's recent enough:
+//
+#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 192528326)
+#  define BOOST_CHARCONV_HAS_BUILTIN_IS_CONSTANT_EVALUATED
+#endif
+
+//
+// As does GCC-9:
+//
+#if !defined(BOOST_NO_CXX14_CONSTEXPR) && (__GNUC__ >= 9) && !defined(BOOST_CHARCONV_HAS_BUILTIN_IS_CONSTANT_EVALUATED)
+#  define BOOST_CHARCONV_HAS_BUILTIN_IS_CONSTANT_EVALUATED
+#endif
+
+#if defined(BOOST_CHARCONV_HAS_IS_CONSTANT_EVALUATED) && !defined(BOOST_NO_CXX14_CONSTEXPR)
+#  define BOOST_CHARCONV_IS_CONSTANT_EVALUATED(x) std::is_constant_evaluated()
+#elif defined(BOOST_CHARCONV_HAS_BUILTIN_IS_CONSTANT_EVALUATED)
+#  define BOOST_CHARCONV_IS_CONSTANT_EVALUATED(x) __builtin_is_constant_evaluated()
+#elif !defined(BOOST_NO_CXX14_CONSTEXPR) && (__GNUC__ >= 6)
+#  define BOOST_CHARCONV_IS_CONSTANT_EVALUATED(x) __builtin_constant_p(x)
+#  define BOOST_CHARCONV_USING_BUILTIN_CONSTANT_P
+#else
+#  define BOOST_CHARCONV_IS_CONSTANT_EVALUATED(x) false
+#  define BOOST_CHARCONV_NO_CONSTEXPR_DETECTION
+#endif
+
+#endif // BOOST_CHARCONV_TOOLS_IS_CONSTANT_EVALUATED_HPP

From 157729dad4879148155c3e5fe0eeb1ca1d367d1a Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Thu, 26 Jan 2023 09:32:19 -0800
Subject: [PATCH 25/63] Add character lookup table

---
 include/boost/charconv/to_chars.hpp | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index 43c8cc3..d430950 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -67,7 +67,14 @@ namespace detail {
     '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 char digit_table[] = {
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
+    'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
+    'u', 'v', 'w', 'x', 'y', 'z'
+    };
 
 // See: https://jk-jeon.github.io/posts/2022/02/jeaiii-algorithm/
 // https://arxiv.org/abs/2101.11408

From 057df19bf7e01c004754162812df75775e330f68 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Thu, 26 Jan 2023 10:26:10 -0800
Subject: [PATCH 26/63] Check STL handling of signed 0

---
 test/Jamfile                       |  2 ++
 test/to_chars_integer_STL_comp.cpp | 55 ++++++++++++++++++++++++++++++
 2 files changed, 57 insertions(+)
 create mode 100644 test/to_chars_integer_STL_comp.cpp

diff --git a/test/Jamfile b/test/Jamfile
index 5bdc53b..f85981a 100644
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -1,4 +1,5 @@
 # Copyright 2022 Peter Dimov
+# Copyright 2023 Matt Borland
 # Distributed under the Boost Software License, Version 1.0.
 # https://www.boost.org/LICENSE_1_0.txt
 
@@ -21,3 +22,4 @@ run from_chars.cpp ;
 run to_chars.cpp ;
 run roundtrip.cpp ;
 run from_chars_STL_comp.cpp : : : [ requires cxx17_std_apply ] ;
+run to_chars_integer_STL_comp.cpp : : : [ requires cxx17_std_apply ] ;
diff --git a/test/to_chars_integer_STL_comp.cpp b/test/to_chars_integer_STL_comp.cpp
new file mode 100644
index 0000000..cb66377
--- /dev/null
+++ b/test/to_chars_integer_STL_comp.cpp
@@ -0,0 +1,55 @@
+// Copyright 2023 Matt Borland
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/config.hpp>
+
+#if !defined(BOOST_NO_CXX17_HDR_CHARCONV) && (!defined(__clang_major__) || (defined(__clang_major__) && __clang_major__ > 7))
+
+#include <boost/charconv.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <charconv>
+#include <type_traits>
+#include <limits>
+#include <cstring>
+#include <cstdint>
+#include <cerrno>
+#include <utility>
+#include <system_error>
+
+template <typename T>
+void test()
+{
+    // Signed 0
+    char buffer1[64] {};
+    T v1 = static_cast<T>(-0);
+    auto r1 = std::to_chars(buffer1, buffer1 + sizeof(buffer1) - 1, v1);
+    (void)r1;
+    BOOST_TEST_CSTR_EQ(buffer1, "0");
+}
+
+int main()
+{
+    test<char>();
+    test<signed char>();
+    test<unsigned char>();
+    test<short>();
+    test<unsigned short>();
+    test<int>();
+    test<unsigned>();
+    test<long>();
+    test<unsigned long>();
+    test<long long>();
+    test<unsigned long long>();
+
+    return boost::report_errors();
+}
+
+#else
+
+int main()
+{ 
+    return 0;
+}
+
+#endif

From d7d278bcd590a20c0a75c22fa0ec82722d726861 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Thu, 26 Jan 2023 11:26:30 -0800
Subject: [PATCH 27/63] Impl for all other bases

[ci skip]
---
 include/boost/charconv/to_chars.hpp | 95 ++++++++++++++++++++++++++++-
 test/to_chars.cpp                   | 12 ++++
 2 files changed, 104 insertions(+), 3 deletions(-)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index d430950..53798b8 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -103,6 +103,8 @@ BOOST_CXX14_CONSTEXPR char* decompose32(std::uint32_t value, char* buffer) noexc
 # pragma warning(disable: 4127)
 #endif
 
+// TODO: Use a temp buffer to hold everything and then write it all into the provided buffer at the end
+// If the temp buffer is larger than the provided buffer return EOVERFLOW
 template <typename Integer>
 BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* last, Integer value) noexcept
 {       
@@ -221,18 +223,105 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
 #endif
 
 // All other bases
+// Use a simple lookup table to put together the Integer in character form
 template <typename Integer>
 BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* last, Integer value, int base) noexcept
 {
     BOOST_CHARCONV_ASSERT_MSG(base >= 2 && base <= 36, "Base must be between 2 and 36 (inclusive)");
-    (void)base;
-    (void)value;
+
+    using Unsigned_Integer = typename std::make_unsigned<Integer>::type;
+
+    const auto output_length = last - first;
+
     if (!(first <= last))
     {
         return {last, EINVAL};
     }
 
-    return {first + std::strlen(first), 0};
+    if (value == 0)
+    {
+        *first++ = '0';
+        return {first, 0};
+    }
+
+    auto unsigned_value = static_cast<Unsigned_Integer>(value < 0 ? -value : value);
+    const auto unsigned_base = static_cast<Unsigned_Integer>(base);
+
+    BOOST_IF_CONSTEXPR (std::is_signed<Integer>::value)
+    {
+        if (value < 0)
+        {
+            *first++ = '-';
+        }
+    }
+
+    constexpr unsigned_value zero = 48U; // Char for '0'
+    std::array<char, sizeof(Unsigned_Integer) * CHAR_BIT> buffer = {};
+    auto end = buffer.end();
+    --end; // Need to point to the last actual element
+
+    // Work from LSB to MSB
+    switch (base)
+    {
+    case 2:
+        while (unsigned_value != 0)
+        {
+            *end-- = static_cast<char>(zero + (unsigned_value & 1U)); // 1<<1 - 1
+            value >>= 1U;
+        }
+        break;
+
+    case 4:
+        while (unsigned_value != 0)
+        {
+            *end-- = static_cast<char>(zero + (unsigned_value & 3U)); // 1<<2 - 1
+            value >>= 2U;
+        }
+        break;
+
+    case 8:
+        while (unsigned_value != 0)
+        {
+            *end-- = static_cast<char>(zero + (unsigned_value & 7U)); // 1<<3 - 1
+            value >>= 3U;
+        }
+        break;
+
+    case 16:
+        while (unsigned_value != 0)
+        {
+            *end-- = static_cast<char>(zero + (unsigned_value & 15U)); // 1<<4 - 1
+            value >>= 4U;
+        }
+        break;
+
+    case 32:
+        while (unsigned_value != 0)
+        {
+            *end-- = static_cast<char>(zero + (unsigned_value & 31U)); // 1<<5 - 1
+            value >>= 5U;
+        }
+        break;
+
+    default:
+        while (unsigned_value != 0)
+        {
+            *end-- = digit_table[unsigned_value % unsigned_base];
+            unsigned_value /= unsigned_base;
+        }
+        break;
+    }
+
+    const auto num_chars = end - buffer.end() + 1;
+
+    if (num_chars > output_length)
+    {
+        return {last, EOVERFLOW};
+    }
+
+    std::memcpy(first, buffer.data() + num_chars, num_chars);
+
+    return {first + num_chars, 0};
 }
 
 } // Namespace detail
diff --git a/test/to_chars.cpp b/test/to_chars.cpp
index 1d048e2..a9b7650 100644
--- a/test/to_chars.cpp
+++ b/test/to_chars.cpp
@@ -10,6 +10,16 @@
 #include <cstring>
 #include <cerrno>
 
+template <typename T>
+void base_two_tests()
+{
+    char buffer1[64] {};
+    T v1 = static_cast<T>(42);
+    auto r1 = boost::charconv::to_chars(buffer1, buffer1 + sizeof(buffer1) - 1, v1, 2);
+    BOOST_TEST_EQ(r1.ec, 0);
+    BOOST_TEST_CSTR_EQ(buffer1, "101010");
+}
+
 template <typename T>
 void sixty_four_bit_tests()
 {
@@ -102,5 +112,7 @@ int main()
     sixty_four_bit_tests<long long>();
     sixty_four_bit_tests<std::uint64_t>();
 
+    base_two_tests<int>();
+
     return boost::report_errors();
 }

From b1e5a06cafbcd591107d4c78ea04b83304483c56 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Thu, 26 Jan 2023 11:46:50 -0800
Subject: [PATCH 28/63] Fix type

[ci skip]
---
 include/boost/charconv/to_chars.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index 53798b8..28397d0 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -255,7 +255,7 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
         }
     }
 
-    constexpr unsigned_value zero = 48U; // Char for '0'
+    constexpr Unsigned_Integer zero = 48U; // Char for '0'
     std::array<char, sizeof(Unsigned_Integer) * CHAR_BIT> buffer = {};
     auto end = buffer.end();
     --end; // Need to point to the last actual element

From c06ae72fb936471a649aa6393bf492210f8584eb Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Thu, 26 Jan 2023 12:03:40 -0800
Subject: [PATCH 29/63] Use c-style array instead of std::array

[ci skip]
---
 include/boost/charconv/to_chars.hpp | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index 28397d0..034ad6b 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -231,7 +231,7 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
 
     using Unsigned_Integer = typename std::make_unsigned<Integer>::type;
 
-    const auto output_length = last - first;
+    const std::ptrdiff_t output_length = last - first;
 
     if (!(first <= last))
     {
@@ -256,9 +256,10 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
     }
 
     constexpr Unsigned_Integer zero = 48U; // Char for '0'
-    std::array<char, sizeof(Unsigned_Integer) * CHAR_BIT> buffer = {};
-    auto end = buffer.end();
-    --end; // Need to point to the last actual element
+    constexpr auto buffer_size = sizeof(Unsigned_Integer) * CHAR_BIT;
+    char buffer[buffer_size];
+    const char* buffer_end = buffer + buffer_size;
+    char* end = buffer + buffer_size;
 
     // Work from LSB to MSB
     switch (base)
@@ -312,14 +313,14 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
         break;
     }
 
-    const auto num_chars = end - buffer.end() + 1;
+    const std::ptrdiff_t num_chars = buffer_end - end;
 
     if (num_chars > output_length)
     {
         return {last, EOVERFLOW};
     }
 
-    std::memcpy(first, buffer.data() + num_chars, num_chars);
+    std::memcpy(first, buffer + (buffer_size - num_chars), num_chars);
 
     return {first + num_chars, 0};
 }

From 0ac231b27a1ce78651c9c5f3a35ef12011a45892 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Fri, 27 Jan 2023 08:52:59 -0800
Subject: [PATCH 30/63] Fix base10 overflow handling

---
 include/boost/charconv/to_chars.hpp | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index 034ad6b..febbcbc 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -103,12 +103,11 @@ BOOST_CXX14_CONSTEXPR char* decompose32(std::uint32_t value, char* buffer) noexc
 # pragma warning(disable: 4127)
 #endif
 
-// TODO: Use a temp buffer to hold everything and then write it all into the provided buffer at the end
-// If the temp buffer is larger than the provided buffer return EOVERFLOW
 template <typename Integer>
 BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* last, Integer value) noexcept
 {       
     char buffer[10] {};
+    const std::ptrdiff_t user_buffer_size = last - first;
     BOOST_ATTRIBUTE_UNUSED bool is_negative = false;
     
     if (!(first <= last))
@@ -139,6 +138,11 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
         const auto converted_value = static_cast<std::uint32_t>(value);
         const auto num_sig_chars = num_digits(converted_value);
 
+        if (num_sig_chars > user_buffer_size)
+        {
+            return {last, EOVERFLOW};
+        }
+
         decompose32(converted_value, buffer);
 
         // TODO: If constant evaluated use unrolled loop
@@ -156,6 +160,11 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
         auto converted_value = static_cast<std::uint64_t>(value);
         const auto converted_value_digits = num_digits(converted_value);
 
+        if (converted_value_digits > user_buffer_size)
+        {
+            return {last, EOVERFLOW};
+        }
+
         if (is_negative)
         {
             *first++ = '-';

From e00712a6a307d13f9dfdb3b526f6050e6d6883e2 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Fri, 27 Jan 2023 09:07:52 -0800
Subject: [PATCH 31/63] Fix handling of all other bases

---
 include/boost/charconv/to_chars.hpp | 12 ++++++------
 test/to_chars.cpp                   |  2 +-
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index febbcbc..02c9945 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -268,7 +268,7 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
     constexpr auto buffer_size = sizeof(Unsigned_Integer) * CHAR_BIT;
     char buffer[buffer_size];
     const char* buffer_end = buffer + buffer_size;
-    char* end = buffer + buffer_size;
+    char* end = buffer + buffer_size - 1;
 
     // Work from LSB to MSB
     switch (base)
@@ -277,7 +277,7 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
         while (unsigned_value != 0)
         {
             *end-- = static_cast<char>(zero + (unsigned_value & 1U)); // 1<<1 - 1
-            value >>= 1U;
+            unsigned_value >>= 1U;
         }
         break;
 
@@ -285,7 +285,7 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
         while (unsigned_value != 0)
         {
             *end-- = static_cast<char>(zero + (unsigned_value & 3U)); // 1<<2 - 1
-            value >>= 2U;
+            unsigned_value >>= 2U;
         }
         break;
 
@@ -293,7 +293,7 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
         while (unsigned_value != 0)
         {
             *end-- = static_cast<char>(zero + (unsigned_value & 7U)); // 1<<3 - 1
-            value >>= 3U;
+            unsigned_value >>= 3U;
         }
         break;
 
@@ -301,7 +301,7 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
         while (unsigned_value != 0)
         {
             *end-- = static_cast<char>(zero + (unsigned_value & 15U)); // 1<<4 - 1
-            value >>= 4U;
+            unsigned_value >>= 4U;
         }
         break;
 
@@ -309,7 +309,7 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
         while (unsigned_value != 0)
         {
             *end-- = static_cast<char>(zero + (unsigned_value & 31U)); // 1<<5 - 1
-            value >>= 5U;
+            unsigned_value >>= 5U;
         }
         break;
 
diff --git a/test/to_chars.cpp b/test/to_chars.cpp
index a9b7650..1d9f9d4 100644
--- a/test/to_chars.cpp
+++ b/test/to_chars.cpp
@@ -17,7 +17,7 @@ void base_two_tests()
     T v1 = static_cast<T>(42);
     auto r1 = boost::charconv::to_chars(buffer1, buffer1 + sizeof(buffer1) - 1, v1, 2);
     BOOST_TEST_EQ(r1.ec, 0);
-    BOOST_TEST_CSTR_EQ(buffer1, "101010");
+    BOOST_TEST(std::memcmp(buffer1, "101010", 6));
 }
 
 template <typename T>

From 3784c1b81b5e8c5dbaddf91bc33b1f606e4bf9ce Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Fri, 27 Jan 2023 09:12:43 -0800
Subject: [PATCH 32/63] Put back memcpy in base10

---
 include/boost/charconv/to_chars.hpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index 02c9945..49db685 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -88,9 +88,10 @@ BOOST_CXX14_CONSTEXPR char* decompose32(std::uint32_t value, char* buffer) noexc
     {
         // Replaces std::memcpy(buffer + i, radix_table + static_cast<std::size_t>(y >> 57) * 2, 2)
         // since it would not be constexpr
-        const char* temp = {radix_table + static_cast<std::size_t>(y >> 57) * 2};
-        buffer[i] = temp[0];
-        buffer[i+1] = temp[1];
+        //const char* temp = {radix_table + static_cast<std::size_t>(y >> 57) * 2};
+        //buffer[i] = temp[0];
+        //buffer[i+1] = temp[1];
+        std::memcpy(buffer + i, radix_table + static_cast<std::size_t>(y >> 57) * 2, 2);
         y &= mask;
         y *= 100;
     }

From 9bc76d803405485c6201db1338041b5a01a50009 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Fri, 27 Jan 2023 09:21:08 -0800
Subject: [PATCH 33/63] Fix buffer offset and get rid of memcmp

---
 include/boost/charconv/to_chars.hpp | 4 ++--
 test/to_chars.cpp                   | 3 ++-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index 49db685..404fe44 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -323,8 +323,8 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
         break;
     }
 
-    const std::ptrdiff_t num_chars = buffer_end - end;
-
+    const std::ptrdiff_t num_chars = buffer_end - end - 1;
+    
     if (num_chars > output_length)
     {
         return {last, EOVERFLOW};
diff --git a/test/to_chars.cpp b/test/to_chars.cpp
index 1d9f9d4..e698933 100644
--- a/test/to_chars.cpp
+++ b/test/to_chars.cpp
@@ -17,7 +17,7 @@ void base_two_tests()
     T v1 = static_cast<T>(42);
     auto r1 = boost::charconv::to_chars(buffer1, buffer1 + sizeof(buffer1) - 1, v1, 2);
     BOOST_TEST_EQ(r1.ec, 0);
-    BOOST_TEST(std::memcmp(buffer1, "101010", 6));
+    BOOST_TEST_CSTR_EQ(buffer1, "101010");
 }
 
 template <typename T>
@@ -113,6 +113,7 @@ int main()
     sixty_four_bit_tests<std::uint64_t>();
 
     base_two_tests<int>();
+    base_two_tests<unsigned>();
 
     return boost::report_errors();
 }

From cce04082b91898941d8bd15ef3b26a4689650fa2 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Fri, 27 Jan 2023 09:51:26 -0800
Subject: [PATCH 34/63] Add consteval memcpy

---
 include/boost/charconv/detail/memcpy.hpp | 46 ++++++++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 include/boost/charconv/detail/memcpy.hpp

diff --git a/include/boost/charconv/detail/memcpy.hpp b/include/boost/charconv/detail/memcpy.hpp
new file mode 100644
index 0000000..7b90e9f
--- /dev/null
+++ b/include/boost/charconv/detail/memcpy.hpp
@@ -0,0 +1,46 @@
+// 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_MEMCPY_HPP
+#define BOOST_CHARCONV_DETAIL_MEMCPY_HPP
+
+#include <boost/charconv/detail/is_constant_evaluated.hpp>
+#include <cstring>
+#include <cstdint>
+
+namespace boost { namespace charconv { namespace detail {
+
+#if !defined(BOOST_CHARCONV_NO_CONSTEXPR_DETECTION) && defined(BOOST_CXX14_CONSTEXPR)
+
+#define BOOST_CHARCONV_CONSTEXPR constexpr
+
+constexpr void* memcpy(void* dest, const void* src, std::size_t count)
+{
+    if (BOOST_CHARCONV_IS_CONSTANT_EVALUATED(count))
+    {
+        for (std::size_t i = 0; i < count; ++i)
+        {
+            *(dest + i) = *(src + i);
+        }
+    }
+    else
+    {
+        std::memcpy(dest, src, count);
+    }
+}
+
+#else // Either not C++14 or no way of telling if we are in a constexpr context
+
+#define BOOST_CHARCONV_CONSTEXPR
+
+inline void* memcpy(void* dest, const void* src, std::size_t count)
+{
+    std::memcpy(dest, src, count);
+}
+
+#endif
+
+}}} // Namespace boost::charconv::detail
+
+#endif // BOOST_CHARCONV_DETAIL_MEMCPY_HPP

From 2e202cecdbe402246f58b1c0f74aee3bbe087155 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Fri, 27 Jan 2023 09:52:48 -0800
Subject: [PATCH 35/63] FIx missing header for CHAR_BIT

---
 include/boost/charconv/to_chars.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index 404fe44..f1d58d5 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -18,6 +18,7 @@
 #include <cstdio>
 #include <cerrno>
 #include <cstdint>
+#include <climits>
 
 namespace boost { namespace charconv {
 

From 1b37d1cb3d095d371d151637b4ab465ee082faa7 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Fri, 27 Jan 2023 10:06:22 -0800
Subject: [PATCH 36/63] Add default initializer to buffer

---
 include/boost/charconv/to_chars.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index f1d58d5..158e385 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -268,7 +268,7 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
 
     constexpr Unsigned_Integer zero = 48U; // Char for '0'
     constexpr auto buffer_size = sizeof(Unsigned_Integer) * CHAR_BIT;
-    char buffer[buffer_size];
+    char buffer[buffer_size] {};
     const char* buffer_end = buffer + buffer_size;
     char* end = buffer + buffer_size - 1;
 

From fb87dfff387b677beaaf3464e225d282a2e0fbd1 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Fri, 27 Jan 2023 10:10:25 -0800
Subject: [PATCH 37/63] Fix MSVC C4146

---
 include/boost/charconv/to_chars.hpp | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index 158e385..e3033b7 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -255,7 +255,7 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
         return {first, 0};
     }
 
-    auto unsigned_value = static_cast<Unsigned_Integer>(value < 0 ? -value : value);
+    Unsigned_Integer unsigned_value {};    
     const auto unsigned_base = static_cast<Unsigned_Integer>(base);
 
     BOOST_IF_CONSTEXPR (std::is_signed<Integer>::value)
@@ -263,7 +263,16 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
         if (value < 0)
         {
             *first++ = '-';
+            unsigned_value = apply_sign(value);
         }
+        else
+        {
+            unsigned_value = value;
+        }
+    }
+    else
+    {
+        unsigned_value = value;
     }
 
     constexpr Unsigned_Integer zero = 48U; // Char for '0'

From f1fac0a7aeeabc119bc751f6f20d857d2e651bb9 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Fri, 27 Jan 2023 10:52:53 -0800
Subject: [PATCH 38/63] Replace std::memcpy with our memcpy

---
 include/boost/charconv/detail/memcpy.hpp |  6 ++--
 include/boost/charconv/to_chars.hpp      | 38 +++++++++++-------------
 2 files changed, 21 insertions(+), 23 deletions(-)

diff --git a/include/boost/charconv/detail/memcpy.hpp b/include/boost/charconv/detail/memcpy.hpp
index 7b90e9f..39b3819 100644
--- a/include/boost/charconv/detail/memcpy.hpp
+++ b/include/boost/charconv/detail/memcpy.hpp
@@ -23,10 +23,12 @@ constexpr void* memcpy(void* dest, const void* src, std::size_t count)
         {
             *(dest + i) = *(src + i);
         }
+
+        return dest;
     }
     else
     {
-        std::memcpy(dest, src, count);
+        return std::memcpy(dest, src, count);
     }
 }
 
@@ -36,7 +38,7 @@ constexpr void* memcpy(void* dest, const void* src, std::size_t count)
 
 inline void* memcpy(void* dest, const void* src, std::size_t count)
 {
-    std::memcpy(dest, src, count);
+    return std::memcpy(dest, src, count);
 }
 
 #endif
diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index e3033b7..6653e38 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -9,6 +9,7 @@
 #include <boost/charconv/detail/apply_sign.hpp>
 #include <boost/charconv/detail/integer_search_trees.hpp>
 #include <boost/charconv/detail/integer_conversion.hpp>
+#include <boost/charconv/detail/memcpy.hpp>
 #include <boost/charconv/config.hpp>
 #include <type_traits>
 #include <array>
@@ -79,7 +80,7 @@ namespace detail {
 
 // See: https://jk-jeon.github.io/posts/2022/02/jeaiii-algorithm/
 // https://arxiv.org/abs/2101.11408
-BOOST_CXX14_CONSTEXPR char* decompose32(std::uint32_t value, char* buffer) noexcept
+BOOST_CHARCONV_CONSTEXPR char* decompose32(std::uint32_t value, char* buffer) noexcept
 {
     constexpr auto mask = (static_cast<std::uint64_t>(1) << 57) - 1; // D = 57 so 2^D - 1
     constexpr auto magic_multiplier = static_cast<std::uint64_t>(1441151881); // floor(2*D / 10*k) where D is 57 and k is 8
@@ -87,12 +88,7 @@ BOOST_CXX14_CONSTEXPR char* decompose32(std::uint32_t value, char* buffer) noexc
 
     for (std::size_t i {}; i < 10; i += 2)
     {
-        // Replaces std::memcpy(buffer + i, radix_table + static_cast<std::size_t>(y >> 57) * 2, 2)
-        // since it would not be constexpr
-        //const char* temp = {radix_table + static_cast<std::size_t>(y >> 57) * 2};
-        //buffer[i] = temp[0];
-        //buffer[i+1] = temp[1];
-        std::memcpy(buffer + i, radix_table + static_cast<std::size_t>(y >> 57) * 2, 2);
+        boost::charconv::detail::memcpy(buffer + i, radix_table + static_cast<std::size_t>(y >> 57) * 2, 2);
         y &= mask;
         y *= 100;
     }
@@ -106,7 +102,7 @@ BOOST_CXX14_CONSTEXPR char* decompose32(std::uint32_t value, char* buffer) noexc
 #endif
 
 template <typename Integer>
-BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* last, Integer value) noexcept
+BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* last, Integer value) noexcept
 {       
     char buffer[10] {};
     const std::ptrdiff_t user_buffer_size = last - first;
@@ -154,7 +150,7 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
             *first++ = '-';
         }
             
-        std::memcpy(first, buffer + (sizeof(buffer) - num_sig_chars), num_sig_chars);
+        boost::charconv::detail::memcpy(first, buffer + (sizeof(buffer) - num_sig_chars), num_sig_chars);
     }
     else if (std::numeric_limits<Integer>::digits <= std::numeric_limits<std::uint64_t>::digits ||
              static_cast<std::uint64_t>(value) <= (std::numeric_limits<std::uint64_t>::max)())
@@ -180,10 +176,10 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
             const int first_value_chars = num_digits(x);
 
             decompose32(x, buffer);
-            std::memcpy(first, buffer + (sizeof(buffer) - first_value_chars), first_value_chars);
+            boost::charconv::detail::memcpy(first, buffer + (sizeof(buffer) - first_value_chars), first_value_chars);
 
             decompose32(y, buffer);
-            std::memcpy(first + first_value_chars, buffer + 1, sizeof(buffer) - 1);
+            boost::charconv::detail::memcpy(first + first_value_chars, buffer + 1, sizeof(buffer) - 1);
         }
         else
         {
@@ -195,24 +191,24 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
             if (converted_value_digits == 19)
             {
                 decompose32(x, buffer);
-                std::memcpy(first, buffer + 2, sizeof(buffer) - 2);
+                boost::charconv::detail::memcpy(first, buffer + 2, sizeof(buffer) - 2);
 
                 decompose32(y, buffer);
-                std::memcpy(first + 8, buffer + 1, sizeof(buffer) - 1);
+                boost::charconv::detail::memcpy(first + 8, buffer + 1, sizeof(buffer) - 1);
             
                 decompose32(z, buffer);
-                std::memcpy(first + 17, buffer + 8, 2);
+                boost::charconv::detail::memcpy(first + 17, buffer + 8, 2);
             }
             else // 20
             {
                 decompose32(x, buffer);
-                std::memcpy(first, buffer + 1, sizeof(buffer) - 1);
+                boost::charconv::detail::memcpy(first, buffer + 1, sizeof(buffer) - 1);
 
                 decompose32(y, buffer);
-                std::memcpy(first + 9, buffer + 1, sizeof(buffer) - 1);
+                boost::charconv::detail::memcpy(first + 9, buffer + 1, sizeof(buffer) - 1);
             
                 decompose32(z, buffer);
-                std::memcpy(first + 18, buffer + 8, 2);
+                boost::charconv::detail::memcpy(first + 18, buffer + 8, 2);
             }
         }
     }
@@ -236,7 +232,7 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
 // All other bases
 // Use a simple lookup table to put together the Integer in character form
 template <typename Integer>
-BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* last, Integer value, int base) noexcept
+BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* last, Integer value, int base) noexcept
 {
     BOOST_CHARCONV_ASSERT_MSG(base >= 2 && base <= 36, "Base must be between 2 and 36 (inclusive)");
 
@@ -340,7 +336,7 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
         return {last, EOVERFLOW};
     }
 
-    std::memcpy(first, buffer + (buffer_size - num_chars), num_chars);
+    boost::charconv::detail::memcpy(first, buffer + (buffer_size - num_chars), num_chars);
 
     return {first + num_chars, 0};
 }
@@ -348,7 +344,7 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* l
 } // Namespace detail
 
 template <typename Integer, typename std::enable_if<std::is_integral<Integer>::value, bool>::type = true>
-BOOST_CXX14_CONSTEXPR to_chars_result to_chars(char* first, char* last, Integer value, int base = 10) noexcept
+BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars(char* first, char* last, Integer value, int base = 10) noexcept
 {
     if (base == 10)
     {
@@ -359,7 +355,7 @@ BOOST_CXX14_CONSTEXPR to_chars_result to_chars(char* first, char* last, Integer
 }
 
 template <>
-BOOST_CXX14_CONSTEXPR to_chars_result to_chars<bool>(char* first, char* last, bool value, int base) noexcept = delete;
+BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars<bool>(char* first, char* last, bool value, int base) noexcept = delete;
 
 // TODO: Not correct, but need to make MSVC happy while working on integers
 BOOST_CHARCONV_DECL to_chars_result to_chars(char* first, char* last, float value) noexcept;

From 60d819d5b96ebb12e073078105f94a7fcdac6497 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Fri, 27 Jan 2023 11:18:48 -0800
Subject: [PATCH 39/63] Add casting to our memcpy

---
 include/boost/charconv/detail/memcpy.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/boost/charconv/detail/memcpy.hpp b/include/boost/charconv/detail/memcpy.hpp
index 39b3819..abf314a 100644
--- a/include/boost/charconv/detail/memcpy.hpp
+++ b/include/boost/charconv/detail/memcpy.hpp
@@ -21,7 +21,7 @@ constexpr void* memcpy(void* dest, const void* src, std::size_t count)
     {
         for (std::size_t i = 0; i < count; ++i)
         {
-            *(dest + i) = *(src + i);
+            *((unsigned char*)dest + i) = *((unsigned char*)src + i);
         }
 
         return dest;

From 2fbfe9d93ee3c3c5fd7b09807f026c376a789b86 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Fri, 27 Jan 2023 11:36:27 -0800
Subject: [PATCH 40/63] Add overflow tests

---
 test/to_chars.cpp | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/test/to_chars.cpp b/test/to_chars.cpp
index e698933..ab5f7fd 100644
--- a/test/to_chars.cpp
+++ b/test/to_chars.cpp
@@ -10,6 +10,20 @@
 #include <cstring>
 #include <cerrno>
 
+template <typename T>
+void overflow_tests()
+{
+    char buffer1[2] {};
+    T v1 = static_cast<T>(250);
+    auto r1 = boost::charconv::to_chars(buffer1, buffer1 + sizeof(buffer1) - 1, v1);
+    BOOST_TEST_EQ(r1.ec, EOVERFLOW);
+
+    char buffer2[3] {};
+    T v2 = static_cast<T>(12341234);
+    auto r2 = boost::charconv::to_chars(buffer2, buffer2 + sizeof(buffer2) - 1, v2);
+    BOOST_TEST_EQ(r2.ec, EOVERFLOW);
+}
+
 template <typename T>
 void base_two_tests()
 {
@@ -115,5 +129,7 @@ int main()
     base_two_tests<int>();
     base_two_tests<unsigned>();
 
+    overflow_tests<int>();
+
     return boost::report_errors();
 }

From 70472c73d5c632f28d0e86e300c573cc9cd320da Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Tue, 31 Jan 2023 08:15:16 -0800
Subject: [PATCH 41/63] Add test for generic impl

---
 include/boost/charconv/detail/memcpy.hpp |  2 +-
 test/to_chars.cpp                        | 20 ++++++++++++++++++++
 2 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/include/boost/charconv/detail/memcpy.hpp b/include/boost/charconv/detail/memcpy.hpp
index abf314a..e5b08dc 100644
--- a/include/boost/charconv/detail/memcpy.hpp
+++ b/include/boost/charconv/detail/memcpy.hpp
@@ -21,7 +21,7 @@ constexpr void* memcpy(void* dest, const void* src, std::size_t count)
     {
         for (std::size_t i = 0; i < count; ++i)
         {
-            *((unsigned char*)dest + i) = *((unsigned char*)src + i);
+            *((unsigned char*)dest + i) = *((const unsigned char*)src + i);
         }
 
         return dest;
diff --git a/test/to_chars.cpp b/test/to_chars.cpp
index ab5f7fd..8684aa0 100644
--- a/test/to_chars.cpp
+++ b/test/to_chars.cpp
@@ -10,6 +10,23 @@
 #include <cstring>
 #include <cerrno>
 
+// Tests the generic implementation
+template <typename T>
+void base_30_tests()
+{
+    char buffer1[64] {};
+    T v1 = static_cast<T>(1234);
+    auto r1 = boost::charconv::to_chars(buffer1, buffer1 + sizeof(buffer1) - 1, v1, 30);
+    BOOST_TEST_EQ(r1.ec, 0);
+    BOOST_TEST_CSTR_EQ(buffer1, "1b4");
+
+    char buffer2[64] {};
+    T v2 = static_cast<T>(-4321);
+    auto r2 = boost::charconv::to_chars(buffer2, buffer2 + sizeof(buffer2) - 1, v2, 30);
+    BOOST_TEST_EQ(r2.ec, 0);
+    BOOST_TEST_CSTR_EQ(buffer2, "-4o1");
+}
+
 template <typename T>
 void overflow_tests()
 {
@@ -129,6 +146,9 @@ int main()
     base_two_tests<int>();
     base_two_tests<unsigned>();
 
+    base_30_tests<int>();
+    base_30_tests<long>();
+
     overflow_tests<int>();
 
     return boost::report_errors();

From ff1ce048a386e644c54a14cb457c9b118d09cb4c Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Tue, 31 Jan 2023 09:20:31 -0800
Subject: [PATCH 42/63] Changes for constexpr context

---
 include/boost/charconv/detail/memcpy.hpp | 6 +++---
 include/boost/charconv/to_chars.hpp      | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/include/boost/charconv/detail/memcpy.hpp b/include/boost/charconv/detail/memcpy.hpp
index e5b08dc..aebf1b7 100644
--- a/include/boost/charconv/detail/memcpy.hpp
+++ b/include/boost/charconv/detail/memcpy.hpp
@@ -15,20 +15,20 @@ namespace boost { namespace charconv { namespace detail {
 
 #define BOOST_CHARCONV_CONSTEXPR constexpr
 
-constexpr void* memcpy(void* dest, const void* src, std::size_t count)
+constexpr char* memcpy(char* dest, const char* src, std::size_t count)
 {
     if (BOOST_CHARCONV_IS_CONSTANT_EVALUATED(count))
     {
         for (std::size_t i = 0; i < count; ++i)
         {
-            *((unsigned char*)dest + i) = *((const unsigned char*)src + i);
+            *(dest + i) = *(src + i);
         }
 
         return dest;
     }
     else
     {
-        return std::memcpy(dest, src, count);
+        return static_cast<char*>(std::memcpy(dest, src, count));
     }
 }
 
diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index 6653e38..8edfde8 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -222,7 +222,7 @@ BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char
         BOOST_CHARCONV_ASSERT_MSG(sizeof(Integer) < 1, "Your type is unsupported. Use a built-in integral type");
     }
     
-    return {first + std::strlen(first), 0};
+    return {--last, 0};
 }
 
 #ifdef BOOST_MSVC

From af3b943333754a5deba2c9091893e3d635abf547 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Tue, 31 Jan 2023 09:56:28 -0800
Subject: [PATCH 43/63] Fix location of returned pointer

---
 include/boost/charconv/to_chars.hpp | 11 ++++++-----
 test/to_chars_integer_STL_comp.cpp  | 13 +++++++++----
 2 files changed, 15 insertions(+), 9 deletions(-)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index 8edfde8..047860a 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -105,6 +105,7 @@ template <typename Integer>
 BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* last, Integer value) noexcept
 {       
     char buffer[10] {};
+    int converted_value_digits {};
     const std::ptrdiff_t user_buffer_size = last - first;
     BOOST_ATTRIBUTE_UNUSED bool is_negative = false;
     
@@ -134,9 +135,9 @@ BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char
         value <= static_cast<Integer>((std::numeric_limits<std::uint32_t>::max)()))
     {
         const auto converted_value = static_cast<std::uint32_t>(value);
-        const auto num_sig_chars = num_digits(converted_value);
+        converted_value_digits = num_digits(converted_value);
 
-        if (num_sig_chars > user_buffer_size)
+        if (converted_value_digits > user_buffer_size)
         {
             return {last, EOVERFLOW};
         }
@@ -150,13 +151,13 @@ BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char
             *first++ = '-';
         }
             
-        boost::charconv::detail::memcpy(first, buffer + (sizeof(buffer) - num_sig_chars), num_sig_chars);
+        boost::charconv::detail::memcpy(first, buffer + (sizeof(buffer) - converted_value_digits), converted_value_digits);
     }
     else if (std::numeric_limits<Integer>::digits <= std::numeric_limits<std::uint64_t>::digits ||
              static_cast<std::uint64_t>(value) <= (std::numeric_limits<std::uint64_t>::max)())
     {
         auto converted_value = static_cast<std::uint64_t>(value);
-        const auto converted_value_digits = num_digits(converted_value);
+        converted_value_digits = num_digits(converted_value);
 
         if (converted_value_digits > user_buffer_size)
         {
@@ -222,7 +223,7 @@ BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char
         BOOST_CHARCONV_ASSERT_MSG(sizeof(Integer) < 1, "Your type is unsupported. Use a built-in integral type");
     }
     
-    return {--last, 0};
+    return {first + converted_value_digits + static_cast<int>(is_negative), 0};
 }
 
 #ifdef BOOST_MSVC
diff --git a/test/to_chars_integer_STL_comp.cpp b/test/to_chars_integer_STL_comp.cpp
index cb66377..4a2b0a6 100644
--- a/test/to_chars_integer_STL_comp.cpp
+++ b/test/to_chars_integer_STL_comp.cpp
@@ -21,11 +21,16 @@ template <typename T>
 void test()
 {
     // Signed 0
-    char buffer1[64] {};
+    char buffer1_stl[64] {};
+    char buffer1_boost[64] {};
     T v1 = static_cast<T>(-0);
-    auto r1 = std::to_chars(buffer1, buffer1 + sizeof(buffer1) - 1, v1);
-    (void)r1;
-    BOOST_TEST_CSTR_EQ(buffer1, "0");
+    auto r1_stl = std::to_chars(buffer1_stl, buffer1_stl + sizeof(buffer1_stl) - 1, v1);
+    auto r1_boost = boost::charconv::to_chars(buffer1_boost, buffer1_boost + sizeof(buffer1_boost) - 1, v1);
+    BOOST_TEST_EQ(r1_stl.ptr, buffer1_stl + 1);
+    BOOST_TEST_EQ(r1_boost.ptr, buffer1_boost + 1);
+    BOOST_TEST_CSTR_EQ(buffer1_stl, "0");
+    BOOST_TEST_CSTR_EQ(buffer1_boost, "0");
+
 }
 
 int main()

From 12147b861f77b301ef5d62af36f21870252d9e56 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Tue, 31 Jan 2023 10:53:22 -0800
Subject: [PATCH 44/63] Replace 57-bit mask with 32-bit mask

Co-authored-by: Junekey Jeon <jk_jeon@kaist.ac.kr>
---
 include/boost/charconv/to_chars.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index 047860a..97d862d 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -1,5 +1,6 @@
 // Copyright 2022 Peter Dimov
 // Copyright 2023 Matt Borland
+// Copyright 2023 Junekey Jeon
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 
@@ -82,13 +83,12 @@ namespace detail {
 // https://arxiv.org/abs/2101.11408
 BOOST_CHARCONV_CONSTEXPR char* decompose32(std::uint32_t value, char* buffer) noexcept
 {
-    constexpr auto mask = (static_cast<std::uint64_t>(1) << 57) - 1; // D = 57 so 2^D - 1
-    constexpr auto magic_multiplier = static_cast<std::uint64_t>(1441151881); // floor(2*D / 10*k) where D is 57 and k is 8
-    auto y = value * magic_multiplier;
+    constexpr auto mask = (static_cast<std::uint64_t>(1) << 32) - 1;
+    auto y = ((value * UINT64_C(720575941)) >> 24) + 1;
 
     for (std::size_t i {}; i < 10; i += 2)
     {
-        boost::charconv::detail::memcpy(buffer + i, radix_table + static_cast<std::size_t>(y >> 57) * 2, 2);
+        boost::charconv::detail::memcpy(buffer + i, radix_table + static_cast<std::size_t>(y >> 32) * 2, 2);
         y &= mask;
         y *= 100;
     }

From f5f0af78e6933163c5b61bdb3e7cd68c41c09bf4 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Tue, 31 Jan 2023 11:21:42 -0800
Subject: [PATCH 45/63] Add more comparisons against STL

---
 include/boost/charconv/to_chars.hpp |  4 ++--
 test/to_chars_integer_STL_comp.cpp  | 33 +++++++++++++++++++++++++++++
 2 files changed, 35 insertions(+), 2 deletions(-)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index 97d862d..98304b7 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -308,7 +308,7 @@ BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char
     case 16:
         while (unsigned_value != 0)
         {
-            *end-- = static_cast<char>(zero + (unsigned_value & 15U)); // 1<<4 - 1
+            *end-- = digit_table[unsigned_value & 15U]; // 1<<4 - 1
             unsigned_value >>= 4U;
         }
         break;
@@ -316,7 +316,7 @@ BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char
     case 32:
         while (unsigned_value != 0)
         {
-            *end-- = static_cast<char>(zero + (unsigned_value & 31U)); // 1<<5 - 1
+            *end-- = digit_table[unsigned_value & 31U]; // 1<<5 - 1
             unsigned_value >>= 5U;
         }
         break;
diff --git a/test/to_chars_integer_STL_comp.cpp b/test/to_chars_integer_STL_comp.cpp
index 4a2b0a6..2a5378b 100644
--- a/test/to_chars_integer_STL_comp.cpp
+++ b/test/to_chars_integer_STL_comp.cpp
@@ -31,6 +31,39 @@ void test()
     BOOST_TEST_CSTR_EQ(buffer1_stl, "0");
     BOOST_TEST_CSTR_EQ(buffer1_boost, "0");
 
+    // Binary
+    char buffer2_stl[64] {};
+    char buffer2_boost[64] {};
+    T v2 = static_cast<T>(42);
+    auto r2_stl = std::to_chars(buffer2_stl, buffer2_stl + sizeof(buffer2_stl) - 1, v2, 2);
+    auto r2_boost = boost::charconv::to_chars(buffer2_boost, buffer2_boost + sizeof(buffer2_boost) - 1, v2, 2);
+    BOOST_TEST_EQ(r2_stl.ptr, buffer2_stl + 6);
+    BOOST_TEST_EQ(r2_boost.ptr, buffer2_boost + 6);
+    BOOST_TEST_CSTR_EQ(buffer2_stl, "101010");
+    BOOST_TEST_CSTR_EQ(buffer2_boost, "101010");
+
+    // Base 10
+    char buffer3_stl[64] {};
+    char buffer3_boost[64] {};
+    T v3 = static_cast<T>(120);
+    auto r3_stl = std::to_chars(buffer3_stl, buffer3_stl + sizeof(buffer3_stl) - 1, v3);
+    auto r3_boost = boost::charconv::to_chars(buffer3_boost, buffer3_boost + sizeof(buffer3_boost) - 1, v3);
+    BOOST_TEST_EQ(r3_stl.ptr, buffer3_stl + 3);
+    BOOST_TEST_EQ(r3_boost.ptr, buffer3_boost + 3);
+    BOOST_TEST_CSTR_EQ(buffer3_stl, "120");
+    BOOST_TEST_CSTR_EQ(buffer3_boost, "120");
+
+    // Hexadecimal
+    char buffer4_stl[64] {};
+    char buffer4_boost[64] {};
+    T v4 = static_cast<T>(44);
+    auto r4_stl = std::to_chars(buffer4_stl, buffer4_stl + sizeof(buffer4_stl) - 1, v4, 16);
+    auto r4_boost = boost::charconv::to_chars(buffer4_boost, buffer4_boost + sizeof(buffer4_boost) - 1, v4, 16);
+    BOOST_TEST_EQ(r4_stl.ptr, buffer4_stl + 2);
+    BOOST_TEST_EQ(r4_boost.ptr, buffer4_boost + 2);
+    BOOST_TEST_CSTR_EQ(buffer4_stl, "2c");
+    BOOST_TEST_CSTR_EQ(buffer4_boost, "2c");
+
 }
 
 int main()

From f85c68f9d257a799388d69be78a2ab94b7e3820d Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Wed, 1 Feb 2023 09:42:01 -0800
Subject: [PATCH 46/63] More STL comparisons

---
 test/to_chars_integer_STL_comp.cpp | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/test/to_chars_integer_STL_comp.cpp b/test/to_chars_integer_STL_comp.cpp
index 2a5378b..0a1c110 100644
--- a/test/to_chars_integer_STL_comp.cpp
+++ b/test/to_chars_integer_STL_comp.cpp
@@ -64,6 +64,25 @@ void test()
     BOOST_TEST_CSTR_EQ(buffer4_stl, "2c");
     BOOST_TEST_CSTR_EQ(buffer4_boost, "2c");
 
+    // Base 28
+    char buffer5_stl[64] {};
+    char buffer5_boost[64] {};
+    T v5 = static_cast<T>(100);
+    auto r5_stl = std::to_chars(buffer5_stl, buffer5_stl + sizeof(buffer5_stl) - 1, v5, 28);
+    auto r5_boost = boost::charconv::to_chars(buffer5_boost, buffer5_boost + sizeof(buffer5_boost) - 1, v5, 28);
+    BOOST_TEST_EQ(r5_stl.ptr, buffer5_stl + 2);
+    BOOST_TEST_EQ(r5_boost.ptr, buffer5_boost + 2);
+    BOOST_TEST_CSTR_EQ(buffer5_stl, "3g");
+    BOOST_TEST_CSTR_EQ(buffer5_boost, "3g");
+
+    // Overflow
+    char buffer6_stl[1] {};
+    char buffer6_boost[1] {};
+    T v6 = static_cast<T>(100);
+    auto r6_stl = std::to_chars(buffer6_stl, buffer6_stl + sizeof(buffer6_stl) - 1, v6);
+    auto r6_boost = boost::charconv::to_chars(buffer6_boost, buffer6_boost + sizeof(buffer6_boost) - 1, v6);
+    BOOST_TEST_EQ(r6_stl.ptr, r6_stl.ptr);
+    BOOST_TEST_EQ(r6_boost.ptr, r6_boost.ptr);
 }
 
 int main()

From 20af2a7eda114dd081b9244ecc1a09411e209466 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Wed, 1 Feb 2023 09:53:51 -0800
Subject: [PATCH 47/63] Cover more code paths

---
 test/to_chars.cpp | 54 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)

diff --git a/test/to_chars.cpp b/test/to_chars.cpp
index 8684aa0..f54017a 100644
--- a/test/to_chars.cpp
+++ b/test/to_chars.cpp
@@ -10,6 +10,46 @@
 #include <cstring>
 #include <cerrno>
 
+template <typename T>
+void base_thirtytwo_tests()
+{
+    char buffer1[64] {};
+    T v1 = static_cast<T>(42);
+    auto r1 = boost::charconv::to_chars(buffer1, buffer1 + sizeof(buffer1) - 1, v1, 32);
+    BOOST_TEST_EQ(r1.ec, 0);
+    BOOST_TEST_CSTR_EQ(buffer1, "1a");
+}
+
+template <typename T>
+void base_sixteen_tests()
+{
+    char buffer1[64] {};
+    T v1 = static_cast<T>(42);
+    auto r1 = boost::charconv::to_chars(buffer1, buffer1 + sizeof(buffer1) - 1, v1, 16);
+    BOOST_TEST_EQ(r1.ec, 0);
+    BOOST_TEST_CSTR_EQ(buffer1, "2a");
+}
+
+template <typename T>
+void base_eight_tests()
+{
+    char buffer1[64] {};
+    T v1 = static_cast<T>(42);
+    auto r1 = boost::charconv::to_chars(buffer1, buffer1 + sizeof(buffer1) - 1, v1, 8);
+    BOOST_TEST_EQ(r1.ec, 0);
+    BOOST_TEST_CSTR_EQ(buffer1, "52");
+}
+
+template <typename T>
+void base_four_tests()
+{
+    char buffer1[64] {};
+    T v1 = static_cast<T>(42);
+    auto r1 = boost::charconv::to_chars(buffer1, buffer1 + sizeof(buffer1) - 1, v1, 4);
+    BOOST_TEST_EQ(r1.ec, 0);
+    BOOST_TEST_CSTR_EQ(buffer1, "222");
+}
+
 // Tests the generic implementation
 template <typename T>
 void base_30_tests()
@@ -143,9 +183,23 @@ int main()
     sixty_four_bit_tests<long long>();
     sixty_four_bit_tests<std::uint64_t>();
 
+    // Tests for every specialized base
     base_two_tests<int>();
     base_two_tests<unsigned>();
 
+    base_four_tests<int>();
+    base_four_tests<unsigned>();
+
+    base_eight_tests<int>();
+    base_eight_tests<unsigned>();
+
+    base_sixteen_tests<int>();
+    base_sixteen_tests<unsigned>();
+
+    base_thirtytwo_tests<int>();
+    base_thirtytwo_tests<unsigned>();
+
+    // The generic impl
     base_30_tests<int>();
     base_30_tests<long>();
 

From 6b5d05deae9284448e9284c3b125efbc109f8082 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Wed, 1 Feb 2023 11:38:06 -0800
Subject: [PATCH 48/63] Add docs and rebuild HTML

---
 doc/charconv.adoc           |   1 +
 doc/charconv.html           | 156 +++++++++++++++++++++++++++++++++++-
 doc/charconv/overview.adoc  |  12 ++-
 doc/charconv/reference.adoc |  17 ++--
 doc/charconv/to_chars.adoc  |  77 ++++++++++++++++++
 5 files changed, 248 insertions(+), 15 deletions(-)
 create mode 100644 doc/charconv/to_chars.adoc

diff --git a/doc/charconv.adoc b/doc/charconv.adoc
index 022fd17..c652ce7 100644
--- a/doc/charconv.adoc
+++ b/doc/charconv.adoc
@@ -18,6 +18,7 @@ Peter Dimov and Matt Borland
 
 include::charconv/overview.adoc[]
 include::charconv/from_chars.adoc[]
+include::charconv/to_chars.adoc[]
 include::charconv/reference.adoc[]
 include::charconv/copyright.adoc[]
 
diff --git a/doc/charconv.html b/doc/charconv.html
index 5fc9ee3..ae6fbb7 100644
--- a/doc/charconv.html
+++ b/doc/charconv.html
@@ -684,6 +684,21 @@ pre.rouge {
 </li>
 </ul>
 </li>
+<li><a href="#from_chars_to_chars">to_chars</a>
+<ul class="sectlevel2">
+<li><a href="#to_chars_to_chars_overview">to_chars overview</a></li>
+<li><a href="#to_chars_to_chars_result">to_chars_result</a></li>
+<li><a href="#to_chars_to_chars">to_chars</a></li>
+<li><a href="#to_chars_to_chars_for_integral_types">to_chars for integral types</a></li>
+<li><a href="#to_chars_examples">Examples</a>
+<ul class="sectlevel3">
+<li><a href="#to_chars_basic_usage">Basic Usage</a></li>
+<li><a href="#to_chars_hexadecimal">Hexadecimal</a></li>
+<li><a href="#to_chars_erange">ERANGE</a></li>
+</ul>
+</li>
+</ul>
+</li>
 <li><a href="#reference">Reference</a>
 <ul class="sectlevel2">
 <li><a href="#ref_boostcharconvfrom_chars_hpp">&lt;boost/charconv/from_chars.hpp&gt;</a>
@@ -722,7 +737,12 @@ pre.rouge {
 <span class="k">const</span> <span class="kt">char</span><span class="o">*</span> <span class="n">buffer</span> <span class="o">=</span> <span class="s">"42"</span><span class="p">;</span>
 <span class="kt">int</span> <span class="n">v</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
 <span class="k">auto</span> <span class="n">r</span> <span class="o">=</span> <span class="n">boost</span><span class="o">::</span><span class="n">charconv</span><span class="o">::</span><span class="n">from_chars</span><span class="p">(</span><span class="n">buffer</span><span class="p">,</span> <span class="n">buffer</span> <span class="o">+</span> <span class="n">std</span><span class="o">::</span><span class="n">strlen</span><span class="p">(</span><span class="n">buffer</span><span class="p">),</span> <span class="n">v</span><span class="p">);</span>
-<span class="n">assert</span><span class="p">(</span><span class="n">r</span> <span class="o">==</span> <span class="mi">42</span><span class="p">);</span></code></pre>
+<span class="n">assert</span><span class="p">(</span><span class="n">r</span> <span class="o">==</span> <span class="mi">42</span><span class="p">);</span>
+
+<span class="kt">char</span> <span class="n">buffer</span><span class="p">[</span><span class="mi">64</span><span class="p">];</span>
+<span class="kt">int</span> <span class="n">v</span> <span class="o">=</span> <span class="mi">12345</span><span class="p">;</span>
+<span class="k">auto</span> <span class="n">r</span> <span class="o">=</span> <span class="n">boost</span><span class="o">::</span><span class="n">charconv</span><span class="o">::</span><span class="n">to_chars</span><span class="p">(</span><span class="n">buffer</span><span class="p">,</span> <span class="n">buffer</span> <span class="o">+</span> <span class="k">sizeof</span><span class="p">(</span><span class="n">buffer</span><span class="p">)</span> <span class="o">-</span> <span class="mi">1</span><span class="p">,</span> <span class="n">v</span><span class="p">);</span>
+<span class="n">assert</span><span class="p">(</span><span class="o">!</span><span class="n">strcmp</span><span class="p">(</span><span class="n">buffer</span><span class="p">,</span> <span class="s">"123456"</span><span class="p">));</span> <span class="c1">// Strcmp returns 0 on match</span></code></pre>
 </div>
 </div>
 </div>
@@ -901,6 +921,134 @@ pre.rouge {
 </div>
 </div>
 <div class="sect1">
+<h2 id="from_chars_to_chars">to_chars</h2>
+<div class="sectionbody">
+<div class="sect2">
+<h3 id="to_chars_to_chars_overview">to_chars overview</h3>
+<div class="listingblock">
+<div class="content">
+<pre class="rouge highlight"><code data-lang="c++"><span class="k">struct</span> <span class="nc">to_chars_result</span>
+<span class="p">{</span>
+    <span class="kt">char</span><span class="o">*</span> <span class="n">ptr</span><span class="p">;</span>
+    <span class="kt">int</span> <span class="n">ec</span><span class="p">;</span>
+
+    <span class="k">friend</span> <span class="k">constexpr</span> <span class="kt">bool</span> <span class="k">operator</span><span class="o">==</span><span class="p">(</span><span class="k">const</span> <span class="n">to_chars_result</span><span class="o">&amp;</span> <span class="n">lhs</span><span class="p">,</span> <span class="k">const</span> <span class="n">to_chars_result</span><span class="o">&amp;</span> <span class="n">rhs</span><span class="p">)</span> <span class="k">noexcept</span><span class="p">;</span>
+    <span class="k">friend</span> <span class="k">constexpr</span> <span class="kt">bool</span> <span class="k">operator</span><span class="o">!=</span><span class="p">(</span><span class="k">const</span> <span class="n">to_chars_result</span><span class="o">&amp;</span> <span class="n">lhs</span><span class="p">,</span> <span class="k">const</span> <span class="n">to_chars_result</span><span class="o">&amp;</span> <span class="n">rhs</span><span class="p">)</span> <span class="k">noexcept</span><span class="p">;</span>
+<span class="p">};</span>
+
+<span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="nc">Integral</span><span class="p">&gt;</span>
+<span class="n">BOOST_CHARCONV_CONSTEXPR</span> <span class="n">to_chars_result</span><span class="p">(</span><span class="kt">char</span><span class="o">*</span> <span class="n">first</span><span class="p">,</span> <span class="kt">char</span><span class="o">*</span> <span class="n">last</span><span class="p">,</span> <span class="n">Integral</span> <span class="n">value</span><span class="p">,</span> <span class="kt">int</span> <span class="n">base</span> <span class="o">=</span> <span class="mi">10</span><span class="p">)</span> <span class="k">noexcept</span><span class="p">;</span>
+
+<span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="nc">Integral</span><span class="p">&gt;</span>
+<span class="n">BOOST_CHARCONV_CONSTEXPR</span> <span class="n">to_chars_result</span><span class="o">&lt;</span><span class="kt">bool</span><span class="o">&gt;</span><span class="p">(</span><span class="kt">char</span><span class="o">*</span> <span class="n">first</span><span class="p">,</span> <span class="kt">char</span><span class="o">*</span> <span class="n">last</span><span class="p">,</span> <span class="n">Integral</span> <span class="n">value</span><span class="p">,</span> <span class="kt">int</span> <span class="n">base</span><span class="p">)</span> <span class="k">noexcept</span> <span class="o">=</span> <span class="k">delete</span><span class="p">;</span></code></pre>
+</div>
+</div>
+</div>
+<div class="sect2">
+<h3 id="to_chars_to_chars_result">to_chars_result</h3>
+<div class="ulist">
+<ul>
+<li>
+<p>ptr - points to the first character</p>
+</li>
+<li>
+<p>ec - the error code. Valid values from &lt;cerrno&gt; are:</p>
+<div class="ulist">
+<ul>
+<li>
+<p>0 - successful parsing</p>
+</li>
+<li>
+<p>EINVAL - invalid argument</p>
+</li>
+<li>
+<p>ERANGE - result out of range (e.g. overflow)</p>
+</li>
+</ul>
+</div>
+</li>
+<li>
+<p>operator== - compares the value of ptr and ec for equality</p>
+</li>
+<li>
+<p>operator!= - compares the value of ptr and ec for inequality</p>
+</li>
+</ul>
+</div>
+</div>
+<div class="sect2">
+<h3 id="to_chars_to_chars">to_chars</h3>
+<div class="ulist">
+<ul>
+<li>
+<p>first, last - pointers to the character buffer</p>
+</li>
+<li>
+<p>value - the value to be paresed into the buffer</p>
+</li>
+<li>
+<p>base - the integer base to use. Must be between 2 and 36 inclusive</p>
+</li>
+<li>
+<p>from_chars for integral type is constexpr (BOOST_CHARCONV_CONSTEXPR is defined) when compiled using <code>-std=c++14</code> or newer and a compiler with <code><em>_builtin</em> is_constant_evaluated</code></p>
+</li>
+</ul>
+</div>
+</div>
+<div class="sect2">
+<h3 id="to_chars_to_chars_for_integral_types">to_chars for integral types</h3>
+<div class="ulist">
+<ul>
+<li>
+<p>All built-in integral types are allowed except bool which is deleted</p>
+</li>
+</ul>
+</div>
+</div>
+<div class="sect2">
+<h3 id="to_chars_examples">Examples</h3>
+<div class="sect3">
+<h4 id="to_chars_basic_usage">Basic Usage</h4>
+<div class="listingblock">
+<div class="content">
+<pre class="rouge highlight"><code data-lang="c++"><span class="kt">char</span> <span class="n">buffer</span><span class="p">[</span><span class="mi">64</span><span class="p">]</span> <span class="p">{};</span>
+<span class="kt">int</span> <span class="n">v</span> <span class="o">=</span> <span class="mi">42</span><span class="p">;</span>
+<span class="n">to_chars_result</span> <span class="n">r</span> <span class="o">=</span> <span class="n">boost</span><span class="o">::</span><span class="n">charconv</span><span class="o">::</span><span class="n">to_chars</span><span class="p">(</span><span class="n">buffer</span><span class="p">,</span> <span class="n">buffer</span> <span class="o">+</span> <span class="k">sizeof</span><span class="p">(</span><span class="n">buffer</span><span class="p">)</span> <span class="o">-</span> <span class="mi">1</span><span class="p">,</span> <span class="n">v</span><span class="p">);</span>
+<span class="n">assert</span><span class="p">(</span><span class="n">r</span><span class="p">.</span><span class="n">ec</span> <span class="o">==</span> <span class="mi">0</span><span class="p">);</span>
+<span class="n">assert</span><span class="p">(</span><span class="o">!</span><span class="n">strcmp</span><span class="p">(</span><span class="n">buffer</span><span class="p">,</span> <span class="s">"42"</span><span class="p">));</span> <span class="c1">// strcmp returns 0 on match</span></code></pre>
+</div>
+</div>
+</div>
+<div class="sect3">
+<h4 id="to_chars_hexadecimal">Hexadecimal</h4>
+<div class="listingblock">
+<div class="content">
+<pre class="rouge highlight"><code data-lang="c++"><span class="kt">char</span> <span class="n">buffer</span><span class="p">[</span><span class="mi">64</span><span class="p">]</span> <span class="p">{};</span>
+<span class="kt">int</span> <span class="n">v</span> <span class="o">=</span> <span class="mi">42</span><span class="p">;</span>
+<span class="n">to_chars_result</span> <span class="n">r</span> <span class="o">=</span> <span class="n">boost</span><span class="o">::</span><span class="n">charconv</span><span class="o">::</span><span class="n">to_chars</span><span class="p">(</span><span class="n">buffer</span><span class="p">,</span> <span class="n">buffer</span> <span class="o">+</span> <span class="k">sizeof</span><span class="p">(</span><span class="n">buffer</span><span class="p">)</span> <span class="o">-</span> <span class="mi">1</span><span class="p">,</span> <span class="n">v</span><span class="p">,</span> <span class="mi">16</span><span class="p">);</span>
+<span class="n">assert</span><span class="p">(</span><span class="n">r</span><span class="p">.</span><span class="n">ec</span> <span class="o">==</span> <span class="mi">0</span><span class="p">);</span>
+<span class="n">assert</span><span class="p">(</span><span class="o">!</span><span class="n">strcmp</span><span class="p">(</span><span class="n">buffer</span><span class="p">,</span> <span class="s">"2a"</span><span class="p">));</span> <span class="c1">// strcmp returns 0 on match</span></code></pre>
+</div>
+</div>
+</div>
+<div class="sect3">
+<h4 id="to_chars_erange">ERANGE</h4>
+<div class="listingblock">
+<div class="content">
+<pre class="rouge highlight"><code data-lang="c++"><span class="kt">char</span> <span class="n">buffer</span><span class="p">[</span><span class="mi">3</span><span class="p">]</span> <span class="p">{};</span>
+<span class="kt">int</span> <span class="n">v</span> <span class="o">=</span> <span class="o">-</span><span class="mi">1234</span><span class="p">;</span>
+<span class="n">to_chars_result</span> <span class="n">r</span> <span class="o">=</span> <span class="n">boost</span><span class="o">::</span><span class="n">charconv</span><span class="o">::</span><span class="n">to_chars</span><span class="p">(</span><span class="n">buffer</span><span class="p">,</span> <span class="n">buffer</span> <span class="o">+</span> <span class="k">sizeof</span><span class="p">(</span><span class="n">buffer</span><span class="p">)</span> <span class="o">-</span> <span class="mi">1</span><span class="p">,</span> <span class="n">v</span><span class="p">,</span> <span class="mi">16</span><span class="p">);</span>
+<span class="n">assert</span><span class="p">(</span><span class="n">r</span><span class="p">.</span><span class="n">ec</span> <span class="o">==</span> <span class="n">ERANGE</span><span class="p">);</span></code></pre>
+</div>
+</div>
+<div class="paragraph">
+<p>In the event of ERANGE to_chars_result.ptr is first</p>
+</div>
+</div>
+</div>
+</div>
+</div>
+<div class="sect1">
 <h2 id="reference">Reference</h2>
 <div class="sectionbody">
 <div class="sect2">
@@ -936,8 +1084,8 @@ pre.rouge {
 
 <span class="k">struct</span> <span class="nc">to_chars_result</span><span class="p">;</span>
 
-<span class="k">template</span><span class="o">&lt;</span><span class="k">class</span> <span class="nc">Integral</span><span class="p">&gt;</span>
-<span class="n">to_chars_result</span> <span class="n">to_chars</span><span class="p">(</span> <span class="kt">char</span><span class="o">*</span> <span class="n">first</span><span class="p">,</span> <span class="kt">char</span><span class="o">*</span> <span class="n">last</span><span class="p">,</span> <span class="n">Integral</span> <span class="n">value</span><span class="p">,</span> <span class="kt">int</span> <span class="n">base</span> <span class="o">=</span> <span class="mi">10</span> <span class="p">);</span>
+<span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="nc">Integral</span><span class="p">&gt;</span>
+<span class="n">BOOST_CHARCONV_CONSTEXPR</span> <span class="n">to_chars_result</span> <span class="n">to_chars</span><span class="p">(</span> <span class="kt">char</span><span class="o">*</span> <span class="n">first</span><span class="p">,</span> <span class="kt">char</span><span class="o">*</span> <span class="n">last</span><span class="p">,</span> <span class="n">Integral</span> <span class="n">value</span><span class="p">,</span> <span class="kt">int</span> <span class="n">base</span> <span class="o">=</span> <span class="mi">10</span> <span class="p">)</span> <span class="k">noexcept</span><span class="p">;</span>
 
 <span class="c1">// ...</span>
 
@@ -968,7 +1116,7 @@ the <a href="http://www.boost.org/LICENSE_1_0.txt">Boost Software License, Versi
 </div>
 <div id="footer">
 <div id="footer-text">
-Last updated 2023-01-16 08:01:11 -0800
+Last updated 2023-02-01 10:02:03 -0800
 </div>
 </div>
 <style>
diff --git a/doc/charconv/overview.adoc b/doc/charconv/overview.adoc
index 7c14230..20c5bcd 100644
--- a/doc/charconv/overview.adoc
+++ b/doc/charconv/overview.adoc
@@ -13,15 +13,21 @@ https://www.boost.org/LICENSE_1_0.txt
 Charconv is a collection of parsing functions that are locale-independent, non-allocating, and non-throwing.
 
 == Usage Examples
-
-```
+[source, c++]
+----
 #include <boost/charconv.hpp>
 
 const char* buffer = "42";
 int v = 0;
 auto r = boost::charconv::from_chars(buffer, buffer + std::strlen(buffer), v);
 assert(r == 42);
-```
+
+char buffer[64];
+int v = 12345;
+auto r = boost::charconv::to_chars(buffer, buffer + sizeof(buffer) - 1, v);
+assert(!strcmp(buffer, "123456")); // Strcmp returns 0 on match
+
+----
 
 == Supported Compilers
 
diff --git a/doc/charconv/reference.adoc b/doc/charconv/reference.adoc
index 1e7c89b..d3c6aad 100644
--- a/doc/charconv/reference.adoc
+++ b/doc/charconv/reference.adoc
@@ -1,5 +1,6 @@
 ////
 Copyright 2022 Peter Dimov
+Copyright 2023 Matt Borland
 Distributed under the Boost Software License, Version 1.0.
 https://www.boost.org/LICENSE_1_0.txt
 ////
@@ -11,8 +12,8 @@ https://www.boost.org/LICENSE_1_0.txt
 == <boost/charconv/from_chars.hpp>
 
 === Synopsis
-
-```
+[source, c++]
+----
 namespace boost {
 namespace charconv {
 
@@ -25,26 +26,26 @@ BOOST_CXX14_CONSTEXPR from_chars_result from_chars(const char* first, const char
 
 } // namespace charconv
 } // namespace boost
-```
+----
 
 == <boost/charconv/to_chars.hpp>
 
 === Synopsis
-
-```
+[source, c++]
+----
 namespace boost {
 namespace charconv {
 
 struct to_chars_result;
 
-template<class Integral>
-to_chars_result to_chars( char* first, char* last, Integral value, int base = 10 );
+template <typename Integral>
+BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars( char* first, char* last, Integral value, int base = 10 ) noexcept;
 
 // ...
 
 } // namespace charconv
 } // namespace boost
-```
+----
 
 == <boost/charconv.hpp>
 
diff --git a/doc/charconv/to_chars.adoc b/doc/charconv/to_chars.adoc
new file mode 100644
index 0000000..f162052
--- /dev/null
+++ b/doc/charconv/to_chars.adoc
@@ -0,0 +1,77 @@
+////
+Copyright 2023 Matt Borland
+Distributed under the Boost Software License, Version 1.0.
+https://www.boost.org/LICENSE_1_0.txt
+////
+
+= to_chars
+:idprefix: to_chars_
+
+== to_chars overview
+[source, c++]
+----
+struct to_chars_result
+{
+    char* ptr;
+    int ec;
+
+    friend constexpr bool operator==(const to_chars_result& lhs, const to_chars_result& rhs) noexcept;
+    friend constexpr bool operator!=(const to_chars_result& lhs, const to_chars_result& rhs) noexcept;
+};
+
+template <typename Integral>
+BOOST_CHARCONV_CONSTEXPR to_chars_result(char* first, char* last, Integral value, int base = 10) noexcept;
+
+template <typename Integral>
+BOOST_CHARCONV_CONSTEXPR to_chars_result<bool>(char* first, char* last, Integral value, int base) noexcept = delete;
+----
+
+== to_chars_result
+* ptr - points to the first character
+* ec - the error code. Valid values from <cerrno> are:
+** 0 - successful parsing
+** EINVAL - invalid argument
+** ERANGE - result out of range (e.g. overflow)
+* operator== - compares the value of ptr and ec for equality
+* operator!= - compares the value of ptr and ec for inequality
+
+== to_chars
+* first, last - pointers to the character buffer
+* value - the value to be paresed into the buffer
+* base - the integer base to use. Must be between 2 and 36 inclusive
+* from_chars for integral type is constexpr (BOOST_CHARCONV_CONSTEXPR is defined) when compiled using `-std=c++14` or newer and a compiler with `__builtin_ is_constant_evaluated`
+
+== to_chars for integral types
+* All built-in integral types are allowed except bool which is deleted
+
+== Examples
+
+=== Basic Usage
+[source, c++]
+----
+char buffer[64] {};
+int v = 42;
+to_chars_result r = boost::charconv::to_chars(buffer, buffer + sizeof(buffer) - 1, v);
+assert(r.ec == 0);
+assert(!strcmp(buffer, "42")); // strcmp returns 0 on match
+----
+
+=== Hexadecimal
+[source, c++]
+----
+char buffer[64] {};
+int v = 42;
+to_chars_result r = boost::charconv::to_chars(buffer, buffer + sizeof(buffer) - 1, v, 16);
+assert(r.ec == 0);
+assert(!strcmp(buffer, "2a")); // strcmp returns 0 on match
+----
+
+=== ERANGE
+[source, c++]
+----
+char buffer[3] {};
+int v = -1234;
+to_chars_result r = boost::charconv::to_chars(buffer, buffer + sizeof(buffer) - 1, v, 16);
+assert(r.ec == ERANGE);
+----
+In the event of ERANGE to_chars_result.ptr is first

From d1117666aa58db62e82ccbf9f1a5d9d8a3af96a4 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Wed, 1 Feb 2023 12:15:37 -0800
Subject: [PATCH 49/63] Fix jamfile requirements

---
 test/Jamfile | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/Jamfile b/test/Jamfile
index f85981a..b4ef1b9 100644
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -21,5 +21,5 @@ run quick.cpp ;
 run from_chars.cpp ;
 run to_chars.cpp ;
 run roundtrip.cpp ;
-run from_chars_STL_comp.cpp : : : [ requires cxx17_std_apply ] ;
-run to_chars_integer_STL_comp.cpp : : : [ requires cxx17_std_apply ] ;
+run from_chars_STL_comp.cpp : : : [ requires cxx17_hdr_charconv ] ;
+run to_chars_integer_STL_comp.cpp : : : [ requires cxx17_hdr_charconv ] ;

From 7970a9919730aca1c685a2ae9f20f354369eb557 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Wed, 1 Feb 2023 12:15:47 -0800
Subject: [PATCH 50/63] Remove no-op macro

---
 include/boost/charconv/detail/integer_conversion.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/boost/charconv/detail/integer_conversion.hpp b/include/boost/charconv/detail/integer_conversion.hpp
index 093cb6a..6ddc7d3 100644
--- a/include/boost/charconv/detail/integer_conversion.hpp
+++ b/include/boost/charconv/detail/integer_conversion.hpp
@@ -19,7 +19,7 @@ constexpr std::uint64_t pack(std::uint32_t word1, std::uint32_t word2) noexcept
 
 BOOST_CXX14_CONSTEXPR std::pair<std::uint32_t, std::uint32_t> unpack(std::uint64_t value)
 {
-    auto x = static_cast<std::uint32_t>((value & UINT64_MAX) >> UINT64_C(32));
+    auto x = static_cast<std::uint32_t>(value >> UINT64_C(32));
     auto y = static_cast<std::uint32_t>(value & UINT32_MAX);
 
     return std::make_pair(x, y);

From a8c8cb73f1da95ce28aef6a135cf4c39671a4534 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Wed, 1 Feb 2023 12:18:00 -0800
Subject: [PATCH 51/63] Simplify is_constant_evaluated_macro

---
 .../boost/charconv/detail/is_constant_evaluated.hpp   | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/include/boost/charconv/detail/is_constant_evaluated.hpp b/include/boost/charconv/detail/is_constant_evaluated.hpp
index f5f8fe4..046c47a 100644
--- a/include/boost/charconv/detail/is_constant_evaluated.hpp
+++ b/include/boost/charconv/detail/is_constant_evaluated.hpp
@@ -8,15 +8,10 @@
 #define BOOST_CHARCONV_TOOLS_IS_CONSTANT_EVALUATED_HPP
 
 #include <boost/charconv/config.hpp>
+#include <type_traits>
 
-#ifdef __has_include
-# if __has_include(<version>)
-#  include <version>
-#  ifdef __cpp_lib_is_constant_evaluated
-#   include <type_traits>
-#   define BOOST_CHARCONV_HAS_IS_CONSTANT_EVALUATED
-#  endif
-# endif
+#ifdef __cpp_lib_is_constant_evaluated
+#  define BOOST_CHARCONV_HAS_IS_CONSTANT_EVALUATED
 #endif
 
 #ifdef __has_builtin

From fb69333f62d5fdf37f91c2dea7ab4d1535cba492 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Wed, 1 Feb 2023 16:09:48 -0800
Subject: [PATCH 52/63] Sign is accounted for by shifting first

---
 include/boost/charconv/to_chars.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index 98304b7..17e418f 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -223,7 +223,7 @@ BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char
         BOOST_CHARCONV_ASSERT_MSG(sizeof(Integer) < 1, "Your type is unsupported. Use a built-in integral type");
     }
     
-    return {first + converted_value_digits + static_cast<int>(is_negative), 0};
+    return {first + converted_value_digits, 0};
 }
 
 #ifdef BOOST_MSVC

From a8991a3c26de049bcef75dc1fc76d96f4cdfcadb Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Thu, 2 Feb 2023 08:32:05 -0800
Subject: [PATCH 53/63] Add tests with random numbers and fixed bases

---
 test/to_chars_integer_STL_comp.cpp | 33 ++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/test/to_chars_integer_STL_comp.cpp b/test/to_chars_integer_STL_comp.cpp
index 0a1c110..21cc93a 100644
--- a/test/to_chars_integer_STL_comp.cpp
+++ b/test/to_chars_integer_STL_comp.cpp
@@ -16,6 +16,29 @@
 #include <cerrno>
 #include <utility>
 #include <system_error>
+#include <random>
+
+template <typename T, int base = 10>
+void random_tests()
+{
+    std::random_device rd;
+    std::mt19937_64 gen(rd());
+    std::uniform_int_distribution<T> dist((std::numeric_limits<T>::min)(), (std::numeric_limits<T>::max)());
+
+    for (std::size_t i = 0; i < 100'000; ++i)
+    {
+        char buffer_stl[64] {};
+        char buffer_boost[64] {};
+
+        T v = dist(gen);
+
+        auto r_stl = std::to_chars(buffer_stl, buffer_stl + sizeof(buffer_stl) - 1, v, base);
+        auto r_boost = boost::charconv::to_chars(buffer_boost, buffer_boost + sizeof(buffer_boost) - 1, v, base);
+
+        BOOST_TEST_EQ(static_cast<std::ptrdiff_t>(r_stl.ptr - buffer_stl), static_cast<std::ptrdiff_t>(r_boost.ptr - buffer_boost));
+        BOOST_TEST_CSTR_EQ(buffer_stl, buffer_boost);
+    }
+}
 
 template <typename T>
 void test()
@@ -99,6 +122,16 @@ int main()
     test<long long>();
     test<unsigned long long>();
 
+    // Specialized bases
+    random_tests<int, 2>();
+    random_tests<int, 4>();
+    random_tests<int, 8>();
+    random_tests<int, 16>();
+    random_tests<int, 32>();
+
+    // Generic implementation
+    random_tests<int, 23>();
+
     return boost::report_errors();
 }
 

From 373954a4a842252b279197f86db1013b2455972a Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Thu, 2 Feb 2023 08:54:49 -0800
Subject: [PATCH 54/63] Revert decompose32 mask change

---
 include/boost/charconv/to_chars.hpp |  8 +++-----
 test/to_chars.cpp                   | 21 +++++++++++++++++++++
 test/to_chars_integer_STL_comp.cpp  |  6 ++++--
 3 files changed, 28 insertions(+), 7 deletions(-)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index 17e418f..52823ff 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -83,12 +83,12 @@ namespace detail {
 // https://arxiv.org/abs/2101.11408
 BOOST_CHARCONV_CONSTEXPR char* decompose32(std::uint32_t value, char* buffer) noexcept
 {
-    constexpr auto mask = (static_cast<std::uint64_t>(1) << 32) - 1;
-    auto y = ((value * UINT64_C(720575941)) >> 24) + 1;
+    constexpr auto mask = (std::uint64_t(1) << 57) - 1;
+    auto y = value * std::uint64_t(1441151881);
 
     for (std::size_t i {}; i < 10; i += 2)
     {
-        boost::charconv::detail::memcpy(buffer + i, radix_table + static_cast<std::size_t>(y >> 32) * 2, 2);
+        boost::charconv::detail::memcpy(buffer + i, radix_table + static_cast<std::size_t>(y >> 57) * 2, 2);
         y &= mask;
         y *= 100;
     }
@@ -144,8 +144,6 @@ BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char
 
         decompose32(converted_value, buffer);
 
-        // TODO: If constant evaluated use unrolled loop
-        // If not constant evaluated use memcpy
         if (is_negative)
         {
             *first++ = '-';
diff --git a/test/to_chars.cpp b/test/to_chars.cpp
index f54017a..68fdbc2 100644
--- a/test/to_chars.cpp
+++ b/test/to_chars.cpp
@@ -7,9 +7,19 @@
 #include <boost/core/lightweight_test.hpp>
 #include <type_traits>
 #include <limits>
+#include <string>
 #include <cstring>
 #include <cerrno>
 
+void off_by_one_tests(int value)
+{
+    char buffer[64] {};
+    auto r = boost::charconv::to_chars(buffer, buffer + sizeof(buffer) - 1, value);
+    BOOST_TEST_EQ(r.ec, 0);
+    std::string value_string = std::to_string(value);
+    BOOST_TEST_CSTR_EQ(buffer, value_string.c_str());
+}
+
 template <typename T>
 void base_thirtytwo_tests()
 {
@@ -205,5 +215,16 @@ int main()
 
     overflow_tests<int>();
 
+    // Resulted in off by one errors from random number generation
+    // Consistently one larger with 10 digit numbers
+    off_by_one_tests(1159137169);
+    off_by_one_tests(-1321793318);
+    off_by_one_tests(2140634902);
+    
+    // If we compensate by one these fail
+    off_by_one_tests(1038882992);
+    off_by_one_tests(-1065658613);
+    off_by_one_tests(-1027205339);
+
     return boost::report_errors();
 }
diff --git a/test/to_chars_integer_STL_comp.cpp b/test/to_chars_integer_STL_comp.cpp
index 21cc93a..fe8d443 100644
--- a/test/to_chars_integer_STL_comp.cpp
+++ b/test/to_chars_integer_STL_comp.cpp
@@ -27,8 +27,8 @@ void random_tests()
 
     for (std::size_t i = 0; i < 100'000; ++i)
     {
-        char buffer_stl[64] {};
-        char buffer_boost[64] {};
+        char buffer_stl[128] {};
+        char buffer_boost[128] {};
 
         T v = dist(gen);
 
@@ -129,6 +129,8 @@ int main()
     random_tests<int, 16>();
     random_tests<int, 32>();
 
+    random_tests<int, 10>();
+
     // Generic implementation
     random_tests<int, 23>();
 

From a111b5c2bd3e68f64881e6e35be1d434a30a8f64 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Thu, 2 Feb 2023 09:21:45 -0800
Subject: [PATCH 55/63] Add stress test and used fixed seed on CI random tests

---
 test/to_chars_integer_STL_comp.cpp | 56 ++++++++++++++++++++++++++++--
 1 file changed, 54 insertions(+), 2 deletions(-)

diff --git a/test/to_chars_integer_STL_comp.cpp b/test/to_chars_integer_STL_comp.cpp
index fe8d443..7f7a490 100644
--- a/test/to_chars_integer_STL_comp.cpp
+++ b/test/to_chars_integer_STL_comp.cpp
@@ -17,12 +17,59 @@
 #include <utility>
 #include <system_error>
 #include <random>
+#include <thread>
+#include <vector>
+
+template <typename T>
+void stress_test_worker()
+{
+    std::random_device rd;
+    std::mt19937_64 gen(rd());
+    std::uniform_int_distribution<T> dist((std::numeric_limits<T>::min)(), (std::numeric_limits<T>::max)());
+
+    std::mt19937_64 base_gen(rd());
+    std::uniform_int_distribution<int> base_dist(2, 36);
+
+    for (std::size_t i = 0; i < 100'000'000; ++i)
+    {
+        char buffer_stl[128] {};
+        char buffer_boost[128] {};
+
+        T v = dist(gen);
+        int base = base_dist(base_gen);
+
+        auto r_stl = std::to_chars(buffer_stl, buffer_stl + sizeof(buffer_stl) - 1, v, base);
+        auto r_boost = boost::charconv::to_chars(buffer_boost, buffer_boost + sizeof(buffer_boost) - 1, v, base);
+
+        BOOST_TEST_EQ(static_cast<std::ptrdiff_t>(r_stl.ptr - buffer_stl), static_cast<std::ptrdiff_t>(r_boost.ptr - buffer_boost));
+        BOOST_TEST_CSTR_EQ(buffer_stl, buffer_boost);
+    }
+}
+
+template <typename T>
+void stress_test()
+{
+    auto num_threads = std::thread::hardware_concurrency();
+    std::vector<std::thread> thread_manager(num_threads);
+
+    for (std::size_t i = 0; i < num_threads; ++i)
+    {
+        thread_manager.emplace_back(std::thread(stress_test_worker<T>));
+    }
+
+    for (std::size_t i = 0; i < thread_manager.size(); ++i)
+    {
+        if (thread_manager[i].joinable())
+        {
+            thread_manager[i].join();
+        }
+    }
+}
 
 template <typename T, int base = 10>
 void random_tests()
 {
-    std::random_device rd;
-    std::mt19937_64 gen(rd());
+    std::mt19937_64 gen(42);
     std::uniform_int_distribution<T> dist((std::numeric_limits<T>::min)(), (std::numeric_limits<T>::max)());
 
     for (std::size_t i = 0; i < 100'000; ++i)
@@ -134,6 +181,11 @@ int main()
     // Generic implementation
     random_tests<int, 23>();
 
+    // Stress tests are disabled for CI
+    #ifdef BOOST_CHARCONV_STRESS_TEST
+    stress_test<int>();
+    #endif
+
     return boost::report_errors();
 }
 

From 6759a4216a046dc2013319183e58f07da3288da4 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Thu, 2 Feb 2023 09:35:27 -0800
Subject: [PATCH 56/63] Add more fixed width integers

---
 test/to_chars_integer_STL_comp.cpp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/test/to_chars_integer_STL_comp.cpp b/test/to_chars_integer_STL_comp.cpp
index 7f7a490..95589ff 100644
--- a/test/to_chars_integer_STL_comp.cpp
+++ b/test/to_chars_integer_STL_comp.cpp
@@ -176,7 +176,12 @@ int main()
     random_tests<int, 16>();
     random_tests<int, 32>();
 
-    random_tests<int, 10>();
+    random_tests<std::int16_t, 10>();
+    random_tests<std::uint16_t, 10>();
+    random_tests<std::int32_t, 10>();
+    random_tests<std::uint32_t, 10>();
+    random_tests<std::int64_t, 10>();
+    random_tests<std::uint64_t, 10>();
 
     // Generic implementation
     random_tests<int, 23>();

From aa13c62ce64478521fa267bb8046c4a320be073f Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Thu, 2 Feb 2023 11:52:02 -0800
Subject: [PATCH 57/63] Fix 8 and 16 bit overflows

---
 include/boost/charconv/to_chars.hpp | 23 +++++++++++++++++------
 test/to_chars.cpp                   | 15 +++++++++++++++
 test/to_chars_integer_STL_comp.cpp  |  2 ++
 3 files changed, 34 insertions(+), 6 deletions(-)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index 52823ff..c1d2291 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -103,7 +103,10 @@ BOOST_CHARCONV_CONSTEXPR char* decompose32(std::uint32_t value, char* buffer) no
 
 template <typename Integer>
 BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char* last, Integer value) noexcept
-{       
+{
+    using Unsigned_Integer = typename std::make_unsigned<Integer>::type;
+    Unsigned_Integer unsigned_value {};
+
     char buffer[10] {};
     int converted_value_digits {};
     const std::ptrdiff_t user_buffer_size = last - first;
@@ -119,9 +122,17 @@ BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char
     {
         if (value < 0)
         {
-            value = apply_sign(value);
             is_negative = true;
+            unsigned_value = apply_sign(value);
         }
+        else
+        {
+            unsigned_value = value;
+        }
+    }
+    else
+    {
+        unsigned_value = value;
     }
 
     // If the type is less than 32 bits we can use this without change
@@ -132,9 +143,9 @@ BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char
     // Yields: warning C4127: conditional expression is constant becuase first half of the expression is constant
     // but we need to short circuit to avoid UB on the second half
     if (std::numeric_limits<Integer>::digits <= std::numeric_limits<std::uint32_t>::digits ||
-        value <= static_cast<Integer>((std::numeric_limits<std::uint32_t>::max)()))
+        unsigned_value <= static_cast<Integer>((std::numeric_limits<std::uint32_t>::max)()))
     {
-        const auto converted_value = static_cast<std::uint32_t>(value);
+        const auto converted_value = static_cast<std::uint32_t>(unsigned_value);
         converted_value_digits = num_digits(converted_value);
 
         if (converted_value_digits > user_buffer_size)
@@ -152,9 +163,9 @@ BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char
         boost::charconv::detail::memcpy(first, buffer + (sizeof(buffer) - converted_value_digits), converted_value_digits);
     }
     else if (std::numeric_limits<Integer>::digits <= std::numeric_limits<std::uint64_t>::digits ||
-             static_cast<std::uint64_t>(value) <= (std::numeric_limits<std::uint64_t>::max)())
+             static_cast<std::uint64_t>(unsigned_value) <= (std::numeric_limits<std::uint64_t>::max)())
     {
-        auto converted_value = static_cast<std::uint64_t>(value);
+        auto converted_value = static_cast<std::uint64_t>(unsigned_value);
         converted_value_digits = num_digits(converted_value);
 
         if (converted_value_digits > user_buffer_size)
diff --git a/test/to_chars.cpp b/test/to_chars.cpp
index 68fdbc2..ee5b1d5 100644
--- a/test/to_chars.cpp
+++ b/test/to_chars.cpp
@@ -11,6 +11,16 @@
 #include <cstring>
 #include <cerrno>
 
+template <typename T>
+void specific_value_tests(T value)
+{
+    char buffer[64] {};
+    auto r = boost::charconv::to_chars(buffer, buffer + sizeof(buffer) - 1, value);
+    BOOST_TEST_EQ(r.ec, 0);
+    std::string value_string = std::to_string(value);
+    BOOST_TEST_CSTR_EQ(buffer, value_string.c_str());
+}
+
 void off_by_one_tests(int value)
 {
     char buffer[64] {};
@@ -173,6 +183,7 @@ void simple_test()
 
 int main()
 {
+    
     simple_test<char>();
     simple_test<signed char>();
     simple_test<unsigned char>();
@@ -226,5 +237,9 @@ int main()
     off_by_one_tests(-1065658613);
     off_by_one_tests(-1027205339);
 
+    // Fails in CI at the time - Likely overflow when converting to positive
+    specific_value_tests<short>(-32768);
+    specific_value_tests<long>(-7061872404794389355);
+
     return boost::report_errors();
 }
diff --git a/test/to_chars_integer_STL_comp.cpp b/test/to_chars_integer_STL_comp.cpp
index 95589ff..19a613c 100644
--- a/test/to_chars_integer_STL_comp.cpp
+++ b/test/to_chars_integer_STL_comp.cpp
@@ -176,6 +176,8 @@ int main()
     random_tests<int, 16>();
     random_tests<int, 32>();
 
+    random_tests<std::int8_t, 10>();
+    random_tests<std::uint8_t, 10>();
     random_tests<std::int16_t, 10>();
     random_tests<std::uint16_t, 10>();
     random_tests<std::int32_t, 10>();

From a27c11a3d40e1b2051f308a6db2b125b3f843086 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Thu, 2 Feb 2023 12:09:17 -0800
Subject: [PATCH 58/63] Fix sign comparison

---
 include/boost/charconv/to_chars.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/boost/charconv/to_chars.hpp b/include/boost/charconv/to_chars.hpp
index c1d2291..b720966 100644
--- a/include/boost/charconv/to_chars.hpp
+++ b/include/boost/charconv/to_chars.hpp
@@ -143,7 +143,7 @@ BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars_integer_impl(char* first, char
     // Yields: warning C4127: conditional expression is constant becuase first half of the expression is constant
     // but we need to short circuit to avoid UB on the second half
     if (std::numeric_limits<Integer>::digits <= std::numeric_limits<std::uint32_t>::digits ||
-        unsigned_value <= static_cast<Integer>((std::numeric_limits<std::uint32_t>::max)()))
+        unsigned_value <= static_cast<Unsigned_Integer>((std::numeric_limits<std::uint32_t>::max)()))
     {
         const auto converted_value = static_cast<std::uint32_t>(unsigned_value);
         converted_value_digits = num_digits(converted_value);

From c71084d46d78ac46281b42443c5f73ec80819437 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Fri, 3 Feb 2023 09:05:52 -0800
Subject: [PATCH 59/63] Add literal to fix MSVC test errors

---
 test/to_chars.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/to_chars.cpp b/test/to_chars.cpp
index ee5b1d5..407a15f 100644
--- a/test/to_chars.cpp
+++ b/test/to_chars.cpp
@@ -239,7 +239,7 @@ int main()
 
     // Fails in CI at the time - Likely overflow when converting to positive
     specific_value_tests<short>(-32768);
-    specific_value_tests<long>(-7061872404794389355);
+    specific_value_tests(-7061872404794389355L);
 
     return boost::report_errors();
 }

From c9376c89bfe35e64da9e2af2440d456867ad61cb Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Fri, 3 Feb 2023 09:29:56 -0800
Subject: [PATCH 60/63] Disable random 8-bit int tests on MSVC

---
 test/to_chars_integer_STL_comp.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/test/to_chars_integer_STL_comp.cpp b/test/to_chars_integer_STL_comp.cpp
index 19a613c..89cdc11 100644
--- a/test/to_chars_integer_STL_comp.cpp
+++ b/test/to_chars_integer_STL_comp.cpp
@@ -176,8 +176,11 @@ int main()
     random_tests<int, 16>();
     random_tests<int, 32>();
 
+    #ifndef _MSC_VER // MSVC does not allow for 8-bit ints in std::uniform_int_distribution
     random_tests<std::int8_t, 10>();
     random_tests<std::uint8_t, 10>();
+    #endif
+
     random_tests<std::int16_t, 10>();
     random_tests<std::uint16_t, 10>();
     random_tests<std::int32_t, 10>();

From 7934db5eb113dd6c4febb13b7666a21503dfd2ff Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Fri, 3 Feb 2023 10:56:49 -0800
Subject: [PATCH 61/63] Ignore GCC10+ memcpy overflow warning

---
 include/boost/charconv/detail/memcpy.hpp | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/include/boost/charconv/detail/memcpy.hpp b/include/boost/charconv/detail/memcpy.hpp
index aebf1b7..15ec0aa 100644
--- a/include/boost/charconv/detail/memcpy.hpp
+++ b/include/boost/charconv/detail/memcpy.hpp
@@ -9,6 +9,19 @@
 #include <cstring>
 #include <cstdint>
 
+// GCC 10 added checks for length of memcpy which yields the following warning (converted to error with -Werror)
+// /usr/include/x86_64-linux-gnu/bits/string_fortified.h:34:33: error: 
+// ‘void* __builtin___memcpy_chk(void*, const void*, long unsigned int, long unsigned int)’ specified size between 
+// 18446744071562067968 and 18446744073709551615 exceeds maximum object size 9223372036854775807 [-Werror=stringop-overflow=]
+//
+// memcpy is defined as taking a size_t for the count and the largest count this will recieve is the number of digits
+// in a 128-bit int (39) so we can safely ignore
+#if __GNUC__ >= 10
+#  pragma GCC diagnostic push
+#  pragma GCC diagnostic ignored "-Wstringop-overflow"
+#  define BOOST_CHARCONV_STRINGOP_OVERFLOW_DISABLED
+#endif
+
 namespace boost { namespace charconv { namespace detail {
 
 #if !defined(BOOST_CHARCONV_NO_CONSTEXPR_DETECTION) && defined(BOOST_CXX14_CONSTEXPR)
@@ -45,4 +58,8 @@ inline void* memcpy(void* dest, const void* src, std::size_t count)
 
 }}} // Namespace boost::charconv::detail
 
+#ifdef BOOST_CHARCONV_STRINGOP_OVERFLOW_DISABLED
+#  pragma GCC diagnostic pop
+#endif
+
 #endif // BOOST_CHARCONV_DETAIL_MEMCPY_HPP

From d46e8fc7a96c726743b588fdc782187607c7b007 Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Fri, 3 Feb 2023 11:54:45 -0800
Subject: [PATCH 62/63] Remove HTML

[ci skip]
---
 doc/charconv.html | 1129 ---------------------------------------------
 1 file changed, 1129 deletions(-)
 delete mode 100644 doc/charconv.html

diff --git a/doc/charconv.html b/doc/charconv.html
deleted file mode 100644
index ae6fbb7..0000000
--- a/doc/charconv.html
+++ /dev/null
@@ -1,1129 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-<meta charset="UTF-8">
-<meta http-equiv="X-UA-Compatible" content="IE=edge">
-<meta name="viewport" content="width=device-width, initial-scale=1.0">
-<meta name="generator" content="Asciidoctor 2.0.18">
-<meta name="author" content="Peter Dimov and Matt Borland">
-<title>CharConv: An Implementation of &lt;charconv&gt; in C&#43;&#43;11</title>
-<link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400,700">
-<style>
-/*! Asciidoctor default stylesheet | MIT License | https://asciidoctor.org */
-/* Uncomment the following line when using as a custom stylesheet */
-/* @import "https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400,700"; */
-html{font-family:sans-serif;-webkit-text-size-adjust:100%}
-a{background:none}
-a:focus{outline:thin dotted}
-a:active,a:hover{outline:0}
-h1{font-size:2em;margin:.67em 0}
-b,strong{font-weight:bold}
-abbr{font-size:.9em}
-abbr[title]{cursor:help;border-bottom:1px dotted #dddddf;text-decoration:none}
-dfn{font-style:italic}
-hr{height:0}
-mark{background:#ff0;color:#000}
-code,kbd,pre,samp{font-family:monospace;font-size:1em}
-pre{white-space:pre-wrap}
-q{quotes:"\201C" "\201D" "\2018" "\2019"}
-small{font-size:80%}
-sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}
-sup{top:-.5em}
-sub{bottom:-.25em}
-img{border:0}
-svg:not(:root){overflow:hidden}
-figure{margin:0}
-audio,video{display:inline-block}
-audio:not([controls]){display:none;height:0}
-fieldset{border:1px solid silver;margin:0 2px;padding:.35em .625em .75em}
-legend{border:0;padding:0}
-button,input,select,textarea{font-family:inherit;font-size:100%;margin:0}
-button,input{line-height:normal}
-button,select{text-transform:none}
-button,html input[type=button],input[type=reset],input[type=submit]{-webkit-appearance:button;cursor:pointer}
-button[disabled],html input[disabled]{cursor:default}
-input[type=checkbox],input[type=radio]{padding:0}
-button::-moz-focus-inner,input::-moz-focus-inner{border:0;padding:0}
-textarea{overflow:auto;vertical-align:top}
-table{border-collapse:collapse;border-spacing:0}
-*,::before,::after{box-sizing:border-box}
-html,body{font-size:100%}
-body{background:#fff;color:rgba(0,0,0,.8);padding:0;margin:0;font-family:"Noto Serif","DejaVu Serif",serif;line-height:1;position:relative;cursor:auto;-moz-tab-size:4;-o-tab-size:4;tab-size:4;word-wrap:anywhere;-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased}
-a:hover{cursor:pointer}
-img,object,embed{max-width:100%;height:auto}
-object,embed{height:100%}
-img{-ms-interpolation-mode:bicubic}
-.left{float:left!important}
-.right{float:right!important}
-.text-left{text-align:left!important}
-.text-right{text-align:right!important}
-.text-center{text-align:center!important}
-.text-justify{text-align:justify!important}
-.hide{display:none}
-img,object,svg{display:inline-block;vertical-align:middle}
-textarea{height:auto;min-height:50px}
-select{width:100%}
-.subheader,.admonitionblock td.content>.title,.audioblock>.title,.exampleblock>.title,.imageblock>.title,.listingblock>.title,.literalblock>.title,.stemblock>.title,.openblock>.title,.paragraph>.title,.quoteblock>.title,table.tableblock>.title,.verseblock>.title,.videoblock>.title,.dlist>.title,.olist>.title,.ulist>.title,.qlist>.title,.hdlist>.title{line-height:1.45;color:#7a2518;font-weight:400;margin-top:0;margin-bottom:.25em}
-div,dl,dt,dd,ul,ol,li,h1,h2,h3,#toctitle,.sidebarblock>.content>.title,h4,h5,h6,pre,form,p,blockquote,th,td{margin:0;padding:0}
-a{color:#2156a5;text-decoration:underline;line-height:inherit}
-a:hover,a:focus{color:#1d4b8f}
-a img{border:0}
-p{line-height:1.6;margin-bottom:1.25em;text-rendering:optimizeLegibility}
-p aside{font-size:.875em;line-height:1.35;font-style:italic}
-h1,h2,h3,#toctitle,.sidebarblock>.content>.title,h4,h5,h6{font-family:"Open Sans","DejaVu Sans",sans-serif;font-weight:300;font-style:normal;color:#ba3925;text-rendering:optimizeLegibility;margin-top:1em;margin-bottom:.5em;line-height:1.0125em}
-h1 small,h2 small,h3 small,#toctitle small,.sidebarblock>.content>.title small,h4 small,h5 small,h6 small{font-size:60%;color:#e99b8f;line-height:0}
-h1{font-size:2.125em}
-h2{font-size:1.6875em}
-h3,#toctitle,.sidebarblock>.content>.title{font-size:1.375em}
-h4,h5{font-size:1.125em}
-h6{font-size:1em}
-hr{border:solid #dddddf;border-width:1px 0 0;clear:both;margin:1.25em 0 1.1875em}
-em,i{font-style:italic;line-height:inherit}
-strong,b{font-weight:bold;line-height:inherit}
-small{font-size:60%;line-height:inherit}
-code{font-family:"Droid Sans Mono","DejaVu Sans Mono",monospace;font-weight:400;color:rgba(0,0,0,.9)}
-ul,ol,dl{line-height:1.6;margin-bottom:1.25em;list-style-position:outside;font-family:inherit}
-ul,ol{margin-left:1.5em}
-ul li ul,ul li ol{margin-left:1.25em;margin-bottom:0}
-ul.circle{list-style-type:circle}
-ul.disc{list-style-type:disc}
-ul.square{list-style-type:square}
-ul.circle ul:not([class]),ul.disc ul:not([class]),ul.square ul:not([class]){list-style:inherit}
-ol li ul,ol li ol{margin-left:1.25em;margin-bottom:0}
-dl dt{margin-bottom:.3125em;font-weight:bold}
-dl dd{margin-bottom:1.25em}
-blockquote{margin:0 0 1.25em;padding:.5625em 1.25em 0 1.1875em;border-left:1px solid #ddd}
-blockquote,blockquote p{line-height:1.6;color:rgba(0,0,0,.85)}
-@media screen and (min-width:768px){h1,h2,h3,#toctitle,.sidebarblock>.content>.title,h4,h5,h6{line-height:1.2}
-h1{font-size:2.75em}
-h2{font-size:2.3125em}
-h3,#toctitle,.sidebarblock>.content>.title{font-size:1.6875em}
-h4{font-size:1.4375em}}
-table{background:#fff;margin-bottom:1.25em;border:1px solid #dedede;word-wrap:normal}
-table thead,table tfoot{background:#f7f8f7}
-table thead tr th,table thead tr td,table tfoot tr th,table tfoot tr td{padding:.5em .625em .625em;font-size:inherit;color:rgba(0,0,0,.8);text-align:left}
-table tr th,table tr td{padding:.5625em .625em;font-size:inherit;color:rgba(0,0,0,.8)}
-table tr.even,table tr.alt{background:#f8f8f7}
-table thead tr th,table tfoot tr th,table tbody tr td,table tr td,table tfoot tr td{line-height:1.6}
-h1,h2,h3,#toctitle,.sidebarblock>.content>.title,h4,h5,h6{line-height:1.2;word-spacing:-.05em}
-h1 strong,h2 strong,h3 strong,#toctitle strong,.sidebarblock>.content>.title strong,h4 strong,h5 strong,h6 strong{font-weight:400}
-.center{margin-left:auto;margin-right:auto}
-.stretch{width:100%}
-.clearfix::before,.clearfix::after,.float-group::before,.float-group::after{content:" ";display:table}
-.clearfix::after,.float-group::after{clear:both}
-:not(pre).nobreak{word-wrap:normal}
-:not(pre).nowrap{white-space:nowrap}
-:not(pre).pre-wrap{white-space:pre-wrap}
-:not(pre):not([class^=L])>code{font-size:.9375em;font-style:normal!important;letter-spacing:0;padding:.1em .5ex;word-spacing:-.15em;background:#f7f7f8;border-radius:4px;line-height:1.45;text-rendering:optimizeSpeed}
-pre{color:rgba(0,0,0,.9);font-family:"Droid Sans Mono","DejaVu Sans Mono",monospace;line-height:1.45;text-rendering:optimizeSpeed}
-pre code,pre pre{color:inherit;font-size:inherit;line-height:inherit}
-pre>code{display:block}
-pre.nowrap,pre.nowrap pre{white-space:pre;word-wrap:normal}
-em em{font-style:normal}
-strong strong{font-weight:400}
-.keyseq{color:rgba(51,51,51,.8)}
-kbd{font-family:"Droid Sans Mono","DejaVu Sans Mono",monospace;display:inline-block;color:rgba(0,0,0,.8);font-size:.65em;line-height:1.45;background:#f7f7f7;border:1px solid #ccc;border-radius:3px;box-shadow:0 1px 0 rgba(0,0,0,.2),inset 0 0 0 .1em #fff;margin:0 .15em;padding:.2em .5em;vertical-align:middle;position:relative;top:-.1em;white-space:nowrap}
-.keyseq kbd:first-child{margin-left:0}
-.keyseq kbd:last-child{margin-right:0}
-.menuseq,.menuref{color:#000}
-.menuseq b:not(.caret),.menuref{font-weight:inherit}
-.menuseq{word-spacing:-.02em}
-.menuseq b.caret{font-size:1.25em;line-height:.8}
-.menuseq i.caret{font-weight:bold;text-align:center;width:.45em}
-b.button::before,b.button::after{position:relative;top:-1px;font-weight:400}
-b.button::before{content:"[";padding:0 3px 0 2px}
-b.button::after{content:"]";padding:0 2px 0 3px}
-p a>code:hover{color:rgba(0,0,0,.9)}
-#header,#content,#footnotes,#footer{width:100%;margin:0 auto;max-width:62.5em;*zoom:1;position:relative;padding-left:.9375em;padding-right:.9375em}
-#header::before,#header::after,#content::before,#content::after,#footnotes::before,#footnotes::after,#footer::before,#footer::after{content:" ";display:table}
-#header::after,#content::after,#footnotes::after,#footer::after{clear:both}
-#content{margin-top:1.25em}
-#content::before{content:none}
-#header>h1:first-child{color:rgba(0,0,0,.85);margin-top:2.25rem;margin-bottom:0}
-#header>h1:first-child+#toc{margin-top:8px;border-top:1px solid #dddddf}
-#header>h1:only-child,body.toc2 #header>h1:nth-last-child(2){border-bottom:1px solid #dddddf;padding-bottom:8px}
-#header .details{border-bottom:1px solid #dddddf;line-height:1.45;padding-top:.25em;padding-bottom:.25em;padding-left:.25em;color:rgba(0,0,0,.6);display:flex;flex-flow:row wrap}
-#header .details span:first-child{margin-left:-.125em}
-#header .details span.email a{color:rgba(0,0,0,.85)}
-#header .details br{display:none}
-#header .details br+span::before{content:"\00a0\2013\00a0"}
-#header .details br+span.author::before{content:"\00a0\22c5\00a0";color:rgba(0,0,0,.85)}
-#header .details br+span#revremark::before{content:"\00a0|\00a0"}
-#header #revnumber{text-transform:capitalize}
-#header #revnumber::after{content:"\00a0"}
-#content>h1:first-child:not([class]){color:rgba(0,0,0,.85);border-bottom:1px solid #dddddf;padding-bottom:8px;margin-top:0;padding-top:1rem;margin-bottom:1.25rem}
-#toc{border-bottom:1px solid #e7e7e9;padding-bottom:.5em}
-#toc>ul{margin-left:.125em}
-#toc ul.sectlevel0>li>a{font-style:italic}
-#toc ul.sectlevel0 ul.sectlevel1{margin:.5em 0}
-#toc ul{font-family:"Open Sans","DejaVu Sans",sans-serif;list-style-type:none}
-#toc li{line-height:1.3334;margin-top:.3334em}
-#toc a{text-decoration:none}
-#toc a:active{text-decoration:underline}
-#toctitle{color:#7a2518;font-size:1.2em}
-@media screen and (min-width:768px){#toctitle{font-size:1.375em}
-body.toc2{padding-left:15em;padding-right:0}
-#toc.toc2{margin-top:0!important;background:#f8f8f7;position:fixed;width:15em;left:0;top:0;border-right:1px solid #e7e7e9;border-top-width:0!important;border-bottom-width:0!important;z-index:1000;padding:1.25em 1em;height:100%;overflow:auto}
-#toc.toc2 #toctitle{margin-top:0;margin-bottom:.8rem;font-size:1.2em}
-#toc.toc2>ul{font-size:.9em;margin-bottom:0}
-#toc.toc2 ul ul{margin-left:0;padding-left:1em}
-#toc.toc2 ul.sectlevel0 ul.sectlevel1{padding-left:0;margin-top:.5em;margin-bottom:.5em}
-body.toc2.toc-right{padding-left:0;padding-right:15em}
-body.toc2.toc-right #toc.toc2{border-right-width:0;border-left:1px solid #e7e7e9;left:auto;right:0}}
-@media screen and (min-width:1280px){body.toc2{padding-left:20em;padding-right:0}
-#toc.toc2{width:20em}
-#toc.toc2 #toctitle{font-size:1.375em}
-#toc.toc2>ul{font-size:.95em}
-#toc.toc2 ul ul{padding-left:1.25em}
-body.toc2.toc-right{padding-left:0;padding-right:20em}}
-#content #toc{border:1px solid #e0e0dc;margin-bottom:1.25em;padding:1.25em;background:#f8f8f7;border-radius:4px}
-#content #toc>:first-child{margin-top:0}
-#content #toc>:last-child{margin-bottom:0}
-#footer{max-width:none;background:rgba(0,0,0,.8);padding:1.25em}
-#footer-text{color:hsla(0,0%,100%,.8);line-height:1.44}
-#content{margin-bottom:.625em}
-.sect1{padding-bottom:.625em}
-@media screen and (min-width:768px){#content{margin-bottom:1.25em}
-.sect1{padding-bottom:1.25em}}
-.sect1:last-child{padding-bottom:0}
-.sect1+.sect1{border-top:1px solid #e7e7e9}
-#content h1>a.anchor,h2>a.anchor,h3>a.anchor,#toctitle>a.anchor,.sidebarblock>.content>.title>a.anchor,h4>a.anchor,h5>a.anchor,h6>a.anchor{position:absolute;z-index:1001;width:1.5ex;margin-left:-1.5ex;display:block;text-decoration:none!important;visibility:hidden;text-align:center;font-weight:400}
-#content h1>a.anchor::before,h2>a.anchor::before,h3>a.anchor::before,#toctitle>a.anchor::before,.sidebarblock>.content>.title>a.anchor::before,h4>a.anchor::before,h5>a.anchor::before,h6>a.anchor::before{content:"\00A7";font-size:.85em;display:block;padding-top:.1em}
-#content h1:hover>a.anchor,#content h1>a.anchor:hover,h2:hover>a.anchor,h2>a.anchor:hover,h3:hover>a.anchor,#toctitle:hover>a.anchor,.sidebarblock>.content>.title:hover>a.anchor,h3>a.anchor:hover,#toctitle>a.anchor:hover,.sidebarblock>.content>.title>a.anchor:hover,h4:hover>a.anchor,h4>a.anchor:hover,h5:hover>a.anchor,h5>a.anchor:hover,h6:hover>a.anchor,h6>a.anchor:hover{visibility:visible}
-#content h1>a.link,h2>a.link,h3>a.link,#toctitle>a.link,.sidebarblock>.content>.title>a.link,h4>a.link,h5>a.link,h6>a.link{color:#ba3925;text-decoration:none}
-#content h1>a.link:hover,h2>a.link:hover,h3>a.link:hover,#toctitle>a.link:hover,.sidebarblock>.content>.title>a.link:hover,h4>a.link:hover,h5>a.link:hover,h6>a.link:hover{color:#a53221}
-details,.audioblock,.imageblock,.literalblock,.listingblock,.stemblock,.videoblock{margin-bottom:1.25em}
-details{margin-left:1.25rem}
-details>summary{cursor:pointer;display:block;position:relative;line-height:1.6;margin-bottom:.625rem;outline:none;-webkit-tap-highlight-color:transparent}
-details>summary::-webkit-details-marker{display:none}
-details>summary::before{content:"";border:solid transparent;border-left:solid;border-width:.3em 0 .3em .5em;position:absolute;top:.5em;left:-1.25rem;transform:translateX(15%)}
-details[open]>summary::before{border:solid transparent;border-top:solid;border-width:.5em .3em 0;transform:translateY(15%)}
-details>summary::after{content:"";width:1.25rem;height:1em;position:absolute;top:.3em;left:-1.25rem}
-.admonitionblock td.content>.title,.audioblock>.title,.exampleblock>.title,.imageblock>.title,.listingblock>.title,.literalblock>.title,.stemblock>.title,.openblock>.title,.paragraph>.title,.quoteblock>.title,table.tableblock>.title,.verseblock>.title,.videoblock>.title,.dlist>.title,.olist>.title,.ulist>.title,.qlist>.title,.hdlist>.title{text-rendering:optimizeLegibility;text-align:left;font-family:"Noto Serif","DejaVu Serif",serif;font-size:1rem;font-style:italic}
-table.tableblock.fit-content>caption.title{white-space:nowrap;width:0}
-.paragraph.lead>p,#preamble>.sectionbody>[class=paragraph]:first-of-type p{font-size:1.21875em;line-height:1.6;color:rgba(0,0,0,.85)}
-.admonitionblock>table{border-collapse:separate;border:0;background:none;width:100%}
-.admonitionblock>table td.icon{text-align:center;width:80px}
-.admonitionblock>table td.icon img{max-width:none}
-.admonitionblock>table td.icon .title{font-weight:bold;font-family:"Open Sans","DejaVu Sans",sans-serif;text-transform:uppercase}
-.admonitionblock>table td.content{padding-left:1.125em;padding-right:1.25em;border-left:1px solid #dddddf;color:rgba(0,0,0,.6);word-wrap:anywhere}
-.admonitionblock>table td.content>:last-child>:last-child{margin-bottom:0}
-.exampleblock>.content{border:1px solid #e6e6e6;margin-bottom:1.25em;padding:1.25em;background:#fff;border-radius:4px}
-.exampleblock>.content>:first-child{margin-top:0}
-.exampleblock>.content>:last-child{margin-bottom:0}
-.sidebarblock{border:1px solid #dbdbd6;margin-bottom:1.25em;padding:1.25em;background:#f3f3f2;border-radius:4px}
-.sidebarblock>:first-child{margin-top:0}
-.sidebarblock>:last-child{margin-bottom:0}
-.sidebarblock>.content>.title{color:#7a2518;margin-top:0;text-align:center}
-.exampleblock>.content>:last-child>:last-child,.exampleblock>.content .olist>ol>li:last-child>:last-child,.exampleblock>.content .ulist>ul>li:last-child>:last-child,.exampleblock>.content .qlist>ol>li:last-child>:last-child,.sidebarblock>.content>:last-child>:last-child,.sidebarblock>.content .olist>ol>li:last-child>:last-child,.sidebarblock>.content .ulist>ul>li:last-child>:last-child,.sidebarblock>.content .qlist>ol>li:last-child>:last-child{margin-bottom:0}
-.literalblock pre,.listingblock>.content>pre{border-radius:4px;overflow-x:auto;padding:1em;font-size:.8125em}
-@media screen and (min-width:768px){.literalblock pre,.listingblock>.content>pre{font-size:.90625em}}
-@media screen and (min-width:1280px){.literalblock pre,.listingblock>.content>pre{font-size:1em}}
-.literalblock pre,.listingblock>.content>pre:not(.highlight),.listingblock>.content>pre[class=highlight],.listingblock>.content>pre[class^="highlight "]{background:#f7f7f8}
-.literalblock.output pre{color:#f7f7f8;background:rgba(0,0,0,.9)}
-.listingblock>.content{position:relative}
-.listingblock code[data-lang]::before{display:none;content:attr(data-lang);position:absolute;font-size:.75em;top:.425rem;right:.5rem;line-height:1;text-transform:uppercase;color:inherit;opacity:.5}
-.listingblock:hover code[data-lang]::before{display:block}
-.listingblock.terminal pre .command::before{content:attr(data-prompt);padding-right:.5em;color:inherit;opacity:.5}
-.listingblock.terminal pre .command:not([data-prompt])::before{content:"$"}
-.listingblock pre.highlightjs{padding:0}
-.listingblock pre.highlightjs>code{padding:1em;border-radius:4px}
-.listingblock pre.prettyprint{border-width:0}
-.prettyprint{background:#f7f7f8}
-pre.prettyprint .linenums{line-height:1.45;margin-left:2em}
-pre.prettyprint li{background:none;list-style-type:inherit;padding-left:0}
-pre.prettyprint li code[data-lang]::before{opacity:1}
-pre.prettyprint li:not(:first-child) code[data-lang]::before{display:none}
-table.linenotable{border-collapse:separate;border:0;margin-bottom:0;background:none}
-table.linenotable td[class]{color:inherit;vertical-align:top;padding:0;line-height:inherit;white-space:normal}
-table.linenotable td.code{padding-left:.75em}
-table.linenotable td.linenos,pre.pygments .linenos{border-right:1px solid;opacity:.35;padding-right:.5em;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none}
-pre.pygments span.linenos{display:inline-block;margin-right:.75em}
-.quoteblock{margin:0 1em 1.25em 1.5em;display:table}
-.quoteblock:not(.excerpt)>.title{margin-left:-1.5em;margin-bottom:.75em}
-.quoteblock blockquote,.quoteblock p{color:rgba(0,0,0,.85);font-size:1.15rem;line-height:1.75;word-spacing:.1em;letter-spacing:0;font-style:italic;text-align:justify}
-.quoteblock blockquote{margin:0;padding:0;border:0}
-.quoteblock blockquote::before{content:"\201c";float:left;font-size:2.75em;font-weight:bold;line-height:.6em;margin-left:-.6em;color:#7a2518;text-shadow:0 1px 2px rgba(0,0,0,.1)}
-.quoteblock blockquote>.paragraph:last-child p{margin-bottom:0}
-.quoteblock .attribution{margin-top:.75em;margin-right:.5ex;text-align:right}
-.verseblock{margin:0 1em 1.25em}
-.verseblock pre{font-family:"Open Sans","DejaVu Sans",sans-serif;font-size:1.15rem;color:rgba(0,0,0,.85);font-weight:300;text-rendering:optimizeLegibility}
-.verseblock pre strong{font-weight:400}
-.verseblock .attribution{margin-top:1.25rem;margin-left:.5ex}
-.quoteblock .attribution,.verseblock .attribution{font-size:.9375em;line-height:1.45;font-style:italic}
-.quoteblock .attribution br,.verseblock .attribution br{display:none}
-.quoteblock .attribution cite,.verseblock .attribution cite{display:block;letter-spacing:-.025em;color:rgba(0,0,0,.6)}
-.quoteblock.abstract blockquote::before,.quoteblock.excerpt blockquote::before,.quoteblock .quoteblock blockquote::before{display:none}
-.quoteblock.abstract blockquote,.quoteblock.abstract p,.quoteblock.excerpt blockquote,.quoteblock.excerpt p,.quoteblock .quoteblock blockquote,.quoteblock .quoteblock p{line-height:1.6;word-spacing:0}
-.quoteblock.abstract{margin:0 1em 1.25em;display:block}
-.quoteblock.abstract>.title{margin:0 0 .375em;font-size:1.15em;text-align:center}
-.quoteblock.excerpt>blockquote,.quoteblock .quoteblock{padding:0 0 .25em 1em;border-left:.25em solid #dddddf}
-.quoteblock.excerpt,.quoteblock .quoteblock{margin-left:0}
-.quoteblock.excerpt blockquote,.quoteblock.excerpt p,.quoteblock .quoteblock blockquote,.quoteblock .quoteblock p{color:inherit;font-size:1.0625rem}
-.quoteblock.excerpt .attribution,.quoteblock .quoteblock .attribution{color:inherit;font-size:.85rem;text-align:left;margin-right:0}
-p.tableblock:last-child{margin-bottom:0}
-td.tableblock>.content{margin-bottom:1.25em;word-wrap:anywhere}
-td.tableblock>.content>:last-child{margin-bottom:-1.25em}
-table.tableblock,th.tableblock,td.tableblock{border:0 solid #dedede}
-table.grid-all>*>tr>*{border-width:1px}
-table.grid-cols>*>tr>*{border-width:0 1px}
-table.grid-rows>*>tr>*{border-width:1px 0}
-table.frame-all{border-width:1px}
-table.frame-ends{border-width:1px 0}
-table.frame-sides{border-width:0 1px}
-table.frame-none>colgroup+*>:first-child>*,table.frame-sides>colgroup+*>:first-child>*{border-top-width:0}
-table.frame-none>:last-child>:last-child>*,table.frame-sides>:last-child>:last-child>*{border-bottom-width:0}
-table.frame-none>*>tr>:first-child,table.frame-ends>*>tr>:first-child{border-left-width:0}
-table.frame-none>*>tr>:last-child,table.frame-ends>*>tr>:last-child{border-right-width:0}
-table.stripes-all>*>tr,table.stripes-odd>*>tr:nth-of-type(odd),table.stripes-even>*>tr:nth-of-type(even),table.stripes-hover>*>tr:hover{background:#f8f8f7}
-th.halign-left,td.halign-left{text-align:left}
-th.halign-right,td.halign-right{text-align:right}
-th.halign-center,td.halign-center{text-align:center}
-th.valign-top,td.valign-top{vertical-align:top}
-th.valign-bottom,td.valign-bottom{vertical-align:bottom}
-th.valign-middle,td.valign-middle{vertical-align:middle}
-table thead th,table tfoot th{font-weight:bold}
-tbody tr th{background:#f7f8f7}
-tbody tr th,tbody tr th p,tfoot tr th,tfoot tr th p{color:rgba(0,0,0,.8);font-weight:bold}
-p.tableblock>code:only-child{background:none;padding:0}
-p.tableblock{font-size:1em}
-ol{margin-left:1.75em}
-ul li ol{margin-left:1.5em}
-dl dd{margin-left:1.125em}
-dl dd:last-child,dl dd:last-child>:last-child{margin-bottom:0}
-li p,ul dd,ol dd,.olist .olist,.ulist .ulist,.ulist .olist,.olist .ulist{margin-bottom:.625em}
-ul.checklist,ul.none,ol.none,ul.no-bullet,ol.no-bullet,ol.unnumbered,ul.unstyled,ol.unstyled{list-style-type:none}
-ul.no-bullet,ol.no-bullet,ol.unnumbered{margin-left:.625em}
-ul.unstyled,ol.unstyled{margin-left:0}
-li>p:empty:only-child::before{content:"";display:inline-block}
-ul.checklist>li>p:first-child{margin-left:-1em}
-ul.checklist>li>p:first-child>.fa-square-o:first-child,ul.checklist>li>p:first-child>.fa-check-square-o:first-child{width:1.25em;font-size:.8em;position:relative;bottom:.125em}
-ul.checklist>li>p:first-child>input[type=checkbox]:first-child{margin-right:.25em}
-ul.inline{display:flex;flex-flow:row wrap;list-style:none;margin:0 0 .625em -1.25em}
-ul.inline>li{margin-left:1.25em}
-.unstyled dl dt{font-weight:400;font-style:normal}
-ol.arabic{list-style-type:decimal}
-ol.decimal{list-style-type:decimal-leading-zero}
-ol.loweralpha{list-style-type:lower-alpha}
-ol.upperalpha{list-style-type:upper-alpha}
-ol.lowerroman{list-style-type:lower-roman}
-ol.upperroman{list-style-type:upper-roman}
-ol.lowergreek{list-style-type:lower-greek}
-.hdlist>table,.colist>table{border:0;background:none}
-.hdlist>table>tbody>tr,.colist>table>tbody>tr{background:none}
-td.hdlist1,td.hdlist2{vertical-align:top;padding:0 .625em}
-td.hdlist1{font-weight:bold;padding-bottom:1.25em}
-td.hdlist2{word-wrap:anywhere}
-.literalblock+.colist,.listingblock+.colist{margin-top:-.5em}
-.colist td:not([class]):first-child{padding:.4em .75em 0;line-height:1;vertical-align:top}
-.colist td:not([class]):first-child img{max-width:none}
-.colist td:not([class]):last-child{padding:.25em 0}
-.thumb,.th{line-height:0;display:inline-block;border:4px solid #fff;box-shadow:0 0 0 1px #ddd}
-.imageblock.left{margin:.25em .625em 1.25em 0}
-.imageblock.right{margin:.25em 0 1.25em .625em}
-.imageblock>.title{margin-bottom:0}
-.imageblock.thumb,.imageblock.th{border-width:6px}
-.imageblock.thumb>.title,.imageblock.th>.title{padding:0 .125em}
-.image.left,.image.right{margin-top:.25em;margin-bottom:.25em;display:inline-block;line-height:0}
-.image.left{margin-right:.625em}
-.image.right{margin-left:.625em}
-a.image{text-decoration:none;display:inline-block}
-a.image object{pointer-events:none}
-sup.footnote,sup.footnoteref{font-size:.875em;position:static;vertical-align:super}
-sup.footnote a,sup.footnoteref a{text-decoration:none}
-sup.footnote a:active,sup.footnoteref a:active{text-decoration:underline}
-#footnotes{padding-top:.75em;padding-bottom:.75em;margin-bottom:.625em}
-#footnotes hr{width:20%;min-width:6.25em;margin:-.25em 0 .75em;border-width:1px 0 0}
-#footnotes .footnote{padding:0 .375em 0 .225em;line-height:1.3334;font-size:.875em;margin-left:1.2em;margin-bottom:.2em}
-#footnotes .footnote a:first-of-type{font-weight:bold;text-decoration:none;margin-left:-1.05em}
-#footnotes .footnote:last-of-type{margin-bottom:0}
-#content #footnotes{margin-top:-.625em;margin-bottom:0;padding:.75em 0}
-div.unbreakable{page-break-inside:avoid}
-.big{font-size:larger}
-.small{font-size:smaller}
-.underline{text-decoration:underline}
-.overline{text-decoration:overline}
-.line-through{text-decoration:line-through}
-.aqua{color:#00bfbf}
-.aqua-background{background:#00fafa}
-.black{color:#000}
-.black-background{background:#000}
-.blue{color:#0000bf}
-.blue-background{background:#0000fa}
-.fuchsia{color:#bf00bf}
-.fuchsia-background{background:#fa00fa}
-.gray{color:#606060}
-.gray-background{background:#7d7d7d}
-.green{color:#006000}
-.green-background{background:#007d00}
-.lime{color:#00bf00}
-.lime-background{background:#00fa00}
-.maroon{color:#600000}
-.maroon-background{background:#7d0000}
-.navy{color:#000060}
-.navy-background{background:#00007d}
-.olive{color:#606000}
-.olive-background{background:#7d7d00}
-.purple{color:#600060}
-.purple-background{background:#7d007d}
-.red{color:#bf0000}
-.red-background{background:#fa0000}
-.silver{color:#909090}
-.silver-background{background:#bcbcbc}
-.teal{color:#006060}
-.teal-background{background:#007d7d}
-.white{color:#bfbfbf}
-.white-background{background:#fafafa}
-.yellow{color:#bfbf00}
-.yellow-background{background:#fafa00}
-span.icon>.fa{cursor:default}
-a span.icon>.fa{cursor:inherit}
-.admonitionblock td.icon [class^="fa icon-"]{font-size:2.5em;text-shadow:1px 1px 2px rgba(0,0,0,.5);cursor:default}
-.admonitionblock td.icon .icon-note::before{content:"\f05a";color:#19407c}
-.admonitionblock td.icon .icon-tip::before{content:"\f0eb";text-shadow:1px 1px 2px rgba(155,155,0,.8);color:#111}
-.admonitionblock td.icon .icon-warning::before{content:"\f071";color:#bf6900}
-.admonitionblock td.icon .icon-caution::before{content:"\f06d";color:#bf3400}
-.admonitionblock td.icon .icon-important::before{content:"\f06a";color:#bf0000}
-.conum[data-value]{display:inline-block;color:#fff!important;background:rgba(0,0,0,.8);border-radius:50%;text-align:center;font-size:.75em;width:1.67em;height:1.67em;line-height:1.67em;font-family:"Open Sans","DejaVu Sans",sans-serif;font-style:normal;font-weight:bold}
-.conum[data-value] *{color:#fff!important}
-.conum[data-value]+b{display:none}
-.conum[data-value]::after{content:attr(data-value)}
-pre .conum[data-value]{position:relative;top:-.125em}
-b.conum *{color:inherit!important}
-.conum:not([data-value]):empty{display:none}
-dt,th.tableblock,td.content,div.footnote{text-rendering:optimizeLegibility}
-h1,h2,p,td.content,span.alt,summary{letter-spacing:-.01em}
-p strong,td.content strong,div.footnote strong{letter-spacing:-.005em}
-p,blockquote,dt,td.content,span.alt,summary{font-size:1.0625rem}
-p{margin-bottom:1.25rem}
-.sidebarblock p,.sidebarblock dt,.sidebarblock td.content,p.tableblock{font-size:1em}
-.exampleblock>.content{background:#fffef7;border-color:#e0e0dc;box-shadow:0 1px 4px #e0e0dc}
-.print-only{display:none!important}
-@page{margin:1.25cm .75cm}
-@media print{*{box-shadow:none!important;text-shadow:none!important}
-html{font-size:80%}
-a{color:inherit!important;text-decoration:underline!important}
-a.bare,a[href^="#"],a[href^="mailto:"]{text-decoration:none!important}
-a[href^="http:"]:not(.bare)::after,a[href^="https:"]:not(.bare)::after{content:"(" attr(href) ")";display:inline-block;font-size:.875em;padding-left:.25em}
-abbr[title]{border-bottom:1px dotted}
-abbr[title]::after{content:" (" attr(title) ")"}
-pre,blockquote,tr,img,object,svg{page-break-inside:avoid}
-thead{display:table-header-group}
-svg{max-width:100%}
-p,blockquote,dt,td.content{font-size:1em;orphans:3;widows:3}
-h2,h3,#toctitle,.sidebarblock>.content>.title{page-break-after:avoid}
-#header,#content,#footnotes,#footer{max-width:none}
-#toc,.sidebarblock,.exampleblock>.content{background:none!important}
-#toc{border-bottom:1px solid #dddddf!important;padding-bottom:0!important}
-body.book #header{text-align:center}
-body.book #header>h1:first-child{border:0!important;margin:2.5em 0 1em}
-body.book #header .details{border:0!important;display:block;padding:0!important}
-body.book #header .details span:first-child{margin-left:0!important}
-body.book #header .details br{display:block}
-body.book #header .details br+span::before{content:none!important}
-body.book #toc{border:0!important;text-align:left!important;padding:0!important;margin:0!important}
-body.book #toc,body.book #preamble,body.book h1.sect0,body.book .sect1>h2{page-break-before:always}
-.listingblock code[data-lang]::before{display:block}
-#footer{padding:0 .9375em}
-.hide-on-print{display:none!important}
-.print-only{display:block!important}
-.hide-for-print{display:none!important}
-.show-for-print{display:inherit!important}}
-@media amzn-kf8,print{#header>h1:first-child{margin-top:1.25rem}
-.sect1{padding:0!important}
-.sect1+.sect1{border:0}
-#footer{background:none}
-#footer-text{color:rgba(0,0,0,.6);font-size:.9em}}
-@media amzn-kf8{#header,#content,#footnotes,#footer{padding:0}}
-</style>
-<style>
-pre.rouge table td { padding: 5px; }
-pre.rouge table pre { margin: 0; }
-pre.rouge .cm {
-  color: #999988;
-  font-style: italic;
-}
-pre.rouge .cp {
-  color: #999999;
-  font-weight: bold;
-}
-pre.rouge .c1 {
-  color: #999988;
-  font-style: italic;
-}
-pre.rouge .cs {
-  color: #999999;
-  font-weight: bold;
-  font-style: italic;
-}
-pre.rouge .c, pre.rouge .ch, pre.rouge .cd, pre.rouge .cpf {
-  color: #999988;
-  font-style: italic;
-}
-pre.rouge .err {
-  color: #a61717;
-  background-color: #e3d2d2;
-}
-pre.rouge .gd {
-  color: #000000;
-  background-color: #ffdddd;
-}
-pre.rouge .ge {
-  color: #000000;
-  font-style: italic;
-}
-pre.rouge .gr {
-  color: #aa0000;
-}
-pre.rouge .gh {
-  color: #999999;
-}
-pre.rouge .gi {
-  color: #000000;
-  background-color: #ddffdd;
-}
-pre.rouge .go {
-  color: #888888;
-}
-pre.rouge .gp {
-  color: #555555;
-}
-pre.rouge .gs {
-  font-weight: bold;
-}
-pre.rouge .gu {
-  color: #aaaaaa;
-}
-pre.rouge .gt {
-  color: #aa0000;
-}
-pre.rouge .kc {
-  color: #000000;
-  font-weight: bold;
-}
-pre.rouge .kd {
-  color: #000000;
-  font-weight: bold;
-}
-pre.rouge .kn {
-  color: #000000;
-  font-weight: bold;
-}
-pre.rouge .kp {
-  color: #000000;
-  font-weight: bold;
-}
-pre.rouge .kr {
-  color: #000000;
-  font-weight: bold;
-}
-pre.rouge .kt {
-  color: #445588;
-  font-weight: bold;
-}
-pre.rouge .k, pre.rouge .kv {
-  color: #000000;
-  font-weight: bold;
-}
-pre.rouge .mf {
-  color: #009999;
-}
-pre.rouge .mh {
-  color: #009999;
-}
-pre.rouge .il {
-  color: #009999;
-}
-pre.rouge .mi {
-  color: #009999;
-}
-pre.rouge .mo {
-  color: #009999;
-}
-pre.rouge .m, pre.rouge .mb, pre.rouge .mx {
-  color: #009999;
-}
-pre.rouge .sa {
-  color: #000000;
-  font-weight: bold;
-}
-pre.rouge .sb {
-  color: #d14;
-}
-pre.rouge .sc {
-  color: #d14;
-}
-pre.rouge .sd {
-  color: #d14;
-}
-pre.rouge .s2 {
-  color: #d14;
-}
-pre.rouge .se {
-  color: #d14;
-}
-pre.rouge .sh {
-  color: #d14;
-}
-pre.rouge .si {
-  color: #d14;
-}
-pre.rouge .sx {
-  color: #d14;
-}
-pre.rouge .sr {
-  color: #009926;
-}
-pre.rouge .s1 {
-  color: #d14;
-}
-pre.rouge .ss {
-  color: #990073;
-}
-pre.rouge .s, pre.rouge .dl {
-  color: #d14;
-}
-pre.rouge .na {
-  color: #008080;
-}
-pre.rouge .bp {
-  color: #999999;
-}
-pre.rouge .nb {
-  color: #0086B3;
-}
-pre.rouge .nc {
-  color: #445588;
-  font-weight: bold;
-}
-pre.rouge .no {
-  color: #008080;
-}
-pre.rouge .nd {
-  color: #3c5d5d;
-  font-weight: bold;
-}
-pre.rouge .ni {
-  color: #800080;
-}
-pre.rouge .ne {
-  color: #990000;
-  font-weight: bold;
-}
-pre.rouge .nf, pre.rouge .fm {
-  color: #990000;
-  font-weight: bold;
-}
-pre.rouge .nl {
-  color: #990000;
-  font-weight: bold;
-}
-pre.rouge .nn {
-  color: #555555;
-}
-pre.rouge .nt {
-  color: #000080;
-}
-pre.rouge .vc {
-  color: #008080;
-}
-pre.rouge .vg {
-  color: #008080;
-}
-pre.rouge .vi {
-  color: #008080;
-}
-pre.rouge .nv, pre.rouge .vm {
-  color: #008080;
-}
-pre.rouge .ow {
-  color: #000000;
-  font-weight: bold;
-}
-pre.rouge .o {
-  color: #000000;
-  font-weight: bold;
-}
-pre.rouge .w {
-  color: #bbbbbb;
-}
-pre.rouge {
-  background-color: #f8f8f8;
-}
-</style>
-</head>
-<body class="article toc2 toc-left">
-<div id="header">
-<h1>CharConv: An Implementation of &lt;charconv&gt; in C&#43;&#43;11</h1>
-<div class="details">
-<span id="author" class="author">Peter Dimov and Matt Borland</span><br>
-</div>
-<div id="toc" class="toc2">
-<div id="toctitle">Table of Contents</div>
-<ul class="sectlevel1">
-<li><a href="#overview">Overview</a>
-<ul class="sectlevel2">
-<li><a href="#overview_description">Description</a></li>
-<li><a href="#overview_usage_examples">Usage Examples</a></li>
-<li><a href="#overview_supported_compilers">Supported Compilers</a></li>
-</ul>
-</li>
-<li><a href="#overview_from_chars">from_chars</a>
-<ul class="sectlevel2">
-<li><a href="#from_chars_from_chars_overview">from_chars overview</a></li>
-<li><a href="#from_chars_from_chars_result">from_chars_result</a></li>
-<li><a href="#from_chars_from_chars">from_chars</a></li>
-<li><a href="#from_chars_from_chars_for_integral_types">from_chars for integral types</a></li>
-<li><a href="#from_chars_examples">Examples</a>
-<ul class="sectlevel3">
-<li><a href="#from_chars_basic_usage">Basic usage</a></li>
-<li><a href="#from_chars_hexadecimal">Hexadecimal</a></li>
-<li><a href="#from_chars_einval">EINVAL</a></li>
-<li><a href="#from_chars_erange">ERANGE</a></li>
-</ul>
-</li>
-</ul>
-</li>
-<li><a href="#from_chars_to_chars">to_chars</a>
-<ul class="sectlevel2">
-<li><a href="#to_chars_to_chars_overview">to_chars overview</a></li>
-<li><a href="#to_chars_to_chars_result">to_chars_result</a></li>
-<li><a href="#to_chars_to_chars">to_chars</a></li>
-<li><a href="#to_chars_to_chars_for_integral_types">to_chars for integral types</a></li>
-<li><a href="#to_chars_examples">Examples</a>
-<ul class="sectlevel3">
-<li><a href="#to_chars_basic_usage">Basic Usage</a></li>
-<li><a href="#to_chars_hexadecimal">Hexadecimal</a></li>
-<li><a href="#to_chars_erange">ERANGE</a></li>
-</ul>
-</li>
-</ul>
-</li>
-<li><a href="#reference">Reference</a>
-<ul class="sectlevel2">
-<li><a href="#ref_boostcharconvfrom_chars_hpp">&lt;boost/charconv/from_chars.hpp&gt;</a>
-<ul class="sectlevel3">
-<li><a href="#ref_synopsis">Synopsis</a></li>
-</ul>
-</li>
-<li><a href="#ref_boostcharconvto_chars_hpp">&lt;boost/charconv/to_chars.hpp&gt;</a>
-<ul class="sectlevel3">
-<li><a href="#ref_synopsis_2">Synopsis</a></li>
-</ul>
-</li>
-<li><a href="#ref_boostcharconv_hpp">&lt;boost/charconv.hpp&gt;</a></li>
-</ul>
-</li>
-<li><a href="#copyright">Copyright and License</a></li>
-</ul>
-</div>
-</div>
-<div id="content">
-<div class="sect1">
-<h2 id="overview">Overview</h2>
-<div class="sectionbody">
-<div class="sect2">
-<h3 id="overview_description">Description</h3>
-<div class="paragraph">
-<p>Charconv is a collection of parsing functions that are locale-independent, non-allocating, and non-throwing.</p>
-</div>
-</div>
-<div class="sect2">
-<h3 id="overview_usage_examples">Usage Examples</h3>
-<div class="listingblock">
-<div class="content">
-<pre class="rouge highlight"><code data-lang="c++"><span class="cp">#include &lt;boost/charconv.hpp&gt;
-</span>
-<span class="k">const</span> <span class="kt">char</span><span class="o">*</span> <span class="n">buffer</span> <span class="o">=</span> <span class="s">"42"</span><span class="p">;</span>
-<span class="kt">int</span> <span class="n">v</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
-<span class="k">auto</span> <span class="n">r</span> <span class="o">=</span> <span class="n">boost</span><span class="o">::</span><span class="n">charconv</span><span class="o">::</span><span class="n">from_chars</span><span class="p">(</span><span class="n">buffer</span><span class="p">,</span> <span class="n">buffer</span> <span class="o">+</span> <span class="n">std</span><span class="o">::</span><span class="n">strlen</span><span class="p">(</span><span class="n">buffer</span><span class="p">),</span> <span class="n">v</span><span class="p">);</span>
-<span class="n">assert</span><span class="p">(</span><span class="n">r</span> <span class="o">==</span> <span class="mi">42</span><span class="p">);</span>
-
-<span class="kt">char</span> <span class="n">buffer</span><span class="p">[</span><span class="mi">64</span><span class="p">];</span>
-<span class="kt">int</span> <span class="n">v</span> <span class="o">=</span> <span class="mi">12345</span><span class="p">;</span>
-<span class="k">auto</span> <span class="n">r</span> <span class="o">=</span> <span class="n">boost</span><span class="o">::</span><span class="n">charconv</span><span class="o">::</span><span class="n">to_chars</span><span class="p">(</span><span class="n">buffer</span><span class="p">,</span> <span class="n">buffer</span> <span class="o">+</span> <span class="k">sizeof</span><span class="p">(</span><span class="n">buffer</span><span class="p">)</span> <span class="o">-</span> <span class="mi">1</span><span class="p">,</span> <span class="n">v</span><span class="p">);</span>
-<span class="n">assert</span><span class="p">(</span><span class="o">!</span><span class="n">strcmp</span><span class="p">(</span><span class="n">buffer</span><span class="p">,</span> <span class="s">"123456"</span><span class="p">));</span> <span class="c1">// Strcmp returns 0 on match</span></code></pre>
-</div>
-</div>
-</div>
-<div class="sect2">
-<h3 id="overview_supported_compilers">Supported Compilers</h3>
-<div class="ulist">
-<ul>
-<li>
-<p>GCC 5 or later with <code>-std=c++11</code> or above</p>
-</li>
-<li>
-<p>Clang 3.9 or later with <code>-std=c++11</code> or above</p>
-</li>
-<li>
-<p>Visual Studio 2015, 2017, 2019</p>
-</li>
-</ul>
-</div>
-<div class="paragraph">
-<p>Tested on <a href="https://github.com/cppalliance/charconv/actions">Github Actions</a>.</p>
-</div>
-</div>
-</div>
-</div>
-<div class="sect1">
-<h2 id="overview_from_chars">from_chars</h2>
-<div class="sectionbody">
-<div class="sect2">
-<h3 id="from_chars_from_chars_overview">from_chars overview</h3>
-<div class="listingblock">
-<div class="content">
-<pre class="rouge highlight"><code data-lang="c++"><span class="k">struct</span> <span class="nc">from_chars_result</span>
-<span class="p">{</span>
-    <span class="k">const</span> <span class="kt">char</span><span class="o">*</span> <span class="n">ptr</span><span class="p">;</span>
-    <span class="kt">int</span> <span class="n">ec</span><span class="p">;</span>
-
-    <span class="k">friend</span> <span class="k">constexpr</span> <span class="kt">bool</span> <span class="k">operator</span><span class="o">==</span><span class="p">(</span><span class="k">const</span> <span class="n">from_chars_result</span><span class="o">&amp;</span> <span class="n">lhs</span><span class="p">,</span> <span class="k">const</span> <span class="n">from_chars_result</span><span class="o">&amp;</span> <span class="n">rhs</span><span class="p">)</span> <span class="k">noexcept</span>
-    <span class="k">friend</span> <span class="k">constexpr</span> <span class="kt">bool</span> <span class="k">operator</span><span class="o">!=</span><span class="p">(</span><span class="k">const</span> <span class="n">from_chars_result</span><span class="o">&amp;</span> <span class="n">lhs</span><span class="p">,</span> <span class="k">const</span> <span class="n">from_chars_result</span><span class="o">&amp;</span> <span class="n">rhs</span><span class="p">)</span> <span class="k">noexcept</span>
-<span class="p">}</span>
-
-<span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="nc">Integral</span><span class="p">&gt;</span>
-<span class="n">BOOST_CXX14_CONSTEXPR</span> <span class="n">from_chars_result</span> <span class="n">from_chars</span><span class="p">(</span><span class="k">const</span> <span class="kt">char</span><span class="o">*</span> <span class="n">first</span><span class="p">,</span> <span class="k">const</span> <span class="kt">char</span><span class="o">*</span> <span class="n">last</span><span class="p">,</span> <span class="n">Integral</span><span class="o">&amp;</span> <span class="n">value</span><span class="p">,</span> <span class="kt">int</span> <span class="n">base</span> <span class="o">=</span> <span class="mi">10</span><span class="p">)</span> <span class="k">noexcept</span><span class="p">;</span>
-
-<span class="n">BOOST_CXX14_CONSTEXPR</span> <span class="n">from_chars_result</span> <span class="n">from_chars</span><span class="o">&lt;</span><span class="kt">bool</span><span class="o">&gt;</span><span class="p">(</span><span class="k">const</span> <span class="kt">char</span><span class="o">*</span> <span class="n">first</span><span class="p">,</span> <span class="k">const</span> <span class="kt">char</span><span class="o">*</span> <span class="n">last</span><span class="p">,</span> <span class="kt">bool</span><span class="o">&amp;</span> <span class="n">value</span><span class="p">,</span> <span class="kt">int</span> <span class="n">base</span><span class="p">)</span> <span class="o">=</span> <span class="k">delete</span><span class="p">;</span></code></pre>
-</div>
-</div>
-</div>
-<div class="sect2">
-<h3 id="from_chars_from_chars_result">from_chars_result</h3>
-<div class="ulist">
-<ul>
-<li>
-<p>ptr - points to the first character not matching the pattern, or has the value of last if all characters are successfully parsed.</p>
-</li>
-<li>
-<p>ec - the error code. Valid values for &lt;cerrno&gt; are:</p>
-<div class="ulist">
-<ul>
-<li>
-<p>0 - successful parsing</p>
-</li>
-<li>
-<p>EINVAL - invalid argument (e.g. parsing a negative number into an unsigned type)</p>
-</li>
-<li>
-<p>ERANGE - result out of range (e.g. overflow)</p>
-</li>
-</ul>
-</div>
-</li>
-<li>
-<p>operator== - compares the values of ptr and ec for equality</p>
-</li>
-<li>
-<p>operator!- - compares the value of ptr and ec for inequality</p>
-</li>
-</ul>
-</div>
-</div>
-<div class="sect2">
-<h3 id="from_chars_from_chars">from_chars</h3>
-<div class="ulist">
-<ul>
-<li>
-<p>first, last - valid range to parse</p>
-</li>
-<li>
-<p>value - where the output is stored upon successful parsing</p>
-</li>
-<li>
-<p>base - the integer base to use. Must be between 2 and 36 inclusive</p>
-</li>
-<li>
-<p>from_chars for integral types is constexpr when compiled using <code>-std=c++14</code> or newer</p>
-<div class="ulist">
-<ul>
-<li>
-<p>One known exception is GCC 5 which does not support constexpr comparison of const char*.</p>
-</li>
-</ul>
-</div>
-</li>
-</ul>
-</div>
-</div>
-<div class="sect2">
-<h3 id="from_chars_from_chars_for_integral_types">from_chars for integral types</h3>
-<div class="ulist">
-<ul>
-<li>
-<p>All built-in integral types are allowed except bool which is deleted</p>
-</li>
-<li>
-<p>These function have been tested to support <code><em>int128</code> and <code>unsigned </em>int128</code> when compiling with <code>-std=gnu++11</code> or newer</p>
-</li>
-</ul>
-</div>
-</div>
-<div class="sect2">
-<h3 id="from_chars_examples">Examples</h3>
-<div class="sect3">
-<h4 id="from_chars_basic_usage">Basic usage</h4>
-<div class="listingblock">
-<div class="content">
-<pre class="rouge highlight"><code data-lang="c++"><span class="k">const</span> <span class="kt">char</span><span class="o">*</span> <span class="n">buffer</span> <span class="o">=</span> <span class="s">"42"</span><span class="p">;</span>
-<span class="kt">int</span> <span class="n">v</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
-<span class="n">from_chars_result</span> <span class="n">r</span> <span class="o">=</span> <span class="n">boost</span><span class="o">::</span><span class="n">charconv</span><span class="o">::</span><span class="n">from_chars</span><span class="p">(</span><span class="n">buffer</span><span class="p">,</span> <span class="n">buffer</span> <span class="o">+</span> <span class="n">std</span><span class="o">::</span><span class="n">strlen</span><span class="p">(</span><span class="n">buffer</span><span class="p">),</span> <span class="n">v</span><span class="p">);</span>
-<span class="n">assert</span><span class="p">(</span><span class="n">r</span><span class="p">.</span><span class="n">ec</span> <span class="o">==</span> <span class="mi">0</span><span class="p">);</span>
-<span class="n">assert</span><span class="p">(</span><span class="n">v</span> <span class="o">==</span> <span class="mi">42</span><span class="p">);</span></code></pre>
-</div>
-</div>
-</div>
-<div class="sect3">
-<h4 id="from_chars_hexadecimal">Hexadecimal</h4>
-<div class="listingblock">
-<div class="content">
-<pre class="rouge highlight"><code data-lang="c++"><span class="k">const</span> <span class="kt">char</span><span class="o">*</span> <span class="n">buffer</span> <span class="o">=</span> <span class="s">"2a"</span><span class="p">;</span>
-<span class="kt">unsigned</span> <span class="n">v</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
-<span class="k">auto</span> <span class="n">r</span> <span class="o">=</span> <span class="n">boost</span><span class="o">::</span><span class="n">charconv</span><span class="o">::</span><span class="n">from_chars</span><span class="p">(</span><span class="n">buffer</span><span class="p">,</span> <span class="n">buffer</span> <span class="o">+</span> <span class="n">std</span><span class="o">::</span><span class="n">strlen</span><span class="p">(</span><span class="n">buffer</span><span class="p">),</span> <span class="n">v</span><span class="p">,</span> <span class="mi">16</span><span class="p">);</span>
-<span class="n">assert</span><span class="p">(</span><span class="n">r</span><span class="p">.</span><span class="n">ec</span> <span class="o">==</span> <span class="mi">0</span><span class="p">);</span>
-<span class="n">assert</span><span class="p">(</span><span class="n">v</span> <span class="o">==</span> <span class="mi">42</span><span class="p">);</span></code></pre>
-</div>
-</div>
-</div>
-<div class="sect3">
-<h4 id="from_chars_einval">EINVAL</h4>
-<div class="listingblock">
-<div class="content">
-<pre class="rouge highlight"><code data-lang="c++"><span class="k">const</span> <span class="kt">char</span><span class="o">*</span> <span class="n">buffer</span> <span class="o">=</span> <span class="s">"-123"</span><span class="p">;</span>
-<span class="kt">unsigned</span> <span class="n">v</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
-<span class="k">auto</span> <span class="n">r</span> <span class="o">=</span> <span class="n">boost</span><span class="o">::</span><span class="n">charconv</span><span class="o">::</span><span class="n">from_chars</span><span class="p">(</span><span class="n">buffer</span><span class="p">,</span> <span class="n">buffer</span> <span class="o">+</span> <span class="n">std</span><span class="o">::</span><span class="n">strlen</span><span class="p">(</span><span class="n">buffer</span><span class="p">),</span> <span class="n">v</span><span class="p">);</span>
-<span class="n">assert</span><span class="p">(</span><span class="n">r</span><span class="p">.</span><span class="n">ec</span><span class="p">,</span> <span class="n">EINVAL</span><span class="p">);</span>
-<span class="n">assert</span><span class="p">(</span><span class="n">v</span> <span class="o">==</span> <span class="mi">0</span><span class="p">);</span></code></pre>
-</div>
-</div>
-<div class="paragraph">
-<p>In the event of EINVAL v is not set by <code>from_chars</code></p>
-</div>
-</div>
-<div class="sect3">
-<h4 id="from_chars_erange">ERANGE</h4>
-<div class="listingblock">
-<div class="content">
-<pre class="rouge highlight"><code data-lang="c++"><span class="k">const</span> <span class="kt">char</span><span class="o">*</span> <span class="n">buffer</span> <span class="o">=</span> <span class="s">"1234"</span><span class="p">;</span>
-<span class="kt">unsigned</span> <span class="kt">char</span> <span class="n">v</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
-<span class="k">auto</span> <span class="n">r</span> <span class="o">=</span> <span class="n">boost</span><span class="o">::</span><span class="n">charconv</span><span class="o">::</span><span class="n">from_chars</span><span class="p">(</span><span class="n">buffer</span><span class="p">,</span> <span class="n">buffer</span> <span class="o">+</span> <span class="n">std</span><span class="o">::</span><span class="n">strlen</span><span class="p">(</span><span class="n">buffer</span><span class="p">),</span> <span class="n">v</span><span class="p">);</span>
-<span class="n">assert</span><span class="p">(</span><span class="n">r</span><span class="p">.</span><span class="n">ec</span> <span class="o">==</span> <span class="n">ERANGE</span><span class="p">);</span>
-<span class="n">assert</span><span class="p">(</span><span class="n">v</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span></code></pre>
-</div>
-</div>
-<div class="paragraph">
-<p>In the event of ERANGE v is not set by <code>from_chars</code></p>
-</div>
-</div>
-</div>
-</div>
-</div>
-<div class="sect1">
-<h2 id="from_chars_to_chars">to_chars</h2>
-<div class="sectionbody">
-<div class="sect2">
-<h3 id="to_chars_to_chars_overview">to_chars overview</h3>
-<div class="listingblock">
-<div class="content">
-<pre class="rouge highlight"><code data-lang="c++"><span class="k">struct</span> <span class="nc">to_chars_result</span>
-<span class="p">{</span>
-    <span class="kt">char</span><span class="o">*</span> <span class="n">ptr</span><span class="p">;</span>
-    <span class="kt">int</span> <span class="n">ec</span><span class="p">;</span>
-
-    <span class="k">friend</span> <span class="k">constexpr</span> <span class="kt">bool</span> <span class="k">operator</span><span class="o">==</span><span class="p">(</span><span class="k">const</span> <span class="n">to_chars_result</span><span class="o">&amp;</span> <span class="n">lhs</span><span class="p">,</span> <span class="k">const</span> <span class="n">to_chars_result</span><span class="o">&amp;</span> <span class="n">rhs</span><span class="p">)</span> <span class="k">noexcept</span><span class="p">;</span>
-    <span class="k">friend</span> <span class="k">constexpr</span> <span class="kt">bool</span> <span class="k">operator</span><span class="o">!=</span><span class="p">(</span><span class="k">const</span> <span class="n">to_chars_result</span><span class="o">&amp;</span> <span class="n">lhs</span><span class="p">,</span> <span class="k">const</span> <span class="n">to_chars_result</span><span class="o">&amp;</span> <span class="n">rhs</span><span class="p">)</span> <span class="k">noexcept</span><span class="p">;</span>
-<span class="p">};</span>
-
-<span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="nc">Integral</span><span class="p">&gt;</span>
-<span class="n">BOOST_CHARCONV_CONSTEXPR</span> <span class="n">to_chars_result</span><span class="p">(</span><span class="kt">char</span><span class="o">*</span> <span class="n">first</span><span class="p">,</span> <span class="kt">char</span><span class="o">*</span> <span class="n">last</span><span class="p">,</span> <span class="n">Integral</span> <span class="n">value</span><span class="p">,</span> <span class="kt">int</span> <span class="n">base</span> <span class="o">=</span> <span class="mi">10</span><span class="p">)</span> <span class="k">noexcept</span><span class="p">;</span>
-
-<span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="nc">Integral</span><span class="p">&gt;</span>
-<span class="n">BOOST_CHARCONV_CONSTEXPR</span> <span class="n">to_chars_result</span><span class="o">&lt;</span><span class="kt">bool</span><span class="o">&gt;</span><span class="p">(</span><span class="kt">char</span><span class="o">*</span> <span class="n">first</span><span class="p">,</span> <span class="kt">char</span><span class="o">*</span> <span class="n">last</span><span class="p">,</span> <span class="n">Integral</span> <span class="n">value</span><span class="p">,</span> <span class="kt">int</span> <span class="n">base</span><span class="p">)</span> <span class="k">noexcept</span> <span class="o">=</span> <span class="k">delete</span><span class="p">;</span></code></pre>
-</div>
-</div>
-</div>
-<div class="sect2">
-<h3 id="to_chars_to_chars_result">to_chars_result</h3>
-<div class="ulist">
-<ul>
-<li>
-<p>ptr - points to the first character</p>
-</li>
-<li>
-<p>ec - the error code. Valid values from &lt;cerrno&gt; are:</p>
-<div class="ulist">
-<ul>
-<li>
-<p>0 - successful parsing</p>
-</li>
-<li>
-<p>EINVAL - invalid argument</p>
-</li>
-<li>
-<p>ERANGE - result out of range (e.g. overflow)</p>
-</li>
-</ul>
-</div>
-</li>
-<li>
-<p>operator== - compares the value of ptr and ec for equality</p>
-</li>
-<li>
-<p>operator!= - compares the value of ptr and ec for inequality</p>
-</li>
-</ul>
-</div>
-</div>
-<div class="sect2">
-<h3 id="to_chars_to_chars">to_chars</h3>
-<div class="ulist">
-<ul>
-<li>
-<p>first, last - pointers to the character buffer</p>
-</li>
-<li>
-<p>value - the value to be paresed into the buffer</p>
-</li>
-<li>
-<p>base - the integer base to use. Must be between 2 and 36 inclusive</p>
-</li>
-<li>
-<p>from_chars for integral type is constexpr (BOOST_CHARCONV_CONSTEXPR is defined) when compiled using <code>-std=c++14</code> or newer and a compiler with <code><em>_builtin</em> is_constant_evaluated</code></p>
-</li>
-</ul>
-</div>
-</div>
-<div class="sect2">
-<h3 id="to_chars_to_chars_for_integral_types">to_chars for integral types</h3>
-<div class="ulist">
-<ul>
-<li>
-<p>All built-in integral types are allowed except bool which is deleted</p>
-</li>
-</ul>
-</div>
-</div>
-<div class="sect2">
-<h3 id="to_chars_examples">Examples</h3>
-<div class="sect3">
-<h4 id="to_chars_basic_usage">Basic Usage</h4>
-<div class="listingblock">
-<div class="content">
-<pre class="rouge highlight"><code data-lang="c++"><span class="kt">char</span> <span class="n">buffer</span><span class="p">[</span><span class="mi">64</span><span class="p">]</span> <span class="p">{};</span>
-<span class="kt">int</span> <span class="n">v</span> <span class="o">=</span> <span class="mi">42</span><span class="p">;</span>
-<span class="n">to_chars_result</span> <span class="n">r</span> <span class="o">=</span> <span class="n">boost</span><span class="o">::</span><span class="n">charconv</span><span class="o">::</span><span class="n">to_chars</span><span class="p">(</span><span class="n">buffer</span><span class="p">,</span> <span class="n">buffer</span> <span class="o">+</span> <span class="k">sizeof</span><span class="p">(</span><span class="n">buffer</span><span class="p">)</span> <span class="o">-</span> <span class="mi">1</span><span class="p">,</span> <span class="n">v</span><span class="p">);</span>
-<span class="n">assert</span><span class="p">(</span><span class="n">r</span><span class="p">.</span><span class="n">ec</span> <span class="o">==</span> <span class="mi">0</span><span class="p">);</span>
-<span class="n">assert</span><span class="p">(</span><span class="o">!</span><span class="n">strcmp</span><span class="p">(</span><span class="n">buffer</span><span class="p">,</span> <span class="s">"42"</span><span class="p">));</span> <span class="c1">// strcmp returns 0 on match</span></code></pre>
-</div>
-</div>
-</div>
-<div class="sect3">
-<h4 id="to_chars_hexadecimal">Hexadecimal</h4>
-<div class="listingblock">
-<div class="content">
-<pre class="rouge highlight"><code data-lang="c++"><span class="kt">char</span> <span class="n">buffer</span><span class="p">[</span><span class="mi">64</span><span class="p">]</span> <span class="p">{};</span>
-<span class="kt">int</span> <span class="n">v</span> <span class="o">=</span> <span class="mi">42</span><span class="p">;</span>
-<span class="n">to_chars_result</span> <span class="n">r</span> <span class="o">=</span> <span class="n">boost</span><span class="o">::</span><span class="n">charconv</span><span class="o">::</span><span class="n">to_chars</span><span class="p">(</span><span class="n">buffer</span><span class="p">,</span> <span class="n">buffer</span> <span class="o">+</span> <span class="k">sizeof</span><span class="p">(</span><span class="n">buffer</span><span class="p">)</span> <span class="o">-</span> <span class="mi">1</span><span class="p">,</span> <span class="n">v</span><span class="p">,</span> <span class="mi">16</span><span class="p">);</span>
-<span class="n">assert</span><span class="p">(</span><span class="n">r</span><span class="p">.</span><span class="n">ec</span> <span class="o">==</span> <span class="mi">0</span><span class="p">);</span>
-<span class="n">assert</span><span class="p">(</span><span class="o">!</span><span class="n">strcmp</span><span class="p">(</span><span class="n">buffer</span><span class="p">,</span> <span class="s">"2a"</span><span class="p">));</span> <span class="c1">// strcmp returns 0 on match</span></code></pre>
-</div>
-</div>
-</div>
-<div class="sect3">
-<h4 id="to_chars_erange">ERANGE</h4>
-<div class="listingblock">
-<div class="content">
-<pre class="rouge highlight"><code data-lang="c++"><span class="kt">char</span> <span class="n">buffer</span><span class="p">[</span><span class="mi">3</span><span class="p">]</span> <span class="p">{};</span>
-<span class="kt">int</span> <span class="n">v</span> <span class="o">=</span> <span class="o">-</span><span class="mi">1234</span><span class="p">;</span>
-<span class="n">to_chars_result</span> <span class="n">r</span> <span class="o">=</span> <span class="n">boost</span><span class="o">::</span><span class="n">charconv</span><span class="o">::</span><span class="n">to_chars</span><span class="p">(</span><span class="n">buffer</span><span class="p">,</span> <span class="n">buffer</span> <span class="o">+</span> <span class="k">sizeof</span><span class="p">(</span><span class="n">buffer</span><span class="p">)</span> <span class="o">-</span> <span class="mi">1</span><span class="p">,</span> <span class="n">v</span><span class="p">,</span> <span class="mi">16</span><span class="p">);</span>
-<span class="n">assert</span><span class="p">(</span><span class="n">r</span><span class="p">.</span><span class="n">ec</span> <span class="o">==</span> <span class="n">ERANGE</span><span class="p">);</span></code></pre>
-</div>
-</div>
-<div class="paragraph">
-<p>In the event of ERANGE to_chars_result.ptr is first</p>
-</div>
-</div>
-</div>
-</div>
-</div>
-<div class="sect1">
-<h2 id="reference">Reference</h2>
-<div class="sectionbody">
-<div class="sect2">
-<h3 id="ref_boostcharconvfrom_chars_hpp">&lt;boost/charconv/from_chars.hpp&gt;</h3>
-<div class="sect3">
-<h4 id="ref_synopsis">Synopsis</h4>
-<div class="listingblock">
-<div class="content">
-<pre class="rouge highlight"><code data-lang="c++"><span class="k">namespace</span> <span class="n">boost</span> <span class="p">{</span>
-<span class="k">namespace</span> <span class="n">charconv</span> <span class="p">{</span>
-
-<span class="k">struct</span> <span class="nc">from_chars_result</span><span class="p">;</span>
-
-<span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="nc">Integral</span><span class="p">&gt;</span>
-<span class="n">BOOST_CXX14_CONSTEXPR</span> <span class="n">from_chars_result</span> <span class="n">from_chars</span><span class="p">(</span><span class="k">const</span> <span class="kt">char</span><span class="o">*</span> <span class="n">first</span><span class="p">,</span> <span class="k">const</span> <span class="kt">char</span><span class="o">*</span> <span class="n">last</span><span class="p">,</span> <span class="n">Integral</span><span class="o">&amp;</span> <span class="n">value</span><span class="p">,</span> <span class="kt">int</span> <span class="n">base</span> <span class="o">=</span> <span class="mi">10</span><span class="p">)</span> <span class="k">noexcept</span><span class="p">;</span>
-
-<span class="c1">// ...</span>
-
-<span class="p">}</span> <span class="c1">// namespace charconv</span>
-<span class="p">}</span> <span class="c1">// namespace boost</span></code></pre>
-</div>
-</div>
-</div>
-</div>
-<div class="sect2">
-<h3 id="ref_boostcharconvto_chars_hpp">&lt;boost/charconv/to_chars.hpp&gt;</h3>
-<div class="sect3">
-<h4 id="ref_synopsis_2">Synopsis</h4>
-<div class="listingblock">
-<div class="content">
-<pre class="rouge highlight"><code data-lang="c++"><span class="k">namespace</span> <span class="n">boost</span> <span class="p">{</span>
-<span class="k">namespace</span> <span class="n">charconv</span> <span class="p">{</span>
-
-<span class="k">struct</span> <span class="nc">to_chars_result</span><span class="p">;</span>
-
-<span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="nc">Integral</span><span class="p">&gt;</span>
-<span class="n">BOOST_CHARCONV_CONSTEXPR</span> <span class="n">to_chars_result</span> <span class="n">to_chars</span><span class="p">(</span> <span class="kt">char</span><span class="o">*</span> <span class="n">first</span><span class="p">,</span> <span class="kt">char</span><span class="o">*</span> <span class="n">last</span><span class="p">,</span> <span class="n">Integral</span> <span class="n">value</span><span class="p">,</span> <span class="kt">int</span> <span class="n">base</span> <span class="o">=</span> <span class="mi">10</span> <span class="p">)</span> <span class="k">noexcept</span><span class="p">;</span>
-
-<span class="c1">// ...</span>
-
-<span class="p">}</span> <span class="c1">// namespace charconv</span>
-<span class="p">}</span> <span class="c1">// namespace boost</span></code></pre>
-</div>
-</div>
-</div>
-</div>
-<div class="sect2">
-<h3 id="ref_boostcharconv_hpp">&lt;boost/charconv.hpp&gt;</h3>
-<div class="paragraph">
-<p>This convenience header includes all headers previously
-mentioned.</p>
-</div>
-</div>
-</div>
-</div>
-<div class="sect1">
-<h2 id="copyright">Copyright and License</h2>
-<div class="sectionbody">
-<div class="paragraph">
-<p>This documentation is copyright 2022-2023 Peter Dimov and Matt Borland and is distributed under
-the <a href="http://www.boost.org/LICENSE_1_0.txt">Boost Software License, Version 1.0</a>.</p>
-</div>
-</div>
-</div>
-</div>
-<div id="footer">
-<div id="footer-text">
-Last updated 2023-02-01 10:02:03 -0800
-</div>
-</div>
-<style>
-
-*:not(pre)>code { background: none; color: #600000; }
-:not(pre):not([class^=L])>code { background: none; color: #600000; }
-
-</style>
-</body>
-</html>
\ No newline at end of file

From 13dd7d1026d41069862634fff354d9ef9bad948a Mon Sep 17 00:00:00 2001
From: Matt Borland <matt@mattborland.com>
Date: Mon, 6 Feb 2023 08:54:48 -0800
Subject: [PATCH 63/63] Workaround for GCC11

---
 include/boost/charconv/detail/memcpy.hpp | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/include/boost/charconv/detail/memcpy.hpp b/include/boost/charconv/detail/memcpy.hpp
index 15ec0aa..7509142 100644
--- a/include/boost/charconv/detail/memcpy.hpp
+++ b/include/boost/charconv/detail/memcpy.hpp
@@ -9,6 +9,7 @@
 #include <cstring>
 #include <cstdint>
 
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=89689
 // GCC 10 added checks for length of memcpy which yields the following warning (converted to error with -Werror)
 // /usr/include/x86_64-linux-gnu/bits/string_fortified.h:34:33: error: 
 // ‘void* __builtin___memcpy_chk(void*, const void*, long unsigned int, long unsigned int)’ specified size between 
@@ -41,7 +42,19 @@ constexpr char* memcpy(char* dest, const char* src, std::size_t count)
     }
     else
     {
-        return static_cast<char*>(std::memcpy(dest, src, count));
+        // Workaround for GCC-11 because it does not honor GCC diagnostic ignored
+        // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=53431
+        // Hopefully the optimizer turns this into memcpy
+        #if __GNUC__ == 11
+            for (std::size_t i = 0; i < count; ++i)
+            {
+                *(dest + i) = *(src + i);
+            }
+
+            return dest;
+        #else
+            return static_cast<char*>(std::memcpy(dest, src, count));
+        #endif
     }
 }