From deca7cd56078ea532c18e4934e294375674dbf88 Mon Sep 17 00:00:00 2001
From: wjr <1966336874@qq.com>
Date: Fri, 14 Jun 2024 15:52:00 +0800
Subject: [PATCH] opt tuple compile time

---
 godbolt/wjr.hpp                          | 19439 ++++++++++-----------
 include/wjr/assert.hpp                   |    49 +-
 include/wjr/container/intrusive/list.hpp |    24 +-
 include/wjr/math/convert.hpp             |     1 +
 include/wjr/math/details.hpp             |    30 +-
 include/wjr/math/div-impl.hpp            |    13 +-
 include/wjr/math/div.hpp                 |    22 +-
 include/wjr/math/mul.hpp                 |     3 +-
 include/wjr/math/uint128_t.hpp           |    98 +
 include/wjr/memory/memory_pool.hpp       |    14 +-
 include/wjr/tuple.hpp                    |    14 +-
 include/wjr/type_traits.hpp              |     8 -
 src/wjr/math/div.cpp                     |     1 +
 src/wjr/math/mul.cpp                     |     1 +
 src/wjr/x86/math/mul.cpp                 |     3 -
 15 files changed, 9246 insertions(+), 10474 deletions(-)
 create mode 100644 include/wjr/math/uint128_t.hpp

diff --git a/godbolt/wjr.hpp b/godbolt/wjr.hpp
index 07b4d360..95d630fb 100644
--- a/godbolt/wjr.hpp
+++ b/godbolt/wjr.hpp
@@ -2508,45 +2508,32 @@ WJR_NORETURN extern void __assert_failed(const char *expr, const char *file,
 // LCOV_EXCL_START
 
 /// @private
-class __assert_handler_t {
-private:
-    WJR_NORETURN static void fn(const char *expr, const char *file, const char *func,
-                                int line) noexcept {
-        __assert_failed(expr, file, func, line);
-    }
-
-    template <typename... Args>
-    WJR_NORETURN WJR_NOINLINE static void fn(const char *expr, const char *file,
-                                             const char *func, int line,
-                                             Args &&...args) noexcept {
-        std::cerr << "Additional information: ";
-        (void)(std::cerr << ... << std::forward<Args>(args));
-        std::cerr << '\n';
-        __assert_failed(expr, file, func, line);
-    }
-
-public:
-    template <typename... Args>
-    WJR_NORETURN void operator()(const char *expr, const char *file, const char *func,
-                                 int line, Args &&...args) const noexcept {
-        fn(expr, file, func, line, std::forward<Args>(args)...);
-    }
-};
+template <typename... Args>
+WJR_NORETURN WJR_NOINLINE void __assert_handler(const char *expr, const char *file,
+                                                const char *func, int line,
+                                                Args &&...args) noexcept {
+    std::cerr << "Additional information: ";
+    (void)(std::cerr << ... << std::forward<Args>(args));
+    std::cerr << '\n';
+    __assert_failed(expr, file, func, line);
+}
 
-inline constexpr __assert_handler_t __assert_handler{};
+/// @private
+WJR_NORETURN inline void __assert_handler(const char *expr, const char *file,
+                                          const char *func, int line) noexcept {
+    __assert_failed(expr, file, func, line);
+}
 
 // LCOV_EXCL_STOP
 
-#define WJR_ASSERT_CHECK_I_HANDLER(handler, expr, ...)                                   \
+#define WJR_ASSERT_CHECK_I(expr, ...)                                                    \
     do {                                                                                 \
         if (WJR_UNLIKELY(!(expr))) {                                                     \
-            handler(#expr, WJR_FILE, WJR_CURRENT_FUNCTION, WJR_LINE, ##__VA_ARGS__);     \
+            ::wjr::__assert_handler(#expr, WJR_FILE, WJR_CURRENT_FUNCTION, WJR_LINE,     \
+                                    ##__VA_ARGS__);                                      \
         }                                                                                \
     } while (0)
 
-#define WJR_ASSERT_CHECK_I(...)                                                          \
-    WJR_ASSERT_CHECK_I_HANDLER(::wjr::__assert_handler, __VA_ARGS__)
-
 // do nothing
 #define WJR_ASSERT_UNCHECK_I(expr, ...)                                                  \
     do {                                                                                 \
@@ -3040,14 +3027,6 @@ using uint_t = typename __uint_selector<n>::type;
 template <size_t n>
 using int_t = typename __int_selector<n>::type;
 
-#if WJR_HAS_FEATURE(INT128)
-using int128_t = int_t<128>;
-#endif
-
-#if WJR_HAS_FEATURE(INT128)
-using uint128_t = uint_t<128>;
-#endif
-
 template <size_t n, bool __s>
 using usint_t = std::conditional_t<__s, int_t<n>, uint_t<n>>;
 
@@ -6156,12 +6135,8 @@ class de_bruijn {
     constexpr static uint8_t mv = digits == 32 ? 27 : 58;
     constexpr de_bruijn() noexcept : lookup(), lookupr() { initialize(); }
 
-    WJR_INTRINSIC_CONSTEXPR int get(T idx) const noexcept {
-        return lookup[(idx * seed) >> mv];
-    }
-    WJR_INTRINSIC_CONSTEXPR int getr(T idx) const noexcept {
-        return lookupr[(idx * seed) >> mv];
-    }
+    constexpr int get(T idx) const noexcept { return lookup[(idx * seed) >> mv]; }
+    constexpr int getr(T idx) const noexcept { return lookupr[(idx * seed) >> mv]; }
 
 private:
     constexpr void initialize() noexcept {
@@ -6184,7 +6159,7 @@ inline constexpr de_bruijn<uint64_t, 0x03f7'9d71'b4ca'8b09> de_bruijn64 = {};
 // preview ...
 
 template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-WJR_CONST WJR_INTRINSIC_CONSTEXPR bool is_zero_or_single_bit(T n) noexcept {
+WJR_CONST constexpr bool is_zero_or_single_bit(T n) noexcept {
     return (n & (n - 1)) == 0;
 }
 
@@ -6194,12 +6169,12 @@ WJR_CONST WJR_INTRINSIC_CONSTEXPR bool is_zero_or_single_bit(T n) noexcept {
  * @note `n & -n` is the lowest bit of n.
  */
 template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-WJR_CONST WJR_INTRINSIC_CONSTEXPR T lowbit(T n) noexcept {
+WJR_CONST constexpr T lowbit(T n) noexcept {
     return n & -n;
 }
 
 template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-WJR_CONST WJR_INTRINSIC_CONSTEXPR T clear_lowbit(T n) noexcept {
+WJR_CONST constexpr T clear_lowbit(T n) noexcept {
     return n & (n - 1);
 }
 
@@ -6216,39 +6191,35 @@ WJR_CONST constexpr decltype(auto) to_unsigned(Value value) noexcept {
 // preview :
 
 template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-WJR_CONST WJR_INTRINSIC_CONSTEXPR bool __has_high_bit(T n) noexcept {
+WJR_CONST constexpr bool __has_high_bit(T n) noexcept {
     return n >> (std::numeric_limits<T>::digits - 1);
 }
 
 template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-WJR_CONST WJR_INTRINSIC_CONSTEXPR T __ceil_div(T n, type_identity_t<T> div) noexcept {
+WJR_CONST constexpr T __ceil_div(T n, type_identity_t<T> div) noexcept {
     return (n + div - 1) / div;
 }
 
 template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-WJR_CONST WJR_INTRINSIC_CONSTEXPR T __align_down(T n,
-                                                 type_identity_t<T> alignment) noexcept {
+WJR_CONST constexpr T __align_down(T n, type_identity_t<T> alignment) noexcept {
     WJR_ASSERT_ASSUME_L2(is_zero_or_single_bit(alignment));
     return n & (-alignment);
 }
 
 template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-WJR_CONST WJR_INTRINSIC_CONSTEXPR T
-__align_down_offset(T n, type_identity_t<T> alignment) noexcept {
+WJR_CONST constexpr T __align_down_offset(T n, type_identity_t<T> alignment) noexcept {
     WJR_ASSERT_ASSUME_L2(is_zero_or_single_bit(alignment));
     return n & (alignment - 1);
 }
 
 template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-WJR_CONST WJR_INTRINSIC_CONSTEXPR T __align_up(T n,
-                                               type_identity_t<T> alignment) noexcept {
+WJR_CONST constexpr T __align_up(T n, type_identity_t<T> alignment) noexcept {
     WJR_ASSERT_ASSUME_L2(is_zero_or_single_bit(alignment));
     return (n + alignment - 1) & (-alignment);
 }
 
 template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-WJR_CONST WJR_INTRINSIC_CONSTEXPR T
-__align_up_offset(T n, type_identity_t<T> alignment) noexcept {
+WJR_CONST constexpr T __align_up_offset(T n, type_identity_t<T> alignment) noexcept {
     WJR_ASSERT_ASSUME_L2(is_zero_or_single_bit(alignment));
     return (-n) & (alignment - 1);
 }
@@ -6944,12 +6915,6 @@ inline constexpr bool is_list_tag_v = is_list_tag<Tag>::value;
 template <typename Tag>
 using list_obj_t = typename Tag::obj_type;
 
-template <typename Tag, WJR_REQUIRES(is_list_tag_v<Tag>)>
-constexpr list_obj_t<Tag> *get(list_node<Tag> *node) noexcept;
-
-template <typename Tag, WJR_REQUIRES(is_list_tag_v<Tag>)>
-constexpr const list_obj_t<Tag> *get(const list_node<Tag> *node) noexcept;
-
 template <typename T>
 class list_node_const_iterator {
     using node_type = list_node<T>;
@@ -7114,22 +7079,22 @@ struct list_node {
 
     template <typename U = Tag, WJR_REQUIRES(is_list_tag_v<U>)>
     constexpr list_obj_t<U> *operator->() noexcept {
-        return wjr::get(this);
+        return static_cast<list_obj_t<Tag> *>(this);
     }
 
     template <typename U = Tag, WJR_REQUIRES(is_list_tag_v<U>)>
     constexpr const list_obj_t<U> *operator->() const noexcept {
-        return wjr::get(this);
+        return static_cast<const list_obj_t<Tag> *>(this);
     }
 
     template <typename U = Tag, WJR_REQUIRES(is_list_tag_v<U>)>
     constexpr list_obj_t<U> &operator*() noexcept {
-        return *wjr::get(this);
+        return *operator->();
     }
 
     template <typename U = Tag, WJR_REQUIRES(is_list_tag_v<U>)>
     constexpr const list_obj_t<U> &operator*() const noexcept {
-        return *wjr::get(this);
+        return *operator->();
     }
 
     list_node *m_prev;
@@ -7200,579 +7165,364 @@ constexpr void replace_uninit(list_node<T> *from, list_node<T> *to) noexcept {
     from->m_next->m_prev = to;
 }
 
-template <typename Tag, WJR_REQUIRES_I(is_list_tag_v<Tag>)>
-constexpr list_obj_t<Tag> *get(list_node<Tag> *node) noexcept {
-    return static_cast<list_obj_t<Tag> *>(node);
-}
-
-template <typename Tag, WJR_REQUIRES_I(is_list_tag_v<Tag>)>
-constexpr const list_obj_t<Tag> *get(const list_node<Tag> *node) noexcept {
-    return static_cast<const list_obj_t<Tag> *>(node);
-}
-
 } // namespace wjr
 
 #endif // WJR_CONTAINER_INTRUSIVE_LIST_HPP__
-#ifndef WJR_CRTP_TRIVIALLY_ALLOCATOR_BASE_HPP__
-#define WJR_CRTP_TRIVIALLY_ALLOCATOR_BASE_HPP__
-
 // Already included
 
 namespace wjr {
 
-WJR_REGISTER_HAS_TYPE(is_trivially_allocator,
-                      std::declval<typename Alloc::is_trivially_allocator>(), Alloc);
-WJR_REGISTER_HAS_TYPE(
-    is_trivially_allocator_constructible,
-    std::declval<typename Alloc::is_trivially_allocator_constructible>(), Alloc);
+namespace memory_pool_details {
 
-WJR_REGISTER_HAS_TYPE(is_trivially_allocator_destructible,
-                      std::declval<typename Alloc::is_trivially_allocator_destructible>(),
-                      Alloc);
+static constexpr uint8_t __ctz_table[32] = {
+    0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
+    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+};
 
-/// @private
-template <typename Alloc, typename = void>
-struct __is_trivially_allocator_impl : std::false_type {};
+} // namespace memory_pool_details
 
-/// @private
-template <typename Alloc>
-struct __is_trivially_allocator_impl<
-    Alloc, std::enable_if_t<has_is_trivially_allocator_v<Alloc>>>
-    : Alloc::is_trivially_allocator {};
+class __default_alloc_template__ {
+private:
+    union obj {
+        union obj *free_list_link;
+        char client_data[1];
+    };
 
-/**
- * @brief Default construct, destruct allocator.
- *
- * @details If `Alloc::is_trivially_allocator` is not defined or
- * `Alloc::is_trivially_allocator` is `std::false_type`, derive from `std::false_type`. \n
- * If is_trivially_allocator_v is true, then `construct_at_using_allocator` and
- * `destroy_at_using_allocator` are same as `construct_at` and `destroy_at`.
- *
- */
-template <typename Alloc>
-struct is_trivially_allocator : __is_trivially_allocator_impl<Alloc> {};
+    struct malloc_chunk {
+        struct __list_node : list_node<> {};
 
-template <typename T>
-struct is_trivially_allocator<std::allocator<T>> : std::true_type {};
+        malloc_chunk() noexcept { init(&head); }
+        ~malloc_chunk() noexcept {
+            for (auto iter = head.begin(); iter != head.end();) {
+                auto now = iter++;
+                auto node = static_cast<__list_node *>(&*now);
+                free(node);
+            }
+        }
 
-template <typename Alloc>
-inline constexpr bool is_trivially_allocator_v = is_trivially_allocator<Alloc>::value;
+        WJR_MALLOC void *allocate(size_t n) noexcept {
+            __list_node *ptr = (__list_node *)malloc(n + sizeof(__list_node));
+            push_back(&head, ptr);
+            return (char *)(ptr) + sizeof(__list_node);
+        }
 
-/// @private
-template <typename Alloc, typename = void>
-struct __is_trivially_allocator_constructible_impl : std::false_type {};
+        void deallocate(void *ptr) noexcept {
+            auto node = (__list_node *)((char *)(ptr) - sizeof(__list_node));
+            remove_uninit(node);
+            free(node);
+        }
 
-/// @private
-template <typename Alloc>
-struct __is_trivially_allocator_constructible_impl<
-    Alloc, std::enable_if_t<has_is_trivially_allocator_constructible_v<Alloc>>>
-    : Alloc::is_trivially_allocator_constructible {};
+        __list_node head;
+    };
 
-template <typename Alloc>
-struct is_trivially_allocator_constructible
-    : std::disjunction<__is_trivially_allocator_constructible_impl<Alloc>,
-                       is_trivially_allocator<Alloc>> {};
+    WJR_CONST static constexpr size_t __round_up(size_t bytes) noexcept {
+        return (((bytes) + 2048 - 1) & ~(2048 - 1));
+    }
 
-template <typename Alloc>
-inline constexpr bool is_trivially_allocator_constructible_v =
-    is_trivially_allocator_constructible<Alloc>::value;
+    WJR_CONST static constexpr uint8_t __get_index(uint16_t bytes) noexcept {
+        if (bytes <= 256) {
+            return memory_pool_details::__ctz_table[(bytes - 1) >> 3];
+        }
 
-/// @private
-template <typename Alloc, typename = void>
-struct __is_trivially_allocator_destructible_impl : std::false_type {};
+        return memory_pool_details::__ctz_table[(bytes - 1) >> 9] + 6;
+    }
 
-/// @private
-template <typename Alloc>
-struct __is_trivially_allocator_destructible_impl<
-    Alloc, std::enable_if_t<has_is_trivially_allocator_destructible_v<Alloc>>>
-    : Alloc::is_trivially_allocator_destructible {};
+    WJR_CONST static constexpr uint16_t __get_size(uint8_t idx) noexcept {
+        return (uint16_t)(1) << (idx + 3);
+    }
 
-template <typename Alloc>
-struct is_trivially_allocator_destructible
-    : std::disjunction<__is_trivially_allocator_destructible_impl<Alloc>,
-                       is_trivially_allocator<Alloc>> {};
+    static malloc_chunk &get_chunk() noexcept {
+        static thread_local malloc_chunk chunk;
+        return chunk;
+    }
 
-template <typename Alloc>
-inline constexpr bool is_trivially_allocator_destructible_v =
-    is_trivially_allocator_destructible<Alloc>::value;
+public:
+    struct object {
 
-template <typename Alloc>
-struct trivially_allocator_traits {
-    using is_trivially = is_trivially_allocator<Alloc>;
-    using is_trivially_constructible = is_trivially_allocator_constructible<Alloc>;
-    using is_trivially_destructible = is_trivially_allocator_destructible<Alloc>;
-};
+        WJR_INTRINSIC_INLINE allocation_result<void *>
+        __small_allocate(size_t n) noexcept {
+            const size_t idx = __get_index(n);
+            const size_t size = __get_size(idx);
+            obj *volatile *my_free_list = free_list + idx;
+            obj *result = *my_free_list;
+            if (WJR_LIKELY(result != nullptr)) {
+                *my_free_list = result->free_list_link;
+                return {result, size};
+            }
 
-} // namespace wjr
+            return {refill(idx), size};
+        }
 
-#endif // WJR_CRTP_TRIVIALLY_ALLOCATOR_BASE_HPP__
-#ifndef WJR_MATH_CLZ_HPP__
-#define WJR_MATH_CLZ_HPP__
+        WJR_INTRINSIC_INLINE void __small_deallocate(void *p, size_t n) noexcept {
+            obj *q = (obj *)p;
+            obj *volatile *my_free_list = free_list + __get_index(n);
+            q->free_list_link = *my_free_list;
+            *my_free_list = q;
+        }
 
-// Already included
-#ifndef WJR_MATH_POPCOUNT_HPP__
-#define WJR_MATH_POPCOUNT_HPP__
+        // n must be > 0
+        WJR_INTRINSIC_INLINE allocation_result<void *> allocate(size_t n) noexcept {
+            if (WJR_LIKELY(n <= 16384)) {
+                return __small_allocate(n);
+            }
 
-// Already included
+            return {malloc(n), n};
+        }
 
-namespace wjr {
+        // p must not be 0
+        WJR_INTRINSIC_INLINE void deallocate(void *p, size_t n) noexcept {
+            if (WJR_LIKELY(n <= 16384)) {
+                return __small_deallocate(p, n);
+            }
 
-template <typename T>
-WJR_CONST WJR_INTRINSIC_CONSTEXPR int fallback_popcount(T x) noexcept {
-    constexpr auto nd = std::numeric_limits<T>::digits;
-    if constexpr (nd < 32) {
-        return fallback_popcount(static_cast<uint32_t>(x));
-    } else {
-        if constexpr (nd == 32) {
-            x -= (x >> 1) & 0x5555'5555;
-            x = (x & 0x3333'3333) + ((x >> 2) & 0x3333'3333);
-            x = (x + (x >> 4)) & 0x0f0f'0f0f;
-            return (x * 0x0101'0101) >> 24;
-        } else {
-            x -= (x >> 1) & 0x5555'5555'5555'5555;
-            x = (x & 0x3333'3333'3333'3333) + ((x >> 2) & 0x3333'3333'3333'3333);
-            x = (x + (x >> 4)) & 0x0f0f'0f0f'0f0f'0f0f;
-            return (x * 0x0101'0101'0101'0101) >> 56;
+            free(p);
         }
-    }
-}
-
-#if WJR_HAS_BUILTIN(__builtin_popcount)
-#define WJR_HAS_BUILTIN_POPCOUNT WJR_HAS_DEF
-#endif
 
-#if WJR_HAS_BUILTIN(POPCOUNT)
+        allocation_result<void *> chunk_allocate(size_t n) noexcept {
+            if (WJR_LIKELY(n <= 16384)) {
+                return __small_allocate(n);
+            }
 
-template <typename T>
-WJR_CONST WJR_INTRINSIC_INLINE int builtin_popcount(T x) noexcept {
-    constexpr auto nd = std::numeric_limits<T>::digits;
-    if constexpr (nd < 32) {
-        return builtin_popcount(static_cast<uint32_t>(x));
-    } else {
-        if constexpr (nd <= std::numeric_limits<unsigned int>::digits) {
-            return __builtin_popcount(x);
-        } else if constexpr (nd <= std::numeric_limits<unsigned long>::digits) {
-            return __builtin_popcountl(x);
-        }
-        if constexpr (nd <= std::numeric_limits<unsigned long long>::digits) {
-            return __builtin_popcountll(x);
-        } else {
-            static_assert(nd <= 64, "not support yet");
+            return {get_chunk().allocate(n), n};
         }
-    }
-}
 
-#endif // WJR_HAS_BUILTIN(POPCOUNT)
+        // p must not be 0
+        WJR_INTRINSIC_INLINE void chunk_deallocate(void *p, size_t n) noexcept {
+            if (WJR_LIKELY(n <= 16384)) {
+                return __small_deallocate(p, n);
+            }
 
-template <typename T>
-WJR_CONST WJR_INTRINSIC_CONSTEXPR_E int popcount_impl(T x) noexcept {
-    if (WJR_BUILTIN_CONSTANT_P(is_zero_or_single_bit(x)) && is_zero_or_single_bit(x)) {
-        return x != 0;
-    }
+            get_chunk().deallocate(p);
+        }
 
-#if WJR_HAS_BUILTIN(POPCOUNT)
-    if (is_constant_evaluated() || WJR_BUILTIN_CONSTANT_P(x)) {
-        return fallback_popcount(x);
-    }
+    private:
+        // Allocates a chunk for nobjs of size "size".  nobjs may be reduced
+        // if it is inconvenient to allocate the requested number.
+        WJR_MALLOC char *chunk_alloc(uint8_t idx, int &nobjs) noexcept;
 
-    return builtin_popcount(x);
-#else
-    return fallback_popcount(x);
-#endif
-}
+        // Returns an object of size n, and optionally adds to size n free list.
+        WJR_MALLOC void *refill(uint8_t idx) noexcept;
 
-template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-WJR_CONST WJR_INTRINSIC_CONSTEXPR_E int popcount(T x) noexcept {
-    const int ret = popcount_impl(x);
-    WJR_ASSUME(0 <= ret && ret <= std::numeric_limits<T>::digits);
-    return ret;
-}
+        obj *volatile free_list[12] = {nullptr};
+        char *start_free = nullptr;
+        char *end_free = nullptr;
+        size_t heap_size = 0;
+    };
 
-} // namespace wjr
+    static object &get_instance() noexcept {
+        static thread_local object instance;
+        return instance;
+    }
 
-#endif // WJR_MATH_POPCOUNT_HPP__
+    // n must be > 0
+    static allocation_result<void *> allocate(size_t n) noexcept {
+        return get_instance().allocate(n);
+    }
 
-namespace wjr {
+    // p must not be 0
+    WJR_INTRINSIC_INLINE static void deallocate(void *p, size_t n) noexcept {
+        get_instance().deallocate(p, n);
+    }
 
-template <typename T>
-WJR_CONST WJR_INTRINSIC_CONSTEXPR_E int fallback_clz_impl(T x) noexcept {
-    constexpr auto nd = std::numeric_limits<T>::digits;
+    // n must be > 0
+    static allocation_result<void *> chunk_allocate(size_t n) noexcept {
+        return get_instance().chunk_allocate(n);
+    }
 
-#if !(WJR_HAS_BUILTIN(POPCOUNT) && WJR_HAS_SIMD(POPCNT))
-    if constexpr (nd >= 32) {
-#endif
-        x |= (x >> 1);
-        x |= (x >> 2);
-        x |= (x >> 4);
+    // p must not be 0
+    WJR_INTRINSIC_INLINE static void chunk_deallocate(void *p, size_t n) noexcept {
+        get_instance().chunk_deallocate(p, n);
+    }
+};
 
-        if constexpr (nd >= 16) {
-            x |= (x >> 8);
-        }
+template <typename Ty>
+class memory_pool {
+private:
+    using allocator_type = __default_alloc_template__;
 
-        if constexpr (nd >= 32) {
-            x |= (x >> 16);
-        }
+public:
+    using value_type = Ty;
+    using size_type = size_t;
+    using difference_type = ptrdiff_t;
+    using propagate_on_container_move_assignment = std::true_type;
+    using is_always_equal = std::true_type;
+    using is_trivially_allocator = std::true_type;
 
-        if constexpr (nd >= 64) {
-            x |= (x >> 32);
-        }
-#if !(WJR_HAS_BUILTIN(POPCOUNT) && WJR_HAS_SIMD(POPCNT))
-    }
-#endif
+    template <typename Other>
+    struct rebind {
+        using other = memory_pool<Other>;
+    };
 
-#if WJR_HAS_BUILTIN(POPCOUNT) && WJR_HAS_SIMD(POPCNT)
-    return popcount<T>(~x);
-#else
-    if constexpr (nd < 32) {
-        return fallback_clz_impl(static_cast<uint32_t>(x)) - (32 - nd);
-    } else {
-        ++x;
+    constexpr memory_pool() noexcept = default;
+    constexpr memory_pool(const memory_pool &) noexcept = default;
+    template <typename Other>
+    constexpr memory_pool(const memory_pool<Other> &) noexcept {}
+    ~memory_pool() = default;
+    memory_pool &operator=(const memory_pool &) noexcept = default;
 
-        if constexpr (nd <= 32) {
-            return math_details::de_bruijn32.getr(x);
-        } else if constexpr (nd <= 64) {
-            return math_details::de_bruijn64.getr(x);
-        } else {
-            static_assert(nd <= 64, "not support yet");
-        }
+    WJR_NODISCARD WJR_CONSTEXPR20 allocation_result<Ty *>
+    allocate_at_least(size_type n) const noexcept {
+        const auto ret = allocator_type::allocate(n * sizeof(Ty));
+        return {static_cast<Ty *>(ret.ptr), ret.count};
     }
-#endif
-}
 
-template <typename T>
-WJR_CONST WJR_INTRINSIC_CONSTEXPR_E int fallback_clz(T x) noexcept {
-    return fallback_clz_impl(x);
-}
+    WJR_NODISCARD WJR_CONSTEXPR20 allocation_result<Ty *>
+    chunk_allocate_at_least(size_type n) const noexcept {
+        const auto ret = allocator_type::chunk_allocate(n * sizeof(Ty));
+        return {static_cast<Ty *>(ret.ptr), ret.count};
+    }
 
-#if WJR_HAS_BUILTIN(__builtin_clz)
-#define WJR_HAS_BUILTIN_CLZ WJR_HAS_DEF
-#endif
+    WJR_NODISCARD WJR_CONSTEXPR20 WJR_MALLOC Ty *allocate(size_type n) const noexcept {
+        return allocate_at_least(n).ptr;
+    }
 
-#if WJR_HAS_BUILTIN(CLZ)
+    WJR_CONSTEXPR20 void deallocate(Ty *ptr, size_type n) const noexcept {
+        return allocator_type::deallocate(static_cast<void *>(ptr), sizeof(Ty) * n);
+    }
 
-template <typename T>
-WJR_CONST WJR_INTRINSIC_INLINE int builtin_clz_impl(T x) noexcept {
-    constexpr auto nd = std::numeric_limits<T>::digits;
+    /**
+     * @details Allocate memory, don't need to deallocate it until the thread exits.   \n
+     * Automatically deallocate memory when the thread exits.                          \n
+     * Used in thread_local memory pool that only needs to allocate memory once and    \n
+     * deallocate it when the thread exits.                                            \n
+     *
+     */
+    WJR_NODISCARD WJR_CONSTEXPR20 WJR_MALLOC Ty *
+    chunk_allocate(size_type n) const noexcept {
+        return chunk_allocate_at_least(n).ptr;
+    }
 
-    if constexpr (nd < 32) {
-        return builtin_clz_impl(static_cast<uint32_t>(x)) - (32 - nd);
-    } else {
-        if constexpr (nd <= std::numeric_limits<unsigned int>::digits) {
-            constexpr auto delta = std::numeric_limits<unsigned int>::digits - nd;
-            return __builtin_clz(static_cast<unsigned int>(x)) - delta;
-        } else if constexpr (nd <= std::numeric_limits<unsigned long>::digits) {
-            constexpr auto delta = std::numeric_limits<unsigned long>::digits - nd;
-            return __builtin_clzl(static_cast<unsigned long>(x)) - delta;
-        } else if constexpr (nd <= std::numeric_limits<unsigned long long>::digits) {
-            constexpr auto delta = std::numeric_limits<unsigned long long>::digits - nd;
-            return __builtin_clzll(static_cast<unsigned long long>(x)) - delta;
-        } else {
-            static_assert(nd <= 64, "not supported yet");
-        }
+    WJR_CONSTEXPR20 void chunk_deallocate(Ty *ptr, size_type n) const noexcept {
+        return allocator_type::chunk_deallocate(static_cast<void *>(ptr), sizeof(Ty) * n);
     }
+
+    constexpr size_t max_size() const noexcept {
+        return static_cast<size_t>(-1) / sizeof(Ty);
+    }
+};
+
+template <typename T, typename U>
+constexpr bool operator==(const memory_pool<T> &, const memory_pool<U> &) noexcept {
+    return true;
 }
 
-template <typename T>
-WJR_CONST WJR_INTRINSIC_INLINE int builtin_clz(T x) noexcept {
-    return builtin_clz_impl(x);
+template <typename T, typename U>
+constexpr bool operator!=(const memory_pool<T> &, const memory_pool<U> &) noexcept {
+    return false;
 }
 
-#endif
+} // namespace wjr
 
-template <typename T>
-WJR_CONST WJR_INTRINSIC_CONSTEXPR_E int clz_impl(T x) noexcept {
-#if WJR_HAS_BUILTIN(CLZ)
-    if (is_constant_evaluated() || WJR_BUILTIN_CONSTANT_P(x)) {
-        return fallback_clz(x);
-    }
+#endif // WJR_MEMORY_MEMORY_POOL_HPP__
+#ifndef WJR_MEMORY_TEMPORARY_VALUE_ALLOCATOR_HPP__
+#define WJR_MEMORY_TEMPORARY_VALUE_ALLOCATOR_HPP__
 
-    return builtin_clz(x);
-#else
-    return fallback_clz(x);
-#endif
-}
+#ifndef WJR_MEMORY_UNINITIALIZED_HPP__
+#define WJR_MEMORY_UNINITIALIZED_HPP__
 
 /**
- * @brief Fast count leading zeros
+ * @file uninitialized.hpp
+ * @brief The header file for uninitialized memory operations using allocator.
+ *
+ * @version 0.0.1
+ * @date 2024-03-18
  *
- * @tparam T Must be an unsigned integral type
  */
-template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-WJR_CONST WJR_INTRINSIC_CONSTEXPR_E int clz(T x) noexcept {
-    WJR_ASSERT_ASSUME_L2(x != 0);
-    const int ret = clz_impl(x);
-    WJR_ASSUME(0 <= ret && ret < std::numeric_limits<T>::digits);
-    return ret;
-}
 
-} // namespace wjr
+// Already included
+#ifndef WJR_CRTP_TRIVIALLY_ALLOCATOR_BASE_HPP__
+#define WJR_CRTP_TRIVIALLY_ALLOCATOR_BASE_HPP__
 
-#endif // WJR_MATH_CLZ_HPP__
 // Already included
 
 namespace wjr {
 
-namespace memory_pool_details {
+WJR_REGISTER_HAS_TYPE(is_trivially_allocator,
+                      std::declval<typename Alloc::is_trivially_allocator>(), Alloc);
+WJR_REGISTER_HAS_TYPE(
+    is_trivially_allocator_constructible,
+    std::declval<typename Alloc::is_trivially_allocator_constructible>(), Alloc);
 
-static constexpr uint8_t __ctz_table[32] = {
-    0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
-    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
-};
+WJR_REGISTER_HAS_TYPE(is_trivially_allocator_destructible,
+                      std::declval<typename Alloc::is_trivially_allocator_destructible>(),
+                      Alloc);
 
-} // namespace memory_pool_details
+/// @private
+template <typename Alloc, typename = void>
+struct __is_trivially_allocator_impl : std::false_type {};
 
-class __default_alloc_template__ {
-private:
-    union obj {
-        union obj *free_list_link;
-        char client_data[1];
-    };
+/// @private
+template <typename Alloc>
+struct __is_trivially_allocator_impl<
+    Alloc, std::enable_if_t<has_is_trivially_allocator_v<Alloc>>>
+    : Alloc::is_trivially_allocator {};
 
-    struct __list_node : list_node<> {};
+/**
+ * @brief Default construct, destruct allocator.
+ *
+ * @details If `Alloc::is_trivially_allocator` is not defined or
+ * `Alloc::is_trivially_allocator` is `std::false_type`, derive from `std::false_type`. \n
+ * If is_trivially_allocator_v is true, then `construct_at_using_allocator` and
+ * `destroy_at_using_allocator` are same as `construct_at` and `destroy_at`.
+ *
+ */
+template <typename Alloc>
+struct is_trivially_allocator : __is_trivially_allocator_impl<Alloc> {};
 
-    struct malloc_chunk {
+template <typename T>
+struct is_trivially_allocator<std::allocator<T>> : std::true_type {};
 
-        malloc_chunk() noexcept { init(&head); }
-        ~malloc_chunk() noexcept {
-            for (auto iter = head.begin(); iter != head.end();) {
-                auto now = iter++;
-                auto node = static_cast<__list_node *>(&*now);
-                free(node);
-            }
-        }
+template <typename Alloc>
+inline constexpr bool is_trivially_allocator_v = is_trivially_allocator<Alloc>::value;
 
-        WJR_MALLOC void *allocate(size_t n) noexcept {
-            __list_node *ptr = (__list_node *)malloc(n + sizeof(__list_node));
-            push_back(&head, ptr);
-            return (char *)(ptr) + sizeof(__list_node);
-        }
-
-        void deallocate(void *ptr) noexcept {
-            auto node = (__list_node *)((char *)(ptr) - sizeof(__list_node));
-            remove_uninit(node);
-            free(node);
-        }
-
-        __list_node head;
-    };
-
-    static WJR_INTRINSIC_CONSTEXPR WJR_CONST size_t __round_up(size_t bytes) noexcept {
-        return (((bytes) + 2048 - 1) & ~(2048 - 1));
-    }
-
-    static WJR_INTRINSIC_CONSTEXPR WJR_CONST uint8_t
-    __get_index(uint16_t bytes) noexcept {
-        if (bytes <= 256) {
-            return memory_pool_details::__ctz_table[(bytes - 1) >> 3];
-        }
-
-        return memory_pool_details::__ctz_table[(bytes - 1) >> 9] + 6;
-    }
-
-    static WJR_INTRINSIC_CONSTEXPR WJR_CONST uint16_t __get_size(uint8_t idx) noexcept {
-        return (uint16_t)(1) << (idx + 3);
-    }
-
-    static malloc_chunk &get_chunk() noexcept {
-        static thread_local malloc_chunk chunk;
-        return chunk;
-    }
-
-public:
-    struct object {
-
-        WJR_INTRINSIC_INLINE allocation_result<void *>
-        __small_allocate(size_t n) noexcept {
-            const size_t idx = __get_index(n);
-            const size_t size = __get_size(idx);
-            obj *volatile *my_free_list = free_list + idx;
-            obj *result = *my_free_list;
-            if (WJR_LIKELY(result != nullptr)) {
-                *my_free_list = result->free_list_link;
-                return {result, size};
-            }
-
-            return {refill(idx), size};
-        }
-
-        WJR_INTRINSIC_INLINE void __small_deallocate(void *p, size_t n) noexcept {
-            obj *q = (obj *)p;
-            obj *volatile *my_free_list = free_list + __get_index(n);
-            q->free_list_link = *my_free_list;
-            *my_free_list = q;
-        }
-
-        // n must be > 0
-        allocation_result<void *> allocate(size_t n) noexcept {
-            if (WJR_LIKELY(n <= 16384)) {
-                return __small_allocate(n);
-            }
-
-            return {malloc(n), n};
-        }
-
-        // p must not be 0
-        WJR_INTRINSIC_INLINE void deallocate(void *p, size_t n) noexcept {
-            if (WJR_LIKELY(n <= 16384)) {
-                return __small_deallocate(p, n);
-            }
-
-            free(p);
-        }
-
-        allocation_result<void *> chunk_allocate(size_t n) noexcept {
-            if (WJR_LIKELY(n <= 16384)) {
-                return __small_allocate(n);
-            }
-
-            return {get_chunk().allocate(n), n};
-        }
-
-        // p must not be 0
-        WJR_INTRINSIC_INLINE void chunk_deallocate(void *p, size_t n) noexcept {
-            if (WJR_LIKELY(n <= 16384)) {
-                return __small_deallocate(p, n);
-            }
-
-            get_chunk().deallocate(p);
-        }
-
-    private:
-        // Allocates a chunk for nobjs of size "size".  nobjs may be reduced
-        // if it is inconvenient to allocate the requested number.
-        WJR_MALLOC char *chunk_alloc(uint8_t idx, int &nobjs) noexcept;
-
-        // Returns an object of size n, and optionally adds to size n free list.
-        WJR_MALLOC void *refill(uint8_t idx) noexcept;
-
-        obj *volatile free_list[12] = {nullptr};
-        char *start_free = nullptr;
-        char *end_free = nullptr;
-        size_t heap_size = 0;
-    };
-
-    static object &get_instance() noexcept {
-        static thread_local object instance;
-        return instance;
-    }
-
-    // n must be > 0
-    static allocation_result<void *> allocate(size_t n) noexcept {
-        return get_instance().allocate(n);
-    }
-
-    // p must not be 0
-    WJR_INTRINSIC_INLINE static void deallocate(void *p, size_t n) noexcept {
-        get_instance().deallocate(p, n);
-    }
-
-    // n must be > 0
-    static allocation_result<void *> chunk_allocate(size_t n) noexcept {
-        return get_instance().chunk_allocate(n);
-    }
-
-    // p must not be 0
-    WJR_INTRINSIC_INLINE static void chunk_deallocate(void *p, size_t n) noexcept {
-        get_instance().chunk_deallocate(p, n);
-    }
-};
-
-template <typename Ty>
-class memory_pool {
-private:
-    using allocator_type = __default_alloc_template__;
-
-public:
-    using value_type = Ty;
-    using size_type = size_t;
-    using difference_type = ptrdiff_t;
-    using propagate_on_container_move_assignment = std::true_type;
-    using is_always_equal = std::true_type;
-    using is_trivially_allocator = std::true_type;
-
-    template <typename Other>
-    struct rebind {
-        using other = memory_pool<Other>;
-    };
+/// @private
+template <typename Alloc, typename = void>
+struct __is_trivially_allocator_constructible_impl : std::false_type {};
 
-    constexpr memory_pool() noexcept = default;
-    constexpr memory_pool(const memory_pool &) noexcept = default;
-    template <typename Other>
-    constexpr memory_pool(const memory_pool<Other> &) noexcept {}
-    ~memory_pool() = default;
-    memory_pool &operator=(const memory_pool &) noexcept = default;
+/// @private
+template <typename Alloc>
+struct __is_trivially_allocator_constructible_impl<
+    Alloc, std::enable_if_t<has_is_trivially_allocator_constructible_v<Alloc>>>
+    : Alloc::is_trivially_allocator_constructible {};
 
-    WJR_NODISCARD WJR_CONSTEXPR20 allocation_result<Ty *>
-    allocate_at_least(size_type n) const noexcept {
-        const auto ret = allocator_type::allocate(n * sizeof(Ty));
-        return {static_cast<Ty *>(ret.ptr), ret.count};
-    }
+template <typename Alloc>
+struct is_trivially_allocator_constructible
+    : std::disjunction<__is_trivially_allocator_constructible_impl<Alloc>,
+                       is_trivially_allocator<Alloc>> {};
 
-    WJR_NODISCARD WJR_CONSTEXPR20 allocation_result<Ty *>
-    chunk_allocate_at_least(size_type n) const noexcept {
-        const auto ret = allocator_type::chunk_allocate(n * sizeof(Ty));
-        return {static_cast<Ty *>(ret.ptr), ret.count};
-    }
+template <typename Alloc>
+inline constexpr bool is_trivially_allocator_constructible_v =
+    is_trivially_allocator_constructible<Alloc>::value;
 
-    WJR_NODISCARD WJR_CONSTEXPR20 WJR_MALLOC Ty *allocate(size_type n) const noexcept {
-        return allocate_at_least(n).ptr;
-    }
+/// @private
+template <typename Alloc, typename = void>
+struct __is_trivially_allocator_destructible_impl : std::false_type {};
 
-    WJR_CONSTEXPR20 void deallocate(Ty *ptr, size_type n) const noexcept {
-        return allocator_type::deallocate(static_cast<void *>(ptr), sizeof(Ty) * n);
-    }
+/// @private
+template <typename Alloc>
+struct __is_trivially_allocator_destructible_impl<
+    Alloc, std::enable_if_t<has_is_trivially_allocator_destructible_v<Alloc>>>
+    : Alloc::is_trivially_allocator_destructible {};
 
-    /**
-     * @details Allocate memory, don't need to deallocate it until the thread exits.   \n
-     * Automatically deallocate memory when the thread exits.                          \n
-     * Used in thread_local memory pool that only needs to allocate memory once and    \n
-     * deallocate it when the thread exits.                                            \n
-     *
-     */
-    WJR_NODISCARD WJR_CONSTEXPR20 WJR_MALLOC Ty *
-    chunk_allocate(size_type n) const noexcept {
-        return chunk_allocate_at_least(n).ptr;
-    }
+template <typename Alloc>
+struct is_trivially_allocator_destructible
+    : std::disjunction<__is_trivially_allocator_destructible_impl<Alloc>,
+                       is_trivially_allocator<Alloc>> {};
 
-    WJR_CONSTEXPR20 void chunk_deallocate(Ty *ptr, size_type n) const noexcept {
-        return allocator_type::chunk_deallocate(static_cast<void *>(ptr), sizeof(Ty) * n);
-    }
+template <typename Alloc>
+inline constexpr bool is_trivially_allocator_destructible_v =
+    is_trivially_allocator_destructible<Alloc>::value;
 
-    constexpr size_t max_size() const noexcept {
-        return static_cast<size_t>(-1) / sizeof(Ty);
-    }
+template <typename Alloc>
+struct trivially_allocator_traits {
+    using is_trivially = is_trivially_allocator<Alloc>;
+    using is_trivially_constructible = is_trivially_allocator_constructible<Alloc>;
+    using is_trivially_destructible = is_trivially_allocator_destructible<Alloc>;
 };
 
-template <typename T, typename U>
-constexpr bool operator==(const memory_pool<T> &, const memory_pool<U> &) noexcept {
-    return true;
-}
-
-template <typename T, typename U>
-constexpr bool operator!=(const memory_pool<T> &, const memory_pool<U> &) noexcept {
-    return false;
-}
-
 } // namespace wjr
 
-#endif // WJR_MEMORY_MEMORY_POOL_HPP__
-#ifndef WJR_MEMORY_TEMPORARY_VALUE_ALLOCATOR_HPP__
-#define WJR_MEMORY_TEMPORARY_VALUE_ALLOCATOR_HPP__
-
-#ifndef WJR_MEMORY_UNINITIALIZED_HPP__
-#define WJR_MEMORY_UNINITIALIZED_HPP__
-
-/**
- * @file uninitialized.hpp
- * @brief The header file for uninitialized memory operations using allocator.
- *
- * @version 0.0.1
- * @date 2024-03-18
- *
- */
-
-// Already included
-// Already included
+#endif // WJR_CRTP_TRIVIALLY_ALLOCATOR_BASE_HPP__
 // Already included
 
 namespace wjr {
@@ -10618,9 +10368,254 @@ struct container_traits<basic_vector<Storage>>
 #ifndef WJR_MATH_BIT_HPP__
 #define WJR_MATH_BIT_HPP__
 
-// Already included
-#ifndef WJR_MATH_CTZ_HPP__
-#define WJR_MATH_CTZ_HPP__
+#ifndef WJR_MATH_CLZ_HPP__
+#define WJR_MATH_CLZ_HPP__
+
+// Already included
+#ifndef WJR_MATH_POPCOUNT_HPP__
+#define WJR_MATH_POPCOUNT_HPP__
+
+// Already included
+
+namespace wjr {
+
+template <typename T>
+WJR_CONST WJR_INTRINSIC_CONSTEXPR int fallback_popcount(T x) noexcept {
+    constexpr auto nd = std::numeric_limits<T>::digits;
+    if constexpr (nd < 32) {
+        return fallback_popcount(static_cast<uint32_t>(x));
+    } else {
+        if constexpr (nd == 32) {
+            x -= (x >> 1) & 0x5555'5555;
+            x = (x & 0x3333'3333) + ((x >> 2) & 0x3333'3333);
+            x = (x + (x >> 4)) & 0x0f0f'0f0f;
+            return (x * 0x0101'0101) >> 24;
+        } else {
+            x -= (x >> 1) & 0x5555'5555'5555'5555;
+            x = (x & 0x3333'3333'3333'3333) + ((x >> 2) & 0x3333'3333'3333'3333);
+            x = (x + (x >> 4)) & 0x0f0f'0f0f'0f0f'0f0f;
+            return (x * 0x0101'0101'0101'0101) >> 56;
+        }
+    }
+}
+
+#if WJR_HAS_BUILTIN(__builtin_popcount)
+#define WJR_HAS_BUILTIN_POPCOUNT WJR_HAS_DEF
+#endif
+
+#if WJR_HAS_BUILTIN(POPCOUNT)
+
+template <typename T>
+WJR_CONST WJR_INTRINSIC_INLINE int builtin_popcount(T x) noexcept {
+    constexpr auto nd = std::numeric_limits<T>::digits;
+    if constexpr (nd < 32) {
+        return builtin_popcount(static_cast<uint32_t>(x));
+    } else {
+        if constexpr (nd <= std::numeric_limits<unsigned int>::digits) {
+            return __builtin_popcount(x);
+        } else if constexpr (nd <= std::numeric_limits<unsigned long>::digits) {
+            return __builtin_popcountl(x);
+        }
+        if constexpr (nd <= std::numeric_limits<unsigned long long>::digits) {
+            return __builtin_popcountll(x);
+        } else {
+            static_assert(nd <= 64, "not support yet");
+        }
+    }
+}
+
+#endif // WJR_HAS_BUILTIN(POPCOUNT)
+
+template <typename T>
+WJR_CONST WJR_INTRINSIC_CONSTEXPR_E int popcount_impl(T x) noexcept {
+    if (WJR_BUILTIN_CONSTANT_P(is_zero_or_single_bit(x)) && is_zero_or_single_bit(x)) {
+        return x != 0;
+    }
+
+#if WJR_HAS_BUILTIN(POPCOUNT)
+    if (is_constant_evaluated() || WJR_BUILTIN_CONSTANT_P(x)) {
+        return fallback_popcount(x);
+    }
+
+    return builtin_popcount(x);
+#else
+    return fallback_popcount(x);
+#endif
+}
+
+template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
+WJR_CONST WJR_INTRINSIC_CONSTEXPR_E int popcount(T x) noexcept {
+    const int ret = popcount_impl(x);
+    WJR_ASSUME(0 <= ret && ret <= std::numeric_limits<T>::digits);
+    return ret;
+}
+
+} // namespace wjr
+
+#endif // WJR_MATH_POPCOUNT_HPP__
+
+namespace wjr {
+
+template <typename T>
+WJR_CONST WJR_INTRINSIC_CONSTEXPR_E int fallback_clz_impl(T x) noexcept {
+    constexpr auto nd = std::numeric_limits<T>::digits;
+
+#if !(WJR_HAS_BUILTIN(POPCOUNT) && WJR_HAS_SIMD(POPCNT))
+    if constexpr (nd >= 32) {
+#endif
+        x |= (x >> 1);
+        x |= (x >> 2);
+        x |= (x >> 4);
+
+        if constexpr (nd >= 16) {
+            x |= (x >> 8);
+        }
+
+        if constexpr (nd >= 32) {
+            x |= (x >> 16);
+        }
+
+        if constexpr (nd >= 64) {
+            x |= (x >> 32);
+        }
+#if !(WJR_HAS_BUILTIN(POPCOUNT) && WJR_HAS_SIMD(POPCNT))
+    }
+#endif
+
+#if WJR_HAS_BUILTIN(POPCOUNT) && WJR_HAS_SIMD(POPCNT)
+    return popcount<T>(~x);
+#else
+    if constexpr (nd < 32) {
+        return fallback_clz_impl(static_cast<uint32_t>(x)) - (32 - nd);
+    } else {
+        ++x;
+
+        if constexpr (nd <= 32) {
+            return math_details::de_bruijn32.getr(x);
+        } else if constexpr (nd <= 64) {
+            return math_details::de_bruijn64.getr(x);
+        } else {
+            static_assert(nd <= 64, "not support yet");
+        }
+    }
+#endif
+}
+
+template <typename T>
+WJR_CONST WJR_INTRINSIC_CONSTEXPR_E int fallback_clz(T x) noexcept {
+    return fallback_clz_impl(x);
+}
+
+#if WJR_HAS_BUILTIN(__builtin_clz)
+#define WJR_HAS_BUILTIN_CLZ WJR_HAS_DEF
+#endif
+
+#if WJR_HAS_BUILTIN(CLZ)
+
+template <typename T>
+WJR_CONST WJR_INTRINSIC_INLINE int builtin_clz_impl(T x) noexcept {
+    constexpr auto nd = std::numeric_limits<T>::digits;
+
+    if constexpr (nd < 32) {
+        return builtin_clz_impl(static_cast<uint32_t>(x)) - (32 - nd);
+    } else {
+        if constexpr (nd <= std::numeric_limits<unsigned int>::digits) {
+            constexpr auto delta = std::numeric_limits<unsigned int>::digits - nd;
+            return __builtin_clz(static_cast<unsigned int>(x)) - delta;
+        } else if constexpr (nd <= std::numeric_limits<unsigned long>::digits) {
+            constexpr auto delta = std::numeric_limits<unsigned long>::digits - nd;
+            return __builtin_clzl(static_cast<unsigned long>(x)) - delta;
+        } else if constexpr (nd <= std::numeric_limits<unsigned long long>::digits) {
+            constexpr auto delta = std::numeric_limits<unsigned long long>::digits - nd;
+            return __builtin_clzll(static_cast<unsigned long long>(x)) - delta;
+        } else {
+            static_assert(nd <= 64, "not supported yet");
+        }
+    }
+}
+
+template <typename T>
+WJR_CONST WJR_INTRINSIC_INLINE int builtin_clz(T x) noexcept {
+    return builtin_clz_impl(x);
+}
+
+#endif
+
+#if !WJR_HAS_BUILTIN(CLZ)
+
+#if defined(WJR_MSVC)
+#define WJR_HAS_BUILTIN_MSVC_CLZ WJR_HAS_DEF
+#endif
+
+#if WJR_HAS_BUILTIN(MSVC_CLZ)
+
+template <typename T>
+WJR_CONST WJR_INTRINSIC_INLINE int builtin_msvc_clz_impl(T x) noexcept {
+    constexpr auto nd = std::numeric_limits<T>::digits;
+
+    if constexpr (nd < 32) {
+        return builtin_msvc_clz_impl(static_cast<uint32_t>(x)) - (32 - nd);
+    } else {
+        if constexpr (nd == 32) {
+            unsigned long result;
+            if (_BitScanReverse(&result, x)) {
+                return 31 - result;
+            }
+            return 0;
+        } else {
+            unsigned long result;
+            if (_BitScanReverse64(&result, x)) {
+                return 63 - result;
+            }
+            return 0;
+        }
+    }
+}
+
+template <typename T>
+WJR_CONST WJR_INTRINSIC_INLINE int builtin_msvc_clz(T x) noexcept {
+    return builtin_msvc_clz_impl(x);
+}
+
+#endif
+
+#endif
+
+template <typename T>
+WJR_CONST WJR_INTRINSIC_CONSTEXPR_E int clz_impl(T x) noexcept {
+#if WJR_HAS_BUILTIN(CLZ) || WJR_HAS_BUILTIN(MSVC_CLZ)
+    if (is_constant_evaluated() || WJR_BUILTIN_CONSTANT_P(x)) {
+        return fallback_clz(x);
+    }
+
+#if WJR_HAS_BUILTIN(CLZ)
+    return builtin_clz(x);
+#else
+    return builtin_msvc_clz(x);
+#endif
+#else
+    return fallback_clz(x);
+#endif
+}
+
+/**
+ * @brief Fast count leading zeros
+ *
+ * @tparam T Must be an unsigned integral type
+ */
+template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
+WJR_CONST WJR_INTRINSIC_CONSTEXPR_E int clz(T x) noexcept {
+    WJR_ASSERT_ASSUME_L2(x != 0);
+    const int ret = clz_impl(x);
+    WJR_ASSUME(0 <= ret && ret < std::numeric_limits<T>::digits);
+    return ret;
+}
+
+} // namespace wjr
+
+#endif // WJR_MATH_CLZ_HPP__
+#ifndef WJR_MATH_CTZ_HPP__
+#define WJR_MATH_CTZ_HPP__
 
 // Already included
 // Already included
@@ -18835,3372 +18830,3035 @@ __greater_equal_128(uint64_t lo0, uint64_t hi0, uint64_t lo1, uint64_t hi1) noex
 
 #include <utility>
 
-#ifndef WJR_TUPLE_HPP__
-#define WJR_TUPLE_HPP__
-
-#include <tuple>
-
 // Already included
+#ifndef WJR_MATH_UINT128_T_HPP__
+#define WJR_MATH_UINT128_T_HPP__
+
 // Already included
 
 namespace wjr {
 
-template <typename... Args>
-class tuple;
-
-} // namespace wjr
+/**
+ * @brief temporary uint128_t for divide 128
+ *
+ * @todo implement more functions
+ *
+ */
+struct uint128_t {
+    WJR_CONSTEXPR20 uint128_t() noexcept = default;
+    constexpr uint128_t(const uint128_t &) noexcept = default;
+    constexpr uint128_t(uint128_t &&) noexcept = default;
+    constexpr uint128_t &operator=(const uint128_t &) noexcept = default;
+    constexpr uint128_t &operator=(uint128_t &&) noexcept = default;
+    ~uint128_t() noexcept = default;
 
-namespace std {
+    constexpr uint128_t(uint64_t lo, uint64_t hi) noexcept : lo(lo), hi(hi) {}
 
-template <typename... Args>
-struct tuple_size<wjr::tuple<Args...>> : std::integral_constant<size_t, sizeof...(Args)> {
-};
+    template <size_t I>
+    constexpr uint64_t &get() & noexcept {
+        if constexpr (I == 0) {
+            return lo;
+        } else {
+            return hi;
+        }
+    }
 
-template <size_t I, typename... Args>
-struct tuple_element<I, wjr::tuple<Args...>> {
-    using type = wjr::tp_at_t<wjr::tuple<Args...>, I>;
-};
+    template <size_t I>
+    constexpr const uint64_t &get() const & noexcept {
+        if constexpr (I == 0) {
+            return lo;
+        } else {
+            return hi;
+        }
+    }
 
-template <typename... Args, WJR_REQUIRES(std::conjunction_v<wjr::is_swappable<Args>...>)>
-constexpr void swap(wjr::tuple<Args...> &lhs,
-                    wjr::tuple<Args...> &rhs) noexcept(noexcept(lhs.swap(rhs)));
+    template <size_t I>
+    constexpr uint64_t &&get() && noexcept {
+        if constexpr (I == 0) {
+            return std::move(lo);
+        } else {
+            return std::move(hi);
+        }
+    }
 
-template <size_t I, typename... Args>
-constexpr tuple_element_t<I, wjr::tuple<Args...>> &get(wjr::tuple<Args...> &t) noexcept;
+    template <size_t I>
+    constexpr const uint64_t &&get() const && noexcept {
+        if constexpr (I == 0) {
+            return std::move(lo);
+        } else {
+            return std::move(hi);
+        }
+    }
 
-template <size_t I, typename... Args>
-constexpr tuple_element_t<I, wjr::tuple<Args...>> &
-get(const wjr::tuple<Args...> &t) noexcept;
+    uint64_t lo;
+    uint64_t hi;
+};
 
-template <size_t I, typename... Args>
-constexpr tuple_element_t<I, wjr::tuple<Args...>> &&get(wjr::tuple<Args...> &&t) noexcept;
+} // namespace wjr
 
-template <size_t I, typename... Args>
-constexpr tuple_element_t<I, wjr::tuple<Args...>> &&
-get(const wjr::tuple<Args...> &&t) noexcept;
+namespace std {
 
-template <typename T, typename... Args>
-constexpr T &get(wjr::tuple<Args...> &t) noexcept;
+template <>
+struct tuple_size<wjr::uint128_t> : std::integral_constant<size_t, 2> {};
 
-template <typename T, typename... Args>
-constexpr T &get(const wjr::tuple<Args...> &t) noexcept;
+template <size_t I>
+struct tuple_element<I, wjr::uint128_t> {
+    using type = uint64_t;
+};
 
-template <typename T, typename... Args>
-constexpr T &&get(wjr::tuple<Args...> &&t) noexcept;
+template <size_t I>
+WJR_NODISCARD constexpr uint64_t &get(wjr::uint128_t &u) noexcept {
+    return u.get<I>();
+}
 
-template <typename T, typename... Args>
-constexpr T &&get(const wjr::tuple<Args...> &&t) noexcept;
+template <size_t I>
+WJR_NODISCARD constexpr const uint64_t &get(const wjr::uint128_t &u) noexcept {
+    return u.get<I>();
+}
+
+template <size_t I>
+WJR_NODISCARD constexpr uint64_t &&get(wjr::uint128_t &&u) noexcept {
+    return std::move(u).get<I>();
+}
+
+template <size_t I>
+WJR_NODISCARD constexpr const uint64_t &&get(const wjr::uint128_t &&u) noexcept {
+    return std::move(u).get<I>();
+}
 
 } // namespace std
 
-namespace wjr {
+#endif // WJR_MATH_UINT128_T_HPP__
 
-template <typename Indexs, typename... Args>
-class tuple_impl;
+namespace wjr {
 
-template <size_t... Indexs, typename... Args>
-class WJR_EMPTY_BASES tuple_impl<std::index_sequence<Indexs...>, Args...>
-    : capture_leaf<std::tuple_element_t<Indexs, tuple<Args...>>,
-                   enable_base_identity_t<
-                       Indexs, tuple_impl<std::index_sequence<Indexs...>, Args...>>>...,
-      enable_special_members_of_args_base<
-          tuple_impl<std::index_sequence<Indexs...>, Args...>,
-          capture_leaf<
-              std::tuple_element_t<Indexs, tuple<Args...>>,
-              enable_base_identity_t<
-                  Indexs, tuple_impl<std::index_sequence<Indexs...>, Args...>>>...> {
-    using Sequence = std::index_sequence<Indexs...>;
+template <typename T>
+class div2by1_divider;
 
-    template <size_t Idx>
-    using Mybase = capture_leaf<std::tuple_element_t<Idx, tuple<Args...>>,
-                                enable_base_identity_t<Idx, tuple_impl>>;
+template <typename T>
+class div3by2_divider;
 
-    using Mybase2 = enable_special_members_of_args_base<
-        tuple_impl<std::index_sequence<Indexs...>, Args...>,
-        capture_leaf<std::tuple_element_t<Indexs, tuple<Args...>>,
-                     enable_base_identity_t<Indexs, tuple_impl>>...>;
+template <typename T>
+class divexact1_divider;
 
-    constexpr static size_t Size = sizeof...(Args);
+WJR_INLINE_CONSTEXPR20 uint64_t
+div128by64to64(uint64_t &rem, uint64_t lo, uint64_t hi,
+               const div2by1_divider<uint64_t> &divider) noexcept;
 
-public:
-    template <typename S = Sequence,
-              WJR_REQUIRES(
-                  std::conjunction_v<std::is_same<S, Sequence>,
-                                     std::is_default_constructible<Mybase<Indexs>>...>)>
-    constexpr tuple_impl() noexcept(
-        std::conjunction_v<std::is_nothrow_constructible<Args>...>)
-        : Mybase2(enable_default_constructor) {}
+WJR_INLINE_CONSTEXPR20 uint64_t div128by64to64(uint64_t &rem, uint64_t lo, uint64_t hi,
+                                               uint64_t div) noexcept;
 
-    template <size_t... _Indexs, typename... _Args,
-              WJR_REQUIRES(
-                  std::conjunction_v<std::is_constructible<Mybase<_Indexs>, _Args>...>)>
-    constexpr tuple_impl(std::index_sequence<_Indexs...>, _Args &&...args) noexcept(
-        std::conjunction_v<std::is_nothrow_constructible<Args, _Args &&>...>)
-        : Mybase<_Indexs>(std::forward<_Args>(args))...,
-          Mybase2(enable_default_constructor) {}
+inline uint128_t div128by64to128(uint64_t &rem, uint64_t lo, uint64_t hi,
+                                 const div2by1_divider<uint64_t> &divider) noexcept;
 
-    template <size_t I>
-    constexpr auto &get() & noexcept {
-        return Mybase<I>::get();
-    }
+inline uint128_t div128by64to128(uint64_t &rem, uint64_t lo, uint64_t hi,
+                                 uint64_t div) noexcept;
 
-    template <size_t I>
-    constexpr const auto &get() const & noexcept {
-        return Mybase<I>::get();
-    }
+WJR_INTRINSIC_CONSTEXPR20 void div_qr_1(uint64_t *dst, uint64_t &rem, const uint64_t *src,
+                                        size_t n,
+                                        const div2by1_divider<uint64_t> &div) noexcept;
 
-    template <size_t I>
-    constexpr auto &&get() && noexcept {
-        return std::move(Mybase<I>::get());
-    }
+WJR_INTRINSIC_CONSTEXPR20 void div_qr_1(uint64_t *dst, uint64_t &rem, const uint64_t *src,
+                                        size_t n, uint64_t div) noexcept;
 
-    template <size_t I>
-    constexpr const auto &&get() const && noexcept {
-        return std::move(Mybase<I>::get());
-    }
-};
+WJR_INTRINSIC_CONSTEXPR20 void div_qr_2(uint64_t *dst, uint64_t *rem, const uint64_t *src,
+                                        size_t n,
+                                        const div3by2_divider<uint64_t> &div) noexcept;
 
-template <typename Tuple>
-struct __tuple_like;
+WJR_INTRINSIC_CONSTEXPR20 void div_qr_2(uint64_t *dst, uint64_t *rem, const uint64_t *src,
+                                        size_t n, const uint64_t *div) noexcept;
 
-template <template <typename...> typename Tuple, typename... Args>
-struct __tuple_like<Tuple<Args...>>
-    : std::disjunction<std::is_same<Tuple<Args...>, std::tuple<Args...>>,
-                       std::is_same<Tuple<Args...>, std::pair<Args...>>> {};
+WJR_INTRINSIC_CONSTEXPR20 void div_qr_s(uint64_t *dst, uint64_t *rem, const uint64_t *src,
+                                        size_t n, const uint64_t *div, size_t m) noexcept;
 
-template <>
-class tuple<> {
-public:
-    constexpr tuple() noexcept = default;
-    constexpr tuple(const tuple &) noexcept = default;
-    constexpr tuple(tuple &&) noexcept = default;
-    constexpr tuple &operator=(const tuple &) noexcept = default;
-    constexpr tuple &operator=(tuple &&) noexcept = default;
-    ~tuple() noexcept = default;
+WJR_INTRINSIC_CONSTEXPR20 uint64_t divexact_dbm1c(uint64_t *dst, const uint64_t *src,
+                                                  size_t n, uint64_t bd,
+                                                  uint64_t h) noexcept;
 
-    constexpr void swap(tuple &) noexcept {}
-};
+WJR_INTRINSIC_CONSTEXPR20 void divexact_dbm1c_shift(uint64_t *dst, const uint64_t *src,
+                                                    size_t n, uint64_t bd, uint64_t cl,
+                                                    uint64_t hicf) noexcept;
 
-template <typename This, typename... Args>
-class tuple<This, Args...>
-    : enable_special_members_of_args_base<
-          tuple<This, Args...>,
-          tuple_impl<std::index_sequence_for<This, Args...>, This, Args...>> {
-    using Sequence = std::index_sequence_for<This, Args...>;
-    using Impl = tuple_impl<Sequence, This, Args...>;
-    using Mybase = enable_special_members_of_args_base<tuple<This, Args...>, Impl>;
+template <uint64_t c>
+WJR_INTRINSIC_CONSTEXPR20 void divexact_byc(uint64_t *dst, const uint64_t *src, size_t n,
+                                            integral_constant<uint64_t, c>,
+                                            WJR_MAYBE_UNUSED uint64_t cf) noexcept;
 
-    constexpr static size_t Size = sizeof...(Args) + 1;
+WJR_INTRINSIC_CONSTEXPR20 void
+divexact_1(uint64_t *dst, const uint64_t *src, size_t n,
+           const divexact1_divider<uint64_t> &div) noexcept;
 
-public:
-#if defined(__cpp_conditional_explicit)
-    template <typename T = This,
-              WJR_REQUIRES(std::conjunction_v<std::is_default_constructible<T>,
-                                              std::is_default_constructible<Args>...>)>
-    constexpr explicit(
-        !std::conjunction_v<is_default_convertible<T>, is_default_convertible<Args>...>)
-        tuple() noexcept(std::is_nothrow_constructible_v<Impl>)
-        : Mybase(enable_default_constructor), m_impl() {}
-#else
-    template <typename T = This,
-              WJR_REQUIRES(std::conjunction_v<std::is_default_constructible<T>,
-                                              std::is_default_constructible<Args>...>
-                               &&std::conjunction_v<is_default_convertible<T>,
-                                                    is_default_convertible<Args>...>)>
-    constexpr tuple() noexcept(std::is_nothrow_constructible_v<Impl>)
-        : Mybase(enable_default_constructor), m_impl() {}
+WJR_INTRINSIC_CONSTEXPR20 void divexact_1(uint64_t *dst, const uint64_t *src, size_t n,
+                                          uint64_t div) noexcept;
 
-    template <typename T = This,
-              WJR_REQUIRES(std::conjunction_v<std::is_default_constructible<T>,
-                                              std::is_default_constructible<Args>...> &&
-                           !std::conjunction_v<is_default_convertible<T>,
-                                               is_default_convertible<Args>...>)>
-    constexpr explicit tuple() noexcept(std::is_nothrow_constructible_v<Impl>)
-        : Mybase(enable_default_constructor), m_impl() {}
-#endif
+WJR_PURE WJR_INTRINSIC_CONSTEXPR20 uint64_t
+mod_1(const uint64_t *src, size_t n, const div2by1_divider<uint64_t> &div) noexcept;
 
-    template <typename Other = This,
-              WJR_REQUIRES(std::is_constructible_v<Impl, Sequence, const Other &,
-                                                   const Args &...>)>
-    constexpr tuple(const Other &first, const Args &...rest) noexcept(
-        std::is_nothrow_constructible_v<Impl, Sequence, const Other &, const Args &...>)
-        : Mybase(enable_default_constructor), m_impl(Sequence(), first, rest...) {}
+WJR_PURE WJR_INTRINSIC_CONSTEXPR20 uint64_t mod_1(const uint64_t *src, size_t n,
+                                                  uint64_t div) noexcept;
 
-    template <
-        typename Other, typename... _Args,
-        WJR_REQUIRES(sizeof...(_Args) + 1 == Size &&
-                     std::conjunction_v<
-                         std::negation<std::conjunction<
-                             std::is_same<This, std::remove_reference_t<Other>>,
-                             std::is_same<Args, std::remove_reference_t<_Args>>...>>,
-                         std::is_constructible<Impl, Sequence, Other &&, _Args &&...>>)>
-    constexpr tuple(Other &&other, _Args &&...args) noexcept(
-        std::is_nothrow_constructible_v<Impl, Sequence, Other &&, _Args &&...>)
-        : Mybase(enable_default_constructor),
-          m_impl(Sequence(), std::forward<Other>(other), std::forward<_Args>(args)...) {}
+} // namespace wjr
 
-private:
-    template <size_t... _Indexs, typename TupleLike>
-    constexpr tuple(
-        std::index_sequence<_Indexs...>, TupleLike &&other,
-        in_place_empty_t) noexcept(std::
-                                       is_nothrow_constructible_v<
-                                           Impl, Sequence,
-                                           decltype(std::get<_Indexs>(
-                                               std::forward<TupleLike>(other)))...>)
-        : Mybase(enable_default_constructor),
-          m_impl(Sequence(), std::get<_Indexs>(std::forward<TupleLike>(other))...) {}
+#endif // WJR_MATH_DIV_IMPL_HPP__
+#ifndef WJR_MATH_DIVIDER_HPP__
+#define WJR_MATH_DIVIDER_HPP__
 
-public:
-    template <typename TupleLike,
-              WJR_REQUIRES(__is_tuple_test_v<std::is_constructible, tuple, TupleLike &&>)>
-    constexpr tuple(TupleLike &&other) noexcept(
-        noexcept(tuple(Sequence(), std::forward<TupleLike>(other), in_place_empty)))
-        : tuple(Sequence(), std::forward<TupleLike>(other), in_place_empty) {}
+#ifndef WJR_MATH_MUL_HPP__
+#define WJR_MATH_MUL_HPP__
 
-private:
-    template <size_t... _Indexs, typename Container>
-    constexpr void __assign(std::index_sequence<_Indexs...>, Container &&other) noexcept(
-        noexcept(((this->template get<_Indexs>() =
-                       std::get<_Indexs>(std::forward<Container>(other))),
-                  ...))) {
-        ((this->template get<_Indexs>() =
-              std::get<_Indexs>(std::forward<Container>(other))),
-         ...);
-    }
+/**
+ * @todo optimize temporary memory usage of mul_s, mul_n, sqr
+ *
+ */
 
-public:
-    template <typename TupleLike,
-              WJR_REQUIRES(__is_tuple_test_v<__is_tuple_assignable, tuple, TupleLike &&>)>
-    constexpr tuple &operator=(TupleLike &&other) noexcept(
-        noexcept(__assign(Sequence(), std::forward<TupleLike>(other)))) {
-        __assign(Sequence(), std::forward<TupleLike>(other));
-        return *this;
-    }
+#ifndef WJR_MATH_ADD_HPP__
+#define WJR_MATH_ADD_HPP__
 
-private:
-    template <size_t... _Indexs>
-    constexpr void
-    __swap(std::index_sequence<_Indexs...>, tuple &other) noexcept(noexcept(((
-        std::swap(this->template get<_Indexs>(), other.template get<_Indexs>()), ...)))) {
-        ((std::swap(this->template get<_Indexs>(), other.template get<_Indexs>()), ...));
-    }
+// Already included
+#ifndef WJR_MATH_ADD_IMPL_HPP__
+#define WJR_MATH_ADD_IMPL_HPP__
 
-public:
-    constexpr void swap(tuple &other) noexcept(noexcept(__swap(Sequence(), other))) {
-        __swap(Sequence(), other);
-    }
+// Already included
 
-    template <size_t I, WJR_REQUIRES(I < Size)>
-    constexpr std::tuple_element_t<I, tuple> &get() & noexcept {
-        return m_impl.template get<I>();
-    }
+namespace wjr {
 
-    template <size_t I, WJR_REQUIRES(I < Size)>
-    constexpr const std::tuple_element_t<I, tuple> &get() const & noexcept {
-        return m_impl.template get<I>();
-    }
+template <typename T, typename U,
+          WJR_REQUIRES(is_nonbool_unsigned_integral_v<T> &&is_unsigned_integral_v<U>)>
+WJR_NODISCARD WJR_INTRINSIC_CONSTEXPR_E T addc(T a, T b, type_identity_t<U> c_in,
+                                               U &c_out) noexcept;
 
-    template <size_t I, WJR_REQUIRES(I < Size)>
-    constexpr std::tuple_element_t<I, tuple> &&get() && noexcept {
-        return std::move(m_impl.template get<I>());
-    }
+template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
+WJR_NODISCARD WJR_INTRINSIC_CONSTEXPR_E T addc_cc(T a, T b, uint8_t c_in,
+                                                  uint8_t &c_out) noexcept;
 
-    template <size_t I, WJR_REQUIRES(I < Size)>
-    constexpr const std::tuple_element_t<I, tuple> &&get() const && noexcept {
-        return std::move(m_impl.template get<I>());
-    }
+template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
+WJR_NODISCARD WJR_INTRINSIC_CONSTEXPR_E bool
+add_overflow(type_identity_t<T> a, type_identity_t<T> b, T &ret) noexcept;
 
-    template <size_t I, WJR_REQUIRES(I >= 0 && I < Size)>
-    constexpr std::tuple_element_t<I, tuple> &
-    operator[](integral_constant<size_t, I>) & noexcept {
-        return get<I>();
-    }
+template <typename U = uint64_t, WJR_REQUIRES(is_unsigned_integral_v<U>)>
+WJR_NODISCARD WJR_INTRINSIC_CONSTEXPR_E U addc_1(uint64_t *dst, const uint64_t *src0,
+                                                 size_t n, uint64_t src1,
+                                                 U c_in = 0) noexcept;
 
-    template <size_t I, WJR_REQUIRES(I >= 0 && I < Size)>
-    constexpr const std::tuple_element_t<I, tuple> &
-    operator[](integral_constant<size_t, I>) const & noexcept {
-        return get<I>();
-    }
+template <typename U = uint64_t, WJR_REQUIRES(is_unsigned_integral_v<U>)>
+WJR_NODISCARD WJR_INTRINSIC_CONSTEXPR_E U addc_n(uint64_t *dst, const uint64_t *src0,
+                                                 const uint64_t *src1, size_t n,
+                                                 U c_in = 0) noexcept;
 
-    template <size_t I, WJR_REQUIRES(I >= 0 && I < Size)>
-    constexpr std::tuple_element_t<I, tuple> &&
-    operator[](integral_constant<size_t, I>) && noexcept {
-        return std::move(get<I>());
-    }
+template <typename U = uint64_t, WJR_REQUIRES(is_unsigned_integral_v<U>)>
+WJR_NODISCARD WJR_INTRINSIC_CONSTEXPR_E U addc_s(uint64_t *dst, const uint64_t *src0,
+                                                 size_t n, const uint64_t *src1, size_t m,
+                                                 U c_in = 0) noexcept;
 
-    template <size_t I, WJR_REQUIRES(I >= 0 && I < Size)>
-    constexpr const std::tuple_element_t<I, tuple> &&
-    operator[](integral_constant<size_t, I>) const && noexcept {
-        return std::move(get<I>());
-    }
+// m can be zero
+template <typename U = uint64_t, WJR_REQUIRES(is_unsigned_integral_v<U>)>
+WJR_NODISCARD WJR_INTRINSIC_CONSTEXPR_E U addc_sz(uint64_t *dst, const uint64_t *src0,
+                                                  size_t n, const uint64_t *src1,
+                                                  size_t m, U c_in = 0) noexcept;
 
-private:
-    Impl m_impl;
-};
+WJR_INTRINSIC_CONSTEXPR_E void __add_128(uint64_t &al, uint64_t &ah, uint64_t lo0,
+                                         uint64_t hi0, uint64_t lo1,
+                                         uint64_t hi1) noexcept;
 
-template <typename... Args>
-tuple(Args...) -> tuple<Args...>;
+WJR_INTRINSIC_CONSTEXPR_E uint64_t __addc_128(uint64_t &al, uint64_t &ah, uint64_t lo0,
+                                              uint64_t hi0, uint64_t lo1, uint64_t hi1,
+                                              uint64_t c_in) noexcept;
 
-template <typename T1, typename T2>
-tuple(std::pair<T1, T2>) -> tuple<T1, T2>;
+WJR_NODISCARD WJR_INTRINSIC_CONSTEXPR_E uint8_t __addc_cc_128(uint64_t &al, uint64_t &ah,
+                                                              uint64_t lo0, uint64_t hi0,
+                                                              uint64_t lo1, uint64_t hi1,
+                                                              uint8_t c_in) noexcept;
 
-template <typename... Args>
-tuple(std::tuple<Args...>) -> tuple<Args...>;
+} // namespace wjr
 
-template <typename... Args>
-constexpr tuple<unref_wrapper_t<Args>...> make_tuple(Args &&...args) noexcept(
-    std::conjunction_v<
-        std::is_nothrow_constructible<unref_wrapper_t<Args>, Args &&>...>) {
-    return tuple<unref_wrapper_t<Args>...>(std::forward<Args>(args)...);
-}
+#endif // WJR_MATH_ADD_IMPL_HPP__
+// Already included
 
-template <typename... Args>
-constexpr tuple<Args &...> tie(Args &...args) noexcept {
-    return tuple<Args &...>(args...);
-}
+#if defined(WJR_X86)
+#ifndef WJR_X86_MATH_ADD_HPP__
+#define WJR_X86_MATH_ADD_HPP__
 
-template <typename... Args>
-constexpr tuple<Args &&...> forward_as_tuple(Args &&...args) noexcept(
-    std::conjunction_v<std::is_nothrow_constructible<Args &&, Args &&>...>) {
-    return tuple<Args &&...>(std::forward<Args>(args)...);
-}
+// Already included
 
-/// @private
-template <typename Func, typename Tuple, size_t... Indexs>
-constexpr decltype(auto)
-apply_impl(Func &&fn, Tuple &&tp, std::index_sequence<Indexs...>) noexcept(noexcept(
-    std::invoke(std::forward<Func>(fn), std::get<Indexs>(std::forward<Tuple>(tp))...))) {
-    return std::invoke(std::forward<Func>(fn),
-                       std::get<Indexs>(std::forward<Tuple>(tp))...);
-}
+#ifndef WJR_X86
+#error "x86 required"
+#endif
 
-template <typename Func, typename Tuple>
-constexpr decltype(auto) apply(Func &&fn, Tuple &&tp) noexcept(noexcept(
-    apply_impl(std::forward<Func>(fn), std::forward<Tuple>(tp),
-               std::make_index_sequence<std::tuple_size_v<remove_cvref_t<Tuple>>>{}))) {
-    return apply_impl(
-        std::forward<Func>(fn), std::forward<Tuple>(tp),
-        std::make_index_sequence<std::tuple_size_v<remove_cvref_t<Tuple>>>{});
-}
+namespace wjr {
 
-/// @private
-template <size_t I, typename Tuple>
-struct __tuple_cat_single_helper {
-    static constexpr size_t Size = std::tuple_size_v<Tuple>;
-    using type0 = tp_repeat_t<tp_list<std::integral_constant<size_t, I>>, Size>;
-    using type1 = tp_make_index_sequence<Size>;
-};
+#if WJR_HAS_FEATURE(GCC_STYLE_INLINE_ASM)
+#define WJR_HAS_BUILTIN_ASM_ADDC WJR_HAS_DEF
+#define WJR_HAS_BUILTIN_ASM_ADDC_N WJR_HAS_DEF
+#define WJR_HAS_BUILTIN___ASM_ADD_128 WJR_HAS_DEF
+#define WJR_HAS_BUILTIN___ASM_ADDC_128 WJR_HAS_DEF
 
-/// @private
-template <typename S, typename... Tuples>
-struct __tuple_cat_helper_impl;
+#if WJR_HAS_FEATURE(INLINE_ASM_CCCOND)
+#define WJR_HAS_BUILTIN_ASM_ADDC_CC WJR_HAS_DEF
+#define WJR_HAS_BUILTIN___ASM_ADDC_CC_128 WJR_HAS_DEF
+#endif
 
-/// @private
-template <size_t... Indexs, typename... Tuples>
-struct __tuple_cat_helper_impl<std::index_sequence<Indexs...>, Tuples...> {
-    using type0 =
-        tp_concat_t<typename __tuple_cat_single_helper<Indexs, Tuples>::type0...>;
-    using type1 =
-        tp_concat_t<typename __tuple_cat_single_helper<Indexs, Tuples>::type1...>;
-};
+#endif
 
-/// @private
-template <typename... Tuples>
-struct __tuple_cat_helper {
-    using Sequence = std::index_sequence_for<Tuples...>;
-    using Impl = __tuple_cat_helper_impl<Sequence, Tuples...>;
-    using type0 = tp_make_std_index_sequence<typename Impl::type0>;
-    using type1 = tp_make_std_index_sequence<typename Impl::type1>;
-};
+#if WJR_HAS_BUILTIN(ASM_ADDC)
 
-/// @private
-template <size_t... I0, size_t... I1, typename... Tuples>
-constexpr decltype(auto) __tuple_cat_impl(std::index_sequence<I0...>,
-                                          std::index_sequence<I1...>,
-                                          tuple<Tuples...> &&tuples) {
-    return tuple(std::get<I1>(std::get<I0>(std::move(tuples)))...);
-}
+/**
+ * @brief Use inline assembly to add two 64-bit integers with carry-in and return the
+ * carry-out.
+ *
+ * @details The carry-in and carry-out flags are both 0 or 1. \n
+ * The carry-out flag is set to 1 if the result overflows. \n
+ * Optimization: \n
+ * 1. Use constraint "i" if a or b is a constant and is in i32 range. \n
+ * 2. If c_in is a constant and c_in == 1, use "stc" to set the carry flag.
+ *
+ * @tparam U The type of the carry.
+ * @param[in] c_in The carry-in flag.
+ * @param[out] c_out The carry-out flag.
+ * @return a + b + c_in
+ */
+template <typename U>
+WJR_INTRINSIC_INLINE uint64_t asm_addc(uint64_t a, uint64_t b, U c_in,
+                                       U &c_out) noexcept {
+    if (WJR_BUILTIN_CONSTANT_P(c_in == 1) && c_in == 1) {
+        if (WJR_BUILTIN_CONSTANT_P(b) && __is_in_i32_range(b)) {
+            asm("stc\n\t"
+                "adc{q %2, %0| %0, %2}\n\t"
+                "setb %b1"
+                : "=r"(a), "+r"(c_in)
+                : "ri"(b), "0"(a)
+                : "cc");
+        } else {
+            asm("stc\n\t"
+                "adc{q %2, %0| %0, %2}\n\t"
+                "setb %b1"
+                : "=r"(a), "+r"(c_in)
+                : "r"(b), "0"(a)
+                : "cc");
+        }
+        c_out = c_in;
+        return a;
+    }
 
-template <typename... Tuples>
-constexpr decltype(auto) tuple_cat(Tuples &&...tuples) {
-    using Helper = __tuple_cat_helper<remove_cvref_t<Tuples>...>;
-    return __tuple_cat_impl(typename Helper::type0{}, typename Helper::type1{},
-                            forward_as_tuple(std::forward<Tuples>(tuples)...));
-}
+    if (WJR_BUILTIN_CONSTANT_P(a)) {
+        if (__is_in_i32_range(a)) {
+            asm("add{b $255, %b1| %b1, 255}\n\t"
+                "adc{q %2, %0| %0, %2}\n\t"
+                "setb %b1"
+                : "=r"(b), "+&r"(c_in)
+                : "ri"(a), "0"(b)
+                : "cc");
+        } else {
+            asm("add{b $255, %b1| %b1, 255}\n\t"
+                "adc{q %2, %0| %0, %2}\n\t"
+                "setb %b1"
+                : "=r"(b), "+&r"(c_in)
+                : "r"(a), "0"(b)
+                : "cc");
+        }
+        c_out = c_in;
+        return b;
+    }
 
-template <typename... TArgs, typename... UArgs>
-constexpr bool
-operator==(const tuple<TArgs...> &lhs, const tuple<UArgs...> &rhs) noexcept(
-    std::conjunction_v<has_noexcept_equal_to<const TArgs &, const UArgs &>...>) {
-    return apply(
-        [&rhs](const auto &...lhs_args) {
-            return apply(
-                [&lhs_args...](const auto &...rhs_args) {
-                    return ((lhs_args == rhs_args) && ...);
-                },
-                rhs);
-        },
-        lhs);
+    if (WJR_BUILTIN_CONSTANT_P(b) && __is_in_i32_range(b)) {
+        asm("add{b $255, %b1| %b1, 255}\n\t"
+            "adc{q %2, %0| %0, %2}\n\t"
+            "setb %b1"
+            : "=r"(a), "+&r"(c_in)
+            : "ri"(b), "0"(a)
+            : "cc");
+    } else {
+        asm("add{b $255, %b1| %b1, 255}\n\t"
+            "adc{q %2, %0| %0, %2}\n\t"
+            "setb %b1"
+            : "=r"(a), "+&r"(c_in)
+            : "r"(b), "0"(a)
+            : "cc");
+    }
+    c_out = c_in;
+    return a;
 }
 
-template <typename... TArgs, typename... UArgs>
-constexpr bool operator!=(const tuple<TArgs...> &lhs,
-                          const tuple<UArgs...> &rhs) noexcept(noexcept(lhs == rhs)) {
-    return !(lhs == rhs);
-}
+#endif
 
-template <typename... TArgs, typename... UArgs>
-constexpr bool operator<(const tuple<TArgs...> &lhs, const tuple<UArgs...> &rhs) noexcept(
-    std::conjunction_v<
-        std::conjunction<has_noexcept_less<const TArgs &, const UArgs &>,
-                         has_noexcept_less<const UArgs &, const TArgs &>>...>) {
-    bool ret = false;
-    apply(
-        [&rhs, &ret](const auto &...lhs_args) {
-            return apply(
-                [&lhs_args..., &ret](const auto &...rhs_args) {
-                    (void)((lhs_args < rhs_args ? (ret = true, false)
-                                                : (rhs_args < lhs_args ? false : true)) &&
-                           ...);
-                },
-                rhs);
-        },
-        lhs);
-    return ret;
-}
+#if WJR_HAS_BUILTIN(ASM_ADDC_CC)
 
-template <typename... TArgs, typename... UArgs>
-constexpr bool operator<=(const tuple<TArgs...> &lhs,
-                          const tuple<UArgs...> &rhs) noexcept(noexcept(rhs < lhs)) {
-    return !(rhs < lhs);
-}
+/**
+ * @brief Use inline assembly to add two 64-bit integers with carry-in and return the
+ * carry-out.
+ *
+ * @details Similar to asm_addc, but the carry-out flag is set by using constraint
+ * "=@cccond" instead of "setb". \n
+ *
+ * @param[in] c_in
+ * @param[out] c_out
+ */
+WJR_INTRINSIC_INLINE uint64_t asm_addc_cc(uint64_t a, uint64_t b, uint8_t c_in,
+                                          uint8_t &c_out) noexcept {
+    if (WJR_BUILTIN_CONSTANT_P(c_in == 1) && c_in == 1) {
+        if (WJR_BUILTIN_CONSTANT_P(b) && __is_in_i32_range(b)) {
+            asm("stc\n\t"
+                "adc{q %2, %0| %0, %2}\n\t" WJR_ASM_CCSET(c)
+                : "=r"(a), WJR_ASM_CCOUT(c)(c_out)
+                : "ri"(b), "0"(a)
+                : "cc");
+        } else {
+            asm("stc\n\t"
+                "adc{q %2, %0| %0, %2}\n\t" WJR_ASM_CCSET(c)
+                : "=r"(a), WJR_ASM_CCOUT(c)(c_out)
+                : "r"(b), "0"(a)
+                : "cc");
+        }
+        return a;
+    }
 
-template <typename... TArgs, typename... UArgs>
-constexpr bool operator>(const tuple<TArgs...> &lhs,
-                         const tuple<UArgs...> &rhs) noexcept(noexcept(rhs < lhs)) {
-    return rhs < lhs;
-}
+    if (WJR_BUILTIN_CONSTANT_P(a)) {
+        if (__is_in_i32_range(a)) {
+            asm("add{b $255, %b1| %b1, 255}\n\t"
+                "adc{q %3, %0| %0, %3}\n\t" WJR_ASM_CCSET(c)
+                : "=r"(b), "+&r"(c_in), WJR_ASM_CCOUT(c)(c_out)
+                : "ri"(a), "0"(b)
+                : "cc");
+        } else {
+            asm("add{b $255, %b1| %b1, 255}\n\t"
+                "adc{q %3, %0| %0, %3}\n\t" WJR_ASM_CCSET(c)
+                : "=r"(b), "+&r"(c_in), WJR_ASM_CCOUT(c)(c_out)
+                : "r"(a), "0"(b)
+                : "cc");
+        }
+        return b;
+    }
 
-template <typename... TArgs, typename... UArgs>
-constexpr bool operator>=(const tuple<TArgs...> &lhs,
-                          const tuple<UArgs...> &rhs) noexcept(noexcept(lhs < rhs)) {
-    return !(lhs < rhs);
+    if (WJR_BUILTIN_CONSTANT_P(b) && __is_in_i32_range(b)) {
+        asm("add{b $255, %b1| %b1, 255}\n\t"
+            "adc{q %3, %0| %0, %3}\n\t" WJR_ASM_CCSET(c)
+            : "=r"(a), "+&r"(c_in), WJR_ASM_CCOUT(c)(c_out)
+            : "ri"(b), "0"(a)
+            : "cc");
+    } else {
+        asm("add{b $255, %b1| %b1, 255}\n\t"
+            "adc{q %3, %0| %0, %3}\n\t" WJR_ASM_CCSET(c)
+            : "=r"(a), "+&r"(c_in), WJR_ASM_CCOUT(c)(c_out)
+            : "r"(b), "0"(a)
+            : "cc");
+    }
+    return a;
 }
 
-template <size_t I, typename... Args>
-struct __in_place_index_tuple_t_tag {};
+#endif
 
-template <size_t I, typename... Args>
-using in_place_index_tuple_t =
-    capture_leaf<tuple<Args...>, __in_place_index_tuple_t_tag<I, Args...>>;
+#if WJR_HAS_BUILTIN(ASM_ADDC_N)
+#define WJR_ADDSUB_I 1
+// WJR_ADDSUB_I :
+// 0 : SUB
+// 1 : ADD
 
-template <size_t I, typename... Args>
-constexpr in_place_index_tuple_t<I, Args &&...>
-in_place_index_tuple(Args &&...args) noexcept(
-    std::conjunction_v<std::is_nothrow_constructible<Args &&, Args &&>...>) {
-    return in_place_index_tuple_t<I, Args &&...>(std::forward<Args>(args)...);
-}
+// Already included
 
-template <typename T, typename... Args>
-struct __in_place_type_tuple_t_tag {};
+#ifndef WJR_ADDSUB_I
+#error "abort"
+#endif
 
-template <typename T, typename... Args>
-using in_place_type_tuple_t =
-    capture_leaf<tuple<Args...>, __in_place_type_tuple_t_tag<T, Args...>>;
+#define WJR_addcsubc WJR_PP_BOOL_IF(WJR_ADDSUB_I, addc, subc)
+#define WJR_adcsbb WJR_PP_BOOL_IF(WJR_ADDSUB_I, adc, sbb)
 
-template <typename T, typename... Args>
-constexpr in_place_type_tuple_t<T, Args &&...>
-in_place_type_tuple(Args &&...args) noexcept(
-    std::conjunction_v<std::is_nothrow_constructible<Args &&, Args &&>...>) {
-    return in_place_type_tuple_t<T, Args &&...>(std::forward<Args>(args)...);
-}
+inline uint64_t WJR_PP_CONCAT(asm_, WJR_PP_CONCAT(WJR_addcsubc, _n_impl))(
+    uint64_t *dst, const uint64_t *src0, const uint64_t *src1, size_t n,
+    uint64_t c_in) noexcept {
+    size_t rcx = n / 8;
+    uint64_t r8 = c_in, r9, r10 = n & 7, r11;
 
-} // namespace wjr
+    asm volatile(
+        "add{b $255, %b[r8]| %b[r8], 255}\n\t"
+        "lea{q| %[r9], [rip +} .Llookup%={(%%rip), %[r9]|]}\n\t"
+        "movs{lq (%[r9], %[r10], 4), %[r10]|xd %[r10], DWORD PTR [%[r9] + %[r10] * 4]}\n\t"
+        "lea{q (%[r9], %[r10], 1), %[r10]| %[r10], [%[r9] + %[r10]]}\n\t"
+        "jmp{q *%[r10]| %[r10]}\n\t"
+        
+        ".align 8\n\t"
+        ".Llookup%=:\n\t"
+        ".long .Ll0%=-.Llookup%=\n\t"
+        ".long .Ll1%=-.Llookup%=\n\t"
+        ".long .Ll2%=-.Llookup%=\n\t"
+        ".long .Ll3%=-.Llookup%=\n\t"
+        ".long .Ll4%=-.Llookup%=\n\t"
+        ".long .Ll5%=-.Llookup%=\n\t"
+        ".long .Ll6%=-.Llookup%=\n\t"
+        ".long .Ll7%=-.Llookup%=\n\t"
+        ".align 16\n\t"
+        
+        ".Ll0%=:\n\t"
+        "mov{q (%[src0]), %[r9]| %[r9], [%[src0]]}\n\t"
+        "mov{q 8(%[src0]), %[r11]| %[r11], [%[src0] + 8]}\n\t"
+        WJR_PP_STR(WJR_adcsbb) "{q (%[src1]), %[r9]| %[r9], [%[src1]]}\n\t"
+        "jmp .Lb0%=\n\t"
 
-namespace std {
+        ".Ld1%=:\n\t"
+        WJR_PP_STR(WJR_adcsbb) "{q (%[src1]), %[r10]| %[r10], [%[src1]]}\n\t"
+        "mov{q %[r10], (%[dst])| [%[dst]], %[r10]}\n\t"
+        "jmp .Ldone%=\n\t"
 
-template <typename... Args,
-          WJR_REQUIRES_I(std::conjunction_v<wjr::is_swappable<Args>...>)>
-constexpr void swap(wjr::tuple<Args...> &lhs,
-                    wjr::tuple<Args...> &rhs) noexcept(noexcept(lhs.swap(rhs))) {
-    lhs.swap(rhs);
-}
+        ".Ll1%=:\n\t"
+        "mov{q (%[src0]), %[r10]| %[r10], [%[src0]]}\n\t"
+        "jrcxz .Ld1%=\n\t"
+        "mov{q 8(%[src0]), %[r9]| %[r9], [%[src0] + 8]}\n\t"
+        WJR_PP_STR(WJR_adcsbb) "{q (%[src1]), %[r10]| %[r10], [%[src1]]}\n\t"
+        "lea{q 8(%[src0]), %[src0]| %[src0], [%[src0] + 8]}\n\t"
+        "lea{q 8(%[src1]), %[src1]| %[src1], [%[src1] + 8]}\n\t"
+        "lea{q 8(%[dst]), %[dst]| %[dst], [%[dst] + 8]}\n\t"
+        "jmp .Lb1%=\n\t"
 
-template <size_t I, typename... Args>
-constexpr tuple_element_t<I, wjr::tuple<Args...>> &get(wjr::tuple<Args...> &t) noexcept {
-    return t.template get<I>();
-}
+        ".Ll3%=:\n\t"
+        "mov{q (%[src0]), %[r11]| %[r11], [%[src0]]}\n\t"
+        "mov{q 8(%[src0]), %[r8]| %[r8], [%[src0] + 8]}\n\t"
+        WJR_PP_STR(WJR_adcsbb) "{q (%[src1]), %[r11]| %[r11], [%[src1]]}\n\t"
+        "lea{q -40(%[src0]), %[src0]| %[src0], [%[src0] - 40]}\n\t"
+        "lea{q -40(%[src1]), %[src1]| %[src1], [%[src1] - 40]}\n\t"
+        "lea{q -40(%[dst]), %[dst]| %[dst], [%[dst] - 40]}\n\t"
+        "inc %[rcx]\n\t"
+        "jmp .Lb3%=\n\t"
 
-template <size_t I, typename... Args>
-constexpr tuple_element_t<I, wjr::tuple<Args...>> &
-get(const wjr::tuple<Args...> &t) noexcept {
-    return t.template get<I>();
-}
+        ".Ll4%=:\n\t"
+        "mov{q (%[src0]), %[r9]| %[r9], [%[src0]]}\n\t"
+        "mov{q 8(%[src0]), %[r11]| %[r11], [%[src0] + 8]}\n\t"
+        WJR_PP_STR(WJR_adcsbb) "{q (%[src1]), %[r9]| %[r9], [%[src1]]}\n\t"
+        "lea{q -32(%[src0]), %[src0]| %[src0], [%[src0] - 32]}\n\t"
+        "lea{q -32(%[src1]), %[src1]| %[src1], [%[src1] - 32]}\n\t"
+        "lea{q -32(%[dst]), %[dst]| %[dst], [%[dst] - 32]}\n\t"
+        "inc %[rcx]\n\t"
+        "jmp .Lb4%=\n\t"
 
-template <size_t I, typename... Args>
-constexpr tuple_element_t<I, wjr::tuple<Args...>> &&
-get(wjr::tuple<Args...> &&t) noexcept {
-    return std::move(t).template get<I>();
-}
+        ".Ll5%=:\n\t"
+        "mov{q (%[src0]), %[r10]| %[r10], [%[src0]]}\n\t"
+        "mov{q 8(%[src0]), %[r9]| %[r9], [%[src0] + 8]}\n\t"
+        WJR_PP_STR(WJR_adcsbb) "{q (%[src1]), %[r10]| %[r10], [%[src1]]}\n\t"
+        "lea{q -24(%[src0]), %[src0]| %[src0], [%[src0] - 24]}\n\t"
+        "lea{q -24(%[src1]), %[src1]| %[src1], [%[src1] - 24]}\n\t"
+        "lea{q -24(%[dst]), %[dst]| %[dst], [%[dst] - 24]}\n\t"
+        "inc %[rcx]\n\t"
+        "jmp .Lb5%=\n\t"
 
-template <size_t I, typename... Args>
-constexpr tuple_element_t<I, wjr::tuple<Args...>> &&
-get(const wjr::tuple<Args...> &&t) noexcept {
-    return std::move(t).template get<I>();
-}
+        ".Ll6%=:\n\t"
+        "mov{q (%[src0]), %[r8]| %[r8], [%[src0]]}\n\t"
+        "mov{q 8(%[src0]), %[r10]| %[r10], [%[src0] + 8]}\n\t"
+        WJR_PP_STR(WJR_adcsbb) "{q (%[src1]), %[r8]| %[r8], [%[src1]]}\n\t"
+        "lea{q -16(%[src0]), %[src0]| %[src0], [%[src0] - 16]}\n\t"
+        "lea{q -16(%[src1]), %[src1]| %[src1], [%[src1] - 16]}\n\t"
+        "lea{q -16(%[dst]), %[dst]| %[dst], [%[dst] - 16]}\n\t"
+        "inc %[rcx]\n\t"
+        "jmp .Lb6%=\n\t"
 
-template <typename T, typename... Args>
-constexpr T &get(wjr::tuple<Args...> &t) noexcept {
-    return get<wjr::tp_find_v<wjr::tuple<Args...>, T>>(t);
-}
-
-template <typename T, typename... Args>
-constexpr T &get(const wjr::tuple<Args...> &t) noexcept {
-    return get<wjr::tp_find_v<wjr::tuple<Args...>, T>>(t);
-}
-
-template <typename T, typename... Args>
-constexpr T &&get(wjr::tuple<Args...> &&t) noexcept {
-    return get<wjr::tp_find_v<wjr::tuple<Args...>, T>>(std::move(t));
-}
+        ".Ll7%=:\n\t"
+        "mov{q (%[src0]), %[r11]| %[r11], [%[src0]]}\n\t"
+        "mov{q 8(%[src0]), %[r8]| %[r8], [%[src0] + 8]}\n\t"
+        WJR_PP_STR(WJR_adcsbb) "{q (%[src1]), %[r11]| %[r11], [%[src1]]}\n\t"
+        "lea{q -8(%[src0]), %[src0]| %[src0], [%[src0] - 8]}\n\t"
+        "lea{q -8(%[src1]), %[src1]| %[src1], [%[src1] - 8]}\n\t"
+        "lea{q -8(%[dst]), %[dst]| %[dst], [%[dst] - 8]}\n\t"
+        "inc %[rcx]\n\t"
+        "jmp .Lb7%=\n\t"
 
-template <typename T, typename... Args>
-constexpr T &&get(const wjr::tuple<Args...> &&t) noexcept {
-    return get<wjr::tp_find_v<wjr::tuple<Args...>, T>>(std::move(t));
-}
+        ".Ld2%=:\n\t"
+        WJR_PP_STR(WJR_adcsbb) "{q 8(%[src1]), %[r10]| %[r10], [%[src1] + 8]}\n\t"
+        "mov{q %[r8], (%[dst])| [%[dst]], %[r8]}\n\t"
+        "mov{q %[r10], 8(%[dst])| [%[dst] + 8], %[r10]}\n\t"
+        "jmp .Ldone%=\n\t"
 
-} // namespace std
+        ".Ll2%=:\n\t"
+        "mov{q (%[src0]), %[r8]| %[r8], [%[src0]]}\n\t"
+        "mov{q 8(%[src0]), %[r10]| %[r10], [%[src0] + 8]}\n\t"
+        WJR_PP_STR(WJR_adcsbb) "{q (%[src1]), %[r8]| %[r8], [%[src1]]}\n\t"
+        "jrcxz .Ld2%=\n\t"
+        "lea{q 16(%[src0]), %[src0]| %[src0], [%[src0] + 16]}\n\t"
+        "lea{q 16(%[src1]), %[src1]| %[src1], [%[src1] + 16]}\n\t"
+        "lea{q 16(%[dst]), %[dst]| %[dst], [%[dst] + 16]}\n\t"
 
-#endif // WJR_TUPLE_HPP__
-// Already included
+        ".align 32\n\t"
+        ".Lloop%=:\n\t"
 
-namespace wjr {
+        ".Lb2%=:\n\t"
+        "mov{q (%[src0]), %[r9]| %[r9], [%[src0]]}\n\t"
+        WJR_PP_STR(WJR_adcsbb) "{q -8(%[src1]), %[r10]| %[r10], [%[src1] - 8]}\n\t"
+        "mov{q %[r8], -16(%[dst])| [%[dst] - 16], %[r8]}\n\t"
 
-template <typename T>
-class div2by1_divider;
+        ".Lb1%=:\n\t"
+        "mov{q 8(%[src0]), %[r11]| %[r11], [%[src0] + 8]}\n\t"
+        WJR_PP_STR(WJR_adcsbb) "{q (%[src1]), %[r9]| %[r9], [%[src1]]}\n\t"
+        "mov{q %[r10], -8(%[dst])| [%[dst] - 8], %[r10]}\n\t"
 
-template <typename T>
-class div3by2_divider;
+        ".Lb0%=:\n\t"
+        "mov{q 16(%[src0]), %[r8]| %[r8], [%[src0] + 16]}\n\t"
+        WJR_PP_STR(WJR_adcsbb) "{q 8(%[src1]), %[r11]| %[r11], [%[src1] + 8]}\n\t"
+        "mov{q %[r9], (%[dst])| [%[dst]], %[r9]}\n\t"
 
-template <typename T>
-class divexact1_divider;
+        ".Lb7%=:\n\t"
+        "mov{q 24(%[src0]), %[r10]| %[r10], [%[src0] + 24]}\n\t"
+        WJR_PP_STR(WJR_adcsbb) "{q 16(%[src1]), %[r8]| %[r8], [%[src1] + 16]}\n\t"
+        "mov{q %[r11], 8(%[dst])| [%[dst] + 8], %[r11]}\n\t"
 
-WJR_INLINE_CONSTEXPR20 uint64_t
-div128by64to64(uint64_t &rem, uint64_t lo, uint64_t hi,
-               const div2by1_divider<uint64_t> &divider) noexcept;
+        ".Lb6%=:\n\t"
+        "mov{q 32(%[src0]), %[r9]| %[r9], [%[src0] + 32]}\n\t"
+        WJR_PP_STR(WJR_adcsbb) "{q 24(%[src1]), %[r10]| %[r10], [%[src1] + 24]}\n\t"
+        "mov{q %[r8], 16(%[dst])| [%[dst] + 16], %[r8]}\n\t"
 
-WJR_INLINE_CONSTEXPR20 uint64_t div128by64to64(uint64_t &rem, uint64_t lo, uint64_t hi,
-                                               uint64_t div) noexcept;
+        ".Lb5%=:\n\t"
+        "mov{q 40(%[src0]), %[r11]| %[r11], [%[src0] + 40]}\n\t"
+        WJR_PP_STR(WJR_adcsbb) "{q 32(%[src1]), %[r9]| %[r9], [%[src1] + 32]}\n\t"
+        "mov{q %[r10], 24(%[dst])| [%[dst] + 24], %[r10]}\n\t"
 
-inline tuple<uint64_t, uint64_t>
-div128by64to128(uint64_t &rem, uint64_t lo, uint64_t hi,
-                const div2by1_divider<uint64_t> &divider) noexcept;
+        ".Lb4%=:\n\t"
+        "mov{q 48(%[src0]), %[r8]| %[r8], [%[src0] + 48]}\n\t"
+        WJR_PP_STR(WJR_adcsbb) "{q 40(%[src1]), %[r11]| %[r11], [%[src1] + 40]}\n\t"
+        "mov{q %[r9], 32(%[dst])| [%[dst] + 32], %[r9]}\n\t"
 
-inline tuple<uint64_t, uint64_t> div128by64to128(uint64_t &rem, uint64_t lo, uint64_t hi,
-                                                 uint64_t div) noexcept;
+        ".Lb3%=:\n\t"
+        "mov{q 56(%[src0]), %[r10]| %[r10], [%[src0] + 56]}\n\t"
+        WJR_PP_STR(WJR_adcsbb) "{q 48(%[src1]), %[r8]| %[r8], [%[src1] + 48]}\n\t"
+        "mov{q %[r11], 40(%[dst])| [%[dst] + 40], %[r11]}\n\t"
 
-WJR_INTRINSIC_CONSTEXPR20 void div_qr_1(uint64_t *dst, uint64_t &rem, const uint64_t *src,
-                                        size_t n,
-                                        const div2by1_divider<uint64_t> &div) noexcept;
+        // TODO : optimize pipeline
+        "lea{q 64(%[src0]), %[src0]| %[src0], [%[src0] + 64]}\n\t"
+        "lea{q 64(%[src1]), %[src1]| %[src1], [%[src1] + 64]}\n\t"
+        "lea{q 64(%[dst]), %[dst]| %[dst], [%[dst] + 64]}\n\t"
+        "dec %[rcx]\n\t"
+        
+        "jne .Lloop%=\n\t"
 
-WJR_INTRINSIC_CONSTEXPR20 void div_qr_1(uint64_t *dst, uint64_t &rem, const uint64_t *src,
-                                        size_t n, uint64_t div) noexcept;
+        WJR_PP_STR(WJR_adcsbb) "{q -8(%[src1]), %[r10]| %[r10], [%[src1] - 8]}\n\t"
+        "mov{q %[r8], -16(%[dst])| [%[dst] - 16], %[r8]}\n\t"
+        "mov{q %[r10], -8(%[dst])| [%[dst] - 8], %[r10]}\n\t"
 
-WJR_INTRINSIC_CONSTEXPR20 void div_qr_2(uint64_t *dst, uint64_t *rem, const uint64_t *src,
-                                        size_t n,
-                                        const div3by2_divider<uint64_t> &div) noexcept;
+        ".Ldone%=:\n\t"
+        "mov %k[rcx], %k[r9]\n\t"
+        "adc{l %k[rcx], %k[r9]| %k[r9], %k[rcx]}"
 
-WJR_INTRINSIC_CONSTEXPR20 void div_qr_2(uint64_t *dst, uint64_t *rem, const uint64_t *src,
-                                        size_t n, const uint64_t *div) noexcept;
+        : [dst] "+r"(dst), [src0] "+r"(src0), [src1] "+r"(src1), [rcx] "+c"(rcx), 
+          [r8] "+r"(r8), [r9] "=&r"(r9), [r10] "+r"(r10), [r11] "=&r"(r11)
+        :
+        : "cc", "memory");
 
-WJR_INTRINSIC_CONSTEXPR20 void div_qr_s(uint64_t *dst, uint64_t *rem, const uint64_t *src,
-                                        size_t n, const uint64_t *div, size_t m) noexcept;
+    WJR_ASSERT_ASSUME(rcx == 0);
+    WJR_ASSERT_ASSUME(r9 <= 1);
 
-WJR_INTRINSIC_CONSTEXPR20 uint64_t divexact_dbm1c(uint64_t *dst, const uint64_t *src,
-                                                  size_t n, uint64_t bd,
-                                                  uint64_t h) noexcept;
+    return r9;
+}
 
-WJR_INTRINSIC_CONSTEXPR20 void divexact_dbm1c_shift(uint64_t *dst, const uint64_t *src,
-                                                    size_t n, uint64_t bd, uint64_t cl,
-                                                    uint64_t hicf) noexcept;
+WJR_INTRINSIC_INLINE uint64_t WJR_PP_CONCAT(asm_, WJR_PP_CONCAT(WJR_addcsubc, _n))(
+    uint64_t *dst, const uint64_t *src0, const uint64_t *src1, size_t n,
+    uint64_t c_in) noexcept {
+    if (WJR_BUILTIN_CONSTANT_P(n)) {
+        if (n == 1) {
+            dst[0] = WJR_PP_CONCAT(asm_, WJR_addcsubc)(src0[0], src1[0], c_in, c_in);
+            return c_in;
+        }
+    }
 
-template <uint64_t c>
-WJR_INTRINSIC_CONSTEXPR20 void divexact_byc(uint64_t *dst, const uint64_t *src, size_t n,
-                                            integral_constant<uint64_t, c>,
-                                            WJR_MAYBE_UNUSED uint64_t cf) noexcept;
+    return WJR_PP_CONCAT(asm_, WJR_PP_CONCAT(WJR_addcsubc, _n_impl))(dst, src0, src1, n,
+                                                                     c_in);
+}
 
-WJR_INTRINSIC_CONSTEXPR20 void
-divexact_1(uint64_t *dst, const uint64_t *src, size_t n,
-           const divexact1_divider<uint64_t> &div) noexcept;
+#undef WJR_adcsbb
+#undef WJR_addcsubc
 
-WJR_INTRINSIC_CONSTEXPR20 void divexact_1(uint64_t *dst, const uint64_t *src, size_t n,
-                                          uint64_t div) noexcept;
+#undef WJR_ADDSUB_I
+#endif
 
-WJR_PURE WJR_INTRINSIC_CONSTEXPR20 uint64_t
-mod_1(const uint64_t *src, size_t n, const div2by1_divider<uint64_t> &div) noexcept;
+#if WJR_HAS_BUILTIN(__ASM_ADD_128)
 
-WJR_PURE WJR_INTRINSIC_CONSTEXPR20 uint64_t mod_1(const uint64_t *src, size_t n,
-                                                  uint64_t div) noexcept;
+/**
+ * @brief Use inline assembly to add two 64-bit integers and return the result.
+ *
+ */
+WJR_INTRINSIC_INLINE void __asm_add_128(uint64_t &al, uint64_t &ah, uint64_t lo0,
+                                        uint64_t hi0, uint64_t lo1,
+                                        uint64_t hi1) noexcept {
+    if (WJR_BUILTIN_CONSTANT_P(hi0) && hi0 <= UINT32_MAX) {
+        asm("add{q %[lo1], %[lo0]| %[lo0], %[lo1]}\n\t"
+            "adc{q %[hi0], %[hi1]| %[hi1], %[hi0]}"
+            : [lo0] "+&r"(lo0), [hi1] "+r"(hi1)
+            : [lo1] "r"(lo1), [hi0] "i"(hi0)
+            : "cc");
+        al = lo0;
+        ah = hi1;
+        return;
+    } else if (WJR_BUILTIN_CONSTANT_P(hi1) && hi1 <= UINT32_MAX) {
+        asm("add{q %[lo1], %[lo0]| %[lo0], %[lo1]}\n\t"
+            "adc{q %[hi1], %[hi0]| %[hi0], %[hi1]}"
+            : [lo0] "+&r"(lo0), [hi0] "+r"(hi0)
+            : [lo1] "r"(lo1), [hi1] "i"(hi1)
+            : "cc");
+        al = lo0;
+        ah = hi0;
+        return;
+    }
 
-} // namespace wjr
+    asm("add{q %[lo1], %[lo0]| %[lo0], %[lo1]}\n\t"
+        "adc{q %[hi1], %[hi0]| %[hi0], %[hi1]}"
+        : [lo0] "+&r"(lo0), [hi0] "+r"(hi0)
+        : [lo1] "r"(lo1), [hi1] "r"(hi1)
+        : "cc");
+    al = lo0;
+    ah = hi0;
+    return;
+}
 
-#endif // WJR_MATH_DIV_IMPL_HPP__
-#ifndef WJR_MATH_DIVIDER_HPP__
-#define WJR_MATH_DIVIDER_HPP__
+#endif
 
-#ifndef WJR_MATH_MUL_HPP__
-#define WJR_MATH_MUL_HPP__
+#if WJR_HAS_BUILTIN(__ASM_ADDC_128) || WJR_HAS_BUILTIN(__ASM_ADDC_CC_128)
 
 /**
- * @todo optimize temporary memory usage of mul_s, mul_n, sqr
+ * @brief Use inline assembly to add two 64-bit integers and return the
+ * carry-out.
+ *
+ * @details Optimzation for __asm_addc_cc_128 and __asm_addc_128 when the carry-in is 0.
  *
  */
+WJR_INTRINSIC_INLINE uint8_t __asm_addc_cc_zero_128(uint64_t &al, uint64_t &ah,
+                                                    uint64_t lo0, uint64_t hi0,
+                                                    uint64_t lo1, uint64_t hi1) noexcept {
+    uint8_t c_out;
+    if (WJR_BUILTIN_CONSTANT_P(hi0) && hi0 <= UINT32_MAX) {
+        asm("add{q %[lo1], %[lo0]| %[lo0], %[lo1]}\n\t"
+            "adc{q %[hi0], %[hi1]| %[hi1], %[hi0]}\n\t" WJR_ASM_CCSET(c)
+            : [lo0] "+&r"(lo0), [hi1] "+r"(hi1), WJR_ASM_CCOUT(c)(c_out)
+            : [lo1] "r"(lo1), [hi0] "i"(hi0)
+            : "cc");
+        al = lo0;
+        ah = hi1;
+        return c_out;
+    } else if (WJR_BUILTIN_CONSTANT_P(hi1) && hi1 <= UINT32_MAX) {
+        asm("add{q %[lo1], %[lo0]| %[lo0], %[lo1]}\n\t"
+            "adc{q %[hi1], %[hi0]| %[hi0], %[hi1]}\n\t" WJR_ASM_CCSET(c)
+            : [lo0] "+&r"(lo0), [hi0] "+r"(hi0), WJR_ASM_CCOUT(c)(c_out)
+            : [lo1] "r"(lo1), [hi1] "i"(hi1)
+            : "cc");
+        al = lo0;
+        ah = hi0;
+        return c_out;
+    }
 
-#ifndef WJR_MATH_ADD_HPP__
-#define WJR_MATH_ADD_HPP__
-
-// Already included
-#ifndef WJR_MATH_ADD_IMPL_HPP__
-#define WJR_MATH_ADD_IMPL_HPP__
-
-// Already included
+    asm("add{q %[lo1], %[lo0]| %[lo0], %[lo1]}\n\t"
+        "adc{q %[hi1], %[hi0]| %[hi0], %[hi1]}\n\t" WJR_ASM_CCSET(c)
+        : [lo0] "+&r"(lo0), [hi0] "+r"(hi0), WJR_ASM_CCOUT(c)(c_out)
+        : [lo1] "r"(lo1), [hi1] "r"(hi1)
+        : "cc");
+    al = lo0;
+    ah = hi0;
+    return c_out;
+}
 
-namespace wjr {
+#endif
 
-template <typename T, typename U,
-          WJR_REQUIRES(is_nonbool_unsigned_integral_v<T> &&is_unsigned_integral_v<U>)>
-WJR_NODISCARD WJR_INTRINSIC_CONSTEXPR_E T addc(T a, T b, type_identity_t<U> c_in,
-                                               U &c_out) noexcept;
+#if WJR_HAS_BUILTIN(__ASM_ADDC_128)
 
-template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-WJR_NODISCARD WJR_INTRINSIC_CONSTEXPR_E T addc_cc(T a, T b, uint8_t c_in,
-                                                  uint8_t &c_out) noexcept;
+/**
+ * @brief Use inline assembly to add two 64-bit integers with carry-in and return the
+ * carry-out.
+ *
+ */
+WJR_INTRINSIC_INLINE uint64_t __asm_addc_128(uint64_t &al, uint64_t &ah, uint64_t lo0,
+                                             uint64_t hi0, uint64_t lo1, uint64_t hi1,
+                                             uint64_t c_in) noexcept {
+    if (WJR_BUILTIN_CONSTANT_P(c_in == 0) && c_in == 0) {
+        return __asm_addc_cc_zero_128(al, ah, lo0, hi0, lo1, hi1);
+    }
 
-template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-WJR_NODISCARD WJR_INTRINSIC_CONSTEXPR_E bool
-add_overflow(type_identity_t<T> a, type_identity_t<T> b, T &ret) noexcept;
+    if (WJR_BUILTIN_CONSTANT_P(hi0) && hi0 <= UINT32_MAX) {
+        asm("add{b $0xff, %b[c_in]| %b[c_in], 0xff}\n\t"
+            "adc{q %[lo1], %[lo0]| %[lo0], %[lo1]}\n\t"
+            "adc{q %[hi0], %[hi1]| %[hi1], %[hi0]}\n\t"
+            "setb %b[c_in]"
+            : [lo0] "+&r"(lo0), [hi1] "+r"(hi1), [c_in] "+&r"(c_in)
+            : [lo1] "r"(lo1), [hi0] "i"(hi0)
+            : "cc");
+        al = lo0;
+        ah = hi1;
+        return c_in;
+    } else if (WJR_BUILTIN_CONSTANT_P(hi1) && hi1 <= UINT32_MAX) {
+        asm("add{b $0xff, %b[c_in]| %b[c_in], 0xff}\n\t"
+            "adc{q %[lo1], %[lo0]| %[lo0], %[lo1]}\n\t"
+            "adc{q %[hi1], %[hi0]| %[hi0], %[hi1]}\n\t"
+            "setb %b[c_in]"
+            : [lo0] "+&r"(lo0), [hi0] "+r"(hi0), [c_in] "+&r"(c_in)
+            : [lo1] "r"(lo1), [hi1] "i"(hi1)
+            : "cc");
+        al = lo0;
+        ah = hi0;
+        return c_in;
+    }
 
-template <typename U = uint64_t, WJR_REQUIRES(is_unsigned_integral_v<U>)>
-WJR_NODISCARD WJR_INTRINSIC_CONSTEXPR_E U addc_1(uint64_t *dst, const uint64_t *src0,
-                                                 size_t n, uint64_t src1,
-                                                 U c_in = 0) noexcept;
+    asm("add{b $0xff, %b[c_in]| %b[c_in], 0xff}\n\t"
+        "adc{q %[lo1], %[lo0]| %[lo0], %[lo1]}\n\t"
+        "adc{q %[hi1], %[hi0]| %[hi0], %[hi1]}\n\t"
+        "setb %b[c_in]"
+        : [lo0] "+&r"(lo0), [hi0] "+r"(hi0), [c_in] "+&r"(c_in)
+        : [lo1] "r"(lo1), [hi1] "r"(hi1)
+        : "cc");
+    al = lo0;
+    ah = hi0;
+    return c_in;
+}
 
-template <typename U = uint64_t, WJR_REQUIRES(is_unsigned_integral_v<U>)>
-WJR_NODISCARD WJR_INTRINSIC_CONSTEXPR_E U addc_n(uint64_t *dst, const uint64_t *src0,
-                                                 const uint64_t *src1, size_t n,
-                                                 U c_in = 0) noexcept;
+#endif
 
-template <typename U = uint64_t, WJR_REQUIRES(is_unsigned_integral_v<U>)>
-WJR_NODISCARD WJR_INTRINSIC_CONSTEXPR_E U addc_s(uint64_t *dst, const uint64_t *src0,
-                                                 size_t n, const uint64_t *src1, size_t m,
-                                                 U c_in = 0) noexcept;
+#if WJR_HAS_BUILTIN(__ASM_ADDC_CC_128)
 
-// m can be zero
-template <typename U = uint64_t, WJR_REQUIRES(is_unsigned_integral_v<U>)>
-WJR_NODISCARD WJR_INTRINSIC_CONSTEXPR_E U addc_sz(uint64_t *dst, const uint64_t *src0,
-                                                  size_t n, const uint64_t *src1,
-                                                  size_t m, U c_in = 0) noexcept;
+/**
+ * @brief Use inline assembly to add two 64-bit integers with carry-in and return the
+ * carry-out.
+ *
+ * @details Similar to __asm_addc_128, but the carry-out flag is set by using constraint
+ * "=@cccond" instead of "setb".
+ *
+ */
+WJR_INTRINSIC_INLINE uint8_t __asm_addc_cc_128(uint64_t &al, uint64_t &ah, uint64_t lo0,
+                                               uint64_t hi0, uint64_t lo1, uint64_t hi1,
+                                               uint8_t c_in) noexcept {
+    if (WJR_BUILTIN_CONSTANT_P(c_in == 0) && c_in == 0) {
+        return __asm_addc_cc_zero_128(al, ah, lo0, hi0, lo1, hi1);
+    }
 
-WJR_INTRINSIC_CONSTEXPR_E void __add_128(uint64_t &al, uint64_t &ah, uint64_t lo0,
-                                         uint64_t hi0, uint64_t lo1,
-                                         uint64_t hi1) noexcept;
+    uint8_t c_out;
+    if (WJR_BUILTIN_CONSTANT_P(hi0) && hi0 <= UINT32_MAX) {
+        asm("add{b $0xff, %b[c_in]| %b[c_in], 0xff}\n\t"
+            "adc{q %[lo1], %[lo0]| %[lo0], %[lo1]}\n\t"
+            "adc{q %[hi0], %[hi1]| %[hi1], %[hi0]}\n\t" WJR_ASM_CCSET(c)
+            : [lo0] "+&r"(lo0), [hi1] "+r"(hi1), [c_in] "+&r"(c_in),
+              WJR_ASM_CCOUT(c)(c_out)
+            : [lo1] "r"(lo1), [hi0] "i"(hi0)
+            : "cc");
+        al = lo0;
+        ah = hi1;
+        return c_out;
+    } else if (WJR_BUILTIN_CONSTANT_P(hi1) && hi1 <= UINT32_MAX) {
+        asm("add{b $0xff, %b[c_in]| %b[c_in], 0xff}\n\t"
+            "adc{q %[lo1], %[lo0]| %[lo0], %[lo1]}\n\t"
+            "adc{q %[hi1], %[hi0]| %[hi0], %[hi1]}\n\t" WJR_ASM_CCSET(c)
+            : [lo0] "+&r"(lo0), [hi0] "+r"(hi0), [c_in] "+&r"(c_in),
+              WJR_ASM_CCOUT(c)(c_out)
+            : [lo1] "r"(lo1), [hi1] "i"(hi1)
+            : "cc");
+        al = lo0;
+        ah = hi0;
+        return c_out;
+    }
 
-WJR_INTRINSIC_CONSTEXPR_E uint64_t __addc_128(uint64_t &al, uint64_t &ah, uint64_t lo0,
-                                              uint64_t hi0, uint64_t lo1, uint64_t hi1,
-                                              uint64_t c_in) noexcept;
+    asm("add{b $0xff, %b[c_in]| %b[c_in], 0xff}\n\t"
+        "adc{q %[lo1], %[lo0]| %[lo0], %[lo1]}\n\t"
+        "adc{q %[hi1], %[hi0]| %[hi0], %[hi1]}\n\t" WJR_ASM_CCSET(c)
+        : [lo0] "+&r"(lo0), [hi0] "+r"(hi0), [c_in] "+&r"(c_in), WJR_ASM_CCOUT(c)(c_out)
+        : [lo1] "r"(lo1), [hi1] "r"(hi1)
+        : "cc");
+    al = lo0;
+    ah = hi0;
+    return c_out;
+}
 
-WJR_NODISCARD WJR_INTRINSIC_CONSTEXPR_E uint8_t __addc_cc_128(uint64_t &al, uint64_t &ah,
-                                                              uint64_t lo0, uint64_t hi0,
-                                                              uint64_t lo1, uint64_t hi1,
-                                                              uint8_t c_in) noexcept;
+#endif
 
 } // namespace wjr
 
-#endif // WJR_MATH_ADD_IMPL_HPP__
-// Already included
+#endif // WJR_X86_MATH_ADD_HPP__
+#endif
 
-#if defined(WJR_X86)
-#ifndef WJR_X86_MATH_ADD_HPP__
-#define WJR_X86_MATH_ADD_HPP__
+namespace wjr {
 
-// Already included
+template <typename T, typename U>
+WJR_INTRINSIC_CONSTEXPR T fallback_addc(T a, T b, U c_in, U &c_out) noexcept {
+    T ret = a;
+    ret += b;
+    U c = ret < b;
+    ret += c_in;
+    c |= ret < c_in;
+    c_out = c;
+    return ret;
+}
 
-#ifndef WJR_X86
-#error "x86 required"
+#if WJR_HAS_BUILTIN(__builtin_addc)
+#define WJR_HAS_BUILTIN_ADDC WJR_HAS_DEF
 #endif
 
-namespace wjr {
+#if WJR_HAS_BUILTIN(ADDC)
 
-#if WJR_HAS_FEATURE(GCC_STYLE_INLINE_ASM)
-#define WJR_HAS_BUILTIN_ASM_ADDC WJR_HAS_DEF
-#define WJR_HAS_BUILTIN_ASM_ADDC_N WJR_HAS_DEF
-#define WJR_HAS_BUILTIN___ASM_ADD_128 WJR_HAS_DEF
-#define WJR_HAS_BUILTIN___ASM_ADDC_128 WJR_HAS_DEF
+template <typename T, typename U>
+WJR_INTRINSIC_INLINE T builtin_addc(T a, T b, U c_in, U &c_out) noexcept {
+    constexpr auto nd = std::numeric_limits<T>::digits;
 
-#if WJR_HAS_FEATURE(INLINE_ASM_CCCOND)
-#define WJR_HAS_BUILTIN_ASM_ADDC_CC WJR_HAS_DEF
-#define WJR_HAS_BUILTIN___ASM_ADDC_CC_128 WJR_HAS_DEF
-#endif
+#define WJR_REGISTER_BUILTIN_ADDC(suffix, type)                                          \
+    if constexpr (nd <= std::numeric_limits<type>::digits) {                             \
+        type __c_out;                                                                    \
+        const T ret = __builtin_addc##suffix(a, b, static_cast<type>(c_in), &__c_out);   \
+        c_out = static_cast<U>(__c_out);                                                 \
+        return ret;                                                                      \
+    } else
 
-#endif
+    WJR_REGISTER_BUILTIN_ADDC(b, unsigned char)
+    WJR_REGISTER_BUILTIN_ADDC(s, unsigned short)
+    WJR_REGISTER_BUILTIN_ADDC(, unsigned int)
+    WJR_REGISTER_BUILTIN_ADDC(l, unsigned long)
+    WJR_REGISTER_BUILTIN_ADDC(ll, unsigned long long) {
+        static_assert(nd <= 64, "not supported yet");
+    }
 
-#if WJR_HAS_BUILTIN(ASM_ADDC)
+#undef WJR_REGISTER_BUILTIN_ADDC
+}
+
+#endif // WJR_HAS_BUILTIN(ADDC)
 
 /**
- * @brief Use inline assembly to add two 64-bit integers with carry-in and return the
- * carry-out.
- *
- * @details The carry-in and carry-out flags are both 0 or 1. \n
- * The carry-out flag is set to 1 if the result overflows. \n
- * Optimization: \n
- * 1. Use constraint "i" if a or b is a constant and is in i32 range. \n
- * 2. If c_in is a constant and c_in == 1, use "stc" to set the carry flag.
+ * @brief Add two numbers with carry-in, and return the result and carry-out
  *
- * @tparam U The type of the carry.
+ * @note The carry-in and carry-out are limited to 0 and 1
+ * @tparam U Type of the carry-in and carry-out. It must be an unsigned integral type.
+ * the default type is the same as `T`
  * @param[in] c_in The carry-in flag.
  * @param[out] c_out The carry-out flag.
+ *
  * @return a + b + c_in
  */
-template <typename U>
-WJR_INTRINSIC_INLINE uint64_t asm_addc(uint64_t a, uint64_t b, U c_in,
-                                       U &c_out) noexcept {
-    if (WJR_BUILTIN_CONSTANT_P(c_in == 1) && c_in == 1) {
-        if (WJR_BUILTIN_CONSTANT_P(b) && __is_in_i32_range(b)) {
-            asm("stc\n\t"
-                "adc{q %2, %0| %0, %2}\n\t"
-                "setb %b1"
-                : "=r"(a), "+r"(c_in)
-                : "ri"(b), "0"(a)
-                : "cc");
-        } else {
-            asm("stc\n\t"
-                "adc{q %2, %0| %0, %2}\n\t"
-                "setb %b1"
-                : "=r"(a), "+r"(c_in)
-                : "r"(b), "0"(a)
-                : "cc");
-        }
-        c_out = c_in;
-        return a;
-    }
+template <typename T, typename U,
+          WJR_REQUIRES_I(is_nonbool_unsigned_integral_v<T> &&is_unsigned_integral_v<U>)>
+WJR_INTRINSIC_CONSTEXPR_E T addc(T a, T b, type_identity_t<U> c_in, U &c_out) noexcept {
+    WJR_ASSERT_ASSUME_L2(c_in <= 1);
 
-    if (WJR_BUILTIN_CONSTANT_P(a)) {
-        if (__is_in_i32_range(a)) {
-            asm("add{b $255, %b1| %b1, 255}\n\t"
-                "adc{q %2, %0| %0, %2}\n\t"
-                "setb %b1"
-                : "=r"(b), "+&r"(c_in)
-                : "ri"(a), "0"(b)
-                : "cc");
-        } else {
-            asm("add{b $255, %b1| %b1, 255}\n\t"
-                "adc{q %2, %0| %0, %2}\n\t"
-                "setb %b1"
-                : "=r"(b), "+&r"(c_in)
-                : "r"(a), "0"(b)
-                : "cc");
-        }
-        c_out = c_in;
-        return b;
-    }
+#if !WJR_HAS_BUILTIN(ADDC) && !WJR_HAS_BUILTIN(ASM_ADDC)
+    return fallback_addc(a, b, c_in, c_out);
+#else
+    constexpr auto is_constant_or_zero = [](auto x) -> int {
+        return WJR_BUILTIN_CONSTANT_P(x == 0) && x == 0 ? 2
+               : WJR_BUILTIN_CONSTANT_P(x)              ? 1
+                                                        : 0;
+    };
 
-    if (WJR_BUILTIN_CONSTANT_P(b) && __is_in_i32_range(b)) {
-        asm("add{b $255, %b1| %b1, 255}\n\t"
-            "adc{q %2, %0| %0, %2}\n\t"
-            "setb %b1"
-            : "=r"(a), "+&r"(c_in)
-            : "ri"(b), "0"(a)
-            : "cc");
-    } else {
-        asm("add{b $255, %b1| %b1, 255}\n\t"
-            "adc{q %2, %0| %0, %2}\n\t"
-            "setb %b1"
-            : "=r"(a), "+&r"(c_in)
-            : "r"(b), "0"(a)
-            : "cc");
+    // The compiler should be able to optimize the judgment condition of if when enabling
+    // optimization. If it doesn't work, then there should be a issue
+    if (is_constant_evaluated() ||
+        // constant value is zero or constant value number greater or equal than 2
+        (is_constant_or_zero(a) + is_constant_or_zero(b) + is_constant_or_zero(c_in) >=
+         2)) {
+        return fallback_addc(a, b, c_in, c_out);
     }
-    c_out = c_in;
-    return a;
-}
 
+    if constexpr (sizeof(T) == 8) {
+        return WJR_PP_BOOL_IF(WJR_HAS_BUILTIN(ASM_ADDC), asm_addc,
+                              WJR_PP_BOOL_IF(WJR_HAS_BUILTIN(ADDC), builtin_addc,
+                                             fallback_addc))(a, b, c_in, c_out);
+    } else {
+        return WJR_PP_BOOL_IF(WJR_HAS_BUILTIN(ADDC), builtin_addc,
+                              fallback_addc)(a, b, c_in, c_out);
+    }
 #endif
-
-#if WJR_HAS_BUILTIN(ASM_ADDC_CC)
+}
 
 /**
- * @brief Use inline assembly to add two 64-bit integers with carry-in and return the
- * carry-out.
+ * @brief Performs addition with carry-in and carry-out, optimized for subsequent
+ * branching based on carry-out.
  *
- * @details Similar to asm_addc, but the carry-out flag is set by using constraint
- * "=@cccond" instead of "setb". \n
+ * @details This function, `addc_cc`, adds two numbers with a carry-in, and returns the
+ * result and a carry-out. The carry-out (`c_out`) is optimized for subsequent code that
+ * branches based on its value. For example, it can be used with jump instructions like
+ * `je` or `jne`. This is in contrast to the `addc` function, which may use instructions
+ * like `setc` or `test` for branching.
  *
- * @param[in] c_in
- * @param[out] c_out
+ * @note The carry-in and carry-out are limited to 0 and 1
+ * @tparam U Type of the carry-in and carry-out. It must be an unsigned integral type.
+ * @param[in] c_in The carry-in flag.
+ * @param[out] c_out The carry-out flag.
  */
-WJR_INTRINSIC_INLINE uint64_t asm_addc_cc(uint64_t a, uint64_t b, uint8_t c_in,
-                                          uint8_t &c_out) noexcept {
-    if (WJR_BUILTIN_CONSTANT_P(c_in == 1) && c_in == 1) {
-        if (WJR_BUILTIN_CONSTANT_P(b) && __is_in_i32_range(b)) {
-            asm("stc\n\t"
-                "adc{q %2, %0| %0, %2}\n\t" WJR_ASM_CCSET(c)
-                : "=r"(a), WJR_ASM_CCOUT(c)(c_out)
-                : "ri"(b), "0"(a)
-                : "cc");
-        } else {
-            asm("stc\n\t"
-                "adc{q %2, %0| %0, %2}\n\t" WJR_ASM_CCSET(c)
-                : "=r"(a), WJR_ASM_CCOUT(c)(c_out)
-                : "r"(b), "0"(a)
-                : "cc");
-        }
-        return a;
-    }
+template <typename T, WJR_REQUIRES_I(is_nonbool_unsigned_integral_v<T>)>
+WJR_INTRINSIC_CONSTEXPR_E T addc_cc(T a, T b, uint8_t c_in, uint8_t &c_out) noexcept {
+    WJR_ASSERT_ASSUME_L2(c_in <= 1);
 
-    if (WJR_BUILTIN_CONSTANT_P(a)) {
-        if (__is_in_i32_range(a)) {
-            asm("add{b $255, %b1| %b1, 255}\n\t"
-                "adc{q %3, %0| %0, %3}\n\t" WJR_ASM_CCSET(c)
-                : "=r"(b), "+&r"(c_in), WJR_ASM_CCOUT(c)(c_out)
-                : "ri"(a), "0"(b)
-                : "cc");
-        } else {
-            asm("add{b $255, %b1| %b1, 255}\n\t"
-                "adc{q %3, %0| %0, %3}\n\t" WJR_ASM_CCSET(c)
-                : "=r"(b), "+&r"(c_in), WJR_ASM_CCOUT(c)(c_out)
-                : "r"(a), "0"(b)
-                : "cc");
-        }
-        return b;
+#if WJR_HAS_BUILTIN(ASM_ADDC_CC)
+    constexpr auto is_constant_or_zero = [](auto x) -> int {
+        return WJR_BUILTIN_CONSTANT_P(x == 0) && x == 0 ? 2
+               : WJR_BUILTIN_CONSTANT_P(x)              ? 1
+                                                        : 0;
+    };
+
+    // The compiler should be able to optimize the judgment condition of if when enabling
+    // optimization. If it doesn't work, then there should be a issue
+    if (is_constant_evaluated() ||
+        // constant value is zero or constant value number greater or equal than 2
+        (is_constant_or_zero(a) + is_constant_or_zero(b) + is_constant_or_zero(c_in) >=
+         2)) {
+        return fallback_addc(a, b, c_in, c_out);
     }
 
-    if (WJR_BUILTIN_CONSTANT_P(b) && __is_in_i32_range(b)) {
-        asm("add{b $255, %b1| %b1, 255}\n\t"
-            "adc{q %3, %0| %0, %3}\n\t" WJR_ASM_CCSET(c)
-            : "=r"(a), "+&r"(c_in), WJR_ASM_CCOUT(c)(c_out)
-            : "ri"(b), "0"(a)
-            : "cc");
+    if constexpr (sizeof(T) == 8) {
+        return asm_addc_cc(a, b, c_in, c_out);
     } else {
-        asm("add{b $255, %b1| %b1, 255}\n\t"
-            "adc{q %3, %0| %0, %3}\n\t" WJR_ASM_CCSET(c)
-            : "=r"(a), "+&r"(c_in), WJR_ASM_CCOUT(c)(c_out)
-            : "r"(b), "0"(a)
-            : "cc");
+        return addc(a, b, c_in, c_out);
     }
-    return a;
+#else
+    return addc(a, b, c_in, c_out);
+#endif
 }
 
+#if WJR_HAS_BUILTIN(__builtin_add_overflow)
+#define WJR_HAS_BUILTIN_ADD_OVERFLOW WJR_HAS_DEF
 #endif
 
-#if WJR_HAS_BUILTIN(ASM_ADDC_N)
-#define WJR_ADDSUB_I 1
-// WJR_ADDSUB_I :
-// 0 : SUB
-// 1 : ADD
+template <typename T>
+WJR_INTRINSIC_CONSTEXPR_E bool fallback_add_overflow(T a, T b, T &ret) noexcept {
+    ret = a + b;
+    return ret < a;
+}
 
-// Already included
+template <typename T, WJR_REQUIRES_I(is_nonbool_unsigned_integral_v<T>)>
+WJR_INTRINSIC_CONSTEXPR_E bool add_overflow(type_identity_t<T> a, type_identity_t<T> b,
+                                            T &ret) noexcept {
+#if WJR_HAS_BUILTIN(ADD_OVERFLOW)
+    if (is_constant_evaluated() ||
+        (WJR_BUILTIN_CONSTANT_P(a) && WJR_BUILTIN_CONSTANT_P(b))) {
+        return fallback_add_overflow(a, b, ret);
+    }
 
-#ifndef WJR_ADDSUB_I
-#error "abort"
+    return __builtin_add_overflow(a, b, &ret);
+#else
+    return fallback_add_overflow(a, b, ret);
 #endif
+}
 
-#define WJR_addcsubc WJR_PP_BOOL_IF(WJR_ADDSUB_I, addc, subc)
-#define WJR_adcsbb WJR_PP_BOOL_IF(WJR_ADDSUB_I, adc, sbb)
+template <typename U>
+WJR_INTRINSIC_CONSTEXPR_E U __addc_1_impl(uint64_t *dst, const uint64_t *src0, size_t n,
+                                          uint64_t src1, U c_in) noexcept {
+    uint8_t overflow = 0;
+    dst[0] = addc_cc(src0[0], src1, c_in, overflow);
 
-inline uint64_t WJR_PP_CONCAT(asm_, WJR_PP_CONCAT(WJR_addcsubc, _n_impl))(
-    uint64_t *dst, const uint64_t *src0, const uint64_t *src1, size_t n,
-    uint64_t c_in) noexcept {
-    size_t rcx = n / 8;
-    uint64_t r8 = c_in, r9, r10 = n & 7, r11;
+    if (overflow) {
+        size_t idx = 1 + replace_find_not(dst + 1, src0 + 1, n - 1, -1, 0);
 
-    asm volatile(
-        "add{b $255, %b[r8]| %b[r8], 255}\n\t"
-        "lea{q| %[r9], [rip +} .Llookup%={(%%rip), %[r9]|]}\n\t"
-        "movs{lq (%[r9], %[r10], 4), %[r10]|xd %[r10], DWORD PTR [%[r9] + %[r10] * 4]}\n\t"
-        "lea{q (%[r9], %[r10], 1), %[r10]| %[r10], [%[r9] + %[r10]]}\n\t"
-        "jmp{q *%[r10]| %[r10]}\n\t"
-        
-        ".align 8\n\t"
-        ".Llookup%=:\n\t"
-        ".long .Ll0%=-.Llookup%=\n\t"
-        ".long .Ll1%=-.Llookup%=\n\t"
-        ".long .Ll2%=-.Llookup%=\n\t"
-        ".long .Ll3%=-.Llookup%=\n\t"
-        ".long .Ll4%=-.Llookup%=\n\t"
-        ".long .Ll5%=-.Llookup%=\n\t"
-        ".long .Ll6%=-.Llookup%=\n\t"
-        ".long .Ll7%=-.Llookup%=\n\t"
-        ".align 16\n\t"
-        
-        ".Ll0%=:\n\t"
-        "mov{q (%[src0]), %[r9]| %[r9], [%[src0]]}\n\t"
-        "mov{q 8(%[src0]), %[r11]| %[r11], [%[src0] + 8]}\n\t"
-        WJR_PP_STR(WJR_adcsbb) "{q (%[src1]), %[r9]| %[r9], [%[src1]]}\n\t"
-        "jmp .Lb0%=\n\t"
+        if (WJR_UNLIKELY(idx == n)) {
+            return static_cast<U>(1);
+        }
 
-        ".Ld1%=:\n\t"
-        WJR_PP_STR(WJR_adcsbb) "{q (%[src1]), %[r10]| %[r10], [%[src1]]}\n\t"
-        "mov{q %[r10], (%[dst])| [%[dst]], %[r10]}\n\t"
-        "jmp .Ldone%=\n\t"
+        dst[idx] = src0[idx] + 1;
 
-        ".Ll1%=:\n\t"
-        "mov{q (%[src0]), %[r10]| %[r10], [%[src0]]}\n\t"
-        "jrcxz .Ld1%=\n\t"
-        "mov{q 8(%[src0]), %[r9]| %[r9], [%[src0] + 8]}\n\t"
-        WJR_PP_STR(WJR_adcsbb) "{q (%[src1]), %[r10]| %[r10], [%[src1]]}\n\t"
-        "lea{q 8(%[src0]), %[src0]| %[src0], [%[src0] + 8]}\n\t"
-        "lea{q 8(%[src1]), %[src1]| %[src1], [%[src1] + 8]}\n\t"
-        "lea{q 8(%[dst]), %[dst]| %[dst], [%[dst] + 8]}\n\t"
-        "jmp .Lb1%=\n\t"
+        dst += idx;
+        src0 += idx;
+        n -= idx;
+    }
 
-        ".Ll3%=:\n\t"
-        "mov{q (%[src0]), %[r11]| %[r11], [%[src0]]}\n\t"
-        "mov{q 8(%[src0]), %[r8]| %[r8], [%[src0] + 8]}\n\t"
-        WJR_PP_STR(WJR_adcsbb) "{q (%[src1]), %[r11]| %[r11], [%[src1]]}\n\t"
-        "lea{q -40(%[src0]), %[src0]| %[src0], [%[src0] - 40]}\n\t"
-        "lea{q -40(%[src1]), %[src1]| %[src1], [%[src1] - 40]}\n\t"
-        "lea{q -40(%[dst]), %[dst]| %[dst], [%[dst] - 40]}\n\t"
-        "inc %[rcx]\n\t"
-        "jmp .Lb3%=\n\t"
+    if (src0 != dst) {
+        std::copy(src0 + 1, src0 + n, dst + 1);
+    }
 
-        ".Ll4%=:\n\t"
-        "mov{q (%[src0]), %[r9]| %[r9], [%[src0]]}\n\t"
-        "mov{q 8(%[src0]), %[r11]| %[r11], [%[src0] + 8]}\n\t"
-        WJR_PP_STR(WJR_adcsbb) "{q (%[src1]), %[r9]| %[r9], [%[src1]]}\n\t"
-        "lea{q -32(%[src0]), %[src0]| %[src0], [%[src0] - 32]}\n\t"
-        "lea{q -32(%[src1]), %[src1]| %[src1], [%[src1] - 32]}\n\t"
-        "lea{q -32(%[dst]), %[dst]| %[dst], [%[dst] - 32]}\n\t"
-        "inc %[rcx]\n\t"
-        "jmp .Lb4%=\n\t"
+    return static_cast<U>(0);
+}
 
-        ".Ll5%=:\n\t"
-        "mov{q (%[src0]), %[r10]| %[r10], [%[src0]]}\n\t"
-        "mov{q 8(%[src0]), %[r9]| %[r9], [%[src0] + 8]}\n\t"
-        WJR_PP_STR(WJR_adcsbb) "{q (%[src1]), %[r10]| %[r10], [%[src1]]}\n\t"
-        "lea{q -24(%[src0]), %[src0]| %[src0], [%[src0] - 24]}\n\t"
-        "lea{q -24(%[src1]), %[src1]| %[src1], [%[src1] - 24]}\n\t"
-        "lea{q -24(%[dst]), %[dst]| %[dst], [%[dst] - 24]}\n\t"
-        "inc %[rcx]\n\t"
-        "jmp .Lb5%=\n\t"
+/**
+ * @brief Add biginteger(src0) and number with carry-in, and return the result(dst) and
+ * carry-out.
+ *
+ * @tparam U Type of the carry-in and carry-out. It must be an unsigned integral type.
+ * @param[out] dst The result of the addition.
+ * @param[in] src0 The biginteger to be added.
+ * @param[in] n The number of elements in the biginteger.
+ * @param[in] src1 The number to be added.
+ * @param[in] c_in The carry-in flag.
+ * @return The carry-out flag.
+ */
+template <typename U, WJR_REQUIRES_I(is_unsigned_integral_v<U>)>
+WJR_INTRINSIC_CONSTEXPR_E U addc_1(uint64_t *dst, const uint64_t *src0, size_t n,
+                                   uint64_t src1, U c_in) noexcept {
+    WJR_ASSERT_ASSUME(n >= 1);
+    WJR_ASSERT_L2(WJR_IS_SAME_OR_INCR_P(dst, n, src0, n));
+    WJR_ASSERT_ASSUME(c_in <= 1);
 
-        ".Ll6%=:\n\t"
-        "mov{q (%[src0]), %[r8]| %[r8], [%[src0]]}\n\t"
-        "mov{q 8(%[src0]), %[r10]| %[r10], [%[src0] + 8]}\n\t"
-        WJR_PP_STR(WJR_adcsbb) "{q (%[src1]), %[r8]| %[r8], [%[src1]]}\n\t"
-        "lea{q -16(%[src0]), %[src0]| %[src0], [%[src0] - 16]}\n\t"
-        "lea{q -16(%[src1]), %[src1]| %[src1], [%[src1] - 16]}\n\t"
-        "lea{q -16(%[dst]), %[dst]| %[dst], [%[dst] - 16]}\n\t"
-        "inc %[rcx]\n\t"
-        "jmp .Lb6%=\n\t"
-
-        ".Ll7%=:\n\t"
-        "mov{q (%[src0]), %[r11]| %[r11], [%[src0]]}\n\t"
-        "mov{q 8(%[src0]), %[r8]| %[r8], [%[src0] + 8]}\n\t"
-        WJR_PP_STR(WJR_adcsbb) "{q (%[src1]), %[r11]| %[r11], [%[src1]]}\n\t"
-        "lea{q -8(%[src0]), %[src0]| %[src0], [%[src0] - 8]}\n\t"
-        "lea{q -8(%[src1]), %[src1]| %[src1], [%[src1] - 8]}\n\t"
-        "lea{q -8(%[dst]), %[dst]| %[dst], [%[dst] - 8]}\n\t"
-        "inc %[rcx]\n\t"
-        "jmp .Lb7%=\n\t"
+    if (WJR_BUILTIN_CONSTANT_P(n == 1) && n == 1) {
+        uint8_t overflow = 0;
+        dst[0] = addc_cc(src0[0], src1, c_in, overflow);
+        return static_cast<U>(overflow);
+    }
 
-        ".Ld2%=:\n\t"
-        WJR_PP_STR(WJR_adcsbb) "{q 8(%[src1]), %[r10]| %[r10], [%[src1] + 8]}\n\t"
-        "mov{q %[r8], (%[dst])| [%[dst]], %[r8]}\n\t"
-        "mov{q %[r10], 8(%[dst])| [%[dst] + 8], %[r10]}\n\t"
-        "jmp .Ldone%=\n\t"
+    return __addc_1_impl(dst, src0, n, src1, c_in);
+}
 
-        ".Ll2%=:\n\t"
-        "mov{q (%[src0]), %[r8]| %[r8], [%[src0]]}\n\t"
-        "mov{q 8(%[src0]), %[r10]| %[r10], [%[src0] + 8]}\n\t"
-        WJR_PP_STR(WJR_adcsbb) "{q (%[src1]), %[r8]| %[r8], [%[src1]]}\n\t"
-        "jrcxz .Ld2%=\n\t"
-        "lea{q 16(%[src0]), %[src0]| %[src0], [%[src0] + 16]}\n\t"
-        "lea{q 16(%[src1]), %[src1]| %[src1], [%[src1] + 16]}\n\t"
-        "lea{q 16(%[dst]), %[dst]| %[dst], [%[dst] + 16]}\n\t"
+template <typename U>
+WJR_INTRINSIC_CONSTEXPR U fallback_addc_n(uint64_t *dst, const uint64_t *src0,
+                                          const uint64_t *src1, size_t n,
+                                          U c_in) noexcept {
+    size_t m = n / 4;
 
-        ".align 32\n\t"
-        ".Lloop%=:\n\t"
+    for (size_t i = 0; i < m; ++i) {
+        dst[0] = addc(src0[0], src1[0], c_in, c_in);
+        dst[1] = addc(src0[1], src1[1], c_in, c_in);
+        dst[2] = addc(src0[2], src1[2], c_in, c_in);
+        dst[3] = addc(src0[3], src1[3], c_in, c_in);
 
-        ".Lb2%=:\n\t"
-        "mov{q (%[src0]), %[r9]| %[r9], [%[src0]]}\n\t"
-        WJR_PP_STR(WJR_adcsbb) "{q -8(%[src1]), %[r10]| %[r10], [%[src1] - 8]}\n\t"
-        "mov{q %[r8], -16(%[dst])| [%[dst] - 16], %[r8]}\n\t"
+        dst += 4;
+        src0 += 4;
+        src1 += 4;
+    }
 
-        ".Lb1%=:\n\t"
-        "mov{q 8(%[src0]), %[r11]| %[r11], [%[src0] + 8]}\n\t"
-        WJR_PP_STR(WJR_adcsbb) "{q (%[src1]), %[r9]| %[r9], [%[src1]]}\n\t"
-        "mov{q %[r10], -8(%[dst])| [%[dst] - 8], %[r10]}\n\t"
+    n &= 3;
+    if (WJR_UNLIKELY(n == 0)) {
+        return c_in;
+    }
 
-        ".Lb0%=:\n\t"
-        "mov{q 16(%[src0]), %[r8]| %[r8], [%[src0] + 16]}\n\t"
-        WJR_PP_STR(WJR_adcsbb) "{q 8(%[src1]), %[r11]| %[r11], [%[src1] + 8]}\n\t"
-        "mov{q %[r9], (%[dst])| [%[dst]], %[r9]}\n\t"
+    dst += n;
+    src0 += n;
+    src1 += n;
 
-        ".Lb7%=:\n\t"
-        "mov{q 24(%[src0]), %[r10]| %[r10], [%[src0] + 24]}\n\t"
-        WJR_PP_STR(WJR_adcsbb) "{q 16(%[src1]), %[r8]| %[r8], [%[src1] + 16]}\n\t"
-        "mov{q %[r11], 8(%[dst])| [%[dst] + 8], %[r11]}\n\t"
+    switch (n) {
+    case 3: {
+        dst[-3] = addc(src0[-3], src1[-3], c_in, c_in);
+        WJR_FALLTHROUGH;
+    }
+    case 2: {
+        dst[-2] = addc(src0[-2], src1[-2], c_in, c_in);
+        WJR_FALLTHROUGH;
+    }
+    case 1: {
+        dst[-1] = addc(src0[-1], src1[-1], c_in, c_in);
+        WJR_FALLTHROUGH;
+    }
+    default: {
+        break;
+    }
+    }
 
-        ".Lb6%=:\n\t"
-        "mov{q 32(%[src0]), %[r9]| %[r9], [%[src0] + 32]}\n\t"
-        WJR_PP_STR(WJR_adcsbb) "{q 24(%[src1]), %[r10]| %[r10], [%[src1] + 24]}\n\t"
-        "mov{q %[r8], 16(%[dst])| [%[dst] + 16], %[r8]}\n\t"
+    return c_in;
+}
 
-        ".Lb5%=:\n\t"
-        "mov{q 40(%[src0]), %[r11]| %[r11], [%[src0] + 40]}\n\t"
-        WJR_PP_STR(WJR_adcsbb) "{q 32(%[src1]), %[r9]| %[r9], [%[src1] + 32]}\n\t"
-        "mov{q %[r10], 24(%[dst])| [%[dst] + 24], %[r10]}\n\t"
+/**
+ * @brief Add biginteger(src0) and biginteger(src1) with carry-in, and return the result
+ * (dst) and carry-out.
+ *
+ * @tparam U Type of the carry-in and carry-out. It must be an unsigned integral type.
+ * @param[out] dst The result of the addition.
+ * @param[in] src0 The biginteger to be added.
+ * @param[in] src1 The biginteger to be added.
+ * @param[in] n The number of elements in the biginteger.
+ * @param[in] c_in The carry-in flag.
+ * @return The carry-out flag.
+ */
+template <typename U, WJR_REQUIRES_I(is_unsigned_integral_v<U>)>
+WJR_INTRINSIC_CONSTEXPR_E U addc_n(uint64_t *dst, const uint64_t *src0,
+                                   const uint64_t *src1, size_t n, U c_in) noexcept {
+    WJR_ASSERT_ASSUME(n >= 1);
+    WJR_ASSERT_L2(WJR_IS_SAME_OR_INCR_P(dst, n, src0, n));
+    WJR_ASSERT_L2(WJR_IS_SAME_OR_INCR_P(dst, n, src1, n));
 
-        ".Lb4%=:\n\t"
-        "mov{q 48(%[src0]), %[r8]| %[r8], [%[src0] + 48]}\n\t"
-        WJR_PP_STR(WJR_adcsbb) "{q 40(%[src1]), %[r11]| %[r11], [%[src1] + 40]}\n\t"
-        "mov{q %[r9], 32(%[dst])| [%[dst] + 32], %[r9]}\n\t"
+#if WJR_HAS_BUILTIN(ASM_ADDC_N)
+    if (is_constant_evaluated()) {
+        return fallback_addc_n(dst, src0, src1, n, c_in);
+    }
 
-        ".Lb3%=:\n\t"
-        "mov{q 56(%[src0]), %[r10]| %[r10], [%[src0] + 56]}\n\t"
-        WJR_PP_STR(WJR_adcsbb) "{q 48(%[src1]), %[r8]| %[r8], [%[src1] + 48]}\n\t"
-        "mov{q %[r11], 40(%[dst])| [%[dst] + 40], %[r11]}\n\t"
+    return asm_addc_n(dst, src0, src1, n, c_in);
+#else
+    return fallback_addc_n(dst, src0, src1, n, c_in);
+#endif
+}
 
-        // TODO : optimize pipeline
-        "lea{q 64(%[src0]), %[src0]| %[src0], [%[src0] + 64]}\n\t"
-        "lea{q 64(%[src1]), %[src1]| %[src1], [%[src1] + 64]}\n\t"
-        "lea{q 64(%[dst]), %[dst]| %[dst], [%[dst] + 64]}\n\t"
-        "dec %[rcx]\n\t"
-        
-        "jne .Lloop%=\n\t"
+/*
+require :
+1. m >= 1
+2. n >= m
+3. WJR_IS_SAME_OR_INCR_P(dst, n, src0, n)
+4. WJR_IS_SAME_OR_INCR_P(dst, m, src1, m)
+*/
+template <typename U, WJR_REQUIRES_I(is_unsigned_integral_v<U>)>
+WJR_INTRINSIC_CONSTEXPR_E U addc_s(uint64_t *dst, const uint64_t *src0, size_t n,
+                                   const uint64_t *src1, size_t m, U c_in) noexcept {
+    WJR_ASSERT_ASSUME(m >= 1);
+    WJR_ASSERT_ASSUME(n >= m);
 
-        WJR_PP_STR(WJR_adcsbb) "{q -8(%[src1]), %[r10]| %[r10], [%[src1] - 8]}\n\t"
-        "mov{q %[r8], -16(%[dst])| [%[dst] - 16], %[r8]}\n\t"
-        "mov{q %[r10], -8(%[dst])| [%[dst] - 8], %[r10]}\n\t"
+    c_in = addc_n(dst, src0, src1, m, c_in);
 
-        ".Ldone%=:\n\t"
-        "mov %k[rcx], %k[r9]\n\t"
-        "adc{l %k[rcx], %k[r9]| %k[r9], %k[rcx]}"
+    if (n != m) {
+        c_in = addc_1(dst + m, src0 + m, n - m, 0, c_in);
+    }
 
-        : [dst] "+r"(dst), [src0] "+r"(src0), [src1] "+r"(src1), [rcx] "+c"(rcx), 
-          [r8] "+r"(r8), [r9] "=&r"(r9), [r10] "+r"(r10), [r11] "=&r"(r11)
-        :
-        : "cc", "memory");
+    return c_in;
+}
 
-    WJR_ASSERT_ASSUME(rcx == 0);
-    WJR_ASSERT_ASSUME(r9 <= 1);
+/*
+require :
+1. n >= 0
+2. n >= m
+3. WJR_IS_SAME_OR_INCR_P(dst, n, src0, n)
+4. WJR_IS_SAME_OR_INCR_P(dst, m, src1, m)
+*/
+template <typename U, WJR_REQUIRES_I(is_unsigned_integral_v<U>)>
+WJR_INTRINSIC_CONSTEXPR_E U addc_sz(uint64_t *dst, const uint64_t *src0, size_t n,
+                                    const uint64_t *src1, size_t m, U c_in) noexcept {
+    WJR_ASSERT_ASSUME(n >= m);
 
-    return r9;
-}
+    if (WJR_LIKELY(m != 0)) {
+        c_in = addc_n(dst, src0, src1, m, c_in);
+    }
 
-WJR_INTRINSIC_INLINE uint64_t WJR_PP_CONCAT(asm_, WJR_PP_CONCAT(WJR_addcsubc, _n))(
-    uint64_t *dst, const uint64_t *src0, const uint64_t *src1, size_t n,
-    uint64_t c_in) noexcept {
-    if (WJR_BUILTIN_CONSTANT_P(n)) {
-        if (n == 1) {
-            dst[0] = WJR_PP_CONCAT(asm_, WJR_addcsubc)(src0[0], src1[0], c_in, c_in);
-            return c_in;
-        }
+    if (n != m) {
+        c_in = addc_1(dst + m, src0 + m, n - m, 0, c_in);
     }
 
-    return WJR_PP_CONCAT(asm_, WJR_PP_CONCAT(WJR_addcsubc, _n_impl))(dst, src0, src1, n,
-                                                                     c_in);
+    return c_in;
 }
 
-#undef WJR_adcsbb
-#undef WJR_addcsubc
+WJR_INTRINSIC_CONSTEXPR void __fallback_add_128(uint64_t &al, uint64_t &ah, uint64_t lo0,
+                                                uint64_t hi0, uint64_t lo1,
+                                                uint64_t hi1) noexcept {
+    uint64_t __al = lo0 + lo1;
+    ah = hi0 + hi1 + (__al < lo0);
+    al = __al;
+}
 
-#undef WJR_ADDSUB_I
+#if WJR_HAS_FEATURE(FAST_INT128_ADDSUB)
+#define WJR_HAS_BUILTIN___BUILTIN_ADD_128 WJR_HAS_DEF
 #endif
 
-#if WJR_HAS_BUILTIN(__ASM_ADD_128)
+#if WJR_HAS_BUILTIN(__BUILTIN_ADD_128)
 
-/**
- * @brief Use inline assembly to add two 64-bit integers and return the result.
- *
- */
-WJR_INTRINSIC_INLINE void __asm_add_128(uint64_t &al, uint64_t &ah, uint64_t lo0,
-                                        uint64_t hi0, uint64_t lo1,
-                                        uint64_t hi1) noexcept {
-    if (WJR_BUILTIN_CONSTANT_P(hi0) && hi0 <= UINT32_MAX) {
-        asm("add{q %[lo1], %[lo0]| %[lo0], %[lo1]}\n\t"
-            "adc{q %[hi0], %[hi1]| %[hi1], %[hi0]}"
-            : [lo0] "+&r"(lo0), [hi1] "+r"(hi1)
-            : [lo1] "r"(lo1), [hi0] "i"(hi0)
-            : "cc");
-        al = lo0;
-        ah = hi1;
-        return;
-    } else if (WJR_BUILTIN_CONSTANT_P(hi1) && hi1 <= UINT32_MAX) {
-        asm("add{q %[lo1], %[lo0]| %[lo0], %[lo1]}\n\t"
-            "adc{q %[hi1], %[hi0]| %[hi0], %[hi1]}"
-            : [lo0] "+&r"(lo0), [hi0] "+r"(hi0)
-            : [lo1] "r"(lo1), [hi1] "i"(hi1)
-            : "cc");
-        al = lo0;
-        ah = hi0;
-        return;
-    }
+WJR_INTRINSIC_INLINE void __builtin_add_128(uint64_t &al, uint64_t &ah, uint64_t lo0,
+                                            uint64_t hi0, uint64_t lo1,
+                                            uint64_t hi1) noexcept {
+    const auto x0 = static_cast<__uint128_t>(hi0) << 64 | lo0;
+    const auto x1 = static_cast<__uint128_t>(hi1) << 64 | lo1;
+    x0 += x1;
 
-    asm("add{q %[lo1], %[lo0]| %[lo0], %[lo1]}\n\t"
-        "adc{q %[hi1], %[hi0]| %[hi0], %[hi1]}"
-        : [lo0] "+&r"(lo0), [hi0] "+r"(hi0)
-        : [lo1] "r"(lo1), [hi1] "r"(hi1)
-        : "cc");
-    al = lo0;
-    ah = hi0;
-    return;
+    al = x0;
+    ah = x0 >> 64;
 }
 
 #endif
 
-#if WJR_HAS_BUILTIN(__ASM_ADDC_128) || WJR_HAS_BUILTIN(__ASM_ADDC_CC_128)
-
-/**
- * @brief Use inline assembly to add two 64-bit integers and return the
- * carry-out.
- *
- * @details Optimzation for __asm_addc_cc_128 and __asm_addc_128 when the carry-in is 0.
- *
- */
-WJR_INTRINSIC_INLINE uint8_t __asm_addc_cc_zero_128(uint64_t &al, uint64_t &ah,
-                                                    uint64_t lo0, uint64_t hi0,
-                                                    uint64_t lo1, uint64_t hi1) noexcept {
-    uint8_t c_out;
-    if (WJR_BUILTIN_CONSTANT_P(hi0) && hi0 <= UINT32_MAX) {
-        asm("add{q %[lo1], %[lo0]| %[lo0], %[lo1]}\n\t"
-            "adc{q %[hi0], %[hi1]| %[hi1], %[hi0]}\n\t" WJR_ASM_CCSET(c)
-            : [lo0] "+&r"(lo0), [hi1] "+r"(hi1), WJR_ASM_CCOUT(c)(c_out)
-            : [lo1] "r"(lo1), [hi0] "i"(hi0)
-            : "cc");
-        al = lo0;
-        ah = hi1;
-        return c_out;
-    } else if (WJR_BUILTIN_CONSTANT_P(hi1) && hi1 <= UINT32_MAX) {
-        asm("add{q %[lo1], %[lo0]| %[lo0], %[lo1]}\n\t"
-            "adc{q %[hi1], %[hi0]| %[hi0], %[hi1]}\n\t" WJR_ASM_CCSET(c)
-            : [lo0] "+&r"(lo0), [hi0] "+r"(hi0), WJR_ASM_CCOUT(c)(c_out)
-            : [lo1] "r"(lo1), [hi1] "i"(hi1)
-            : "cc");
-        al = lo0;
-        ah = hi0;
-        return c_out;
+// <ah, al> = <hi0, lo0> + <hi1, lo1>
+WJR_INTRINSIC_CONSTEXPR_E void __add_128(uint64_t &al, uint64_t &ah, uint64_t lo0,
+                                         uint64_t hi0, uint64_t lo1,
+                                         uint64_t hi1) noexcept {
+#if WJR_HAS_BUILTIN(__BUILTIN_ADD_128) || WJR_HAS_BUILTIN(__ASM_ADD_128)
+    if (is_constant_evaluated() || (WJR_BUILTIN_CONSTANT_P(lo0 == 0) && lo0 == 0) ||
+        (WJR_BUILTIN_CONSTANT_P(lo1 == 0) && lo1 == 0)) {
+        return __fallback_add_128(al, ah, lo0, hi0, lo1, hi1);
     }
 
-    asm("add{q %[lo1], %[lo0]| %[lo0], %[lo1]}\n\t"
-        "adc{q %[hi1], %[hi0]| %[hi0], %[hi1]}\n\t" WJR_ASM_CCSET(c)
-        : [lo0] "+&r"(lo0), [hi0] "+r"(hi0), WJR_ASM_CCOUT(c)(c_out)
-        : [lo1] "r"(lo1), [hi1] "r"(hi1)
-        : "cc");
-    al = lo0;
-    ah = hi0;
-    return c_out;
+    return WJR_PP_BOOL_IF(WJR_HAS_BUILTIN(__BUILTIN_ADD_128), __builtin_add_128,
+                          __asm_add_128)(al, ah, lo0, hi0, lo1, hi1);
+#else
+    return __fallback_add_128(al, ah, lo0, hi0, lo1, hi1);
+#endif
 }
 
-#endif
+WJR_INTRINSIC_CONSTEXPR_E uint64_t __fallback_addc_128(uint64_t &al, uint64_t &ah,
+                                                       uint64_t lo0, uint64_t hi0,
+                                                       uint64_t lo1, uint64_t hi1,
+                                                       uint64_t c_in) noexcept {
+    al = addc(lo0, lo1, c_in, c_in);
+    ah = addc(hi0, hi1, c_in, c_in);
+    return c_in;
+}
 
+// return c_out
+WJR_INTRINSIC_CONSTEXPR_E uint64_t __addc_128(uint64_t &al, uint64_t &ah, uint64_t lo0,
+                                              uint64_t hi0, uint64_t lo1, uint64_t hi1,
+                                              uint64_t c_in) noexcept {
 #if WJR_HAS_BUILTIN(__ASM_ADDC_128)
-
-/**
- * @brief Use inline assembly to add two 64-bit integers with carry-in and return the
- * carry-out.
- *
- */
-WJR_INTRINSIC_INLINE uint64_t __asm_addc_128(uint64_t &al, uint64_t &ah, uint64_t lo0,
-                                             uint64_t hi0, uint64_t lo1, uint64_t hi1,
-                                             uint64_t c_in) noexcept {
-    if (WJR_BUILTIN_CONSTANT_P(c_in == 0) && c_in == 0) {
-        return __asm_addc_cc_zero_128(al, ah, lo0, hi0, lo1, hi1);
-    }
-
-    if (WJR_BUILTIN_CONSTANT_P(hi0) && hi0 <= UINT32_MAX) {
-        asm("add{b $0xff, %b[c_in]| %b[c_in], 0xff}\n\t"
-            "adc{q %[lo1], %[lo0]| %[lo0], %[lo1]}\n\t"
-            "adc{q %[hi0], %[hi1]| %[hi1], %[hi0]}\n\t"
-            "setb %b[c_in]"
-            : [lo0] "+&r"(lo0), [hi1] "+r"(hi1), [c_in] "+&r"(c_in)
-            : [lo1] "r"(lo1), [hi0] "i"(hi0)
-            : "cc");
-        al = lo0;
-        ah = hi1;
-        return c_in;
-    } else if (WJR_BUILTIN_CONSTANT_P(hi1) && hi1 <= UINT32_MAX) {
-        asm("add{b $0xff, %b[c_in]| %b[c_in], 0xff}\n\t"
-            "adc{q %[lo1], %[lo0]| %[lo0], %[lo1]}\n\t"
-            "adc{q %[hi1], %[hi0]| %[hi0], %[hi1]}\n\t"
-            "setb %b[c_in]"
-            : [lo0] "+&r"(lo0), [hi0] "+r"(hi0), [c_in] "+&r"(c_in)
-            : [lo1] "r"(lo1), [hi1] "i"(hi1)
-            : "cc");
-        al = lo0;
-        ah = hi0;
-        return c_in;
+    if (is_constant_evaluated()) {
+        return __fallback_addc_128(al, ah, lo0, hi0, lo1, hi1, c_in);
     }
 
-    asm("add{b $0xff, %b[c_in]| %b[c_in], 0xff}\n\t"
-        "adc{q %[lo1], %[lo0]| %[lo0], %[lo1]}\n\t"
-        "adc{q %[hi1], %[hi0]| %[hi0], %[hi1]}\n\t"
-        "setb %b[c_in]"
-        : [lo0] "+&r"(lo0), [hi0] "+r"(hi0), [c_in] "+&r"(c_in)
-        : [lo1] "r"(lo1), [hi1] "r"(hi1)
-        : "cc");
-    al = lo0;
-    ah = hi0;
-    return c_in;
+    return __asm_addc_128(al, ah, lo0, hi0, lo1, hi1, c_in);
+#else
+    return __fallback_addc_128(al, ah, lo0, hi0, lo1, hi1, c_in);
+#endif
 }
 
+WJR_INTRINSIC_CONSTEXPR_E uint8_t __addc_cc_128(uint64_t &al, uint64_t &ah, uint64_t lo0,
+                                                uint64_t hi0, uint64_t lo1, uint64_t hi1,
+                                                uint8_t c_in) noexcept {
+#if WJR_HAS_BUILTIN(__ASM_ADDC_CC_128)
+    if (is_constant_evaluated()) {
+        return __fallback_addc_128(al, ah, lo0, hi0, lo1, hi1, c_in);
+    }
+
+    return __asm_addc_cc_128(al, ah, lo0, hi0, lo1, hi1, c_in);
+#else
+    return __addc_128(al, ah, lo0, hi0, lo1, hi1, c_in);
 #endif
+}
 
-#if WJR_HAS_BUILTIN(__ASM_ADDC_CC_128)
+} // namespace wjr
 
-/**
- * @brief Use inline assembly to add two 64-bit integers with carry-in and return the
- * carry-out.
- *
- * @details Similar to __asm_addc_128, but the carry-out flag is set by using constraint
- * "=@cccond" instead of "setb".
- *
- */
-WJR_INTRINSIC_INLINE uint8_t __asm_addc_cc_128(uint64_t &al, uint64_t &ah, uint64_t lo0,
-                                               uint64_t hi0, uint64_t lo1, uint64_t hi1,
-                                               uint8_t c_in) noexcept {
-    if (WJR_BUILTIN_CONSTANT_P(c_in == 0) && c_in == 0) {
-        return __asm_addc_cc_zero_128(al, ah, lo0, hi0, lo1, hi1);
-    }
+#endif // WJR_MATH_ADD_HPP__
+#ifndef WJR_MATH_BIGNUM_CONFIG_HPP__
+#define WJR_MATH_BIGNUM_CONFIG_HPP__
 
-    uint8_t c_out;
-    if (WJR_BUILTIN_CONSTANT_P(hi0) && hi0 <= UINT32_MAX) {
-        asm("add{b $0xff, %b[c_in]| %b[c_in], 0xff}\n\t"
-            "adc{q %[lo1], %[lo0]| %[lo0], %[lo1]}\n\t"
-            "adc{q %[hi0], %[hi1]| %[hi1], %[hi0]}\n\t" WJR_ASM_CCSET(c)
-            : [lo0] "+&r"(lo0), [hi1] "+r"(hi1), [c_in] "+&r"(c_in),
-              WJR_ASM_CCOUT(c)(c_out)
-            : [lo1] "r"(lo1), [hi0] "i"(hi0)
-            : "cc");
-        al = lo0;
-        ah = hi1;
-        return c_out;
-    } else if (WJR_BUILTIN_CONSTANT_P(hi1) && hi1 <= UINT32_MAX) {
-        asm("add{b $0xff, %b[c_in]| %b[c_in], 0xff}\n\t"
-            "adc{q %[lo1], %[lo0]| %[lo0], %[lo1]}\n\t"
-            "adc{q %[hi1], %[hi0]| %[hi0], %[hi1]}\n\t" WJR_ASM_CCSET(c)
-            : [lo0] "+&r"(lo0), [hi0] "+r"(hi0), [c_in] "+&r"(c_in),
-              WJR_ASM_CCOUT(c)(c_out)
-            : [lo1] "r"(lo1), [hi1] "i"(hi1)
-            : "cc");
-        al = lo0;
-        ah = hi0;
-        return c_out;
-    }
+#ifndef WJR_TOOM22_MUL_THRESHOLD
+#define WJR_TOOM22_MUL_THRESHOLD 22
+#endif
 
-    asm("add{b $0xff, %b[c_in]| %b[c_in], 0xff}\n\t"
-        "adc{q %[lo1], %[lo0]| %[lo0], %[lo1]}\n\t"
-        "adc{q %[hi1], %[hi0]| %[hi0], %[hi1]}\n\t" WJR_ASM_CCSET(c)
-        : [lo0] "+&r"(lo0), [hi0] "+r"(hi0), [c_in] "+&r"(c_in), WJR_ASM_CCOUT(c)(c_out)
-        : [lo1] "r"(lo1), [hi1] "r"(hi1)
-        : "cc");
-    al = lo0;
-    ah = hi0;
-    return c_out;
-}
+#ifndef WJR_TOOM33_MUL_THRESHOLD
+#define WJR_TOOM33_MUL_THRESHOLD 84
+#endif
 
+#ifndef WJR_TOOM44_MUL_THRESHOLD
+#define WJR_TOOM44_MUL_THRESHOLD 208
 #endif
 
-} // namespace wjr
+#ifndef WJR_TOOM55_MUL_THRESHOLD
+#define WJR_TOOM55_MUL_THRESHOLD 800
+#endif
 
-#endif // WJR_X86_MATH_ADD_HPP__
+#ifndef WJR_TOOM32_TO_TOOM43_MUL_THRESHOLD
+#define WJR_TOOM32_TO_TOOM43_MUL_THRESHOLD 73
 #endif
 
-namespace wjr {
+#ifndef WJR_TOOM32_TO_TOOM53_MUL_THRESHOLD
+#define WJR_TOOM32_TO_TOOM53_MUL_THRESHOLD 153
+#endif
 
-template <typename T, typename U>
-WJR_INTRINSIC_CONSTEXPR T fallback_addc(T a, T b, U c_in, U &c_out) noexcept {
-    T ret = a;
-    ret += b;
-    U c = ret < b;
-    ret += c_in;
-    c |= ret < c_in;
-    c_out = c;
-    return ret;
-}
+#ifndef WJR_TOOM42_TO_TOOM53_MUL_THRESHOLD
+#define WJR_TOOM42_TO_TOOM53_MUL_THRESHOLD 137
+#endif
 
-#if WJR_HAS_BUILTIN(__builtin_addc)
-#define WJR_HAS_BUILTIN_ADDC WJR_HAS_DEF
+#ifndef WJR_TOOM42_TO_TOOM63_MUL_THRESHOLD
+#define WJR_TOOM42_TO_TOOM63_MUL_THRESHOLD 153
 #endif
 
-#if WJR_HAS_BUILTIN(ADDC)
+#ifndef WJR_TOOM2_SQR_THRESHOLD
+#define WJR_TOOM2_SQR_THRESHOLD 34
+#endif
 
-template <typename T, typename U>
-WJR_INTRINSIC_INLINE T builtin_addc(T a, T b, U c_in, U &c_out) noexcept {
-    constexpr auto nd = std::numeric_limits<T>::digits;
+#ifndef WJR_TOOM3_SQR_THRESHOLD
+#define WJR_TOOM3_SQR_THRESHOLD 124
+#endif
 
-#define WJR_REGISTER_BUILTIN_ADDC(suffix, type)                                          \
-    if constexpr (nd <= std::numeric_limits<type>::digits) {                             \
-        type __c_out;                                                                    \
-        const T ret = __builtin_addc##suffix(a, b, static_cast<type>(c_in), &__c_out);   \
-        c_out = static_cast<U>(__c_out);                                                 \
-        return ret;                                                                      \
-    } else
+#ifndef WJR_TOOM4_SQR_THRESHOLD
+#define WJR_TOOM4_SQR_THRESHOLD 288
+#endif
 
-    WJR_REGISTER_BUILTIN_ADDC(b, unsigned char)
-    WJR_REGISTER_BUILTIN_ADDC(s, unsigned short)
-    WJR_REGISTER_BUILTIN_ADDC(, unsigned int)
-    WJR_REGISTER_BUILTIN_ADDC(l, unsigned long)
-    WJR_REGISTER_BUILTIN_ADDC(ll, unsigned long long) {
-        static_assert(nd <= 64, "not supported yet");
-    }
+#ifndef WJR_TOOM5_SQR_THRESHOLD
+#define WJR_TOOM5_SQR_THRESHOLD 980
+#endif
 
-#undef WJR_REGISTER_BUILTIN_ADDC
-}
+#ifndef WJR_DC_DIV_QR_THRESHOLD
+#define WJR_DC_DIV_QR_THRESHOLD (WJR_TOOM22_MUL_THRESHOLD * 2)
+#endif // WJR_DC_DIV_QR_THRESHOLD
 
-#endif // WJR_HAS_BUILTIN(ADDC)
+#ifndef WJR_DC_BIGNUM_TO_CHARS_THRESHOLD
+#define WJR_DC_BIGNUM_TO_CHARS_THRESHOLD 20
+#endif
 
-/**
- * @brief Add two numbers with carry-in, and return the result and carry-out
- *
- * @note The carry-in and carry-out are limited to 0 and 1
- * @tparam U Type of the carry-in and carry-out. It must be an unsigned integral type.
- * the default type is the same as `T`
- * @param[in] c_in The carry-in flag.
- * @param[out] c_out The carry-out flag.
- *
- * @return a + b + c_in
- */
-template <typename T, typename U,
-          WJR_REQUIRES_I(is_nonbool_unsigned_integral_v<T> &&is_unsigned_integral_v<U>)>
-WJR_INTRINSIC_CONSTEXPR_E T addc(T a, T b, type_identity_t<U> c_in, U &c_out) noexcept {
-    WJR_ASSERT_ASSUME_L2(c_in <= 1);
+#ifndef WJR_DC_BIGNUM_TO_CHARS_PRECOMPUTE_THRESHOLD
+#define WJR_DC_BIGNUM_TO_CHARS_PRECOMPUTE_THRESHOLD 20
+#endif
 
-#if !WJR_HAS_BUILTIN(ADDC) && !WJR_HAS_BUILTIN(ASM_ADDC)
-    return fallback_addc(a, b, c_in, c_out);
-#else
-    constexpr auto is_constant_or_zero = [](auto x) -> int {
-        return WJR_BUILTIN_CONSTANT_P(x == 0) && x == 0 ? 2
-               : WJR_BUILTIN_CONSTANT_P(x)              ? 1
-                                                        : 0;
-    };
+#ifndef WJR_DC_BIGNUM_FROM_CHARS_THRESHOLD
+#define WJR_DC_BIGNUM_FROM_CHARS_THRESHOLD 1670
+#endif
 
-    // The compiler should be able to optimize the judgment condition of if when enabling
-    // optimization. If it doesn't work, then there should be a issue
-    if (is_constant_evaluated() ||
-        // constant value is zero or constant value number greater or equal than 2
-        (is_constant_or_zero(a) + is_constant_or_zero(b) + is_constant_or_zero(c_in) >=
-         2)) {
-        return fallback_addc(a, b, c_in, c_out);
-    }
+#ifndef WJR_DC_BIGNUM_FROM_CHARS_PRECOMPUTE_THRESHOLD
+#define WJR_DC_BIGNUM_FROM_CHARS_PRECOMPUTE_THRESHOLD 3105
+#endif
 
-    if constexpr (sizeof(T) == 8) {
-        return WJR_PP_BOOL_IF(WJR_HAS_BUILTIN(ASM_ADDC), asm_addc,
-                              WJR_PP_BOOL_IF(WJR_HAS_BUILTIN(ADDC), builtin_addc,
-                                             fallback_addc))(a, b, c_in, c_out);
-    } else {
-        return WJR_PP_BOOL_IF(WJR_HAS_BUILTIN(ADDC), builtin_addc,
-                              fallback_addc)(a, b, c_in, c_out);
-    }
+#endif // WJR_MATH_BIGNUM_CONFIG_HPP__
+// Already included
+// Already included
+#ifndef WJR_MATH_SHIFT_HPP__
+#define WJR_MATH_SHIFT_HPP__
+
+// Already included
+// Already included
+
+#if defined(WJR_X86)
+#ifndef WJR_X86_MATH_SHIFT_HPP__
+#define WJR_X86_MATH_SHIFT_HPP__
+
+// Already included
+
+#ifndef WJR_X86
+#error "x86 required"
 #endif
-}
 
-/**
- * @brief Performs addition with carry-in and carry-out, optimized for subsequent
- * branching based on carry-out.
- *
- * @details This function, `addc_cc`, adds two numbers with a carry-in, and returns the
- * result and a carry-out. The carry-out (`c_out`) is optimized for subsequent code that
- * branches based on its value. For example, it can be used with jump instructions like
- * `je` or `jne`. This is in contrast to the `addc` function, which may use instructions
- * like `setc` or `test` for branching.
- *
- * @note The carry-in and carry-out are limited to 0 and 1
- * @tparam U Type of the carry-in and carry-out. It must be an unsigned integral type.
- * @param[in] c_in The carry-in flag.
- * @param[out] c_out The carry-out flag.
- */
-template <typename T, WJR_REQUIRES_I(is_nonbool_unsigned_integral_v<T>)>
-WJR_INTRINSIC_CONSTEXPR_E T addc_cc(T a, T b, uint8_t c_in, uint8_t &c_out) noexcept {
-    WJR_ASSERT_ASSUME_L2(c_in <= 1);
+namespace wjr {
 
-#if WJR_HAS_BUILTIN(ASM_ADDC_CC)
-    constexpr auto is_constant_or_zero = [](auto x) -> int {
-        return WJR_BUILTIN_CONSTANT_P(x == 0) && x == 0 ? 2
-               : WJR_BUILTIN_CONSTANT_P(x)              ? 1
-                                                        : 0;
-    };
+template <typename T>
+WJR_INTRINSIC_CONSTEXPR_E T shld(T hi, T lo, unsigned int c) noexcept;
 
-    // The compiler should be able to optimize the judgment condition of if when enabling
-    // optimization. If it doesn't work, then there should be a issue
-    if (is_constant_evaluated() ||
-        // constant value is zero or constant value number greater or equal than 2
-        (is_constant_or_zero(a) + is_constant_or_zero(b) + is_constant_or_zero(c_in) >=
-         2)) {
-        return fallback_addc(a, b, c_in, c_out);
-    }
+template <typename T>
+WJR_INTRINSIC_CONSTEXPR_E T shrd(T lo, T hi, unsigned int c) noexcept;
 
-    if constexpr (sizeof(T) == 8) {
-        return asm_addc_cc(a, b, c_in, c_out);
+#if WJR_HAS_SIMD(SSE2) && WJR_HAS_SIMD(X86_SIMD)
+#define WJR_HAS_BUILTIN_LSHIFT_N WJR_HAS_DEF
+#define WJR_HAS_BUILTIN_RSHIFT_N WJR_HAS_DEF
+#endif
+
+#if WJR_HAS_BUILTIN(LSHIFT_N) || WJR_HAS_BUILTIN(RSHIFT_N)
+
+/// @private
+template <bool is_constant>
+WJR_INTRINSIC_INLINE auto __mm_get_shift(unsigned int c) noexcept {
+    if constexpr (is_constant) {
+        return c;
     } else {
-        return addc(a, b, c_in, c_out);
+        return simd_cast<unsigned int, __m128i_t>(c);
     }
-#else
-    return addc(a, b, c_in, c_out);
-#endif
 }
 
-#if WJR_HAS_BUILTIN(__builtin_add_overflow)
-#define WJR_HAS_BUILTIN_ADD_OVERFLOW WJR_HAS_DEF
-#endif
-
-template <typename T>
-WJR_INTRINSIC_CONSTEXPR_E bool fallback_add_overflow(T a, T b, T &ret) noexcept {
-    ret = a + b;
-    return ret < a;
+/// @private
+WJR_INTRINSIC_INLINE __m128i __mm_sll_epi64(__m128i x, unsigned int c) noexcept {
+    return sse::slli_epi64(x, c);
 }
 
-template <typename T, WJR_REQUIRES_I(is_nonbool_unsigned_integral_v<T>)>
-WJR_INTRINSIC_CONSTEXPR_E bool add_overflow(type_identity_t<T> a, type_identity_t<T> b,
-                                            T &ret) noexcept {
-#if WJR_HAS_BUILTIN(ADD_OVERFLOW)
-    if (is_constant_evaluated() ||
-        (WJR_BUILTIN_CONSTANT_P(a) && WJR_BUILTIN_CONSTANT_P(b))) {
-        return fallback_add_overflow(a, b, ret);
-    }
+/// @private
+WJR_INTRINSIC_INLINE __m128i __mm_sll_epi64(__m128i x, __m128i c) noexcept {
+    return sse::sll_epi64(x, c);
+}
 
-    return __builtin_add_overflow(a, b, &ret);
-#else
-    return fallback_add_overflow(a, b, ret);
-#endif
+/// @private
+WJR_INTRINSIC_INLINE __m128i __mm_srl_epi64(__m128i x, unsigned int c) noexcept {
+    return sse::srli_epi64(x, c);
 }
 
-template <typename U>
-WJR_INTRINSIC_CONSTEXPR_E U __addc_1_impl(uint64_t *dst, const uint64_t *src0, size_t n,
-                                          uint64_t src1, U c_in) noexcept {
-    uint8_t overflow = 0;
-    dst[0] = addc_cc(src0[0], src1, c_in, overflow);
+/// @private
+WJR_INTRINSIC_INLINE __m128i __mm_srl_epi64(__m128i x, __m128i c) noexcept {
+    return sse::srl_epi64(x, c);
+}
 
-    if (overflow) {
-        size_t idx = 1 + replace_find_not(dst + 1, src0 + 1, n - 1, -1, 0);
+#endif
 
-        if (WJR_UNLIKELY(idx == n)) {
-            return static_cast<U>(1);
-        }
+#if WJR_HAS_BUILTIN(LSHIFT_N)
 
-        dst[idx] = src0[idx] + 1;
+#define WJR_REGISTER_LSHIFT_N_IMPL_UNALIGNED(index)                                      \
+    do {                                                                                 \
+        __m128i x1 = sse::loadu((__m128i *)(src - 3 - (index)));                         \
+        x0 = simd_cast<__m128_t, __m128i_t>(sse::template shuffle_ps<78>(                \
+            simd_cast<__m128i_t, __m128_t>(x1), simd_cast<__m128i_t, __m128_t>(x0)));    \
+                                                                                         \
+        __m128i r0 = __mm_sll_epi64(x0, y);                                              \
+        __m128i r1 = __mm_srl_epi64(x1, z);                                              \
+                                                                                         \
+        __m128i r = sse::Or(r0, r1);                                                     \
+                                                                                         \
+        sse::storeu((__m128i *)(dst - 2 - (index)), r);                                  \
+                                                                                         \
+        x0 = x1;                                                                         \
+    } while (0)
 
-        dst += idx;
-        src0 += idx;
-        n -= idx;
-    }
+template <bool is_constant, typename T>
+void large_builtin_lshift_n_impl(T *dst, const T *src, size_t n,
+                                 unsigned int c) noexcept {
+    const auto y = __mm_get_shift<is_constant>(c);
+    const auto z = __mm_get_shift<is_constant>(64 - c);
 
-    if (src0 != dst) {
-        std::copy(src0 + 1, src0 + n, dst + 1);
+    if (n & 1) {
+        dst[-1] = shld(src[-1], src[-2], c);
+        --src;
+        --dst;
     }
 
-    return static_cast<U>(0);
-}
+    __m128i x0 = sse::set1_epi64(src[-1]);
 
-/**
- * @brief Add biginteger(src0) and number with carry-in, and return the result(dst) and
- * carry-out.
- *
- * @tparam U Type of the carry-in and carry-out. It must be an unsigned integral type.
- * @param[out] dst The result of the addition.
- * @param[in] src0 The biginteger to be added.
- * @param[in] n The number of elements in the biginteger.
- * @param[in] src1 The number to be added.
- * @param[in] c_in The carry-in flag.
- * @return The carry-out flag.
- */
-template <typename U, WJR_REQUIRES_I(is_unsigned_integral_v<U>)>
-WJR_INTRINSIC_CONSTEXPR_E U addc_1(uint64_t *dst, const uint64_t *src0, size_t n,
-                                   uint64_t src1, U c_in) noexcept {
-    WJR_ASSERT_ASSUME(n >= 1);
-    WJR_ASSERT_L2(WJR_IS_SAME_OR_INCR_P(dst, n, src0, n));
-    WJR_ASSERT_ASSUME(c_in <= 1);
+    if (n & 2) {
+        WJR_REGISTER_LSHIFT_N_IMPL_UNALIGNED(0);
 
-    if (WJR_BUILTIN_CONSTANT_P(n == 1) && n == 1) {
-        uint8_t overflow = 0;
-        dst[0] = addc_cc(src0[0], src1, c_in, overflow);
-        return static_cast<U>(overflow);
+        src -= 2;
+        dst -= 2;
     }
 
-    return __addc_1_impl(dst, src0, n, src1, c_in);
-}
+    if (n & 4) {
+        WJR_REGISTER_LSHIFT_N_IMPL_UNALIGNED(0);
+        WJR_REGISTER_LSHIFT_N_IMPL_UNALIGNED(2);
 
-template <typename U>
-WJR_INTRINSIC_CONSTEXPR U fallback_addc_n(uint64_t *dst, const uint64_t *src0,
-                                          const uint64_t *src1, size_t n,
-                                          U c_in) noexcept {
-    size_t m = n / 4;
+        src -= 4;
+        dst -= 4;
+    }
 
-    for (size_t i = 0; i < m; ++i) {
-        dst[0] = addc(src0[0], src1[0], c_in, c_in);
-        dst[1] = addc(src0[1], src1[1], c_in, c_in);
-        dst[2] = addc(src0[2], src1[2], c_in, c_in);
-        dst[3] = addc(src0[3], src1[3], c_in, c_in);
+    size_t idx = n / 8;
 
-        dst += 4;
-        src0 += 4;
-        src1 += 4;
+    if (WJR_UNLIKELY(idx == 0)) {
+        return;
     }
 
-    n &= 3;
-    if (WJR_UNLIKELY(n == 0)) {
-        return c_in;
-    }
+    do {
+        WJR_REGISTER_LSHIFT_N_IMPL_UNALIGNED(0);
+        WJR_REGISTER_LSHIFT_N_IMPL_UNALIGNED(2);
+        WJR_REGISTER_LSHIFT_N_IMPL_UNALIGNED(4);
+        WJR_REGISTER_LSHIFT_N_IMPL_UNALIGNED(6);
 
-    dst += n;
-    src0 += n;
-    src1 += n;
+        src -= 8;
+        dst -= 8;
+        --idx;
+    } while (WJR_LIKELY(idx != 0));
+}
 
-    switch (n) {
-    case 3: {
-        dst[-3] = addc(src0[-3], src1[-3], c_in, c_in);
-        WJR_FALLTHROUGH;
-    }
-    case 2: {
-        dst[-2] = addc(src0[-2], src1[-2], c_in, c_in);
-        WJR_FALLTHROUGH;
-    }
-    case 1: {
-        dst[-1] = addc(src0[-1], src1[-1], c_in, c_in);
-        WJR_FALLTHROUGH;
-    }
-    default: {
-        break;
+template <typename T>
+WJR_INTRINSIC_INLINE void builtin_lshift_n_impl(T *dst, const T *src, size_t n,
+                                                unsigned int c) noexcept {
+    if (WJR_UNLIKELY(n < 4)) {
+        switch (n) {
+        case 3: {
+            dst[2] = shld(src[2], src[1], c);
+            WJR_FALLTHROUGH;
+        }
+        case 2: {
+            dst[1] = shld(src[1], src[0], c);
+            WJR_FALLTHROUGH;
+        }
+        case 1: {
+            dst[0] = shld(src[0], src[-1], c);
+            WJR_FALLTHROUGH;
+        }
+        case 0: {
+            break;
+        }
+        default: {
+            WJR_UNREACHABLE();
+            break;
+        }
+        }
+
+        return;
     }
+
+    src += n;
+    dst += n;
+
+    if (WJR_BUILTIN_CONSTANT_P(c)) {
+        return large_builtin_lshift_n_impl<true>(dst, src, n, c);
     }
 
-    return c_in;
+    return large_builtin_lshift_n_impl<false>(dst, src, n, c);
 }
 
-/**
- * @brief Add biginteger(src0) and biginteger(src1) with carry-in, and return the result
- * (dst) and carry-out.
- *
- * @tparam U Type of the carry-in and carry-out. It must be an unsigned integral type.
- * @param[out] dst The result of the addition.
- * @param[in] src0 The biginteger to be added.
- * @param[in] src1 The biginteger to be added.
- * @param[in] n The number of elements in the biginteger.
- * @param[in] c_in The carry-in flag.
- * @return The carry-out flag.
- */
-template <typename U, WJR_REQUIRES_I(is_unsigned_integral_v<U>)>
-WJR_INTRINSIC_CONSTEXPR_E U addc_n(uint64_t *dst, const uint64_t *src0,
-                                   const uint64_t *src1, size_t n, U c_in) noexcept {
-    WJR_ASSERT_ASSUME(n >= 1);
-    WJR_ASSERT_L2(WJR_IS_SAME_OR_INCR_P(dst, n, src0, n));
-    WJR_ASSERT_L2(WJR_IS_SAME_OR_INCR_P(dst, n, src1, n));
+#undef WJR_REGISTER_LSHIFT_N_IMPL_UNALIGNED
 
-#if WJR_HAS_BUILTIN(ASM_ADDC_N)
-    if (is_constant_evaluated()) {
-        return fallback_addc_n(dst, src0, src1, n, c_in);
-    }
+template <typename T>
+WJR_INTRINSIC_INLINE T builtin_lshift_n(T *dst, const T *src, size_t n, unsigned int c,
+                                        T lo) noexcept {
+    const T ret = src[n - 1] >> (64 - c);
+    builtin_lshift_n_impl(dst + 1, src + 1, n - 1, c);
+    dst[0] = shld(src[0], lo, c);
+    return ret;
+}
 
-    return asm_addc_n(dst, src0, src1, n, c_in);
-#else
-    return fallback_addc_n(dst, src0, src1, n, c_in);
 #endif
-}
 
-/*
-require :
-1. m >= 1
-2. n >= m
-3. WJR_IS_SAME_OR_INCR_P(dst, n, src0, n)
-4. WJR_IS_SAME_OR_INCR_P(dst, m, src1, m)
-*/
-template <typename U, WJR_REQUIRES_I(is_unsigned_integral_v<U>)>
-WJR_INTRINSIC_CONSTEXPR_E U addc_s(uint64_t *dst, const uint64_t *src0, size_t n,
-                                   const uint64_t *src1, size_t m, U c_in) noexcept {
-    WJR_ASSERT_ASSUME(m >= 1);
-    WJR_ASSERT_ASSUME(n >= m);
+#if WJR_HAS_BUILTIN(RSHIFT_N)
 
-    c_in = addc_n(dst, src0, src1, m, c_in);
+#define WJR_REGISTER_RSHIFT_N_IMPL_UNALIGNED(index)                                      \
+    do {                                                                                 \
+        __m128i x1 = sse::loadu((__m128i *)(src + 1 + (index)));                         \
+        x0 = simd_cast<__m128_t, __m128i_t>(sse::template shuffle_ps<78>(                \
+            simd_cast<__m128i_t, __m128_t>(x0), simd_cast<__m128i_t, __m128_t>(x1)));    \
+                                                                                         \
+        __m128i r0 = __mm_srl_epi64(x0, y);                                              \
+        __m128i r1 = __mm_sll_epi64(x1, z);                                              \
+                                                                                         \
+        __m128i r = sse::Or(r0, r1);                                                     \
+                                                                                         \
+        sse::storeu((__m128i *)(dst + (index)), r);                                      \
+                                                                                         \
+        x0 = x1;                                                                         \
+    } while (0)
 
-    if (n != m) {
-        c_in = addc_1(dst + m, src0 + m, n - m, 0, c_in);
+template <bool is_constant, typename T>
+void large_builtin_rshift_n_impl(T *dst, const T *src, size_t n,
+                                 unsigned int c) noexcept {
+    const auto y = __mm_get_shift<is_constant>(c);
+    const auto z = __mm_get_shift<is_constant>(64 - c);
+
+    if (n & 1) {
+        dst[0] = shrd(src[0], src[1], c);
+        ++src;
+        ++dst;
     }
 
-    return c_in;
-}
+    __m128i x0 = sse::set1_epi64(src[0]);
 
-/*
-require :
-1. n >= 0
-2. n >= m
-3. WJR_IS_SAME_OR_INCR_P(dst, n, src0, n)
-4. WJR_IS_SAME_OR_INCR_P(dst, m, src1, m)
-*/
-template <typename U, WJR_REQUIRES_I(is_unsigned_integral_v<U>)>
-WJR_INTRINSIC_CONSTEXPR_E U addc_sz(uint64_t *dst, const uint64_t *src0, size_t n,
-                                    const uint64_t *src1, size_t m, U c_in) noexcept {
-    WJR_ASSERT_ASSUME(n >= m);
+    if (n & 2) {
+        WJR_REGISTER_RSHIFT_N_IMPL_UNALIGNED(0);
 
-    if (WJR_LIKELY(m != 0)) {
-        c_in = addc_n(dst, src0, src1, m, c_in);
+        src += 2;
+        dst += 2;
     }
 
-    if (n != m) {
-        c_in = addc_1(dst + m, src0 + m, n - m, 0, c_in);
+    if (n & 4) {
+        WJR_REGISTER_RSHIFT_N_IMPL_UNALIGNED(0);
+        WJR_REGISTER_RSHIFT_N_IMPL_UNALIGNED(2);
+
+        src += 4;
+        dst += 4;
     }
 
-    return c_in;
-}
+    size_t idx = n / 8;
 
-WJR_INTRINSIC_CONSTEXPR void __fallback_add_128(uint64_t &al, uint64_t &ah, uint64_t lo0,
-                                                uint64_t hi0, uint64_t lo1,
-                                                uint64_t hi1) noexcept {
-    uint64_t __al = lo0 + lo1;
-    ah = hi0 + hi1 + (__al < lo0);
-    al = __al;
-}
+    if (WJR_UNLIKELY(idx == 0)) {
+        return;
+    }
 
-#if WJR_HAS_FEATURE(FAST_INT128_ADDSUB)
-#define WJR_HAS_BUILTIN___BUILTIN_ADD_128 WJR_HAS_DEF
-#endif
+    do {
+        WJR_REGISTER_RSHIFT_N_IMPL_UNALIGNED(0);
+        WJR_REGISTER_RSHIFT_N_IMPL_UNALIGNED(2);
+        WJR_REGISTER_RSHIFT_N_IMPL_UNALIGNED(4);
+        WJR_REGISTER_RSHIFT_N_IMPL_UNALIGNED(6);
 
-#if WJR_HAS_BUILTIN(__BUILTIN_ADD_128)
+        dst += 8;
+        src += 8;
+        --idx;
+    } while (WJR_LIKELY(idx != 0));
+}
 
-WJR_INTRINSIC_INLINE void __builtin_add_128(uint64_t &al, uint64_t &ah, uint64_t lo0,
-                                            uint64_t hi0, uint64_t lo1,
-                                            uint64_t hi1) noexcept {
-    const auto x0 = static_cast<__uint128_t>(hi0) << 64 | lo0;
-    const auto x1 = static_cast<__uint128_t>(hi1) << 64 | lo1;
-    x0 += x1;
+template <typename T>
+WJR_INTRINSIC_INLINE void builtin_rshift_n_impl(T *dst, const T *src, size_t n,
+                                                unsigned int c) noexcept {
+    if (WJR_UNLIKELY(n < 4)) {
+        dst += n - 3;
+        src += n - 3;
 
-    al = x0;
-    ah = x0 >> 64;
-}
+        switch (n) {
+        case 3: {
+            dst[0] = shrd(src[0], src[1], c);
+            WJR_FALLTHROUGH;
+        }
+        case 2: {
+            dst[1] = shrd(src[1], src[2], c);
+            WJR_FALLTHROUGH;
+        }
+        case 1: {
+            dst[2] = shrd(src[2], src[3], c);
+            WJR_FALLTHROUGH;
+        }
+        case 0: {
+            break;
+        }
+        default: {
+            WJR_UNREACHABLE();
+            break;
+        }
+        }
 
-#endif
+        return;
+    }
 
-// <ah, al> = <hi0, lo0> + <hi1, lo1>
-WJR_INTRINSIC_CONSTEXPR_E void __add_128(uint64_t &al, uint64_t &ah, uint64_t lo0,
-                                         uint64_t hi0, uint64_t lo1,
-                                         uint64_t hi1) noexcept {
-#if WJR_HAS_BUILTIN(__BUILTIN_ADD_128) || WJR_HAS_BUILTIN(__ASM_ADD_128)
-    if (is_constant_evaluated() || (WJR_BUILTIN_CONSTANT_P(lo0 == 0) && lo0 == 0) ||
-        (WJR_BUILTIN_CONSTANT_P(lo1 == 0) && lo1 == 0)) {
-        return __fallback_add_128(al, ah, lo0, hi0, lo1, hi1);
+    if (WJR_BUILTIN_CONSTANT_P(c)) {
+        return large_builtin_rshift_n_impl<true>(dst, src, n, c);
     }
 
-    return WJR_PP_BOOL_IF(WJR_HAS_BUILTIN(__BUILTIN_ADD_128), __builtin_add_128,
-                          __asm_add_128)(al, ah, lo0, hi0, lo1, hi1);
-#else
-    return __fallback_add_128(al, ah, lo0, hi0, lo1, hi1);
-#endif
+    return large_builtin_rshift_n_impl<false>(dst, src, n, c);
 }
 
-WJR_INTRINSIC_CONSTEXPR_E uint64_t __fallback_addc_128(uint64_t &al, uint64_t &ah,
-                                                       uint64_t lo0, uint64_t hi0,
-                                                       uint64_t lo1, uint64_t hi1,
-                                                       uint64_t c_in) noexcept {
-    al = addc(lo0, lo1, c_in, c_in);
-    ah = addc(hi0, hi1, c_in, c_in);
-    return c_in;
-}
-
-// return c_out
-WJR_INTRINSIC_CONSTEXPR_E uint64_t __addc_128(uint64_t &al, uint64_t &ah, uint64_t lo0,
-                                              uint64_t hi0, uint64_t lo1, uint64_t hi1,
-                                              uint64_t c_in) noexcept {
-#if WJR_HAS_BUILTIN(__ASM_ADDC_128)
-    if (is_constant_evaluated()) {
-        return __fallback_addc_128(al, ah, lo0, hi0, lo1, hi1, c_in);
-    }
+#undef WJR_REGISTER_RSHIFT_N_IMPL_UNALIGNED
 
-    return __asm_addc_128(al, ah, lo0, hi0, lo1, hi1, c_in);
-#else
-    return __fallback_addc_128(al, ah, lo0, hi0, lo1, hi1, c_in);
-#endif
+template <typename T>
+WJR_INTRINSIC_INLINE T builtin_rshift_n(T *dst, const T *src, size_t n, unsigned int c,
+                                        T hi) noexcept {
+    const T ret = src[0] << (64 - c);
+    builtin_rshift_n_impl(dst, src, n - 1, c);
+    dst[n - 1] = shrd(src[n - 1], hi, c);
+    return ret;
 }
 
-WJR_INTRINSIC_CONSTEXPR_E uint8_t __addc_cc_128(uint64_t &al, uint64_t &ah, uint64_t lo0,
-                                                uint64_t hi0, uint64_t lo1, uint64_t hi1,
-                                                uint8_t c_in) noexcept {
-#if WJR_HAS_BUILTIN(__ASM_ADDC_CC_128)
-    if (is_constant_evaluated()) {
-        return __fallback_addc_128(al, ah, lo0, hi0, lo1, hi1, c_in);
-    }
-
-    return __asm_addc_cc_128(al, ah, lo0, hi0, lo1, hi1, c_in);
-#else
-    return __addc_128(al, ah, lo0, hi0, lo1, hi1, c_in);
 #endif
-}
 
 } // namespace wjr
 
-#endif // WJR_MATH_ADD_HPP__
-#ifndef WJR_MATH_BIGNUM_CONFIG_HPP__
-#define WJR_MATH_BIGNUM_CONFIG_HPP__
-
-#ifndef WJR_TOOM22_MUL_THRESHOLD
-#define WJR_TOOM22_MUL_THRESHOLD 22
+#endif // WJR_X86_MATH_SHIFT_HPP__
 #endif
 
-#ifndef WJR_TOOM33_MUL_THRESHOLD
-#define WJR_TOOM33_MUL_THRESHOLD 84
-#endif
+namespace wjr {
 
-#ifndef WJR_TOOM44_MUL_THRESHOLD
-#define WJR_TOOM44_MUL_THRESHOLD 208
-#endif
+template <typename T>
+WJR_INTRINSIC_CONSTEXPR T fallback_shld(T hi, T lo, unsigned int c) noexcept {
+    constexpr auto digits = std::numeric_limits<T>::digits;
+    return hi << c | lo >> (digits - c);
+}
 
-#ifndef WJR_TOOM55_MUL_THRESHOLD
-#define WJR_TOOM55_MUL_THRESHOLD 800
-#endif
+template <typename T>
+WJR_CONST WJR_INTRINSIC_CONSTEXPR_E T shld(T hi, T lo, unsigned int c) noexcept {
+    return fallback_shld(hi, lo, c);
+}
 
-#ifndef WJR_TOOM32_TO_TOOM43_MUL_THRESHOLD
-#define WJR_TOOM32_TO_TOOM43_MUL_THRESHOLD 73
-#endif
+template <typename T>
+WJR_INTRINSIC_CONSTEXPR T fallback_shrd(T lo, T hi, unsigned int c) noexcept {
+    constexpr auto digits = std::numeric_limits<T>::digits;
+    return lo >> c | hi << (digits - c);
+}
 
-#ifndef WJR_TOOM32_TO_TOOM53_MUL_THRESHOLD
-#define WJR_TOOM32_TO_TOOM53_MUL_THRESHOLD 153
-#endif
+template <typename T>
+WJR_CONST WJR_INTRINSIC_CONSTEXPR_E T shrd(T lo, T hi, unsigned int c) noexcept {
+    return fallback_shrd(lo, hi, c);
+}
 
-#ifndef WJR_TOOM42_TO_TOOM53_MUL_THRESHOLD
-#define WJR_TOOM42_TO_TOOM53_MUL_THRESHOLD 137
-#endif
+template <typename T>
+WJR_INTRINSIC_CONSTEXPR T fallback_lshift_n(T *dst, const T *src, size_t n,
+                                            unsigned int c, T lo) noexcept {
+    constexpr auto nd = std::numeric_limits<T>::digits;
+    T ret = src[n - 1] >> (nd - c);
+    for (size_t i = 0; i < n - 1; ++i) {
+        dst[n - i - 1] = fallback_shld(src[n - i - 1], src[n - i - 2], c);
+    }
+    dst[0] = fallback_shld(src[0], lo, c);
+    return ret;
+}
 
-#ifndef WJR_TOOM42_TO_TOOM63_MUL_THRESHOLD
-#define WJR_TOOM42_TO_TOOM63_MUL_THRESHOLD 153
-#endif
+/*
+require :
+1. n >= 1
+2. WJR_IS_SAME_OR_DECR_P(dst, n, src, n)
+*/
+template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
+WJR_NODISCARD WJR_INTRINSIC_CONSTEXPR_E T lshift_n(T *dst, const T *src, size_t n,
+                                                   unsigned int c,
+                                                   type_identity_t<T> lo = 0) noexcept {
+    WJR_ASSERT_ASSUME(n >= 1);
+    WJR_ASSERT_L2(WJR_IS_SAME_OR_DECR_P(dst, n, src, n));
+    WJR_ASSERT_L2(c < std::numeric_limits<T>::digits);
 
-#ifndef WJR_TOOM2_SQR_THRESHOLD
-#define WJR_TOOM2_SQR_THRESHOLD 34
-#endif
+    if (WJR_UNLIKELY(c == 0)) {
+        if (WJR_LIKELY(dst != src)) {
+            std::copy_backward(src, src + n, dst + n);
+        }
 
-#ifndef WJR_TOOM3_SQR_THRESHOLD
-#define WJR_TOOM3_SQR_THRESHOLD 124
-#endif
+        return 0;
+    }
 
-#ifndef WJR_TOOM4_SQR_THRESHOLD
-#define WJR_TOOM4_SQR_THRESHOLD 288
-#endif
+#if WJR_HAS_BUILTIN(LSHIFT_N)
+    if constexpr (sizeof(T) == 8) {
+        if (is_constant_evaluated()) {
+            return fallback_lshift_n(dst, src, n, c, lo);
+        }
 
-#ifndef WJR_TOOM5_SQR_THRESHOLD
-#define WJR_TOOM5_SQR_THRESHOLD 980
+        return builtin_lshift_n(dst, src, n, c, lo);
+    } else {
+        return fallback_lshift_n(dst, src, n, c, lo);
+    }
+#else
+    return fallback_lshift_n(dst, src, n, c, lo);
 #endif
+}
 
-#ifndef WJR_DC_DIV_QR_THRESHOLD
-#define WJR_DC_DIV_QR_THRESHOLD (WJR_TOOM22_MUL_THRESHOLD * 2)
-#endif // WJR_DC_DIV_QR_THRESHOLD
+template <typename T>
+WJR_INTRINSIC_CONSTEXPR T fallback_rshift_n(T *dst, const T *src, size_t n,
+                                            unsigned int c, T hi) noexcept {
+    constexpr auto nd = std::numeric_limits<T>::digits;
+    T ret = src[0] << (nd - c);
+    for (size_t i = 0; i < n - 1; ++i) {
+        dst[i] = fallback_shrd(src[i], src[i + 1], c);
+    }
+    dst[n - 1] = fallback_shrd(src[n - 1], hi, c);
+    return ret;
+}
 
-#ifndef WJR_DC_BIGNUM_TO_CHARS_THRESHOLD
-#define WJR_DC_BIGNUM_TO_CHARS_THRESHOLD 20
-#endif
+/*
+require :
+1. n >= 1
+2. WJR_IS_SAME_OR_INCR_P(dst, n, src, n)
+*/
+template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
+WJR_INTRINSIC_CONSTEXPR_E T rshift_n(T *dst, const T *src, size_t n, unsigned int c,
+                                     type_identity_t<T> hi = 0) noexcept {
+    WJR_ASSERT_ASSUME(n >= 1);
+    WJR_ASSERT_L2(WJR_IS_SAME_OR_INCR_P(dst, n, src, n));
+    WJR_ASSERT_L2(c < std::numeric_limits<T>::digits);
 
-#ifndef WJR_DC_BIGNUM_TO_CHARS_PRECOMPUTE_THRESHOLD
-#define WJR_DC_BIGNUM_TO_CHARS_PRECOMPUTE_THRESHOLD 20
-#endif
+    if (WJR_UNLIKELY(c == 0)) {
+        if (WJR_LIKELY(dst != src)) {
+            std::copy(src, src + n, dst);
+        }
 
-#ifndef WJR_DC_BIGNUM_FROM_CHARS_THRESHOLD
-#define WJR_DC_BIGNUM_FROM_CHARS_THRESHOLD 1670
-#endif
+        return 0;
+    }
 
-#ifndef WJR_DC_BIGNUM_FROM_CHARS_PRECOMPUTE_THRESHOLD
-#define WJR_DC_BIGNUM_FROM_CHARS_PRECOMPUTE_THRESHOLD 3105
+#if WJR_HAS_BUILTIN(RSHIFT_N)
+    if constexpr (sizeof(T) == 8) {
+        if (is_constant_evaluated()) {
+            return fallback_rshift_n(dst, src, n, c, hi);
+        }
+
+        return builtin_rshift_n(dst, src, n, c, hi);
+    } else {
+        return fallback_rshift_n(dst, src, n, c, hi);
+    }
+#else
+    return fallback_rshift_n(dst, src, n, c, hi);
 #endif
+}
 
-#endif // WJR_MATH_BIGNUM_CONFIG_HPP__
-// Already included
-// Already included
+} // namespace wjr
+
+#endif // WJR_MATH_SHIFT_HPP__
 // Already included
-#ifndef WJR_MATH_SHIFT_HPP__
-#define WJR_MATH_SHIFT_HPP__
+#ifndef WJR_MEMORY_SAFE_POINTER_HPP__
+#define WJR_MEMORY_SAFE_POINTER_HPP__
+
+#ifndef WJR_SPAN_HPP__
+#define WJR_SPAN_HPP__
+
+#include <stdexcept>
 
 // Already included
 // Already included
 
-#if defined(WJR_X86)
-#ifndef WJR_X86_MATH_SHIFT_HPP__
-#define WJR_X86_MATH_SHIFT_HPP__
+namespace wjr {
 
-// Already included
+/**
+ * @brief A type representing a static-sized span.
+ *
+ * @tparam Extent The number of elements in the span.
+ */
+template <typename T, size_t Extent>
+struct __span_static_storage {
 
-#ifndef WJR_X86
-#error "x86 required"
-#endif
+    __span_static_storage() noexcept = default;
+    __span_static_storage(const __span_static_storage &) noexcept = default;
+    __span_static_storage &operator=(const __span_static_storage &) noexcept = default;
 
-namespace wjr {
+    __span_static_storage(T *p, WJR_MAYBE_UNUSED size_t s) noexcept : ptr(p) {
+        WJR_ASSERT_L2(s == size);
+    }
 
-template <typename T>
-WJR_INTRINSIC_CONSTEXPR_E T shld(T hi, T lo, unsigned int c) noexcept;
+    T *ptr = nullptr;
+    static constexpr size_t size = Extent;
+};
 
+/**
+ * @brief A type representing a dynamic-sized span.
+ */
 template <typename T>
-WJR_INTRINSIC_CONSTEXPR_E T shrd(T lo, T hi, unsigned int c) noexcept;
+struct __span_dynamic_storage {
 
-#if WJR_HAS_SIMD(SSE2) && WJR_HAS_SIMD(X86_SIMD)
-#define WJR_HAS_BUILTIN_LSHIFT_N WJR_HAS_DEF
-#define WJR_HAS_BUILTIN_RSHIFT_N WJR_HAS_DEF
-#endif
+    __span_dynamic_storage() noexcept = default;
+    __span_dynamic_storage(const __span_dynamic_storage &) noexcept = default;
+    __span_dynamic_storage &operator=(const __span_dynamic_storage &) noexcept = default;
 
-#if WJR_HAS_BUILTIN(LSHIFT_N) || WJR_HAS_BUILTIN(RSHIFT_N)
+    __span_dynamic_storage(T *p, size_t s) noexcept : ptr(p), size(s) {}
 
-/// @private
-template <bool is_constant>
-WJR_INTRINSIC_INLINE auto __mm_get_shift(unsigned int c) noexcept {
-    if constexpr (is_constant) {
-        return c;
-    } else {
-        return simd_cast<unsigned int, __m128i_t>(c);
-    }
-}
+    T *ptr = nullptr;
+    size_t size = 0;
+};
 
-/// @private
-WJR_INTRINSIC_INLINE __m128i __mm_sll_epi64(__m128i x, unsigned int c) noexcept {
-    return sse::slli_epi64(x, c);
-}
+template <typename Iter, typename Elem>
+struct __is_span_iterator
+    : std::conjunction<is_contiguous_iterator<Iter>,
+                       std::is_convertible<iterator_contiguous_pointer_t<Iter>, Elem *>> {
+};
+
+template <typename T, size_t Extent = dynamic_extent>
+class span;
+
+namespace span_details {
+
+WJR_REGISTER_HAS_TYPE(data, std::data(std::declval<Container &>()), Container);
+WJR_REGISTER_HAS_TYPE(size, std::size(std::declval<Container &>()), Container);
 
 /// @private
-WJR_INTRINSIC_INLINE __m128i __mm_sll_epi64(__m128i x, __m128i c) noexcept {
-    return sse::sll_epi64(x, c);
-}
+template <typename T>
+struct __is_std_array : std::false_type {};
 
 /// @private
-WJR_INTRINSIC_INLINE __m128i __mm_srl_epi64(__m128i x, unsigned int c) noexcept {
-    return sse::srli_epi64(x, c);
-}
+template <typename T, size_t N>
+struct __is_std_array<std::array<T, N>> : std::true_type {};
 
 /// @private
-WJR_INTRINSIC_INLINE __m128i __mm_srl_epi64(__m128i x, __m128i c) noexcept {
-    return sse::srl_epi64(x, c);
-}
+template <typename T>
+inline constexpr bool __is_std_array_v = __is_std_array<T>::value;
 
-#endif
+template <typename T>
+struct __is_span : std::false_type {};
 
-#if WJR_HAS_BUILTIN(LSHIFT_N)
+template <typename T, size_t Extent>
+struct __is_span<span<T, Extent>> : std::true_type {};
 
-#define WJR_REGISTER_LSHIFT_N_IMPL_UNALIGNED(index)                                      \
-    do {                                                                                 \
-        __m128i x1 = sse::loadu((__m128i *)(src - 3 - (index)));                         \
-        x0 = simd_cast<__m128_t, __m128i_t>(sse::template shuffle_ps<78>(                \
-            simd_cast<__m128i_t, __m128_t>(x1), simd_cast<__m128i_t, __m128_t>(x0)));    \
-                                                                                         \
-        __m128i r0 = __mm_sll_epi64(x0, y);                                              \
-        __m128i r1 = __mm_srl_epi64(x1, z);                                              \
-                                                                                         \
-        __m128i r = sse::Or(r0, r1);                                                     \
-                                                                                         \
-        sse::storeu((__m128i *)(dst - 2 - (index)), r);                                  \
-                                                                                         \
-        x0 = x1;                                                                         \
-    } while (0)
+template <typename T>
+inline constexpr bool __is_span_v = __is_span<T>::value;
 
-template <bool is_constant, typename T>
-void large_builtin_lshift_n_impl(T *dst, const T *src, size_t n,
-                                 unsigned int c) noexcept {
-    const auto y = __mm_get_shift<is_constant>(c);
-    const auto z = __mm_get_shift<is_constant>(64 - c);
+/// @private
+template <typename Container, typename = void>
+struct __is_container_like : std::false_type {};
 
-    if (n & 1) {
-        dst[-1] = shld(src[-1], src[-2], c);
-        --src;
-        --dst;
-    }
+/// @private
+template <typename Container>
+struct __is_container_like<
+    Container, std::enable_if_t<has_data_v<Container &> && has_size_v<Container &>>>
+    : std::conjunction<
+          std::negation<std::is_array<remove_cvref_t<Container>>>,
+          std::negation<__is_std_array<remove_cvref_t<Container>>>,
+          std::negation<__is_span<remove_cvref_t<Container>>>,
+          std::is_pointer<decltype(std::data(std::declval<Container &>()))>> {};
 
-    __m128i x0 = sse::set1_epi64(src[-1]);
+/// @private
+template <typename Container>
+inline constexpr bool __is_container_like_v = __is_container_like<Container>::value;
 
-    if (n & 2) {
-        WJR_REGISTER_LSHIFT_N_IMPL_UNALIGNED(0);
+template <typename Container, typename Elem, typename = void>
+struct __is_span_like : std::false_type {};
 
-        src -= 2;
-        dst -= 2;
-    }
+template <typename Container, typename Elem>
+struct __is_span_like<
+    Container, Elem, std::enable_if_t<has_data_v<Container &> && has_size_v<Container &>>>
+    : std::conjunction<
+          __is_container_like<Container>,
+          std::is_convertible<decltype(std::data(std::declval<Container &>())), Elem *>> {
+};
 
-    if (n & 4) {
-        WJR_REGISTER_LSHIFT_N_IMPL_UNALIGNED(0);
-        WJR_REGISTER_LSHIFT_N_IMPL_UNALIGNED(2);
+template <typename Container, typename Elem>
+inline constexpr bool __is_span_like_v = __is_span_like<Container, Elem>::value;
 
-        src -= 4;
-        dst -= 4;
-    }
+/// @private
+template <typename T>
+struct basic_span_traits {
+    using value_type = std::remove_cv_t<T>;
+    using difference_type = ptrdiff_t;
+    using pointer = T *;
+    using const_pointer = const T *;
+    using reference = T &;
+    using const_reference = const T &;
+};
 
-    size_t idx = n / 8;
+} // namespace span_details
 
-    if (WJR_UNLIKELY(idx == 0)) {
-        return;
-    }
+/**
+ * @class span
+ *
+ * @brief A view over a contiguous sequence of objectsd.
+ *
+ * @tparam Extent if Extent is `dynamic_extent`, the span is a runtime-sized view.
+ * Otherwise, the span is a compile-time-sized view.
+ */
+template <typename T, size_t Extent>
+class span {
+    static constexpr bool __is_dynamic = Extent == dynamic_extent;
+    using __storage = std::conditional_t<__is_dynamic, __span_dynamic_storage<T>,
+                                         __span_static_storage<T, Extent>>;
 
-    do {
-        WJR_REGISTER_LSHIFT_N_IMPL_UNALIGNED(0);
-        WJR_REGISTER_LSHIFT_N_IMPL_UNALIGNED(2);
-        WJR_REGISTER_LSHIFT_N_IMPL_UNALIGNED(4);
-        WJR_REGISTER_LSHIFT_N_IMPL_UNALIGNED(6);
+    using IteratorTraits = span_details::basic_span_traits<T>;
 
-        src -= 8;
-        dst -= 8;
-        --idx;
-    } while (WJR_LIKELY(idx != 0));
-}
+public:
+    using element_type = T;
+    using value_type = std::remove_cv_t<T>;
+    using size_type = size_t;
+    using difference_type = ptrdiff_t;
+    using pointer = T *;
+    using const_pointer = const T *;
+    using reference = T &;
+    using const_reference = const T &;
+    using iterator = contiguous_iterator_adapter<span, IteratorTraits>;
+    using const_iterator = contiguous_const_iterator_adapter<span, IteratorTraits>;
+    using reverse_iterator = std::reverse_iterator<iterator>;
+    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
-template <typename T>
-WJR_INTRINSIC_INLINE void builtin_lshift_n_impl(T *dst, const T *src, size_t n,
-                                                unsigned int c) noexcept {
-    if (WJR_UNLIKELY(n < 4)) {
-        switch (n) {
-        case 3: {
-            dst[2] = shld(src[2], src[1], c);
-            WJR_FALLTHROUGH;
-        }
-        case 2: {
-            dst[1] = shld(src[1], src[0], c);
-            WJR_FALLTHROUGH;
-        }
-        case 1: {
-            dst[0] = shld(src[0], src[-1], c);
-            WJR_FALLTHROUGH;
-        }
-        case 0: {
-            break;
-        }
-        default: {
-            WJR_UNREACHABLE();
-            break;
-        }
-        }
+    template <size_t Ex = Extent, WJR_REQUIRES(Ex == dynamic_extent || Ex == 0)>
+    constexpr span() noexcept : storage() {}
 
-        return;
-    }
+#if defined(__cpp_conditional_explicit)
+    template <typename It, WJR_REQUIRES(__is_span_iterator<It, element_type>::value)>
+    constexpr explicit(!__is_dynamic) span(It first, size_type count) noexcept
+        : storage((to_address)(first), count) {}
+#else
+    template <typename It,
+              WJR_REQUIRES(__is_span_iterator<It, element_type>::value &&__is_dynamic)>
+    constexpr span(It first, size_type count) noexcept
+        : storage((to_address)(first), count) {}
 
-    src += n;
-    dst += n;
+    template <typename It,
+              WJR_REQUIRES(__is_span_iterator<It, element_type>::value && !__is_dynamic)>
+    constexpr explicit span(It first, size_type count) noexcept
+        : storage((to_address)(first), count) {}
+#endif
 
-    if (WJR_BUILTIN_CONSTANT_P(c)) {
-        return large_builtin_lshift_n_impl<true>(dst, src, n, c);
-    }
+#if defined(__cpp_conditional_explicit)
+    template <typename It, WJR_REQUIRES(__is_span_iterator<It, element_type>::value)>
+    constexpr explicit(!__is_dynamic) span(It first, It last) noexcept
+        : storage((to_address)(first), static_cast<size_type>(last - first)) {}
+#else
+    template <typename It,
+              WJR_REQUIRES(__is_span_iterator<It, element_type>::value &&__is_dynamic)>
+    constexpr span(It first, It last) noexcept
+        : storage((to_address)(first), static_cast<size_type>(last - first)) {}
 
-    return large_builtin_lshift_n_impl<false>(dst, src, n, c);
-}
+    template <typename It,
+              WJR_REQUIRES(__is_span_iterator<It, element_type>::value && !__is_dynamic)>
+    constexpr explicit span(It first, It last) noexcept
+        : storage((to_address)(first), static_cast<size_type>(last - first)) {}
+#endif
 
-#undef WJR_REGISTER_LSHIFT_N_IMPL_UNALIGNED
+    template <size_t N, WJR_REQUIRES((__is_dynamic || N == Extent))>
+    constexpr span(type_identity_t<element_type> (&arr)[N]) noexcept
+        : storage(std::data(arr), N) {}
 
-template <typename T>
-WJR_INTRINSIC_INLINE T builtin_lshift_n(T *dst, const T *src, size_t n, unsigned int c,
-                                        T lo) noexcept {
-    const T ret = src[n - 1] >> (64 - c);
-    builtin_lshift_n_impl(dst + 1, src + 1, n - 1, c);
-    dst[0] = shld(src[0], lo, c);
-    return ret;
-}
+    template <typename U, size_t N,
+              WJR_REQUIRES((__is_dynamic || N == Extent) &&
+                           std::is_convertible_v<U *, T *>)>
+    constexpr span(std::array<U, N> &arr) noexcept
+        : storage(std::data(arr), std::size(arr)) {}
 
-#endif
+    template <typename U, size_t N,
+              WJR_REQUIRES((__is_dynamic || N == Extent) &&
+                           std::is_convertible_v<const U *, T *>)>
+    constexpr span(const std::array<U, N> &arr) noexcept
+        : storage(std::data(arr), std::size(arr)) {}
 
-#if WJR_HAS_BUILTIN(RSHIFT_N)
+#if defined(__cpp_conditional_explicit)
+    template <typename U, size_t N,
+              WJR_REQUIRES((__is_dynamic || N == dynamic_extent || N == Extent) &&
+                           std::is_convertible_v<U *, T *>)>
+    constexpr explicit(!__is_dynamic) span(const span<U, N> &source) noexcept
+        : storage(source.data(), source.size()) {}
+#else
+    template <typename U, size_t N,
+              WJR_REQUIRES((__is_dynamic || N == dynamic_extent || N == Extent) &&
+                           std::is_convertible_v<U *, T *> && __is_dynamic)>
+    constexpr span(const span<U, N> &source) noexcept
+        : storage(source.data(), source.size()) {}
 
-#define WJR_REGISTER_RSHIFT_N_IMPL_UNALIGNED(index)                                      \
-    do {                                                                                 \
-        __m128i x1 = sse::loadu((__m128i *)(src + 1 + (index)));                         \
-        x0 = simd_cast<__m128_t, __m128i_t>(sse::template shuffle_ps<78>(                \
-            simd_cast<__m128i_t, __m128_t>(x0), simd_cast<__m128i_t, __m128_t>(x1)));    \
-                                                                                         \
-        __m128i r0 = __mm_srl_epi64(x0, y);                                              \
-        __m128i r1 = __mm_sll_epi64(x1, z);                                              \
-                                                                                         \
-        __m128i r = sse::Or(r0, r1);                                                     \
-                                                                                         \
-        sse::storeu((__m128i *)(dst + (index)), r);                                      \
-                                                                                         \
-        x0 = x1;                                                                         \
-    } while (0)
+    template <typename U, size_t N,
+              WJR_REQUIRES((__is_dynamic || N == dynamic_extent || N == Extent) &&
+                           std::is_convertible_v<U *, T *> && !__is_dynamic)>
+    constexpr explicit span(const span<U, N> &source) noexcept
+        : storage(source.data(), source.size()) {}
+#endif
 
-template <bool is_constant, typename T>
-void large_builtin_rshift_n_impl(T *dst, const T *src, size_t n,
-                                 unsigned int c) noexcept {
-    const auto y = __mm_get_shift<is_constant>(c);
-    const auto z = __mm_get_shift<is_constant>(64 - c);
+    constexpr span(const span &other) noexcept = default;
+    constexpr span &operator=(const span &other) noexcept = default;
 
-    if (n & 1) {
-        dst[0] = shrd(src[0], src[1], c);
-        ++src;
-        ++dst;
-    }
+    ~span() = default;
 
-    __m128i x0 = sse::set1_epi64(src[0]);
+    WJR_PURE WJR_CONSTEXPR20 pointer begin_unsafe() noexcept { return data(); }
+    WJR_PURE WJR_CONSTEXPR20 const_pointer begin_unsafe() const noexcept {
+        return data();
+    }
+    WJR_PURE WJR_CONSTEXPR20 const_pointer cbegin_unsafe() const noexcept {
+        return data();
+    }
 
-    if (n & 2) {
-        WJR_REGISTER_RSHIFT_N_IMPL_UNALIGNED(0);
+    WJR_PURE WJR_CONSTEXPR20 pointer end_unsafe() noexcept { return data() + size(); }
+    WJR_PURE WJR_CONSTEXPR20 const_pointer end_unsafe() const noexcept {
+        return data() + size();
+    }
+    WJR_PURE WJR_CONSTEXPR20 const_pointer cend_unsafe() const noexcept {
+        return end_unsafe();
+    }
 
-        src += 2;
-        dst += 2;
+private:
+    WJR_PURE WJR_CONSTEXPR20 iterator __make_iterator(const_pointer ptr) const noexcept {
+        return iterator(const_cast<pointer>(ptr), this);
     }
 
-    if (n & 4) {
-        WJR_REGISTER_RSHIFT_N_IMPL_UNALIGNED(0);
-        WJR_REGISTER_RSHIFT_N_IMPL_UNALIGNED(2);
+    WJR_PURE WJR_CONSTEXPR20 pointer __get_pointer(iterator ptr) const noexcept {
+        ptr.check_same_container(this);
+        return (to_address)(ptr);
+    }
 
-        src += 4;
-        dst += 4;
+    WJR_PURE WJR_CONSTEXPR20 pointer __get_pointer(const_iterator ptr) const noexcept {
+        ptr.check_same_container(this);
+        return const_cast<pointer>((to_address)(ptr));
     }
 
-    size_t idx = n / 8;
+public:
+    constexpr iterator begin() noexcept { return __make_iterator(begin_unsafe()); }
+    constexpr const_iterator begin() const noexcept {
+        return __make_iterator(begin_unsafe());
+    }
+    constexpr const_iterator cbegin() const noexcept {
+        return __make_iterator(begin_unsafe());
+    }
 
-    if (WJR_UNLIKELY(idx == 0)) {
-        return;
+    constexpr iterator end() noexcept { return __make_iterator(end_unsafe()); }
+    constexpr const_iterator end() const noexcept {
+        return __make_iterator(end_unsafe());
+    }
+    constexpr const_iterator cend() const noexcept {
+        return __make_iterator(end_unsafe());
     }
 
-    do {
-        WJR_REGISTER_RSHIFT_N_IMPL_UNALIGNED(0);
-        WJR_REGISTER_RSHIFT_N_IMPL_UNALIGNED(2);
-        WJR_REGISTER_RSHIFT_N_IMPL_UNALIGNED(4);
-        WJR_REGISTER_RSHIFT_N_IMPL_UNALIGNED(6);
+    constexpr reverse_iterator rbegin() noexcept {
+        return std::make_reverse_iterator(end());
+    }
+    constexpr reverse_iterator rbegin() const noexcept {
+        return std::make_reverse_iterator(end());
+    }
+    constexpr const_reverse_iterator crbegin() const noexcept {
+        return std::make_reverse_iterator(cend());
+    }
 
-        dst += 8;
-        src += 8;
-        --idx;
-    } while (WJR_LIKELY(idx != 0));
-}
+    constexpr reverse_iterator rend() noexcept {
+        return std::make_reverse_iterator(begin());
+    }
+    constexpr reverse_iterator rend() const noexcept {
+        return std::make_reverse_iterator(begin());
+    }
+    constexpr const_reverse_iterator crend() const noexcept {
+        return std::make_reverse_iterator(cbegin());
+    }
 
-template <typename T>
-WJR_INTRINSIC_INLINE void builtin_rshift_n_impl(T *dst, const T *src, size_t n,
-                                                unsigned int c) noexcept {
-    if (WJR_UNLIKELY(n < 4)) {
-        dst += n - 3;
-        src += n - 3;
+    constexpr reference front() const noexcept {
+#if WJR_HAS_DEBUG(CONTIGUOUS_ITERATOR_CHECKER)
+        WJR_ASSERT_L0(size() > 0, "basic_vector::front: empty");
+#endif
+        return *data();
+    }
+    constexpr reference back() const noexcept {
+#if WJR_HAS_DEBUG(CONTIGUOUS_ITERATOR_CHECKER)
+        WJR_ASSERT_L0(size() > 0, "basic_vector::front: empty");
+#endif
+        return *(end_unsafe() - 1);
+    }
 
-        switch (n) {
-        case 3: {
-            dst[0] = shrd(src[0], src[1], c);
-            WJR_FALLTHROUGH;
-        }
-        case 2: {
-            dst[1] = shrd(src[1], src[2], c);
-            WJR_FALLTHROUGH;
-        }
-        case 1: {
-            dst[2] = shrd(src[2], src[3], c);
-            WJR_FALLTHROUGH;
-        }
-        case 0: {
-            break;
-        }
-        default: {
-            WJR_UNREACHABLE();
-            break;
-        }
+    constexpr reference at(size_type pos) const noexcept {
+        if (WJR_UNLIKELY(pos >= size())) {
+            WJR_THROW(std::out_of_range("span at out of range"));
         }
 
-        return;
+        return data()[pos];
     }
 
-    if (WJR_BUILTIN_CONSTANT_P(c)) {
-        return large_builtin_rshift_n_impl<true>(dst, src, n, c);
+    constexpr reference operator[](size_type pos) const noexcept {
+#if WJR_HAS_DEBUG(CONTIGUOUS_ITERATOR_CHECKER)
+        WJR_ASSERT_L0(pos < size(), "basic_vector::operator[]: out of range");
+#endif
+        return data()[pos];
     }
 
-    return large_builtin_rshift_n_impl<false>(dst, src, n, c);
-}
+    constexpr pointer data() const noexcept { return storage.ptr; }
+    constexpr size_type size() const noexcept { return storage.size; }
+    constexpr size_type size_bytes() const noexcept {
+        return size() * sizeof(element_type);
+    }
+    constexpr bool empty() const noexcept { return size() == 0; }
 
-#undef WJR_REGISTER_RSHIFT_N_IMPL_UNALIGNED
+    template <size_t Count>
+    constexpr span<element_type, Count> first() const noexcept {
+        static_assert(Count <= Extent, "");
 
-template <typename T>
-WJR_INTRINSIC_INLINE T builtin_rshift_n(T *dst, const T *src, size_t n, unsigned int c,
-                                        T hi) noexcept {
-    const T ret = src[0] << (64 - c);
-    builtin_rshift_n_impl(dst, src, n - 1, c);
-    dst[n - 1] = shrd(src[n - 1], hi, c);
-    return ret;
-}
+        return {begin(), Count};
+    }
 
-#endif
+    constexpr span<element_type, dynamic_extent> first(size_type Count) const noexcept {
+        WJR_ASSERT_L2(Count <= size());
 
-} // namespace wjr
+        return {begin(), Count};
+    }
 
-#endif // WJR_X86_MATH_SHIFT_HPP__
-#endif
+    template <size_t Count>
+    constexpr span<element_type, Count> last() const noexcept {
+        static_assert(Count <= Extent, "");
 
-namespace wjr {
+        return {end() - Count, Count};
+    }
 
-template <typename T>
-WJR_INTRINSIC_CONSTEXPR T fallback_shld(T hi, T lo, unsigned int c) noexcept {
-    constexpr auto digits = std::numeric_limits<T>::digits;
-    return hi << c | lo >> (digits - c);
-}
+    constexpr span<element_type, dynamic_extent> last(size_type Count) const noexcept {
+        WJR_ASSERT_L2(Count <= size());
 
-template <typename T>
-WJR_CONST WJR_INTRINSIC_CONSTEXPR_E T shld(T hi, T lo, unsigned int c) noexcept {
-    return fallback_shld(hi, lo, c);
-}
+        return {data() - Count, Count};
+    }
 
-template <typename T>
-WJR_INTRINSIC_CONSTEXPR T fallback_shrd(T lo, T hi, unsigned int c) noexcept {
-    constexpr auto digits = std::numeric_limits<T>::digits;
-    return lo >> c | hi << (digits - c);
-}
+    template <size_t Offset, size_t Count = dynamic_extent>
+    constexpr span<element_type, Count != dynamic_extent    ? Count
+                                 : Extent != dynamic_extent ? Extent - Offset
+                                                            : dynamic_extent>
+    subspan() const noexcept {
+        if constexpr (Extent != dynamic_extent) {
+            static_assert(Offset <= Extent, "");
+            static_assert(Count == dynamic_extent || Count <= Extent - Offset, "");
+        } else {
+            WJR_ASSERT_L2(Offset <= size());
+            if constexpr (Count != dynamic_extent) {
+                WJR_ASSERT_L2(Count <= size() - Offset);
+            }
+        }
+        return {begin() + Offset, Count == dynamic_extent ? size() - Offset : Count};
+    }
 
-template <typename T>
-WJR_CONST WJR_INTRINSIC_CONSTEXPR_E T shrd(T lo, T hi, unsigned int c) noexcept {
-    return fallback_shrd(lo, hi, c);
-}
+    constexpr span<element_type, dynamic_extent>
+    subspan(size_type Offset, size_type Count = dynamic_extent) const noexcept {
+        WJR_ASSERT_L2(Offset <= size());
 
-template <typename T>
-WJR_INTRINSIC_CONSTEXPR T fallback_lshift_n(T *dst, const T *src, size_t n,
-                                            unsigned int c, T lo) noexcept {
-    constexpr auto nd = std::numeric_limits<T>::digits;
-    T ret = src[n - 1] >> (nd - c);
-    for (size_t i = 0; i < n - 1; ++i) {
-        dst[n - i - 1] = fallback_shld(src[n - i - 1], src[n - i - 2], c);
+        return {begin() + Offset, Count == dynamic_extent ? size() - Offset : Count};
     }
-    dst[0] = fallback_shld(src[0], lo, c);
-    return ret;
-}
 
-/*
-require :
-1. n >= 1
-2. WJR_IS_SAME_OR_DECR_P(dst, n, src, n)
-*/
-template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-WJR_NODISCARD WJR_INTRINSIC_CONSTEXPR_E T lshift_n(T *dst, const T *src, size_t n,
-                                                   unsigned int c,
-                                                   type_identity_t<T> lo = 0) noexcept {
-    WJR_ASSERT_ASSUME(n >= 1);
-    WJR_ASSERT_L2(WJR_IS_SAME_OR_DECR_P(dst, n, src, n));
-    WJR_ASSERT_L2(c < std::numeric_limits<T>::digits);
-
-    if (WJR_UNLIKELY(c == 0)) {
-        if (WJR_LIKELY(dst != src)) {
-            std::copy_backward(src, src + n, dst + n);
-        }
-
-        return 0;
-    }
+    // extension :
 
-#if WJR_HAS_BUILTIN(LSHIFT_N)
-    if constexpr (sizeof(T) == 8) {
-        if (is_constant_evaluated()) {
-            return fallback_lshift_n(dst, src, n, c, lo);
-        }
+    /**
+     * @brief Construct a span from a container.
+     *
+     * @details The container must have a `data()` member function that returns a @ref
+     * __is_span_iterator. The container must also have a `size()` member function that
+     * can be converted to `size_type`.
+     *
+     */
+    template <typename Container, WJR_REQUIRES(span_details::__is_span_like_v<
+                                               Container, element_type> &&__is_dynamic)>
+    constexpr span(Container &&c) noexcept : storage(std::data(c), std::size(c)) {}
 
-        return builtin_lshift_n(dst, src, n, c, lo);
-    } else {
-        return fallback_lshift_n(dst, src, n, c, lo);
-    }
-#else
-    return fallback_lshift_n(dst, src, n, c, lo);
-#endif
-}
+    /**
+     * @brief Construct a span from a container.
+     *
+     * @details Like @ref span(Container &&), but the span is not dynamic-sized, so the
+     * construct must be explicit.
+     *
+     */
+    template <typename Container,
+              WJR_REQUIRES(span_details::__is_span_like_v<Container, element_type> &&
+                           !__is_dynamic)>
+    constexpr explicit span(Container &&c) noexcept
+        : storage(std::data(c), std::size(c)) {}
 
-template <typename T>
-WJR_INTRINSIC_CONSTEXPR T fallback_rshift_n(T *dst, const T *src, size_t n,
-                                            unsigned int c, T hi) noexcept {
-    constexpr auto nd = std::numeric_limits<T>::digits;
-    T ret = src[0] << (nd - c);
-    for (size_t i = 0; i < n - 1; ++i) {
-        dst[i] = fallback_shrd(src[i], src[i + 1], c);
-    }
-    dst[n - 1] = fallback_shrd(src[n - 1], hi, c);
-    return ret;
-}
+private:
+    __storage storage;
+};
 
-/*
-require :
-1. n >= 1
-2. WJR_IS_SAME_OR_INCR_P(dst, n, src, n)
-*/
-template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-WJR_INTRINSIC_CONSTEXPR_E T rshift_n(T *dst, const T *src, size_t n, unsigned int c,
-                                     type_identity_t<T> hi = 0) noexcept {
-    WJR_ASSERT_ASSUME(n >= 1);
-    WJR_ASSERT_L2(WJR_IS_SAME_OR_INCR_P(dst, n, src, n));
-    WJR_ASSERT_L2(c < std::numeric_limits<T>::digits);
+template <typename T, size_t Extent>
+span(T (&)[Extent]) -> span<T, Extent>;
 
-    if (WJR_UNLIKELY(c == 0)) {
-        if (WJR_LIKELY(dst != src)) {
-            std::copy(src, src + n, dst);
-        }
+template <typename T, size_t Size>
+span(std::array<T, Size> &) -> span<T, Size>;
 
-        return 0;
-    }
+template <typename T, size_t Size>
+span(const std::array<T, Size> &) -> span<const T, Size>;
 
-#if WJR_HAS_BUILTIN(RSHIFT_N)
-    if constexpr (sizeof(T) == 8) {
-        if (is_constant_evaluated()) {
-            return fallback_rshift_n(dst, src, n, c, hi);
-        }
+template <typename It, typename End, WJR_REQUIRES(is_contiguous_iterator_v<It>)>
+span(It, End) -> span<iterator_contiguous_value_t<It>>;
 
-        return builtin_rshift_n(dst, src, n, c, hi);
-    } else {
-        return fallback_rshift_n(dst, src, n, c, hi);
-    }
-#else
-    return fallback_rshift_n(dst, src, n, c, hi);
-#endif
-}
+template <typename Container,
+          WJR_REQUIRES(span_details::__is_container_like_v<Container>)>
+span(Container &&) -> span<
+    iterator_contiguous_value_t<decltype(std::data(std::declval<Container &>()))>>;
 
 } // namespace wjr
 
-#endif // WJR_MATH_SHIFT_HPP__
-#ifndef WJR_MATH_STACK_ALLOCATOR_HPP__
-#define WJR_MATH_STACK_ALLOCATOR_HPP__
-
-#ifndef WJR_STACK_ALLOCATOR_HPP__
-#define WJR_STACK_ALLOCATOR_HPP__
-
-#include <algorithm>
-
-#ifndef WJR_CRTP_NONSENDABLE_HPP__
-#define WJR_CRTP_NONSENDABLE_HPP__
-
-/**
- * @file nonsendable.hpp
- * @author wjr
- * @brief  A type to disable sending the object to another thread.
- *
- * @version 0.1
- * @date 2024-05-26
- *
- * @copyright Copyright (c) 2024
- *
- */
-
-#include <memory>
+#endif // WJR_SPAN_HPP__
 
-// Already included
+namespace wjr {
 
 #if WJR_DEBUG_LEVEL > 2
-#define WJR_HAS_DEBUG_NONSENDABLE_CHECKER WJR_HAS_DEF
-#endif
-
-#if WJR_HAS_DEBUG(NONSENDABLE_CHECKER)
-#include <thread>
+#define WJR_HAS_DEBUG_SAFE_POINTER WJR_HAS_DEF
 #endif
 
-namespace wjr {
-
-#if WJR_HAS_DEBUG(NONSENDABLE_CHECKER)
+#if WJR_HAS_DEBUG(SAFE_POINTER)
 
-/**
- * @brief A type to disable sending the object to another thread.
- *
- */
-template <typename Tag = void>
-class nonsendable {
+template <typename T, typename Tag = void>
+class safe_array {
 public:
-    static constexpr bool is_nonsendable = true;
+    using element_type = T;
+    using value_type = std::remove_cv_t<T>;
+    using pointer = T *;
+    using reference = T &;
+    using difference_type = ptrdiff_t;
+    using size_type = size_t;
 
-protected:
-    nonsendable() noexcept : m_thread_id(std::this_thread::get_id()) {}
-    nonsendable(const nonsendable &) noexcept = default;
-    nonsendable(nonsendable &&) noexcept = default;
-    nonsendable &operator=(const nonsendable &) noexcept = default;
-    nonsendable &operator=(nonsendable &&) noexcept = default;
-    ~nonsendable() noexcept { check(); }
+    constexpr safe_array() noexcept = default;
+    constexpr safe_array(const safe_array &) noexcept = default;
+    constexpr safe_array(safe_array &&) noexcept = default;
+    constexpr safe_array &operator=(const safe_array &) noexcept = default;
+    constexpr safe_array &operator=(safe_array &&) noexcept = default;
+    ~safe_array() noexcept = default;
 
-    void check() const noexcept {
-        WJR_ASSERT_L0(m_thread_id == std::this_thread::get_id(),
-                      "Cross-thread access detected when using a nonsendable object.");
+    constexpr safe_array &reset_range() noexcept {
+        m_length -= m_offset;
+        m_offset = 0;
+        return *this;
     }
 
-    friend bool operator==(const nonsendable &lhs, const nonsendable &rhs) noexcept {
-        return lhs.m_thread_id == rhs.m_thread_id;
-    }
+    constexpr pointer get() const noexcept { return m_ptr; }
+    constexpr pointer data() const noexcept { return m_ptr; }
+    constexpr reference operator[](size_type i) const noexcept { return m_ptr[i]; }
 
-    friend bool operator!=(const nonsendable &lhs, const nonsendable &rhs) noexcept {
-        return lhs.m_thread_id != rhs.m_thread_id;
+    constexpr safe_array(span<T> s) noexcept
+        : m_ptr(s.data()), m_offset(0), m_size(s.size()), m_length(s.size()) {}
+
+    constexpr safe_array first(size_type count) const noexcept {
+        WJR_ASSERT_L3(m_ptr != nullptr, "safe_array: nullptr");
+        WJR_ASSERT_L3(count <= m_size, "safe_array: out of range");
+        return {m_ptr, m_offset, count, m_length};
     }
 
-private:
-    std::thread::id m_thread_id;
-};
+    constexpr safe_array subspan(size_type offset, size_type count) const noexcept {
+        WJR_ASSERT_L3(m_ptr != nullptr, "safe_array: nullptr");
+        WJR_ASSERT_L3(offset + count <= m_size, "safe_array: out of range");
+        return {m_ptr + offset, m_offset + offset, count, m_length};
+    }
 
-#else
+    constexpr safe_array &append(size_type length) noexcept {
+        WJR_ASSERT_L3(m_offset + m_size + length <= m_length);
+        m_size += length;
+        return *this;
+    }
 
-/**
- * @brief A type to disable sending the object to another thread.
- *
- */
-template <typename Tag = void>
-class nonsendable {
-public:
-    static constexpr bool is_nonsendable = true;
+    constexpr safe_array &operator=(span<T> s) noexcept {
+        m_ptr = s.data();
+        m_offset = 0;
+        m_size = s.size();
+        m_length = s.size();
+        return *this;
+    }
 
-protected:
-    constexpr static void check() noexcept {}
+    constexpr safe_array &operator=(std::nullptr_t) noexcept {
+        m_ptr = nullptr;
+        m_offset = 0;
+        m_size = 0;
+        m_length = 0;
+        return *this;
+    }
 
-    friend bool operator==(const nonsendable &, const nonsendable &) noexcept {
-        return true;
+    constexpr safe_array &operator+=(size_type n) noexcept {
+        WJR_ASSERT_L3(m_ptr != nullptr, "safe_array: nullptr");
+        WJR_ASSERT_L3(n <= m_size, "safe_array: out of range");
+        m_ptr += n;
+        m_offset += n;
+        m_size -= n;
+        return *this;
     }
 
-    friend bool operator!=(const nonsendable &, const nonsendable &) noexcept {
-        return false;
+    constexpr friend safe_array operator+(safe_array lhs, size_type rhs) noexcept {
+        return lhs += rhs;
     }
-};
 
-#endif
+    constexpr friend safe_array operator+(size_type lhs, safe_array rhs) noexcept {
+        return rhs += lhs;
+    }
 
-} // namespace wjr
+    constexpr safe_array &operator++() noexcept {
+        (*this) += 1;
+        return *this;
+    }
 
-#endif // WJR_CRTP_NONSENDABLE_HPP__
-// Already included
-// Already included
-
-namespace wjr {
-
-template <typename StackAllocator>
-class unique_stack_allocator;
+    constexpr safe_array operator++(int) noexcept {
+        safe_array tmp = *this;
+        ++*this;
+        return tmp;
+    }
 
-template <size_t Cache>
-class stack_allocator_object {
-    template <typename StackAllocator>
-    friend class unique_stack_allocator;
+    constexpr safe_array &operator-=(size_type n) noexcept {
+        WJR_ASSERT_L3(m_ptr != nullptr, "safe_array: nullptr");
+        WJR_ASSERT_L3(m_offset >= n, "safe_array: out of range");
+        m_ptr -= n;
+        m_offset -= n;
+        m_size += n;
+        return *this;
+    }
 
-    constexpr static uint16_t bufsize = 5;
+    constexpr friend safe_array operator-(safe_array lhs, size_type rhs) noexcept {
+        return lhs -= rhs;
+    }
 
-    struct alloc_node {
-        char *ptr;
-        char *end;
-    };
+    constexpr friend ptrdiff_t operator-(const safe_array &lhs,
+                                         const safe_array &rhs) noexcept {
+        return lhs.m_ptr - rhs.m_ptr;
+    }
 
-    struct large_stack_top {
-        large_stack_top *prev;
-        char buffer[];
-    };
+    constexpr safe_array &operator--() noexcept {
+        (*this) -= 1;
+        return *this;
+    }
 
-public:
-    struct stack_top {
-        char *ptr;
-        uint16_t idx;
-        large_stack_top *large;
-    };
+    constexpr safe_array operator--(int) noexcept {
+        safe_array tmp = *this;
+        --*this;
+        return tmp;
+    }
 
 private:
-    WJR_CONSTEXPR20 void *__large_allocate(size_t n, stack_top &top) noexcept {
-        const auto buffer = (large_stack_top *)malloc(sizeof(large_stack_top) + n);
-        buffer->prev = top.large;
-        top.large = buffer;
-        return buffer->buffer;
-    }
+    constexpr safe_array(pointer ptr, size_type offset, size_type size,
+                         size_type length) noexcept
+        : m_ptr(ptr), m_offset(offset), m_size(size), m_length(length) {}
 
-    WJR_NOINLINE WJR_CONSTEXPR20 void __small_reallocate(stack_top &top) noexcept {
-        if (WJR_UNLIKELY(top.idx == (uint16_t)in_place_max)) {
-            top.idx = m_idx;
-        }
+    pointer m_ptr = nullptr;
+    size_type m_offset;
+    size_type m_size;
+    size_type m_length;
+};
 
-        ++m_idx;
-        if (WJR_UNLIKELY(m_idx == m_size)) {
+#else
 
-            if (WJR_UNLIKELY(m_size == m_capacity)) {
-                uint16_t new_capacity = m_idx + 2 * (bufsize - 1);
-                memory_pool<alloc_node> pool;
-                auto new_ptr = pool.chunk_allocate(new_capacity);
-                if (WJR_LIKELY(m_idx != 0)) {
-                    std::copy_n(m_ptr, m_idx, new_ptr);
-                    pool.chunk_deallocate(m_ptr, m_capacity);
-                }
-                m_ptr = new_ptr;
-                m_capacity = new_capacity;
-            }
+template <typename T, typename Tag = void>
+class safe_array {
+public:
+    using element_type = T;
+    using value_type = std::remove_cv_t<T>;
+    using pointer = T *;
+    using reference = T &;
+    using difference_type = ptrdiff_t;
+    using size_type = size_t;
 
-            ++m_size;
+    constexpr safe_array() noexcept = default;
+    constexpr safe_array(const safe_array &) noexcept = default;
+    constexpr safe_array(safe_array &&) noexcept = default;
+    constexpr safe_array &operator=(const safe_array &) noexcept = default;
+    constexpr safe_array &operator=(safe_array &&) noexcept = default;
+    ~safe_array() noexcept = default;
 
-            const size_t capacity = Cache << ((3 * m_idx + 2) / 5);
-            memory_pool<char> pool;
-            const auto buffer = pool.chunk_allocate(capacity);
-            alloc_node node = {buffer, buffer + capacity};
-            m_ptr[m_idx] = node;
+    constexpr safe_array &reset_range() noexcept { return *this; }
 
-            if (WJR_UNLIKELY(m_idx == 0)) {
-                top.ptr = node.ptr;
-                top.idx = 0;
-            }
+    constexpr pointer get() const noexcept { return m_ptr; }
+    constexpr pointer data() const noexcept { return m_ptr; }
+    constexpr reference operator[](size_type i) const noexcept { return m_ptr[i]; }
 
-            m_cache = node;
-        } else {
-            m_cache = m_ptr[m_idx];
-        }
+    constexpr safe_array(span<T> s) noexcept : m_ptr(s.data()) {}
 
-        WJR_ASSERT(top.ptr != nullptr);
+    constexpr safe_array first(WJR_MAYBE_UNUSED size_type count) const noexcept {
+        return safe_array{m_ptr};
     }
 
-    WJR_COLD WJR_CONSTEXPR20 void __small_redeallocate() noexcept {
-        const uint16_t new_size = m_idx + bufsize - 1;
-        memory_pool<char> pool;
-
-        for (uint16_t i = new_size; i < m_size; ++i) {
-            pool.chunk_deallocate(m_ptr[i].ptr, m_ptr[i].end - m_ptr[i].ptr);
-        }
-
-        m_size = new_size;
+    constexpr safe_array subspan(size_type offset,
+                                 WJR_MAYBE_UNUSED size_type count) const noexcept {
+        return safe_array{m_ptr + offset};
     }
 
-    WJR_CONSTEXPR20 void __small_deallocate(const stack_top &top) noexcept {
-        if (WJR_UNLIKELY(top.ptr == nullptr)) {
-            return;
-        }
-
-        m_cache.ptr = top.ptr;
-
-        if (WJR_UNLIKELY(top.idx != (uint16_t)in_place_max)) {
-            const uint16_t idx = top.idx;
-            m_cache.end = m_ptr[idx].end;
-            m_idx = idx;
-            if (WJR_UNLIKELY(m_size - idx >= bufsize)) {
-                __small_redeallocate();
-            }
-        }
+    constexpr safe_array &operator=(span<T> s) noexcept {
+        m_ptr = s.data();
+        return *this;
     }
 
-    WJR_MALLOC WJR_CONSTEXPR20 void *__small_allocate(size_t n, stack_top &top) noexcept {
-        auto ptr = m_cache.ptr;
-
-        if (WJR_UNLIKELY(static_cast<size_t>(m_cache.end - ptr) < n)) {
-            __small_reallocate(top);
-            ptr = m_cache.ptr;
-        }
-
-        WJR_ASSERT_ASSUME_L2(m_cache.ptr != nullptr);
-        WJR_ASSERT_ASSUME_L2(top.ptr != nullptr);
-
-        m_cache.ptr += n;
-        return ptr;
+    constexpr safe_array &operator=(std::nullptr_t) noexcept {
+        m_ptr = nullptr;
+        return *this;
     }
 
-public:
-    using value_type = void;
-    using size_type = size_t;
-    using difference_type = ptrdiff_t;
-    using propagate_on_container_move_assignment = std::true_type;
-
-    stack_allocator_object() noexcept = default;
-    stack_allocator_object(stack_allocator_object &) = delete;
-    stack_allocator_object(stack_allocator_object &&) = delete;
-    stack_allocator_object &operator=(stack_allocator_object &) = delete;
-    stack_allocator_object &operator=(stack_allocator_object &&) = delete;
-    ~stack_allocator_object() noexcept = default;
+    constexpr safe_array &operator+=(size_type n) noexcept {
+        m_ptr += n;
+        return *this;
+    }
 
-    WJR_NODISCARD WJR_MALLOC WJR_CONSTEXPR20 void *allocate(size_t n, stack_top &top,
-                                                            size_t threshold) noexcept {
-        if (WJR_UNLIKELY(n >= threshold)) {
-            return __large_allocate(n, top);
-        }
+    constexpr friend safe_array operator+(safe_array lhs, size_type rhs) noexcept {
+        return lhs += rhs;
+    }
 
-        return __small_allocate(n, top);
+    constexpr friend safe_array operator+(size_type lhs, safe_array rhs) noexcept {
+        return rhs += lhs;
     }
 
-    WJR_CONSTEXPR20 void deallocate(const stack_top &top) noexcept {
-        __small_deallocate(top);
+    constexpr safe_array &operator-=(size_type n) noexcept {
+        m_ptr -= n;
+        return *this;
+    }
 
-        auto buffer = top.large;
-        while (WJR_UNLIKELY(buffer != nullptr)) {
-            auto prev = buffer->prev;
-            free(buffer);
-            buffer = prev;
-        }
+    constexpr friend safe_array operator-(safe_array lhs, size_type rhs) noexcept {
+        return lhs -= rhs;
     }
 
-    WJR_CONSTEXPR20 void set(stack_top &top) const noexcept {
-        top.ptr = m_cache.ptr;
-        top.idx = in_place_max;
-        top.large = nullptr;
+    constexpr friend ptrdiff_t operator-(const safe_array &lhs,
+                                         const safe_array &rhs) noexcept {
+        return lhs.m_ptr - rhs.m_ptr;
     }
 
 private:
-    alloc_node m_cache = {nullptr, nullptr};
-    uint16_t m_idx = in_place_max;
-    alignas(32) uint16_t m_size = 0;
-    uint16_t m_capacity = 0;
-    alloc_node *m_ptr = nullptr;
+    T *m_ptr;
 };
 
-/**
- * @brief A stack allocator for fast simulation of stack memory on the heap, singleton
- * mode.
- *
- * @tparam Cache The size of the first heap memory allocation
- */
-template <size_t Cache, size_t DefaultThreshold>
-struct singleton_stack_allocator_object {
-    using Instance = stack_allocator_object<Cache>;
-    constexpr static size_t __default_threshold = DefaultThreshold;
+#endif
 
-    static_assert(DefaultThreshold < Cache, "DefaultThreshold must be less than Cache.");
+} // namespace wjr
 
-    static Instance &get_instance() noexcept {
-        static thread_local Instance instance;
-        return instance;
-    }
-};
+#endif // WJR_MEMORY_SAFE_POINTER_HPP__
+#ifndef WJR_TUPLE_HPP__
+#define WJR_TUPLE_HPP__
 
-/**
- * @details Used for container. This allocator won't deallocate memory allocated by
- * __small_allocate until container is destroyed.
- *
- */
-template <typename T, typename StackAllocator>
-class weak_stack_allocator;
+#include <tuple>
 
-/**
- * @brief A unique stack allocator for fast simulation of stack memory on the heap.
- *
- * @details When a unique_stack_allocator object is destroyed, all the memory it allocates
- * is released.\n And a new unique_stack_allocator constructed in the lifetime of a
- * unique_stack_allocator object must be destroyed in the current lifetime.
- *
- */
-template <typename StackAllocator>
-class unique_stack_allocator
-    : public nonsendable<unique_stack_allocator<StackAllocator>> {
-    using Mybase = nonsendable<unique_stack_allocator<StackAllocator>>;
-    using Instance = typename StackAllocator::Instance;
-    using stack_top = typename Instance::stack_top;
-
-    constexpr static size_t __default_threshold = StackAllocator::__default_threshold;
-
-    template <typename T, typename S>
-    friend class weak_stack_allocator;
-
-public:
-    unique_stack_allocator(const StackAllocator &al) noexcept
-        : m_instance(&(al.get_instance())) {
-        m_instance->set(m_top);
-    }
+// Already included
+// Already included
 
-    unique_stack_allocator(const unique_stack_allocator &) = delete;
-    unique_stack_allocator(unique_stack_allocator &&) = delete;
-    unique_stack_allocator &operator=(const unique_stack_allocator &) = delete;
-    unique_stack_allocator &operator=(unique_stack_allocator &&) = delete;
+namespace wjr {
 
-    ~unique_stack_allocator() noexcept { m_instance->deallocate(m_top); }
+template <typename... Args>
+class tuple;
 
-    WJR_NODISCARD WJR_MALLOC WJR_CONSTEXPR20 void *
-    allocate(size_t n, size_t threshold = __default_threshold) noexcept {
-        Mybase::check();
-        return m_instance->allocate(n, m_top, threshold);
-    }
+} // namespace wjr
 
-private:
-    WJR_NODISCARD WJR_MALLOC WJR_CONSTEXPR20 void *__small_allocate(size_t n) noexcept {
-        Mybase::check();
-        return m_instance->__small_allocate(n, m_top);
-    }
+namespace std {
 
-    Instance *m_instance;
-    stack_top m_top;
+template <typename... Args>
+struct tuple_size<wjr::tuple<Args...>> : std::integral_constant<size_t, sizeof...(Args)> {
 };
 
-template <typename StackAllocator>
-unique_stack_allocator(const StackAllocator &) -> unique_stack_allocator<StackAllocator>;
-
-/**
- * @brief Point to unique_stack_allocator.
- *
- * @details Use a pointer to unique_stack_allocator to allocate memory. This class must be
- * used carefully. If recursively using it as a reference and allocating memory,
- * unique_stack_allocator should be avoided from being reused in the current function.
- *
- */
-template <typename T, size_t Cache, size_t DefaultThreshold>
-class weak_stack_allocator<T, singleton_stack_allocator_object<Cache, DefaultThreshold>> {
-    using StackAllocator = singleton_stack_allocator_object<Cache, DefaultThreshold>;
-    using UniqueStackAllocator = unique_stack_allocator<StackAllocator>;
-
-    constexpr static size_t __default_threshold = StackAllocator::__default_threshold;
-
-    template <typename U, typename A>
-    friend class weak_stack_allocator;
-
-public:
-    using value_type = T;
-    using size_type = size_t;
-    using difference_type = ptrdiff_t;
-    using propagate_on_container_move_assignment = std::true_type;
-    using is_trivially_allocator = std::true_type;
-
-    template <typename Other>
-    struct rebind {
-        using other = weak_stack_allocator<Other, StackAllocator>;
-    };
+template <size_t I, typename... Args>
+struct tuple_element<I, wjr::tuple<Args...>> {
+    using type = wjr::tp_at_t<wjr::tuple<Args...>, I>;
+};
 
-    weak_stack_allocator() noexcept = default;
-    weak_stack_allocator(UniqueStackAllocator &alloc) noexcept : m_alloc(&alloc) {}
-    weak_stack_allocator(const weak_stack_allocator &) noexcept = default;
-    weak_stack_allocator &operator=(const weak_stack_allocator &) noexcept = default;
-    weak_stack_allocator(weak_stack_allocator &&) noexcept = default;
-    weak_stack_allocator &operator=(weak_stack_allocator &&) noexcept = default;
-    ~weak_stack_allocator() noexcept = default;
+template <typename... Args, WJR_REQUIRES(std::conjunction_v<wjr::is_swappable<Args>...>)>
+constexpr void swap(wjr::tuple<Args...> &lhs,
+                    wjr::tuple<Args...> &rhs) noexcept(noexcept(lhs.swap(rhs)));
 
-    template <typename U>
-    weak_stack_allocator(const weak_stack_allocator<U, StackAllocator> &other) noexcept
-        : m_alloc(other.m_alloc) {}
+template <size_t I, typename... Args>
+constexpr tuple_element_t<I, wjr::tuple<Args...>> &get(wjr::tuple<Args...> &t) noexcept;
 
-    WJR_NODISCARD WJR_MALLOC WJR_CONSTEXPR20 T *allocate(size_type n) noexcept {
-        const size_t size = n * sizeof(T);
-        if (WJR_UNLIKELY(size >= __default_threshold)) {
-            return static_cast<T *>(malloc(size));
-        }
+template <size_t I, typename... Args>
+constexpr tuple_element_t<I, wjr::tuple<Args...>> &
+get(const wjr::tuple<Args...> &t) noexcept;
 
-        return static_cast<T *>(m_alloc->__small_allocate(size));
-    }
+template <size_t I, typename... Args>
+constexpr tuple_element_t<I, wjr::tuple<Args...>> &&get(wjr::tuple<Args...> &&t) noexcept;
 
-    WJR_CONSTEXPR20 void deallocate(WJR_MAYBE_UNUSED T *ptr,
-                                    WJR_MAYBE_UNUSED size_type n) noexcept {
-        const size_t size = n * sizeof(T);
-        if (WJR_UNLIKELY(size >= __default_threshold)) {
-            free(ptr);
-        }
-    }
+template <size_t I, typename... Args>
+constexpr tuple_element_t<I, wjr::tuple<Args...>> &&
+get(const wjr::tuple<Args...> &&t) noexcept;
 
-private:
-    UniqueStackAllocator *m_alloc = nullptr;
-};
+template <typename T, typename... Args>
+constexpr T &get(wjr::tuple<Args...> &t) noexcept;
 
-} // namespace wjr
+template <typename T, typename... Args>
+constexpr T &get(const wjr::tuple<Args...> &t) noexcept;
 
-#endif // WJR_STACK_ALLOCATOR_HPP__
+template <typename T, typename... Args>
+constexpr T &&get(wjr::tuple<Args...> &&t) noexcept;
 
-namespace wjr::math_details {
+template <typename T, typename... Args>
+constexpr T &&get(const wjr::tuple<Args...> &&t) noexcept;
 
-using stack_alloc_object = singleton_stack_allocator_object<36 * 1024, 16 * 1024>;
-inline constexpr stack_alloc_object stack_alloc = {};
+} // namespace std
 
-using unique_stack_alloc = unique_stack_allocator<stack_alloc_object>;
+namespace wjr {
 
-template <typename T>
-using weak_stack_alloc = weak_stack_allocator<T, stack_alloc_object>;
+template <typename Indexs, typename... Args>
+class tuple_impl;
 
-} // namespace wjr::math_details
+template <size_t... Indexs, typename... Args>
+class WJR_EMPTY_BASES tuple_impl<std::index_sequence<Indexs...>, Args...>
+    : capture_leaf<Args,
+                   enable_base_identity_t<
+                       Indexs, tuple_impl<std::index_sequence<Indexs...>, Args...>>>...,
+      enable_special_members_of_args_base<
+          tuple_impl<std::index_sequence<Indexs...>, Args...>,
+          capture_leaf<Args, enable_base_identity_t<
+                                 Indexs, tuple_impl<std::index_sequence<Indexs...>,
+                                                    Args...>>>...> {
+    using Sequence = std::index_sequence<Indexs...>;
 
-#endif // WJR_MATH_STACK_ALLOCATOR_HPP__
-// Already included
-#ifndef WJR_MEMORY_SAFE_POINTER_HPP__
-#define WJR_MEMORY_SAFE_POINTER_HPP__
+    template <size_t Idx>
+    using Mybase = capture_leaf<std::tuple_element_t<Idx, tuple<Args...>>,
+                                enable_base_identity_t<Idx, tuple_impl>>;
 
-#ifndef WJR_SPAN_HPP__
-#define WJR_SPAN_HPP__
+    using Mybase2 = enable_special_members_of_args_base<
+        tuple_impl<Sequence, Args...>,
+        capture_leaf<Args, enable_base_identity_t<Indexs, tuple_impl>>...>;
 
-#include <stdexcept>
+    constexpr static size_t Size = sizeof...(Args);
 
-// Already included
-// Already included
+public:
+    template <typename S = Sequence,
+              WJR_REQUIRES(
+                  std::conjunction_v<std::is_same<S, Sequence>,
+                                     std::is_default_constructible<Mybase<Indexs>>...>)>
+    constexpr tuple_impl() noexcept(
+        std::conjunction_v<std::is_nothrow_constructible<Args>...>)
+        : Mybase2(enable_default_constructor) {}
 
-namespace wjr {
+    template <size_t... _Indexs, typename... _Args,
+              WJR_REQUIRES(
+                  std::conjunction_v<std::is_constructible<Mybase<_Indexs>, _Args>...>)>
+    constexpr tuple_impl(std::index_sequence<_Indexs...>, _Args &&...args) noexcept(
+        std::conjunction_v<std::is_nothrow_constructible<Args, _Args &&>...>)
+        : Mybase<_Indexs>(std::forward<_Args>(args))...,
+          Mybase2(enable_default_constructor) {}
 
-/**
- * @brief A type representing a static-sized span.
- *
- * @tparam Extent The number of elements in the span.
- */
-template <typename T, size_t Extent>
-struct __span_static_storage {
+    template <size_t I>
+    constexpr auto &get() & noexcept {
+        return Mybase<I>::get();
+    }
 
-    __span_static_storage() noexcept = default;
-    __span_static_storage(const __span_static_storage &) noexcept = default;
-    __span_static_storage &operator=(const __span_static_storage &) noexcept = default;
+    template <size_t I>
+    constexpr const auto &get() const & noexcept {
+        return Mybase<I>::get();
+    }
 
-    __span_static_storage(T *p, WJR_MAYBE_UNUSED size_t s) noexcept : ptr(p) {
-        WJR_ASSERT_L2(s == size);
+    template <size_t I>
+    constexpr auto &&get() && noexcept {
+        return std::move(Mybase<I>::get());
     }
 
-    T *ptr = nullptr;
-    static constexpr size_t size = Extent;
+    template <size_t I>
+    constexpr const auto &&get() const && noexcept {
+        return std::move(Mybase<I>::get());
+    }
 };
 
-/**
- * @brief A type representing a dynamic-sized span.
- */
-template <typename T>
-struct __span_dynamic_storage {
+template <typename Tuple>
+struct __tuple_like;
 
-    __span_dynamic_storage() noexcept = default;
-    __span_dynamic_storage(const __span_dynamic_storage &) noexcept = default;
-    __span_dynamic_storage &operator=(const __span_dynamic_storage &) noexcept = default;
+template <template <typename...> typename Tuple, typename... Args>
+struct __tuple_like<Tuple<Args...>>
+    : std::disjunction<std::is_same<Tuple<Args...>, std::tuple<Args...>>,
+                       std::is_same<Tuple<Args...>, std::pair<Args...>>> {};
 
-    __span_dynamic_storage(T *p, size_t s) noexcept : ptr(p), size(s) {}
+template <>
+class tuple<> {
+public:
+    constexpr tuple() noexcept = default;
+    constexpr tuple(const tuple &) noexcept = default;
+    constexpr tuple(tuple &&) noexcept = default;
+    constexpr tuple &operator=(const tuple &) noexcept = default;
+    constexpr tuple &operator=(tuple &&) noexcept = default;
+    ~tuple() noexcept = default;
 
-    T *ptr = nullptr;
-    size_t size = 0;
+    constexpr void swap(tuple &) noexcept {}
 };
 
-template <typename Iter, typename Elem>
-struct __is_span_iterator
-    : std::conjunction<is_contiguous_iterator<Iter>,
-                       std::is_convertible<iterator_contiguous_pointer_t<Iter>, Elem *>> {
-};
+template <typename This, typename... Args>
+class tuple<This, Args...>
+    : enable_special_members_of_args_base<
+          tuple<This, Args...>,
+          tuple_impl<std::index_sequence_for<This, Args...>, This, Args...>> {
+    using Sequence = std::index_sequence_for<This, Args...>;
+    using Impl = tuple_impl<Sequence, This, Args...>;
+    using Mybase = enable_special_members_of_args_base<tuple<This, Args...>, Impl>;
 
-template <typename T, size_t Extent = dynamic_extent>
-class span;
+    constexpr static size_t Size = sizeof...(Args) + 1;
 
-namespace span_details {
+public:
+#if defined(__cpp_conditional_explicit)
+    template <typename T = This,
+              WJR_REQUIRES(std::conjunction_v<std::is_default_constructible<T>,
+                                              std::is_default_constructible<Args>...>)>
+    constexpr explicit(
+        !std::conjunction_v<is_default_convertible<T>, is_default_convertible<Args>...>)
+        tuple() noexcept(std::is_nothrow_constructible_v<Impl>)
+        : Mybase(enable_default_constructor), m_impl() {}
+#else
+    template <typename T = This,
+              WJR_REQUIRES(std::conjunction_v<std::is_default_constructible<T>,
+                                              std::is_default_constructible<Args>...>
+                               &&std::conjunction_v<is_default_convertible<T>,
+                                                    is_default_convertible<Args>...>)>
+    constexpr tuple() noexcept(std::is_nothrow_constructible_v<Impl>)
+        : Mybase(enable_default_constructor), m_impl() {}
 
-WJR_REGISTER_HAS_TYPE(data, std::data(std::declval<Container &>()), Container);
-WJR_REGISTER_HAS_TYPE(size, std::size(std::declval<Container &>()), Container);
+    template <typename T = This,
+              WJR_REQUIRES(std::conjunction_v<std::is_default_constructible<T>,
+                                              std::is_default_constructible<Args>...> &&
+                           !std::conjunction_v<is_default_convertible<T>,
+                                               is_default_convertible<Args>...>)>
+    constexpr explicit tuple() noexcept(std::is_nothrow_constructible_v<Impl>)
+        : Mybase(enable_default_constructor), m_impl() {}
+#endif
 
-/// @private
-template <typename T>
-struct __is_std_array : std::false_type {};
+    template <typename Other = This,
+              WJR_REQUIRES(std::is_constructible_v<Impl, Sequence, const Other &,
+                                                   const Args &...>)>
+    constexpr tuple(const Other &first, const Args &...rest) noexcept(
+        std::is_nothrow_constructible_v<Impl, Sequence, const Other &, const Args &...>)
+        : Mybase(enable_default_constructor), m_impl(Sequence(), first, rest...) {}
 
-/// @private
-template <typename T, size_t N>
-struct __is_std_array<std::array<T, N>> : std::true_type {};
+    template <
+        typename Other, typename... _Args,
+        WJR_REQUIRES(sizeof...(_Args) + 1 == Size &&
+                     std::conjunction_v<
+                         std::negation<std::conjunction<
+                             std::is_same<This, std::remove_reference_t<Other>>,
+                             std::is_same<Args, std::remove_reference_t<_Args>>...>>,
+                         std::is_constructible<Impl, Sequence, Other &&, _Args &&...>>)>
+    constexpr tuple(Other &&other, _Args &&...args) noexcept(
+        std::is_nothrow_constructible_v<Impl, Sequence, Other &&, _Args &&...>)
+        : Mybase(enable_default_constructor),
+          m_impl(Sequence(), std::forward<Other>(other), std::forward<_Args>(args)...) {}
 
-/// @private
-template <typename T>
-inline constexpr bool __is_std_array_v = __is_std_array<T>::value;
+private:
+    template <size_t... _Indexs, typename TupleLike>
+    constexpr tuple(
+        std::index_sequence<_Indexs...>, TupleLike &&other,
+        in_place_empty_t) noexcept(std::
+                                       is_nothrow_constructible_v<
+                                           Impl, Sequence,
+                                           decltype(std::get<_Indexs>(
+                                               std::forward<TupleLike>(other)))...>)
+        : Mybase(enable_default_constructor),
+          m_impl(Sequence(), std::get<_Indexs>(std::forward<TupleLike>(other))...) {}
 
-template <typename T>
-struct __is_span : std::false_type {};
+public:
+    template <typename TupleLike,
+              WJR_REQUIRES(__is_tuple_test_v<std::is_constructible, tuple, TupleLike &&>)>
+    constexpr tuple(TupleLike &&other) noexcept(
+        noexcept(tuple(Sequence(), std::forward<TupleLike>(other), in_place_empty)))
+        : tuple(Sequence(), std::forward<TupleLike>(other), in_place_empty) {}
 
-template <typename T, size_t Extent>
-struct __is_span<span<T, Extent>> : std::true_type {};
+private:
+    template <size_t... _Indexs, typename Container>
+    constexpr void __assign(std::index_sequence<_Indexs...>, Container &&other) noexcept(
+        noexcept(((this->template get<_Indexs>() =
+                       std::get<_Indexs>(std::forward<Container>(other))),
+                  ...))) {
+        ((this->template get<_Indexs>() =
+              std::get<_Indexs>(std::forward<Container>(other))),
+         ...);
+    }
 
-template <typename T>
-inline constexpr bool __is_span_v = __is_span<T>::value;
+public:
+    template <typename TupleLike,
+              WJR_REQUIRES(__is_tuple_test_v<__is_tuple_assignable, tuple, TupleLike &&>)>
+    constexpr tuple &operator=(TupleLike &&other) noexcept(
+        noexcept(__assign(Sequence(), std::forward<TupleLike>(other)))) {
+        __assign(Sequence(), std::forward<TupleLike>(other));
+        return *this;
+    }
 
-/// @private
-template <typename Container, typename = void>
-struct __is_container_like : std::false_type {};
+private:
+    template <size_t... _Indexs>
+    constexpr void
+    __swap(std::index_sequence<_Indexs...>, tuple &other) noexcept(noexcept(((
+        std::swap(this->template get<_Indexs>(), other.template get<_Indexs>()), ...)))) {
+        ((std::swap(this->template get<_Indexs>(), other.template get<_Indexs>()), ...));
+    }
 
-/// @private
-template <typename Container>
-struct __is_container_like<
-    Container, std::enable_if_t<has_data_v<Container &> && has_size_v<Container &>>>
-    : std::conjunction<
-          std::negation<std::is_array<remove_cvref_t<Container>>>,
-          std::negation<__is_std_array<remove_cvref_t<Container>>>,
-          std::negation<__is_span<remove_cvref_t<Container>>>,
-          std::is_pointer<decltype(std::data(std::declval<Container &>()))>> {};
+public:
+    constexpr void swap(tuple &other) noexcept(noexcept(__swap(Sequence(), other))) {
+        __swap(Sequence(), other);
+    }
 
-/// @private
-template <typename Container>
-inline constexpr bool __is_container_like_v = __is_container_like<Container>::value;
+    template <size_t I, WJR_REQUIRES(I < Size)>
+    constexpr std::tuple_element_t<I, tuple> &get() & noexcept {
+        return m_impl.template get<I>();
+    }
 
-template <typename Container, typename Elem, typename = void>
-struct __is_span_like : std::false_type {};
+    template <size_t I, WJR_REQUIRES(I < Size)>
+    constexpr const std::tuple_element_t<I, tuple> &get() const & noexcept {
+        return m_impl.template get<I>();
+    }
 
-template <typename Container, typename Elem>
-struct __is_span_like<
-    Container, Elem, std::enable_if_t<has_data_v<Container &> && has_size_v<Container &>>>
-    : std::conjunction<
-          __is_container_like<Container>,
-          std::is_convertible<decltype(std::data(std::declval<Container &>())), Elem *>> {
-};
+    template <size_t I, WJR_REQUIRES(I < Size)>
+    constexpr std::tuple_element_t<I, tuple> &&get() && noexcept {
+        return std::move(m_impl.template get<I>());
+    }
 
-template <typename Container, typename Elem>
-inline constexpr bool __is_span_like_v = __is_span_like<Container, Elem>::value;
+    template <size_t I, WJR_REQUIRES(I < Size)>
+    constexpr const std::tuple_element_t<I, tuple> &&get() const && noexcept {
+        return std::move(m_impl.template get<I>());
+    }
 
-/// @private
-template <typename T>
-struct basic_span_traits {
-    using value_type = std::remove_cv_t<T>;
-    using difference_type = ptrdiff_t;
-    using pointer = T *;
-    using const_pointer = const T *;
-    using reference = T &;
-    using const_reference = const T &;
-};
+    template <size_t I, WJR_REQUIRES(I >= 0 && I < Size)>
+    constexpr std::tuple_element_t<I, tuple> &
+    operator[](integral_constant<size_t, I>) & noexcept {
+        return get<I>();
+    }
 
-} // namespace span_details
+    template <size_t I, WJR_REQUIRES(I >= 0 && I < Size)>
+    constexpr const std::tuple_element_t<I, tuple> &
+    operator[](integral_constant<size_t, I>) const & noexcept {
+        return get<I>();
+    }
 
-/**
- * @class span
- *
- * @brief A view over a contiguous sequence of objectsd.
- *
- * @tparam Extent if Extent is `dynamic_extent`, the span is a runtime-sized view.
- * Otherwise, the span is a compile-time-sized view.
- */
-template <typename T, size_t Extent>
-class span {
-    static constexpr bool __is_dynamic = Extent == dynamic_extent;
-    using __storage = std::conditional_t<__is_dynamic, __span_dynamic_storage<T>,
-                                         __span_static_storage<T, Extent>>;
+    template <size_t I, WJR_REQUIRES(I >= 0 && I < Size)>
+    constexpr std::tuple_element_t<I, tuple> &&
+    operator[](integral_constant<size_t, I>) && noexcept {
+        return std::move(get<I>());
+    }
 
-    using IteratorTraits = span_details::basic_span_traits<T>;
+    template <size_t I, WJR_REQUIRES(I >= 0 && I < Size)>
+    constexpr const std::tuple_element_t<I, tuple> &&
+    operator[](integral_constant<size_t, I>) const && noexcept {
+        return std::move(get<I>());
+    }
 
-public:
-    using element_type = T;
-    using value_type = std::remove_cv_t<T>;
-    using size_type = size_t;
-    using difference_type = ptrdiff_t;
-    using pointer = T *;
-    using const_pointer = const T *;
-    using reference = T &;
-    using const_reference = const T &;
-    using iterator = contiguous_iterator_adapter<span, IteratorTraits>;
-    using const_iterator = contiguous_const_iterator_adapter<span, IteratorTraits>;
-    using reverse_iterator = std::reverse_iterator<iterator>;
-    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+private:
+    Impl m_impl;
+};
 
-    template <size_t Ex = Extent, WJR_REQUIRES(Ex == dynamic_extent || Ex == 0)>
-    constexpr span() noexcept : storage() {}
+template <typename... Args>
+tuple(Args...) -> tuple<Args...>;
 
-#if defined(__cpp_conditional_explicit)
-    template <typename It, WJR_REQUIRES(__is_span_iterator<It, element_type>::value)>
-    constexpr explicit(!__is_dynamic) span(It first, size_type count) noexcept
-        : storage((to_address)(first), count) {}
-#else
-    template <typename It,
-              WJR_REQUIRES(__is_span_iterator<It, element_type>::value &&__is_dynamic)>
-    constexpr span(It first, size_type count) noexcept
-        : storage((to_address)(first), count) {}
+template <typename T1, typename T2>
+tuple(std::pair<T1, T2>) -> tuple<T1, T2>;
 
-    template <typename It,
-              WJR_REQUIRES(__is_span_iterator<It, element_type>::value && !__is_dynamic)>
-    constexpr explicit span(It first, size_type count) noexcept
-        : storage((to_address)(first), count) {}
-#endif
+template <typename... Args>
+tuple(std::tuple<Args...>) -> tuple<Args...>;
 
-#if defined(__cpp_conditional_explicit)
-    template <typename It, WJR_REQUIRES(__is_span_iterator<It, element_type>::value)>
-    constexpr explicit(!__is_dynamic) span(It first, It last) noexcept
-        : storage((to_address)(first), static_cast<size_type>(last - first)) {}
-#else
-    template <typename It,
-              WJR_REQUIRES(__is_span_iterator<It, element_type>::value &&__is_dynamic)>
-    constexpr span(It first, It last) noexcept
-        : storage((to_address)(first), static_cast<size_type>(last - first)) {}
+template <typename... Args>
+constexpr tuple<unref_wrapper_t<Args>...> make_tuple(Args &&...args) noexcept(
+    std::conjunction_v<
+        std::is_nothrow_constructible<unref_wrapper_t<Args>, Args &&>...>) {
+    return tuple<unref_wrapper_t<Args>...>(std::forward<Args>(args)...);
+}
 
-    template <typename It,
-              WJR_REQUIRES(__is_span_iterator<It, element_type>::value && !__is_dynamic)>
-    constexpr explicit span(It first, It last) noexcept
-        : storage((to_address)(first), static_cast<size_type>(last - first)) {}
-#endif
+template <typename... Args>
+constexpr tuple<Args &...> tie(Args &...args) noexcept {
+    return tuple<Args &...>(args...);
+}
 
-    template <size_t N, WJR_REQUIRES((__is_dynamic || N == Extent))>
-    constexpr span(type_identity_t<element_type> (&arr)[N]) noexcept
-        : storage(std::data(arr), N) {}
-
-    template <typename U, size_t N,
-              WJR_REQUIRES((__is_dynamic || N == Extent) &&
-                           std::is_convertible_v<U *, T *>)>
-    constexpr span(std::array<U, N> &arr) noexcept
-        : storage(std::data(arr), std::size(arr)) {}
-
-    template <typename U, size_t N,
-              WJR_REQUIRES((__is_dynamic || N == Extent) &&
-                           std::is_convertible_v<const U *, T *>)>
-    constexpr span(const std::array<U, N> &arr) noexcept
-        : storage(std::data(arr), std::size(arr)) {}
+template <typename... Args>
+constexpr tuple<Args &&...> forward_as_tuple(Args &&...args) noexcept(
+    std::conjunction_v<std::is_nothrow_constructible<Args &&, Args &&>...>) {
+    return tuple<Args &&...>(std::forward<Args>(args)...);
+}
 
-#if defined(__cpp_conditional_explicit)
-    template <typename U, size_t N,
-              WJR_REQUIRES((__is_dynamic || N == dynamic_extent || N == Extent) &&
-                           std::is_convertible_v<U *, T *>)>
-    constexpr explicit(!__is_dynamic) span(const span<U, N> &source) noexcept
-        : storage(source.data(), source.size()) {}
-#else
-    template <typename U, size_t N,
-              WJR_REQUIRES((__is_dynamic || N == dynamic_extent || N == Extent) &&
-                           std::is_convertible_v<U *, T *> && __is_dynamic)>
-    constexpr span(const span<U, N> &source) noexcept
-        : storage(source.data(), source.size()) {}
+/// @private
+template <typename Func, typename Tuple, size_t... Indexs>
+constexpr decltype(auto)
+apply_impl(Func &&fn, Tuple &&tp, std::index_sequence<Indexs...>) noexcept(noexcept(
+    std::invoke(std::forward<Func>(fn), std::get<Indexs>(std::forward<Tuple>(tp))...))) {
+    return std::invoke(std::forward<Func>(fn),
+                       std::get<Indexs>(std::forward<Tuple>(tp))...);
+}
 
-    template <typename U, size_t N,
-              WJR_REQUIRES((__is_dynamic || N == dynamic_extent || N == Extent) &&
-                           std::is_convertible_v<U *, T *> && !__is_dynamic)>
-    constexpr explicit span(const span<U, N> &source) noexcept
-        : storage(source.data(), source.size()) {}
-#endif
+template <typename Func, typename Tuple>
+constexpr decltype(auto) apply(Func &&fn, Tuple &&tp) noexcept(noexcept(
+    apply_impl(std::forward<Func>(fn), std::forward<Tuple>(tp),
+               std::make_index_sequence<std::tuple_size_v<remove_cvref_t<Tuple>>>{}))) {
+    return apply_impl(
+        std::forward<Func>(fn), std::forward<Tuple>(tp),
+        std::make_index_sequence<std::tuple_size_v<remove_cvref_t<Tuple>>>{});
+}
 
-    constexpr span(const span &other) noexcept = default;
-    constexpr span &operator=(const span &other) noexcept = default;
+/// @private
+template <size_t I, typename Tuple>
+struct __tuple_cat_single_helper {
+    static constexpr size_t Size = std::tuple_size_v<Tuple>;
+    using type0 = tp_repeat_t<tp_list<std::integral_constant<size_t, I>>, Size>;
+    using type1 = tp_make_index_sequence<Size>;
+};
 
-    ~span() = default;
+/// @private
+template <typename S, typename... Tuples>
+struct __tuple_cat_helper_impl;
 
-    WJR_PURE WJR_CONSTEXPR20 pointer begin_unsafe() noexcept { return data(); }
-    WJR_PURE WJR_CONSTEXPR20 const_pointer begin_unsafe() const noexcept {
-        return data();
-    }
-    WJR_PURE WJR_CONSTEXPR20 const_pointer cbegin_unsafe() const noexcept {
-        return data();
-    }
+/// @private
+template <size_t... Indexs, typename... Tuples>
+struct __tuple_cat_helper_impl<std::index_sequence<Indexs...>, Tuples...> {
+    using type0 =
+        tp_concat_t<typename __tuple_cat_single_helper<Indexs, Tuples>::type0...>;
+    using type1 =
+        tp_concat_t<typename __tuple_cat_single_helper<Indexs, Tuples>::type1...>;
+};
 
-    WJR_PURE WJR_CONSTEXPR20 pointer end_unsafe() noexcept { return data() + size(); }
-    WJR_PURE WJR_CONSTEXPR20 const_pointer end_unsafe() const noexcept {
-        return data() + size();
-    }
-    WJR_PURE WJR_CONSTEXPR20 const_pointer cend_unsafe() const noexcept {
-        return end_unsafe();
-    }
+/// @private
+template <typename... Tuples>
+struct __tuple_cat_helper {
+    using Sequence = std::index_sequence_for<Tuples...>;
+    using Impl = __tuple_cat_helper_impl<Sequence, Tuples...>;
+    using type0 = tp_make_std_index_sequence<typename Impl::type0>;
+    using type1 = tp_make_std_index_sequence<typename Impl::type1>;
+};
 
-private:
-    WJR_PURE WJR_CONSTEXPR20 iterator __make_iterator(const_pointer ptr) const noexcept {
-        return iterator(const_cast<pointer>(ptr), this);
-    }
+/// @private
+template <size_t... I0, size_t... I1, typename... Tuples>
+constexpr decltype(auto) __tuple_cat_impl(std::index_sequence<I0...>,
+                                          std::index_sequence<I1...>,
+                                          tuple<Tuples...> &&tuples) {
+    return tuple(std::get<I1>(std::get<I0>(std::move(tuples)))...);
+}
 
-    WJR_PURE WJR_CONSTEXPR20 pointer __get_pointer(iterator ptr) const noexcept {
-        ptr.check_same_container(this);
-        return (to_address)(ptr);
-    }
+template <typename... Tuples>
+constexpr decltype(auto) tuple_cat(Tuples &&...tuples) {
+    using Helper = __tuple_cat_helper<remove_cvref_t<Tuples>...>;
+    return __tuple_cat_impl(typename Helper::type0{}, typename Helper::type1{},
+                            forward_as_tuple(std::forward<Tuples>(tuples)...));
+}
 
-    WJR_PURE WJR_CONSTEXPR20 pointer __get_pointer(const_iterator ptr) const noexcept {
-        ptr.check_same_container(this);
-        return const_cast<pointer>((to_address)(ptr));
-    }
+template <typename... TArgs, typename... UArgs>
+constexpr bool
+operator==(const tuple<TArgs...> &lhs, const tuple<UArgs...> &rhs) noexcept(
+    std::conjunction_v<has_noexcept_equal_to<const TArgs &, const UArgs &>...>) {
+    return apply(
+        [&rhs](const auto &...lhs_args) {
+            return apply(
+                [&lhs_args...](const auto &...rhs_args) {
+                    return ((lhs_args == rhs_args) && ...);
+                },
+                rhs);
+        },
+        lhs);
+}
 
-public:
-    constexpr iterator begin() noexcept { return __make_iterator(begin_unsafe()); }
-    constexpr const_iterator begin() const noexcept {
-        return __make_iterator(begin_unsafe());
-    }
-    constexpr const_iterator cbegin() const noexcept {
-        return __make_iterator(begin_unsafe());
-    }
+template <typename... TArgs, typename... UArgs>
+constexpr bool operator!=(const tuple<TArgs...> &lhs,
+                          const tuple<UArgs...> &rhs) noexcept(noexcept(lhs == rhs)) {
+    return !(lhs == rhs);
+}
 
-    constexpr iterator end() noexcept { return __make_iterator(end_unsafe()); }
-    constexpr const_iterator end() const noexcept {
-        return __make_iterator(end_unsafe());
-    }
-    constexpr const_iterator cend() const noexcept {
-        return __make_iterator(end_unsafe());
-    }
+template <typename... TArgs, typename... UArgs>
+constexpr bool operator<(const tuple<TArgs...> &lhs, const tuple<UArgs...> &rhs) noexcept(
+    std::conjunction_v<
+        std::conjunction<has_noexcept_less<const TArgs &, const UArgs &>,
+                         has_noexcept_less<const UArgs &, const TArgs &>>...>) {
+    bool ret = false;
+    apply(
+        [&rhs, &ret](const auto &...lhs_args) {
+            return apply(
+                [&lhs_args..., &ret](const auto &...rhs_args) {
+                    (void)((lhs_args < rhs_args ? (ret = true, false)
+                                                : (rhs_args < lhs_args ? false : true)) &&
+                           ...);
+                },
+                rhs);
+        },
+        lhs);
+    return ret;
+}
 
-    constexpr reverse_iterator rbegin() noexcept {
-        return std::make_reverse_iterator(end());
-    }
-    constexpr reverse_iterator rbegin() const noexcept {
-        return std::make_reverse_iterator(end());
-    }
-    constexpr const_reverse_iterator crbegin() const noexcept {
-        return std::make_reverse_iterator(cend());
-    }
+template <typename... TArgs, typename... UArgs>
+constexpr bool operator<=(const tuple<TArgs...> &lhs,
+                          const tuple<UArgs...> &rhs) noexcept(noexcept(rhs < lhs)) {
+    return !(rhs < lhs);
+}
 
-    constexpr reverse_iterator rend() noexcept {
-        return std::make_reverse_iterator(begin());
-    }
-    constexpr reverse_iterator rend() const noexcept {
-        return std::make_reverse_iterator(begin());
-    }
-    constexpr const_reverse_iterator crend() const noexcept {
-        return std::make_reverse_iterator(cbegin());
-    }
+template <typename... TArgs, typename... UArgs>
+constexpr bool operator>(const tuple<TArgs...> &lhs,
+                         const tuple<UArgs...> &rhs) noexcept(noexcept(rhs < lhs)) {
+    return rhs < lhs;
+}
 
-    constexpr reference front() const noexcept {
-#if WJR_HAS_DEBUG(CONTIGUOUS_ITERATOR_CHECKER)
-        WJR_ASSERT_L0(size() > 0, "basic_vector::front: empty");
-#endif
-        return *data();
-    }
-    constexpr reference back() const noexcept {
-#if WJR_HAS_DEBUG(CONTIGUOUS_ITERATOR_CHECKER)
-        WJR_ASSERT_L0(size() > 0, "basic_vector::front: empty");
-#endif
-        return *(end_unsafe() - 1);
-    }
+template <typename... TArgs, typename... UArgs>
+constexpr bool operator>=(const tuple<TArgs...> &lhs,
+                          const tuple<UArgs...> &rhs) noexcept(noexcept(lhs < rhs)) {
+    return !(lhs < rhs);
+}
 
-    constexpr reference at(size_type pos) const noexcept {
-        if (WJR_UNLIKELY(pos >= size())) {
-            WJR_THROW(std::out_of_range("span at out of range"));
-        }
+template <size_t I, typename... Args>
+struct __in_place_index_tuple_t_tag {};
 
-        return data()[pos];
-    }
+template <size_t I, typename... Args>
+using in_place_index_tuple_t =
+    capture_leaf<tuple<Args...>, __in_place_index_tuple_t_tag<I, Args...>>;
 
-    constexpr reference operator[](size_type pos) const noexcept {
-#if WJR_HAS_DEBUG(CONTIGUOUS_ITERATOR_CHECKER)
-        WJR_ASSERT_L0(pos < size(), "basic_vector::operator[]: out of range");
-#endif
-        return data()[pos];
-    }
+template <size_t I, typename... Args>
+constexpr in_place_index_tuple_t<I, Args &&...>
+in_place_index_tuple(Args &&...args) noexcept(
+    std::conjunction_v<std::is_nothrow_constructible<Args &&, Args &&>...>) {
+    return in_place_index_tuple_t<I, Args &&...>(std::forward<Args>(args)...);
+}
 
-    constexpr pointer data() const noexcept { return storage.ptr; }
-    constexpr size_type size() const noexcept { return storage.size; }
-    constexpr size_type size_bytes() const noexcept {
-        return size() * sizeof(element_type);
-    }
-    constexpr bool empty() const noexcept { return size() == 0; }
+template <typename T, typename... Args>
+struct __in_place_type_tuple_t_tag {};
 
-    template <size_t Count>
-    constexpr span<element_type, Count> first() const noexcept {
-        static_assert(Count <= Extent, "");
+template <typename T, typename... Args>
+using in_place_type_tuple_t =
+    capture_leaf<tuple<Args...>, __in_place_type_tuple_t_tag<T, Args...>>;
 
-        return {begin(), Count};
-    }
+template <typename T, typename... Args>
+constexpr in_place_type_tuple_t<T, Args &&...>
+in_place_type_tuple(Args &&...args) noexcept(
+    std::conjunction_v<std::is_nothrow_constructible<Args &&, Args &&>...>) {
+    return in_place_type_tuple_t<T, Args &&...>(std::forward<Args>(args)...);
+}
 
-    constexpr span<element_type, dynamic_extent> first(size_type Count) const noexcept {
-        WJR_ASSERT_L2(Count <= size());
+} // namespace wjr
 
-        return {begin(), Count};
-    }
+namespace std {
 
-    template <size_t Count>
-    constexpr span<element_type, Count> last() const noexcept {
-        static_assert(Count <= Extent, "");
+template <typename... Args,
+          WJR_REQUIRES_I(std::conjunction_v<wjr::is_swappable<Args>...>)>
+constexpr void swap(wjr::tuple<Args...> &lhs,
+                    wjr::tuple<Args...> &rhs) noexcept(noexcept(lhs.swap(rhs))) {
+    lhs.swap(rhs);
+}
 
-        return {end() - Count, Count};
-    }
+template <size_t I, typename... Args>
+constexpr tuple_element_t<I, wjr::tuple<Args...>> &get(wjr::tuple<Args...> &t) noexcept {
+    return t.template get<I>();
+}
 
-    constexpr span<element_type, dynamic_extent> last(size_type Count) const noexcept {
-        WJR_ASSERT_L2(Count <= size());
+template <size_t I, typename... Args>
+constexpr tuple_element_t<I, wjr::tuple<Args...>> &
+get(const wjr::tuple<Args...> &t) noexcept {
+    return t.template get<I>();
+}
 
-        return {data() - Count, Count};
-    }
+template <size_t I, typename... Args>
+constexpr tuple_element_t<I, wjr::tuple<Args...>> &&
+get(wjr::tuple<Args...> &&t) noexcept {
+    return std::move(t).template get<I>();
+}
 
-    template <size_t Offset, size_t Count = dynamic_extent>
-    constexpr span<element_type, Count != dynamic_extent    ? Count
-                                 : Extent != dynamic_extent ? Extent - Offset
-                                                            : dynamic_extent>
-    subspan() const noexcept {
-        if constexpr (Extent != dynamic_extent) {
-            static_assert(Offset <= Extent, "");
-            static_assert(Count == dynamic_extent || Count <= Extent - Offset, "");
-        } else {
-            WJR_ASSERT_L2(Offset <= size());
-            if constexpr (Count != dynamic_extent) {
-                WJR_ASSERT_L2(Count <= size() - Offset);
-            }
-        }
-        return {begin() + Offset, Count == dynamic_extent ? size() - Offset : Count};
-    }
+template <size_t I, typename... Args>
+constexpr tuple_element_t<I, wjr::tuple<Args...>> &&
+get(const wjr::tuple<Args...> &&t) noexcept {
+    return std::move(t).template get<I>();
+}
 
-    constexpr span<element_type, dynamic_extent>
-    subspan(size_type Offset, size_type Count = dynamic_extent) const noexcept {
-        WJR_ASSERT_L2(Offset <= size());
+template <typename T, typename... Args>
+constexpr T &get(wjr::tuple<Args...> &t) noexcept {
+    return get<wjr::tp_find_v<wjr::tuple<Args...>, T>>(t);
+}
 
-        return {begin() + Offset, Count == dynamic_extent ? size() - Offset : Count};
-    }
+template <typename T, typename... Args>
+constexpr T &get(const wjr::tuple<Args...> &t) noexcept {
+    return get<wjr::tp_find_v<wjr::tuple<Args...>, T>>(t);
+}
 
-    // extension :
+template <typename T, typename... Args>
+constexpr T &&get(wjr::tuple<Args...> &&t) noexcept {
+    return get<wjr::tp_find_v<wjr::tuple<Args...>, T>>(std::move(t));
+}
 
-    /**
-     * @brief Construct a span from a container.
-     *
-     * @details The container must have a `data()` member function that returns a @ref
-     * __is_span_iterator. The container must also have a `size()` member function that
-     * can be converted to `size_type`.
-     *
-     */
-    template <typename Container, WJR_REQUIRES(span_details::__is_span_like_v<
-                                               Container, element_type> &&__is_dynamic)>
-    constexpr span(Container &&c) noexcept : storage(std::data(c), std::size(c)) {}
+template <typename T, typename... Args>
+constexpr T &&get(const wjr::tuple<Args...> &&t) noexcept {
+    return get<wjr::tp_find_v<wjr::tuple<Args...>, T>>(std::move(t));
+}
 
-    /**
-     * @brief Construct a span from a container.
-     *
-     * @details Like @ref span(Container &&), but the span is not dynamic-sized, so the
-     * construct must be explicit.
-     *
-     */
-    template <typename Container,
-              WJR_REQUIRES(span_details::__is_span_like_v<Container, element_type> &&
-                           !__is_dynamic)>
-    constexpr explicit span(Container &&c) noexcept
-        : storage(std::data(c), std::size(c)) {}
+} // namespace std
 
-private:
-    __storage storage;
-};
+#endif // WJR_TUPLE_HPP__
 
-template <typename T, size_t Extent>
-span(T (&)[Extent]) -> span<T, Extent>;
+#if defined(WJR_X86)
+#ifndef WJR_X86_MATH_MUL_HPP__
+#define WJR_X86_MATH_MUL_HPP__
 
-template <typename T, size_t Size>
-span(std::array<T, Size> &) -> span<T, Size>;
+// Already included
+#ifndef WJR_X86_MATH_MUL_IMPL_HPP__
+#define WJR_X86_MATH_MUL_IMPL_HPP__
 
-template <typename T, size_t Size>
-span(const std::array<T, Size> &) -> span<const T, Size>;
+// Already included
 
-template <typename It, typename End, WJR_REQUIRES(is_contiguous_iterator_v<It>)>
-span(It, End) -> span<iterator_contiguous_value_t<It>>;
+#ifndef WJR_X86
+#error "x86 required"
+#endif
 
-template <typename Container,
-          WJR_REQUIRES(span_details::__is_container_like_v<Container>)>
-span(Container &&) -> span<
-    iterator_contiguous_value_t<decltype(std::data(std::declval<Container &>()))>>;
+namespace wjr {
 
-} // namespace wjr
+#define WJR_HAS_BUILTIN_MUL64 WJR_HAS_DEF
 
-#endif // WJR_SPAN_HPP__
+#if WJR_HAS_FEATURE(INT128)
+#define WJR_HAS_BUILTIN_INT128_MUL64 WJR_HAS_DEF
+#elif WJR_HAS_FEATURE(GCC_STYLE_INLINE_ASM)
+#define WJR_HAS_BUILTIN_ASM_MUL64 WJR_HAS_DEF
+#else
+#undef WJR_HAS_BUILTIN_MUL64
+#endif
 
-namespace wjr {
+#if defined(__BMI2__)
+#define WJR_HAS_BUILTIN_MULX_U64 WJR_HAS_DEF
+#endif
 
-#if WJR_DEBUG_LEVEL > 2
-#define WJR_HAS_DEBUG_SAFE_POINTER WJR_HAS_DEF
+#if WJR_HAS_BUILTIN(MULX_U64) && WJR_HAS_FEATURE(GCC_STYLE_INLINE_ASM)
+#define WJR_HAS_BUILTIN_ASM_MUL_1 WJR_HAS_DEF
 #endif
 
-#if WJR_HAS_DEBUG(SAFE_POINTER)
+#if WJR_HAS_BUILTIN(ASM_MUL_1) && defined(__ADX__)
+#define WJR_HAS_BUILTIN_ASM_ADDMUL_1 WJR_HAS_DEF
+#endif
 
-template <typename T, typename Tag = void>
-class safe_array {
-public:
-    using element_type = T;
-    using value_type = std::remove_cv_t<T>;
-    using pointer = T *;
-    using reference = T &;
-    using difference_type = ptrdiff_t;
-    using size_type = size_t;
+#if WJR_HAS_BUILTIN(ASM_MUL_1) && WJR_HAS_BUILTIN(ASM_ADDMUL_1)
+#define WJR_HAS_BUILTIN_ASM_BASECASE_MUL_S WJR_HAS_DEF
+#define WJR_HAS_BUILTIN_ASM_BASECASE_SQR WJR_HAS_DEF
+#endif
 
-    constexpr safe_array() noexcept = default;
-    constexpr safe_array(const safe_array &) noexcept = default;
-    constexpr safe_array(safe_array &&) noexcept = default;
-    constexpr safe_array &operator=(const safe_array &) noexcept = default;
-    constexpr safe_array &operator=(safe_array &&) noexcept = default;
-    ~safe_array() noexcept = default;
+#if WJR_HAS_BUILTIN(ASM_ADDMUL_1)
+#define WJR_HAS_BUILTIN_ASM_SUBMUL_1 WJR_HAS_DEF
+#endif
 
-    constexpr safe_array &reset_range() noexcept {
-        m_length -= m_offset;
-        m_offset = 0;
-        return *this;
-    }
+#if WJR_HAS_BUILTIN(ASM_MUL_1)
+#define WJR_HAS_BUILTIN_ASM_ADDLSH_N WJR_HAS_DEF
+#define WJR_HAS_BUILTIN_ASM_RSBLSH_N WJR_HAS_DEF
+#endif
 
-    constexpr pointer get() const noexcept { return m_ptr; }
-    constexpr pointer data() const noexcept { return m_ptr; }
-    constexpr reference operator[](size_type i) const noexcept { return m_ptr[i]; }
+} // namespace wjr
 
-    constexpr safe_array(span<T> s) noexcept
-        : m_ptr(s.data()), m_offset(0), m_size(s.size()), m_length(s.size()) {}
+#endif // WJR_X86_MATH_MUL_IMPL_HPP__
 
-    constexpr safe_array first(size_type count) const noexcept {
-        WJR_ASSERT_L3(m_ptr != nullptr, "safe_array: nullptr");
-        WJR_ASSERT_L3(count <= m_size, "safe_array: out of range");
-        return {m_ptr, m_offset, count, m_length};
-    }
+namespace wjr {
 
-    constexpr safe_array subspan(size_type offset, size_type count) const noexcept {
-        WJR_ASSERT_L3(m_ptr != nullptr, "safe_array: nullptr");
-        WJR_ASSERT_L3(offset + count <= m_size, "safe_array: out of range");
-        return {m_ptr + offset, m_offset + offset, count, m_length};
-    }
+#if WJR_HAS_BUILTIN(MUL64)
 
-    constexpr safe_array &append(size_type length) noexcept {
-        WJR_ASSERT_L3(m_offset + m_size + length <= m_length);
-        m_size += length;
-        return *this;
-    }
+WJR_INTRINSIC_INLINE uint64_t builtin_mul64(uint64_t a, uint64_t b,
+                                            uint64_t &hi) noexcept {
+#if WJR_HAS_BUILTIN(INT128_MUL64)
+    const __uint128_t x = static_cast<__uint128_t>(a) * b;
+    hi = x >> 64;
+    return static_cast<uint64_t>(x);
+#elif WJR_HAS_BUILTIN(ASM_MUL64)
+    uint64_t lo;
+    asm("mul{q %3| %3}\n\t" : "=a,a"(lo), "=d,d"(hi) : "%a,r"(a), "r,a"(b) : "cc");
+    return lo;
+#endif
+}
 
-    constexpr safe_array &operator=(span<T> s) noexcept {
-        m_ptr = s.data();
-        m_offset = 0;
-        m_size = s.size();
-        m_length = s.size();
-        return *this;
-    }
+#endif
 
-    constexpr safe_array &operator=(std::nullptr_t) noexcept {
-        m_ptr = nullptr;
-        m_offset = 0;
-        m_size = 0;
-        m_length = 0;
-        return *this;
-    }
+#if WJR_HAS_BUILTIN(MULX_U64)
 
-    constexpr safe_array &operator+=(size_type n) noexcept {
-        WJR_ASSERT_L3(m_ptr != nullptr, "safe_array: nullptr");
-        WJR_ASSERT_L3(n <= m_size, "safe_array: out of range");
-        m_ptr += n;
-        m_offset += n;
-        m_size -= n;
-        return *this;
-    }
-
-    constexpr friend safe_array operator+(safe_array lhs, size_type rhs) noexcept {
-        return lhs += rhs;
-    }
-
-    constexpr friend safe_array operator+(size_type lhs, safe_array rhs) noexcept {
-        return rhs += lhs;
-    }
-
-    constexpr safe_array &operator++() noexcept {
-        (*this) += 1;
-        return *this;
-    }
-
-    constexpr safe_array operator++(int) noexcept {
-        safe_array tmp = *this;
-        ++*this;
-        return tmp;
-    }
-
-    constexpr safe_array &operator-=(size_type n) noexcept {
-        WJR_ASSERT_L3(m_ptr != nullptr, "safe_array: nullptr");
-        WJR_ASSERT_L3(m_offset >= n, "safe_array: out of range");
-        m_ptr -= n;
-        m_offset -= n;
-        m_size += n;
-        return *this;
-    }
-
-    constexpr friend safe_array operator-(safe_array lhs, size_type rhs) noexcept {
-        return lhs -= rhs;
-    }
-
-    constexpr friend ptrdiff_t operator-(const safe_array &lhs,
-                                         const safe_array &rhs) noexcept {
-        return lhs.m_ptr - rhs.m_ptr;
-    }
-
-    constexpr safe_array &operator--() noexcept {
-        (*this) -= 1;
-        return *this;
-    }
-
-    constexpr safe_array operator--(int) noexcept {
-        safe_array tmp = *this;
-        --*this;
-        return tmp;
-    }
-
-private:
-    constexpr safe_array(pointer ptr, size_type offset, size_type size,
-                         size_type length) noexcept
-        : m_ptr(ptr), m_offset(offset), m_size(size), m_length(length) {}
-
-    pointer m_ptr = nullptr;
-    size_type m_offset;
-    size_type m_size;
-    size_type m_length;
-};
-
-#else
-
-template <typename T, typename Tag = void>
-class safe_array {
-public:
-    using element_type = T;
-    using value_type = std::remove_cv_t<T>;
-    using pointer = T *;
-    using reference = T &;
-    using difference_type = ptrdiff_t;
-    using size_type = size_t;
-
-    constexpr safe_array() noexcept = default;
-    constexpr safe_array(const safe_array &) noexcept = default;
-    constexpr safe_array(safe_array &&) noexcept = default;
-    constexpr safe_array &operator=(const safe_array &) noexcept = default;
-    constexpr safe_array &operator=(safe_array &&) noexcept = default;
-    ~safe_array() noexcept = default;
-
-    constexpr safe_array &reset_range() noexcept { return *this; }
-
-    constexpr pointer get() const noexcept { return m_ptr; }
-    constexpr pointer data() const noexcept { return m_ptr; }
-    constexpr reference operator[](size_type i) const noexcept { return m_ptr[i]; }
-
-    constexpr safe_array(span<T> s) noexcept : m_ptr(s.data()) {}
-
-    constexpr safe_array first(WJR_MAYBE_UNUSED size_type count) const noexcept {
-        return safe_array{m_ptr};
-    }
-
-    constexpr safe_array subspan(size_type offset,
-                                 WJR_MAYBE_UNUSED size_type count) const noexcept {
-        return safe_array{m_ptr + offset};
-    }
-
-    constexpr safe_array &operator=(span<T> s) noexcept {
-        m_ptr = s.data();
-        return *this;
-    }
-
-    constexpr safe_array &operator=(std::nullptr_t) noexcept {
-        m_ptr = nullptr;
-        return *this;
-    }
-
-    constexpr safe_array &operator+=(size_type n) noexcept {
-        m_ptr += n;
-        return *this;
-    }
-
-    constexpr friend safe_array operator+(safe_array lhs, size_type rhs) noexcept {
-        return lhs += rhs;
-    }
-
-    constexpr friend safe_array operator+(size_type lhs, safe_array rhs) noexcept {
-        return rhs += lhs;
-    }
-
-    constexpr safe_array &operator-=(size_type n) noexcept {
-        m_ptr -= n;
-        return *this;
-    }
-
-    constexpr friend safe_array operator-(safe_array lhs, size_type rhs) noexcept {
-        return lhs -= rhs;
-    }
-
-    constexpr friend ptrdiff_t operator-(const safe_array &lhs,
-                                         const safe_array &rhs) noexcept {
-        return lhs.m_ptr - rhs.m_ptr;
-    }
-
-private:
-    T *m_ptr;
-};
-
-#endif
-
-} // namespace wjr
-
-#endif // WJR_MEMORY_SAFE_POINTER_HPP__
-
-#if defined(WJR_X86)
-#ifndef WJR_X86_MATH_MUL_HPP__
-#define WJR_X86_MATH_MUL_HPP__
-
-// Already included
-#ifndef WJR_X86_MATH_MUL_IMPL_HPP__
-#define WJR_X86_MATH_MUL_IMPL_HPP__
-
-// Already included
-
-#ifndef WJR_X86
-#error "x86 required"
-#endif
-
-namespace wjr {
-
-#define WJR_HAS_BUILTIN_MUL64 WJR_HAS_DEF
-
-#if WJR_HAS_FEATURE(INT128)
-#define WJR_HAS_BUILTIN_INT128_MUL64 WJR_HAS_DEF
-#elif WJR_HAS_FEATURE(GCC_STYLE_INLINE_ASM)
-#define WJR_HAS_BUILTIN_ASM_MUL64 WJR_HAS_DEF
-#else
-#undef WJR_HAS_BUILTIN_MUL64
-#endif
-
-#if defined(__BMI2__)
-#define WJR_HAS_BUILTIN_MULX_U64 WJR_HAS_DEF
-#endif
-
-#if WJR_HAS_BUILTIN(MULX_U64) && WJR_HAS_FEATURE(GCC_STYLE_INLINE_ASM)
-#define WJR_HAS_BUILTIN_ASM_MUL_1 WJR_HAS_DEF
-#endif
-
-#if WJR_HAS_BUILTIN(ASM_MUL_1) && defined(__ADX__)
-#define WJR_HAS_BUILTIN_ASM_ADDMUL_1 WJR_HAS_DEF
-#endif
-
-#if WJR_HAS_BUILTIN(ASM_MUL_1) && WJR_HAS_BUILTIN(ASM_ADDMUL_1)
-#define WJR_HAS_BUILTIN_ASM_BASECASE_MUL_S WJR_HAS_DEF
-#define WJR_HAS_BUILTIN_ASM_BASECASE_SQR WJR_HAS_DEF
-#endif
-
-#if WJR_HAS_BUILTIN(ASM_ADDMUL_1)
-#define WJR_HAS_BUILTIN_ASM_SUBMUL_1 WJR_HAS_DEF
-#endif
-
-#if WJR_HAS_BUILTIN(ASM_MUL_1)
-#define WJR_HAS_BUILTIN_ASM_ADDLSH_N WJR_HAS_DEF
-#define WJR_HAS_BUILTIN_ASM_RSBLSH_N WJR_HAS_DEF
-#endif
-
-} // namespace wjr
-
-#endif // WJR_X86_MATH_MUL_IMPL_HPP__
-
-namespace wjr {
-
-#if WJR_HAS_BUILTIN(MUL64)
-
-WJR_INTRINSIC_INLINE uint64_t builtin_mul64(uint64_t a, uint64_t b,
-                                            uint64_t &hi) noexcept {
-#if WJR_HAS_BUILTIN(INT128_MUL64)
-    const __uint128_t x = static_cast<__uint128_t>(a) * b;
-    hi = x >> 64;
-    return static_cast<uint64_t>(x);
-#elif WJR_HAS_BUILTIN(ASM_MUL64)
-    uint64_t lo;
-    asm("mul{q %3| %3}\n\t" : "=a,a"(lo), "=d,d"(hi) : "%a,r"(a), "r,a"(b) : "cc");
-    return lo;
-#endif
-}
-
-#endif
-
-#if WJR_HAS_BUILTIN(MULX_U64)
-
-template <typename T>
-WJR_INTRINSIC_INLINE T mulx(T a, T b, T &hi) noexcept {
-    static_assert(sizeof(T) == 8, "");
+template <typename T>
+WJR_INTRINSIC_INLINE T mulx(T a, T b, T &hi) noexcept {
+    static_assert(sizeof(T) == 8, "");
 
 #if defined(WJR_COMPILER_GCC)
     T lo;
@@ -23338,25 +22996,25 @@ WJR_INTRINSIC_CONSTEXPR_E T mul(T a, T b, T &hi) noexcept {
     }
 }
 
-template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-WJR_CONST WJR_INTRINSIC_CONSTEXPR_E T mulhi(T a, T b) noexcept {
-    T ret = 0;
-    (void)mul(a, b, ret);
-    return ret;
-}
-
 #if defined(WJR_MSVC) && defined(WJR_X86_64) && WJR_HAS_SIMD(X86_SIMD)
 #define WJR_HAS_BUILTIN_MSVC_MULHI64 WJR_HAS_DEF
 #endif
 
+template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
+WJR_CONST WJR_INTRINSIC_CONSTEXPR_E T mulhi(T a, T b) noexcept {
 #if WJR_HAS_BUILTIN(MSVC_MULHI64)
-
-template <>
-WJR_CONST WJR_INTRINSIC_INLINE uint64_t mulhi<uint64_t>(uint64_t a, uint64_t b) noexcept {
-    return __umulh(a, b);
-}
-
+    constexpr auto nd = std::numeric_limits<T>::digits;
+    if constexpr (nd < 64) {
+#endif
+        T ret = 0;
+        (void)mul(a, b, ret);
+        return ret;
+#if WJR_HAS_BUILTIN(MSVC_MULHI64)
+    } else {
+        return __umulh(a, b);
+    }
 #endif
+}
 
 template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
 WJR_CONST WJR_INTRINSIC_CONSTEXPR T mullo(T a, T b) noexcept {
@@ -24657,24 +24315,325 @@ class divexact1_divider {
 } // namespace wjr
 
 #endif // WJR_MATH_DIVIDER_HPP__
+// libdivide.h - Optimized integer division
+// https://libdivide.com
+//
+// Copyright (C) 2010 - 2022 ridiculous_fish, <libdivide@ridiculousfish.com>
+// Copyright (C) 2016 - 2022 Kim Walisch, <kim.walisch@gmail.com>
+//
+// libdivide is dual-licensed under the Boost or zlib licenses.
+// You may use libdivide under the terms of either of these.
+// See LICENSE.txt for more details.
 
-#if defined(WJR_X86)
-#ifndef WJR_X86_MATH_DIV_HPP__
-#define WJR_X86_MATH_DIV_HPP__
+#ifndef WJR_LIBDIVIDE_HPP__
+#define WJR_LIBDIVIDE_HPP__
 
 // Already included
-
-#ifndef WJR_X86
-#error "x86 required"
-#endif
+// Already included
+// Already included
+// Already included
 
 namespace wjr {
 
-#if WJR_HAS_FEATURE(GCC_STYLE_INLINE_ASM) && defined(__BMI2__)
-#define WJR_HAS_BUILTIN_ASM_DIVEXACT_DBM1C WJR_HAS_DEF
-#endif
-
-#if WJR_HAS_BUILTIN(ASM_DIVEXACT_DBM1C)
+// pack divider structs to prevent compilers from padding.
+// This reduces memory usage by up to 43% when using a large
+// array of libdivide dividers and improves performance
+// by up to 10% because of reduced memory bandwidth.
+#pragma pack(push, 1)
+
+template <typename T>
+struct libdivide_uint_t_impl {
+    T magic;
+    uint8_t more;
+};
+
+template <typename T>
+struct libdivide_uint_branchfree_t_impl {
+    T magic;
+    uint8_t more;
+};
+
+template <typename T, bool branchfree>
+using libdivide_uint_t =
+    std::conditional_t<branchfree, libdivide_uint_branchfree_t_impl<T>,
+                       libdivide_uint_t_impl<T>>;
+
+#pragma pack(pop)
+
+// Explanation of the "more" field:
+//
+// * Bits 0-5 is the shift value (for shift path or mult path).
+// * Bit 6 is the add indicator for mult path.
+// * Bit 7 is set if the divisor is negative. We use bit 7 as the negative
+//   divisor indicator so that we can efficiently use sign extension to
+//   create a bitmask with all bits set to 1 (if the divisor is negative)
+//   or 0 (if the divisor is positive).
+//
+// u32: [0-4] shift value
+//      [5] ignored
+//      [6] add indicator
+//      magic number of 0 indicates shift path
+//
+// s32: [0-4] shift value
+//      [5] ignored
+//      [6] add indicator
+//      [7] indicates negative divisor
+//      magic number of 0 indicates shift path
+//
+// u64: [0-5] shift value
+//      [6] add indicator
+//      magic number of 0 indicates shift path
+//
+// s64: [0-5] shift value
+//      [6] add indicator
+//      [7] indicates negative divisor
+//      magic number of 0 indicates shift path
+//
+// In s32 and s64 branchfree modes, the magic number is negated according to
+// whether the divisor is negated. In branchfree strategy, it is not negated.
+
+enum {
+    LIBDIVIDE_16_SHIFT_MASK = 0x1F,
+    LIBDIVIDE_32_SHIFT_MASK = 0x1F,
+    LIBDIVIDE_64_SHIFT_MASK = 0x3F,
+    LIBDIVIDE_ADD_MARKER = 0x40,
+    LIBDIVIDE_NEGATIVE_DIVISOR = 0x80
+};
+
+template <typename T, bool branchfree>
+WJR_CONST WJR_INTRINSIC_INLINE libdivide_uint_t<T, false>
+libdivide_internal_uint_gen(T d) noexcept;
+
+template <typename T, bool branchfree>
+WJR_CONST WJR_INTRINSIC_INLINE libdivide_uint_t<T, branchfree>
+libdivide_uint_gen(T d) noexcept;
+
+template <typename T, bool branchfree>
+WJR_CONST WJR_INTRINSIC_INLINE T
+libdivide_uint_do(T d, const libdivide_uint_t<T, branchfree> &denom) noexcept;
+
+//////// Internal Utility Functions
+
+template <typename T>
+WJR_INTRINSIC_INLINE T libdivide_div_half(T hi, T lo, T den, T &rem) noexcept {
+    constexpr auto nd = std::numeric_limits<T>::digits;
+    using U = uint_t<nd * 2>;
+    const U n = (static_cast<U>(hi) << nd) | lo;
+    const auto result = static_cast<T>(n / den);
+    rem = n - result * static_cast<U>(den);
+    return result;
+}
+
+template <>
+WJR_INTRINSIC_INLINE uint64_t libdivide_div_half<uint64_t>(uint64_t hi, uint64_t lo,
+                                                           uint64_t den,
+                                                           uint64_t &rem) noexcept {
+    return div128by64to64(rem, lo, hi, den);
+}
+
+////////// UINT16
+
+template <typename T, bool branchfree>
+WJR_CONST WJR_INTRINSIC_INLINE libdivide_uint_t<T, false>
+libdivide_internal_uint_gen(T d) noexcept {
+    constexpr auto nd = std::numeric_limits<T>::digits;
+
+    WJR_ASSERT(d != 0, "divider must be != 0");
+
+    libdivide_uint_t<T, false> result;
+    uint8_t floor_log_2_d = static_cast<uint8_t>(nd - 1 - clz<T>(d));
+
+    // Power of 2
+    if (is_zero_or_single_bit(d)) {
+        // We need to subtract 1 from the shift value in case of an unsigned
+        // branchfree divider because there is a hardcoded right shift by 1
+        // in its division algorithm. Because of this we also need to add back
+        // 1 in its recovery algorithm.
+        result.magic = 0;
+        result.more = (uint8_t)(floor_log_2_d - (branchfree != 0));
+    } else {
+        uint8_t more;
+        T rem, proposed_m;
+        proposed_m = libdivide_div_half<T>(static_cast<T>(1) << floor_log_2_d, 0, d, rem);
+
+        WJR_ASSERT(rem > 0 && rem < d);
+        const T e = d - rem;
+
+        // This power works if e < 2**floor_log_2_d.
+        if (!branchfree && (e < (static_cast<T>(1) << floor_log_2_d))) {
+            // This power works
+            more = floor_log_2_d;
+        } else {
+            // We have to use the general 17-bit algorithm.  We need to compute
+            // (2**power) / d. However, we already have (2**(power-1))/d and
+            // its remainder.  By doubling both, and then correcting the
+            // remainder, we can compute the larger division.
+            // don't care about overflow here - in fact, we expect it
+            proposed_m += proposed_m;
+            const T twice_rem = rem + rem;
+            if (twice_rem >= d || twice_rem < rem)
+                proposed_m += 1;
+            more = floor_log_2_d | LIBDIVIDE_ADD_MARKER;
+        }
+        result.magic = 1 + proposed_m;
+        result.more = more;
+        // result.more's shift should in general be ceil_log_2_d. But if we
+        // used the smaller power, we subtract one from the shift because we're
+        // using the smaller power. If we're using the larger power, we
+        // subtract one from the shift because it's taken care of by the add
+        // indicator. So floor_log_2_d happens to be correct in both cases.
+    }
+
+    return result;
+}
+
+template <typename T>
+struct libdivide_shift_mask {
+    static const uint8_t value = 0;
+};
+
+#define WJR_REGISTER_SHIFT_MASK(nd)                                                      \
+    template <>                                                                          \
+    struct libdivide_shift_mask<uint##nd##_t> {                                          \
+        static const uint8_t value = LIBDIVIDE_##nd##_SHIFT_MASK;                        \
+    }
+
+WJR_REGISTER_SHIFT_MASK(16);
+WJR_REGISTER_SHIFT_MASK(32);
+WJR_REGISTER_SHIFT_MASK(64);
+
+#undef WJR_REGISTER_SHIFT_MASK
+
+template <typename T, bool branchfree>
+WJR_CONST WJR_INTRINSIC_INLINE libdivide_uint_t<T, branchfree>
+libdivide_uint_gen(T d) noexcept {
+    if constexpr (!branchfree) {
+        return libdivide_internal_uint_gen<T, false>(d);
+    } else {
+        WJR_ASSERT(d != 1, "divider must be != 1");
+        const auto tmp = libdivide_internal_uint_gen<T, true>(d);
+        libdivide_uint_t<T, true> ret = {
+            tmp.magic, (uint8_t)(tmp.more & libdivide_shift_mask<T>::value)};
+        return ret;
+    }
+}
+
+template <typename T>
+WJR_CONST WJR_INTRINSIC_INLINE T
+libdivide_uint_do_impl(T d, const libdivide_uint_t<T, false> &denom) noexcept {
+    const T magic = denom.magic;
+    const uint8_t more = denom.more;
+    if (!magic) {
+        return d >> more;
+    } else {
+        T q = mulhi<T>(magic, d);
+        if (more & LIBDIVIDE_ADD_MARKER) {
+            T t = ((d - q) >> 1) + q;
+            return t >> (more & libdivide_shift_mask<T>::value);
+        } else {
+            // All upper bits are 0,
+            // don't need to mask them off.
+            return q >> more;
+        }
+    }
+}
+
+template <typename T>
+WJR_CONST WJR_INTRINSIC_INLINE T
+libdivide_uint_branchfree_do_impl(T d, const libdivide_uint_t<T, true> &denom) noexcept {
+    const T q = mulhi<T>(denom.magic, d);
+    const T t = ((d - q) >> 1) + q;
+    return t >> denom.more;
+}
+
+template <typename T, bool branchfree>
+WJR_CONST WJR_INTRINSIC_INLINE T
+libdivide_uint_do(T d, const libdivide_uint_t<T, branchfree> &denom) noexcept {
+    if constexpr (!branchfree) {
+        return libdivide_uint_do_impl(d, denom);
+    } else {
+        return libdivide_uint_branchfree_do_impl(d, denom);
+    }
+}
+
+/////////// C++ stuff
+
+// This is the main divider class for use by the user (C++ API).
+// The actual division algorithm is selected using the dispatcher struct
+// based on the integer width and algorithm template parameters.
+template <typename T, bool branchfree = false>
+class divider {
+private:
+    using dispatcher_t = libdivide_uint_t<T, branchfree>;
+
+public:
+    // We leave the default constructor empty so that creating
+    // an array of dividers and then initializing them
+    // later doesn't slow us down.
+    constexpr divider() = default;
+    constexpr divider(const divider &) = default;
+    constexpr divider(divider &&) = default;
+    constexpr divider &operator=(const divider &) = default;
+    constexpr divider &operator=(divider &&) = default;
+    ~divider() = default;
+
+    // Constructor that takes the divisor as a parameter
+    WJR_INTRINSIC_INLINE divider(T d) { div = libdivide_uint_gen<T, branchfree>(d); }
+
+    // Divides n by the divisor
+    WJR_INTRINSIC_INLINE T divide(T n) const { return libdivide_uint_do(n, div); }
+
+    WJR_CONST bool operator==(const divider<T, branchfree> &other) const {
+        return div.denom.magic == other.denom.magic && div.denom.more == other.denom.more;
+    }
+
+    WJR_CONST bool operator!=(const divider<T, branchfree> &other) const {
+        return !(*this == other);
+    }
+
+private:
+    // Storage for the actual divisor
+    dispatcher_t div;
+};
+
+// Overload of operator / for scalar division
+template <typename T, bool branchfree>
+WJR_INTRINSIC_INLINE T operator/(T n, const divider<T, branchfree> &div) {
+    return div.divide(n);
+}
+
+// Overload of operator /= for scalar division
+template <typename T, bool branchfree>
+WJR_INTRINSIC_INLINE T &operator/=(T &n, const divider<T, branchfree> &div) {
+    n = div.divide(n);
+    return n;
+}
+
+template <typename T>
+using branchfree_divider = divider<T, true>;
+
+} // namespace wjr
+
+#endif // WJR_LIBDIVIDE_HPP__
+
+
+#if defined(WJR_X86)
+#ifndef WJR_X86_MATH_DIV_HPP__
+#define WJR_X86_MATH_DIV_HPP__
+
+// Already included
+
+#ifndef WJR_X86
+#error "x86 required"
+#endif
+
+namespace wjr {
+
+#if WJR_HAS_FEATURE(GCC_STYLE_INLINE_ASM) && defined(__BMI2__)
+#define WJR_HAS_BUILTIN_ASM_DIVEXACT_DBM1C WJR_HAS_DEF
+#endif
+
+#if WJR_HAS_BUILTIN(ASM_DIVEXACT_DBM1C)
 
 // TODO : optimize pipeline
 inline uint64_t asm_divexact_dbm1c(uint64_t *dst, const uint64_t *src, size_t n,
@@ -24796,7 +24755,7 @@ WJR_INLINE_CONSTEXPR20 uint64_t div128by64to64(uint64_t &rem, uint64_t lo, uint6
     return div128by64to64_impl(rem, lo, hi, wjr::div2by1_divider<uint64_t>(div));
 }
 
-WJR_INLINE_CONSTEXPR20 tuple<uint64_t, uint64_t>
+inline uint128_t
 div128by64to128_noshift(uint64_t &rem, uint64_t lo, uint64_t hi,
                         const div2by1_divider_noshift<uint64_t> &divider) noexcept {
     const auto divisor = divider.get_divisor();
@@ -24809,10 +24768,10 @@ div128by64to128_noshift(uint64_t &rem, uint64_t lo, uint64_t hi,
 
     q0 = divider.divide(lo, hi);
     rem = hi;
-    return std::make_pair(q0, q1);
+    return {q0, q1};
 }
 
-inline tuple<uint64_t, uint64_t>
+inline uint128_t
 div128by64to128_shift(uint64_t &rem, uint64_t lo, uint64_t hi,
                       const div2by1_divider<uint64_t> &divider) noexcept {
     const auto shift = divider.get_shift();
@@ -24828,12 +24787,11 @@ div128by64to128_shift(uint64_t &rem, uint64_t lo, uint64_t hi,
     q0 = div.divide(u0, u2);
 
     rem = u2 >> shift;
-    return std::make_pair(q0, q1);
+    return {q0, q1};
 }
 
-inline tuple<uint64_t, uint64_t>
-div128by64to128_impl(uint64_t &rem, uint64_t lo, uint64_t hi,
-                     const div2by1_divider<uint64_t> &divider) noexcept {
+inline uint128_t div128by64to128_impl(uint64_t &rem, uint64_t lo, uint64_t hi,
+                                      const div2by1_divider<uint64_t> &divider) noexcept {
     if (divider.get_shift() == 0) {
         return div128by64to128_noshift(rem, lo, hi, divider);
     }
@@ -24845,9 +24803,8 @@ div128by64to128_impl(uint64_t &rem, uint64_t lo, uint64_t hi,
  not optimize for divider that is power of 2,
  manually consider whether it needs to be optimized
 */
-inline tuple<uint64_t, uint64_t>
-div128by64to128(uint64_t &rem, uint64_t lo, uint64_t hi,
-                const div2by1_divider<uint64_t> &divider) noexcept {
+inline uint128_t div128by64to128(uint64_t &rem, uint64_t lo, uint64_t hi,
+                                 const div2by1_divider<uint64_t> &divider) noexcept {
     return div128by64to128_impl(rem, lo, hi, divider);
 }
 
@@ -24855,8 +24812,8 @@ div128by64to128(uint64_t &rem, uint64_t lo, uint64_t hi,
  not optimize for divider that is power of 2,
  manually consider whether it needs to be optimized
 */
-inline tuple<uint64_t, uint64_t> div128by64to128(uint64_t &rem, uint64_t lo, uint64_t hi,
-                                                 uint64_t div) noexcept {
+inline uint128_t div128by64to128(uint64_t &rem, uint64_t lo, uint64_t hi,
+                                 uint64_t div) noexcept {
     return div128by64to128_impl(rem, lo, hi, div2by1_divider<uint64_t>(div));
 }
 
@@ -25589,1783 +25546,1451 @@ precompute_chars_convert(precompute_chars_convert_t *pre, size_t n, unsigned int
 
 #endif // WJR_MATH_PRECOMPUTE_CHARS_CONVERT_HPP__
 // Already included
+#ifndef WJR_MATH_STACK_ALLOCATOR_HPP__
+#define WJR_MATH_STACK_ALLOCATOR_HPP__
 
-#if defined(WJR_X86)
-#ifndef WJR_X86_MATH_CONVERT_HPP__
-#define WJR_X86_MATH_CONVERT_HPP__
+#ifndef WJR_STACK_ALLOCATOR_HPP__
+#define WJR_STACK_ALLOCATOR_HPP__
 
-// Already included
-// Already included
+#include <algorithm>
 
-#ifndef WJR_X86
-#error "x86 required"
-#endif
+#ifndef WJR_CRTP_NONSENDABLE_HPP__
+#define WJR_CRTP_NONSENDABLE_HPP__
 
-namespace wjr {
+/**
+ * @file nonsendable.hpp
+ * @author wjr
+ * @brief  A type to disable sending the object to another thread.
+ *
+ * @version 0.1
+ * @date 2024-05-26
+ *
+ * @copyright Copyright (c) 2024
+ *
+ */
 
-#if WJR_HAS_SIMD(SSE4_1) && WJR_HAS_SIMD(X86_SIMD)
-#define WJR_HAS_BUILTIN_TO_CHARS_UNROLL_8_FAST WJR_HAS_DEF
+#include <memory>
 
-#define WJR_HAS_BUILTIN_FROM_CHARS_UNROLL_8_FAST WJR_HAS_DEF
-#define WJR_HAS_BUILTIN_FROM_CHARS_UNROLL_16_FAST WJR_HAS_DEF
+// Already included
+
+#if WJR_DEBUG_LEVEL > 2
+#define WJR_HAS_DEBUG_NONSENDABLE_CHECKER WJR_HAS_DEF
 #endif
 
-#if WJR_HAS_BUILTIN(TO_CHARS_UNROLL_8_FAST)
+#if WJR_HAS_DEBUG(NONSENDABLE_CHECKER)
+#include <thread>
+#endif
 
-namespace to_chars_details {
+namespace wjr {
 
-const static __m128i mul10p4 = simd_cast<uint32_t, __m128i_t>(3518437209);
-const static __m128i mul10p4x = simd_cast<uint32_t, __m128i_t>(10000);
-const static __m128i mul10p2 = sse::set1_epi16(5243);
-const static __m128i mul10p2x = sse::set1_epi16(100);
-const static __m128i mul10p1 = sse::set1_epi16((short)52429u);
-const static __m128i mul10p1x = sse::set1_epi16(10);
+#if WJR_HAS_DEBUG(NONSENDABLE_CHECKER)
 
-const static __m128i shuf =
-    sse::setr_epi8(0, 8, 4, 12, 2, 10, 6, 14, 1, 1, 1, 1, 1, 1, 1, 1);
+/**
+ * @brief A type to disable sending the object to another thread.
+ *
+ */
+template <typename Tag = void>
+class nonsendable {
+public:
+    static constexpr bool is_nonsendable = true;
 
-} // namespace to_chars_details
+protected:
+    nonsendable() noexcept : m_thread_id(std::this_thread::get_id()) {}
+    nonsendable(const nonsendable &) noexcept = default;
+    nonsendable(nonsendable &&) noexcept = default;
+    nonsendable &operator=(const nonsendable &) noexcept = default;
+    nonsendable &operator=(nonsendable &&) noexcept = default;
+    ~nonsendable() noexcept { check(); }
 
-#endif
+    void check() const noexcept {
+        WJR_ASSERT_L0(m_thread_id == std::this_thread::get_id(),
+                      "Cross-thread access detected when using a nonsendable object.");
+    }
 
-#if WJR_HAS_BUILTIN(TO_CHARS_UNROLL_8_FAST)
+    friend bool operator==(const nonsendable &lhs, const nonsendable &rhs) noexcept {
+        return lhs.m_thread_id == rhs.m_thread_id;
+    }
 
-inline uint64_t builtin_to_chars_unroll_8_fast_10(uint32_t in) noexcept {
+    friend bool operator!=(const nonsendable &lhs, const nonsendable &rhs) noexcept {
+        return lhs.m_thread_id != rhs.m_thread_id;
+    }
 
-    __m128i x = simd_cast<uint32_t, __m128i_t>(in);
-    __m128i q, r;
+private:
+    std::thread::id m_thread_id;
+};
 
-    q = _mm_mul_epu32(x, to_chars_details::mul10p4);
-    q = _mm_srli_epi64(q, 45);
+#else
 
-    r = _mm_sub_epi32(x, _mm_mul_epu32(q, to_chars_details::mul10p4x));
-    x = _mm_packus_epi32(q, r);
+/**
+ * @brief A type to disable sending the object to another thread.
+ *
+ */
+template <typename Tag = void>
+class nonsendable {
+public:
+    static constexpr bool is_nonsendable = true;
 
-    q = _mm_mulhi_epu16(x, to_chars_details::mul10p2);
-    q = _mm_srli_epi16(q, 3);
+protected:
+    constexpr static void check() noexcept {}
 
-    r = _mm_sub_epi16(x, _mm_mullo_epi16(q, to_chars_details::mul10p2x));
-    x = _mm_packus_epi16(q, r);
+    friend bool operator==(const nonsendable &, const nonsendable &) noexcept {
+        return true;
+    }
 
-    q = _mm_mulhi_epu16(x, to_chars_details::mul10p1);
-    q = _mm_srli_epi16(q, 3);
+    friend bool operator!=(const nonsendable &, const nonsendable &) noexcept {
+        return false;
+    }
+};
 
-    r = _mm_sub_epi16(x, _mm_mullo_epi16(q, to_chars_details::mul10p1x));
-    x = _mm_packus_epi16(q, r);
+#endif
 
-    return simd_cast<__m128i_t, uint64_t>(sse::shuffle_epi8(x, to_chars_details::shuf));
-}
+} // namespace wjr
 
-template <uint64_t Base>
-uint64_t builtin_to_chars_unroll_8_fast(uint32_t in) noexcept {
-    if constexpr (Base == 10) {
-        return builtin_to_chars_unroll_8_fast_10(in);
-    } else {
-        static_assert(Base == 10, "");
-    }
-}
+#endif // WJR_CRTP_NONSENDABLE_HPP__
+// Already included
+// Already included
 
-template <uint64_t Base>
-void builtin_to_chars_unroll_8_fast(void *ptr, uint32_t in, char_converter_t) noexcept {
-    const uint64_t x = builtin_to_chars_unroll_8_fast<Base>(in) + 0x3030303030303030ull;
-    write_memory<uint64_t>(ptr, x);
-}
+namespace wjr {
 
-template <uint64_t Base>
-void builtin_to_chars_unroll_8_fast(void *ptr, uint32_t in, origin_converter_t) noexcept {
-    const uint64_t x = builtin_to_chars_unroll_8_fast<Base>(in);
-    write_memory<uint64_t>(ptr, x);
-}
+template <typename StackAllocator>
+class unique_stack_allocator;
 
-#endif
-
-#if WJR_HAS_BUILTIN(FROM_CHARS_UNROLL_8_FAST) ||                                         \
-    WJR_HAS_BUILTIN(FROM_CHARS_UNROLL_16_FAST)
-
-namespace from_chars_details {
+template <size_t Cache>
+class stack_allocator_object {
+    template <typename StackAllocator>
+    friend class unique_stack_allocator;
 
-/// @private
-template <uint64_t Base>
-inline constexpr uint64_t __base2 = Base * Base;
+    constexpr static uint16_t bufsize = 5;
 
-/// @private
-template <uint64_t Base>
-inline constexpr uint64_t __base4 = __base2<Base> * __base2<Base>;
+    struct alloc_node {
+        char *ptr;
+        char *end;
+    };
 
-/// @private
-template <uint64_t Base>
-inline constexpr uint64_t __base8 = __base4<Base> * __base4<Base>;
+    struct large_stack_top {
+        large_stack_top *prev;
+        char buffer[];
+    };
 
-/// @private
-template <uint64_t Base>
-const static __m128i mulp1x = sse::setr_epi8(Base, 1, Base, 1, Base, 1, Base, 1, Base, 1,
-                                             Base, 1, Base, 1, Base, 1);
+public:
+    struct stack_top {
+        char *ptr;
+        uint16_t idx;
+        large_stack_top *large;
+    };
 
-/// @private
-template <uint64_t Base>
-const static __m128i mulp2x = sse::setr_epi16(__base2<Base>, 1, __base2<Base>, 1,
-                                              __base2<Base>, 1, __base2<Base>, 1);
+private:
+    WJR_CONSTEXPR20 void *__large_allocate(size_t n, stack_top &top) noexcept {
+        const auto buffer = (large_stack_top *)malloc(sizeof(large_stack_top) + n);
+        buffer->prev = top.large;
+        top.large = buffer;
+        return buffer->buffer;
+    }
 
-/// @private
-template <uint64_t Base>
-const static __m128i mulp4x = sse::setr_epi16(__base4<Base>, 1, __base4<Base>, 1,
-                                              __base4<Base>, 1, __base4<Base>, 1);
+    WJR_NOINLINE WJR_CONSTEXPR20 void __small_reallocate(stack_top &top) noexcept {
+        if (WJR_UNLIKELY(top.idx == (uint16_t)in_place_max)) {
+            top.idx = m_idx;
+        }
 
-/// @private
-template <uint64_t Base>
-const static __m128i baseu8 =
-    sse::setr_epi8(Base, Base, Base, Base, Base, Base, Base, 0xff, 0xff, 0xff, 0xff, 0xff,
-                   0xff, 0xff, 0xff, 0xff);
+        ++m_idx;
+        if (WJR_UNLIKELY(m_idx == m_size)) {
 
-/// @private
-static __m128i ascii = sse::set1_epi8(0x30);
+            if (WJR_UNLIKELY(m_size == m_capacity)) {
+                uint16_t new_capacity = m_idx + 2 * (bufsize - 1);
+                memory_pool<alloc_node> pool;
+                auto new_ptr = pool.chunk_allocate(new_capacity);
+                if (WJR_LIKELY(m_idx != 0)) {
+                    std::copy_n(m_ptr, m_idx, new_ptr);
+                    pool.chunk_deallocate(m_ptr, m_capacity);
+                }
+                m_ptr = new_ptr;
+                m_capacity = new_capacity;
+            }
 
-} // namespace from_chars_details
+            ++m_size;
 
-#endif
+            const size_t capacity = Cache << ((3 * m_idx + 2) / 5);
+            memory_pool<char> pool;
+            const auto buffer = pool.chunk_allocate(capacity);
+            alloc_node node = {buffer, buffer + capacity};
+            m_ptr[m_idx] = node;
 
-#if WJR_HAS_BUILTIN(FROM_CHARS_UNROLL_8_FAST)
+            if (WJR_UNLIKELY(m_idx == 0)) {
+                top.ptr = node.ptr;
+                top.idx = 0;
+            }
 
-template <uint64_t Base>
-uint32_t builtin_from_chars_unroll_8_fast(__m128i in) noexcept {
-    const __m128i t1 = _mm_maddubs_epi16(in, from_chars_details::mulp1x<Base>);
-    const __m128i t2 = _mm_madd_epi16(t1, from_chars_details::mulp2x<Base>);
-    const __m128i t3 = _mm_packus_epi32(t2, t2);
-    const __m128i t4 = _mm_madd_epi16(t3, from_chars_details::mulp4x<Base>);
+            m_cache = node;
+        } else {
+            m_cache = m_ptr[m_idx];
+        }
 
-    return simd_cast<__m128i_t, uint32_t>(t4);
-}
+        WJR_ASSERT(top.ptr != nullptr);
+    }
 
-template <uint64_t Base>
-uint32_t builtin_from_chars_unroll_8_fast(const void *ptr, char_converter_t) noexcept {
-    static_assert(Base <= 10, "");
-    const __m128i in = _mm_sub_epi8(sse::loadu_si64(ptr), from_chars_details::ascii);
-    return builtin_from_chars_unroll_8_fast<Base>(in);
-}
+    WJR_COLD WJR_CONSTEXPR20 void __small_redeallocate() noexcept {
+        const uint16_t new_size = m_idx + bufsize - 1;
+        memory_pool<char> pool;
 
-template <uint64_t Base>
-uint32_t builtin_from_chars_unroll_8_fast(const void *ptr, origin_converter_t) noexcept {
-    static_assert(Base <= 10, "");
-    const __m128i in = sse::loadu_si64(ptr);
-    return builtin_from_chars_unroll_8_fast<Base>(in);
-}
+        for (uint16_t i = new_size; i < m_size; ++i) {
+            pool.chunk_deallocate(m_ptr[i].ptr, m_ptr[i].end - m_ptr[i].ptr);
+        }
 
-#endif
+        m_size = new_size;
+    }
 
-#if WJR_HAS_BUILTIN(FROM_CHARS_UNROLL_16_FAST)
+    WJR_CONSTEXPR20 void __small_deallocate(const stack_top &top) noexcept {
+        if (WJR_UNLIKELY(top.ptr == nullptr)) {
+            return;
+        }
 
-template <uint64_t Base>
-uint64_t builtin_from_chars_unroll_16_fast(__m128i in) noexcept {
-    const __m128i t1 = _mm_maddubs_epi16(in, from_chars_details::mulp1x<Base>);
-    const __m128i t2 = _mm_madd_epi16(t1, from_chars_details::mulp2x<Base>);
-    const __m128i t3 = _mm_packus_epi32(t2, t2);
-    const __m128i t4 = _mm_madd_epi16(t3, from_chars_details::mulp4x<Base>);
+        m_cache.ptr = top.ptr;
 
-    const uint64_t val = simd_cast<__m128i_t, uint64_t>(t4);
-    const uint32_t lo = val;
-    const uint32_t hi = val >> 32;
+        if (WJR_UNLIKELY(top.idx != (uint16_t)in_place_max)) {
+            const uint16_t idx = top.idx;
+            m_cache.end = m_ptr[idx].end;
+            m_idx = idx;
+            if (WJR_UNLIKELY(m_size - idx >= bufsize)) {
+                __small_redeallocate();
+            }
+        }
+    }
 
-    return lo * from_chars_details::__base8<Base> + hi;
-}
+    WJR_MALLOC WJR_CONSTEXPR20 void *__small_allocate(size_t n, stack_top &top) noexcept {
+        auto ptr = m_cache.ptr;
 
-template <uint64_t Base>
-uint64_t builtin_from_chars_unroll_16_fast(const void *ptr, char_converter_t) noexcept {
-    static_assert(Base <= 10, "");
-    const __m128i in =
-        _mm_sub_epi8(sse::loadu((__m128i *)(ptr)), from_chars_details::ascii);
-    return builtin_from_chars_unroll_16_fast<Base>(in);
-}
+        if (WJR_UNLIKELY(static_cast<size_t>(m_cache.end - ptr) < n)) {
+            __small_reallocate(top);
+            ptr = m_cache.ptr;
+        }
 
-template <uint64_t Base>
-uint64_t builtin_from_chars_unroll_16_fast(const void *ptr, origin_converter_t) noexcept {
-    static_assert(Base <= 10, "");
-    const __m128i in = sse::loadu((__m128i *)(ptr));
-    return builtin_from_chars_unroll_16_fast<Base>(in);
-}
+        WJR_ASSERT_ASSUME_L2(m_cache.ptr != nullptr);
+        WJR_ASSERT_ASSUME_L2(top.ptr != nullptr);
 
-#endif
+        m_cache.ptr += n;
+        return ptr;
+    }
 
-} // namespace wjr
+public:
+    using value_type = void;
+    using size_type = size_t;
+    using difference_type = ptrdiff_t;
+    using propagate_on_container_move_assignment = std::true_type;
 
-#endif // WJR_X86_MATH_CONVERT_HPP__
-#endif
+    stack_allocator_object() noexcept = default;
+    stack_allocator_object(stack_allocator_object &) = delete;
+    stack_allocator_object(stack_allocator_object &&) = delete;
+    stack_allocator_object &operator=(stack_allocator_object &) = delete;
+    stack_allocator_object &operator=(stack_allocator_object &&) = delete;
+    ~stack_allocator_object() noexcept = default;
 
-namespace wjr {
+    WJR_NODISCARD WJR_MALLOC WJR_CONSTEXPR20 void *allocate(size_t n, stack_top &top,
+                                                            size_t threshold) noexcept {
+        if (WJR_UNLIKELY(n >= threshold)) {
+            return __large_allocate(n, top);
+        }
 
-inline constexpr size_t dc_bignum_to_chars_threshold = WJR_DC_BIGNUM_TO_CHARS_THRESHOLD;
-inline constexpr size_t dc_bignum_to_chars_precompute_threshold =
-    WJR_DC_BIGNUM_TO_CHARS_THRESHOLD;
+        return __small_allocate(n, top);
+    }
 
-inline constexpr size_t dc_bignum_from_chars_threshold =
-    WJR_DC_BIGNUM_FROM_CHARS_THRESHOLD;
-inline constexpr size_t dc_bignum_from_chars_precompute_threshold =
-    WJR_DC_BIGNUM_FROM_CHARS_PRECOMPUTE_THRESHOLD;
+    WJR_CONSTEXPR20 void deallocate(const stack_top &top) noexcept {
+        __small_deallocate(top);
 
-inline constexpr auto div2by1_divider_noshift_of_big_base_10 =
-    div2by1_divider_noshift<uint64_t>(10'000'000'000'000'000'000ull,
-                                      15'581'492'618'384'294'730ull);
+        auto buffer = top.large;
+        while (WJR_UNLIKELY(buffer != nullptr)) {
+            auto prev = buffer->prev;
+            free(buffer);
+            buffer = prev;
+        }
+    }
 
-inline constexpr auto div3by2_divider_shift_of_big_base_10 = div3by2_divider<uint64_t>(
-    1374799102801346560ull, 10842021724855044340ull, 12'938'764'603'223'852'203ull, 1);
+    WJR_CONSTEXPR20 void set(stack_top &top) const noexcept {
+        top.ptr = m_cache.ptr;
+        top.idx = in_place_max;
+        top.large = nullptr;
+    }
 
-namespace convert_details {
+private:
+    alloc_node m_cache = {nullptr, nullptr};
+    uint16_t m_idx = in_place_max;
+    alignas(32) uint16_t m_size = 0;
+    uint16_t m_capacity = 0;
+    alloc_node *m_ptr = nullptr;
+};
 
-WJR_CONST constexpr bool __isspace(uint8_t ch) noexcept {
-    return char_converter.from(ch) == 64;
-}
+/**
+ * @brief A stack allocator for fast simulation of stack memory on the heap, singleton
+ * mode.
+ *
+ * @tparam Cache The size of the first heap memory allocation
+ */
+template <size_t Cache, size_t DefaultThreshold>
+struct singleton_stack_allocator_object {
+    using Instance = stack_allocator_object<Cache>;
+    constexpr static size_t __default_threshold = DefaultThreshold;
 
-template <typename T>
-struct __is_fast_convert_value
-    : std::conjunction<std::is_trivial<T>, std::bool_constant<sizeof(T) == 1>> {};
+    static_assert(DefaultThreshold < Cache, "DefaultThreshold must be less than Cache.");
 
-template <typename T>
-inline constexpr bool __is_fast_convert_value_v = __is_fast_convert_value<T>::value;
+    static Instance &get_instance() noexcept {
+        static thread_local Instance instance;
+        return instance;
+    }
+};
 
-template <typename Iter, typename = void>
-struct __is_fast_convert_iterator_helper : std::false_type {};
-
-template <typename Iter>
-struct __is_fast_convert_iterator_helper<Iter,
-                                         std::enable_if_t<is_contiguous_iterator_v<Iter>>>
-    : __is_fast_convert_value<iterator_contiguous_value_t<Iter>> {};
-
-template <typename Iter>
-struct __is_fast_convert_iterator : __is_fast_convert_iterator_helper<Iter> {};
+/**
+ * @details Used for container. This allocator won't deallocate memory allocated by
+ * __small_allocate until container is destroyed.
+ *
+ */
+template <typename T, typename StackAllocator>
+class weak_stack_allocator;
 
 /**
- * @brief Iterator concept that can be used in fast_convert.
+ * @brief A unique stack allocator for fast simulation of stack memory on the heap.
  *
- * @details The iterator must be contiguous iterator and the value_type must be
- * trivial and sizeof(value_type) == 1. Cast to_address(iter) to uint8_t*(to_chars)/const
- * uint8_t*(from_chars) in fast_convert.
+ * @details When a unique_stack_allocator object is destroyed, all the memory it allocates
+ * is released.\n And a new unique_stack_allocator constructed in the lifetime of a
+ * unique_stack_allocator object must be destroyed in the current lifetime.
  *
  */
-template <typename Iter>
-inline constexpr bool __is_fast_convert_iterator_v =
-    __is_fast_convert_iterator<Iter>::value;
+template <typename StackAllocator>
+class unique_stack_allocator
+    : public nonsendable<unique_stack_allocator<StackAllocator>> {
+    using Mybase = nonsendable<unique_stack_allocator<StackAllocator>>;
+    using Instance = typename StackAllocator::Instance;
+    using stack_top = typename Instance::stack_top;
 
-template <typename Value, typename Converter>
-struct __is_valid_converter
-    : std::disjunction<std::conjunction<std::is_same<Converter, char_converter_t>,
-                                        is_nonbool_integral<Value>>,
-                       std::conjunction<std::is_same<Converter, origin_converter_t>,
-                                        is_nonbool_unsigned_integral<Value>>> {};
+    constexpr static size_t __default_threshold = StackAllocator::__default_threshold;
 
-template <typename Value, typename Converter>
-inline constexpr bool __is_valid_converter_v =
-    __is_valid_converter<Value, Converter>::value;
+    template <typename T, typename S>
+    friend class weak_stack_allocator;
 
-WJR_REGISTER_HAS_TYPE(to_chars_fast_fn_fast_conv,
-                      Base::__fast_conv(std::declval<void *>(), std::declval<Args>()...),
-                      Base);
+public:
+    unique_stack_allocator(const StackAllocator &al) noexcept
+        : m_instance(&(al.get_instance())) {
+        m_instance->set(m_top);
+    }
 
-WJR_REGISTER_HAS_TYPE(from_chars_fast_fn_fast_conv,
-                      Base::__fast_conv(std::declval<const void *>(),
-                                        std::declval<Args>()...),
-                      Base);
+    unique_stack_allocator(const unique_stack_allocator &) = delete;
+    unique_stack_allocator(unique_stack_allocator &&) = delete;
+    unique_stack_allocator &operator=(const unique_stack_allocator &) = delete;
+    unique_stack_allocator &operator=(unique_stack_allocator &&) = delete;
 
-template <typename Iter, typename = void>
-struct fast_buffer {
-private:
-    using value_type = iterator_value_t<Iter>;
+    ~unique_stack_allocator() noexcept { m_instance->deallocate(m_top); }
 
-public:
-    using type =
-        std::conditional_t<__is_fast_convert_value_v<value_type>, value_type, char>;
-};
+    WJR_NODISCARD WJR_MALLOC WJR_CONSTEXPR20 void *
+    allocate(size_t n, size_t threshold = __default_threshold) noexcept {
+        Mybase::check();
+        return m_instance->allocate(n, m_top, threshold);
+    }
 
-// back_inserter or inserter
-template <typename Iter>
-struct fast_buffer<Iter, std::void_t<decltype(std::declval<std::enable_if_t<
-                                                  is_any_insert_iterator_v<Iter>>>())>> {
 private:
-    using value_type = typename Iter::container_type::value_type;
+    WJR_NODISCARD WJR_MALLOC WJR_CONSTEXPR20 void *__small_allocate(size_t n) noexcept {
+        Mybase::check();
+        return m_instance->__small_allocate(n, m_top);
+    }
 
-public:
-    using type =
-        std::conditional_t<__is_fast_convert_value_v<value_type>, value_type, char>;
+    Instance *m_instance;
+    stack_top m_top;
 };
 
-template <typename Iter>
-using fast_buffer_t = typename fast_buffer<Iter>::type;
-
-template <typename Container>
-struct __fast_container_inserter_test {
-private:
-    using traits_type = container_traits<Container>;
-
-public:
-    static constexpr int value =
-        traits_type::is_trivially_contiguous_v &&
-                has_container_resize_v<Container, size_t>
-            ? (has_container_resize_v<Container, size_t, dctor_t> ? 2 : 1)
-            : 0;
+template <typename StackAllocator>
+unique_stack_allocator(const StackAllocator &) -> unique_stack_allocator<StackAllocator>;
 
-    static_assert(value != 2 || has_container_append_v<Container, size_t, dctor_t>, "");
-};
+/**
+ * @brief Point to unique_stack_allocator.
+ *
+ * @details Use a pointer to unique_stack_allocator to allocate memory. This class must be
+ * used carefully. If recursively using it as a reference and allocating memory,
+ * unique_stack_allocator should be avoided from being reused in the current function.
+ *
+ */
+template <typename T, size_t Cache, size_t DefaultThreshold>
+class weak_stack_allocator<T, singleton_stack_allocator_object<Cache, DefaultThreshold>> {
+    using StackAllocator = singleton_stack_allocator_object<Cache, DefaultThreshold>;
+    using UniqueStackAllocator = unique_stack_allocator<StackAllocator>;
 
-template <typename Iter, typename = void>
-struct __is_fast_container_inserter {
-    static constexpr int value = 0;
-};
+    constexpr static size_t __default_threshold = StackAllocator::__default_threshold;
 
-template <typename Iter>
-struct __is_fast_container_inserter<
-    Iter,
-    std::void_t<
-        decltype(std::declval<std::enable_if_t<is_any_insert_iterator_v<Iter>>>(),
-                 __fast_container_inserter_test<typename Iter::container_type>::value)>> {
-private:
-    using container_type = typename Iter::container_type;
+    template <typename U, typename A>
+    friend class weak_stack_allocator;
 
 public:
-    static constexpr int value =
-        __is_fast_convert_value_v<typename container_type::value_type> &&
-                is_trivially_allocator_constructible_v<
-                    typename container_type::allocator_type>
-            ? __fast_container_inserter_test<container_type>::value
-            : 0;
-};
+    using value_type = T;
+    using size_type = size_t;
+    using difference_type = ptrdiff_t;
+    using propagate_on_container_move_assignment = std::true_type;
+    using is_trivially_allocator = std::true_type;
 
-template <typename Iter>
-inline constexpr int is_fast_container_inserter_v =
-    __is_fast_container_inserter<Iter>::value;
+    template <typename Other>
+    struct rebind {
+        using other = weak_stack_allocator<Other, StackAllocator>;
+    };
 
-} // namespace convert_details
+    weak_stack_allocator() noexcept = default;
+    weak_stack_allocator(UniqueStackAllocator &alloc) noexcept : m_alloc(&alloc) {}
+    weak_stack_allocator(const weak_stack_allocator &) noexcept = default;
+    weak_stack_allocator &operator=(const weak_stack_allocator &) noexcept = default;
+    weak_stack_allocator(weak_stack_allocator &&) noexcept = default;
+    weak_stack_allocator &operator=(weak_stack_allocator &&) noexcept = default;
+    ~weak_stack_allocator() noexcept = default;
 
-// require operator() of Converter is constexpr
-template <typename Converter, uint64_t Base, int Unroll>
-class __char_converter_table_t {
-    static constexpr uint64_t pw2 = Unroll == 2 ? Base * Base : Base * Base * Base * Base;
+    template <typename U>
+    weak_stack_allocator(const weak_stack_allocator<U, StackAllocator> &other) noexcept
+        : m_alloc(other.m_alloc) {}
 
-public:
-    constexpr __char_converter_table_t() : table() {
-        for (uint64_t i = 0, j = 0; i < pw2; ++i, j += Unroll) {
-            int x = i;
-            for (int k = Unroll - 1; ~k; --k) {
-                table[j + k] = Converter::to(x % Base);
-                x /= Base;
-            }
+    WJR_NODISCARD WJR_MALLOC WJR_CONSTEXPR20 T *allocate(size_type n) noexcept {
+        const size_t size = n * sizeof(T);
+        if (WJR_UNLIKELY(size >= __default_threshold)) {
+            return static_cast<T *>(malloc(size));
         }
-    }
 
-    WJR_CONST constexpr char operator[](unsigned int idx) const noexcept {
-        return table[idx];
+        return static_cast<T *>(m_alloc->__small_allocate(size));
     }
 
-    WJR_CONST constexpr const char *data() const noexcept { return table.data(); }
+    WJR_CONSTEXPR20 void deallocate(WJR_MAYBE_UNUSED T *ptr,
+                                    WJR_MAYBE_UNUSED size_type n) noexcept {
+        const size_t size = n * sizeof(T);
+        if (WJR_UNLIKELY(size >= __default_threshold)) {
+            free(ptr);
+        }
+    }
 
 private:
-    std::array<char, pw2 * Unroll> table;
+    UniqueStackAllocator *m_alloc = nullptr;
 };
 
-template <typename Converter, uint64_t Base, int Unroll>
-inline constexpr __char_converter_table_t<Converter, Base, Unroll>
-    __char_converter_table{};
+} // namespace wjr
 
-template <uint64_t Base>
-class __to_chars_unroll_2_fast_fn_impl_base {
-public:
-    template <typename Converter>
-    WJR_INTRINSIC_INLINE static void __fast_conv(void *ptr, uint32_t val,
-                                                 Converter) noexcept {
-        auto str = (char *)ptr;
-        if constexpr (Base * Base <= 16) {
-            constexpr auto &table = __char_converter_table<Converter, Base, 4>;
-            std::memcpy(str, table.data() + val * 4 + 2, 2);
-        } else {
-            constexpr auto &table = __char_converter_table<Converter, Base, 2>;
-            std::memcpy(str, table.data() + val * 2, 2);
-        }
-    }
-};
+#endif // WJR_STACK_ALLOCATOR_HPP__
 
-template <uint64_t Base>
-class __to_chars_unroll_2_fast_fn_impl {};
+namespace wjr::math_details {
 
-template <>
-class __to_chars_unroll_2_fast_fn_impl<2>
-    : public __to_chars_unroll_2_fast_fn_impl_base<2> {};
+using stack_alloc_object = singleton_stack_allocator_object<36 * 1024, 16 * 1024>;
+inline constexpr stack_alloc_object stack_alloc = {};
 
-template <>
-class __to_chars_unroll_2_fast_fn_impl<8>
-    : public __to_chars_unroll_2_fast_fn_impl_base<8> {};
+using unique_stack_alloc = unique_stack_allocator<stack_alloc_object>;
 
-template <>
-class __to_chars_unroll_2_fast_fn_impl<10>
-    : public __to_chars_unroll_2_fast_fn_impl_base<10> {};
+template <typename T>
+using weak_stack_alloc = weak_stack_allocator<T, stack_alloc_object>;
 
-template <>
-class __to_chars_unroll_2_fast_fn_impl<16>
-    : public __to_chars_unroll_2_fast_fn_impl_base<16> {};
+} // namespace wjr::math_details
 
-template <uint64_t Base>
-class __to_chars_unroll_4_fast_fn_impl_base {
-public:
-    template <typename Converter>
-    WJR_INTRINSIC_INLINE static void __fast_conv(void *ptr, uint32_t val,
-                                                 Converter) noexcept {
-        auto str = (char *)ptr;
-        if constexpr (Base * Base <= 16) {
-            constexpr auto &table = __char_converter_table<Converter, Base, 4>;
-            std::memcpy(str, table.data() + val * 4, 4);
-        } else {
-            constexpr auto &table = __char_converter_table<Converter, Base, 2>;
-            constexpr auto Base2 = Base * Base;
-            const uint32_t hi = val / Base2;
-            const uint32_t lo = val % Base2;
+#endif // WJR_MATH_STACK_ALLOCATOR_HPP__
 
-            std::memcpy(str, table.data() + hi * 2, 2);
-            std::memcpy(str + 2, table.data() + lo * 2, 2);
-        }
-    }
-};
+#if defined(WJR_X86)
+#ifndef WJR_X86_MATH_CONVERT_HPP__
+#define WJR_X86_MATH_CONVERT_HPP__
 
-template <uint64_t Base>
-class __to_chars_unroll_4_fast_fn_impl {};
+// Already included
+// Already included
 
-template <>
-class __to_chars_unroll_4_fast_fn_impl<2>
-    : public __to_chars_unroll_4_fast_fn_impl_base<2> {};
+#ifndef WJR_X86
+#error "x86 required"
+#endif
 
-template <>
-class __to_chars_unroll_4_fast_fn_impl<8>
-    : public __to_chars_unroll_4_fast_fn_impl_base<8> {};
+namespace wjr {
 
-template <>
-class __to_chars_unroll_4_fast_fn_impl<10>
-    : public __to_chars_unroll_4_fast_fn_impl_base<10> {};
+#if WJR_HAS_SIMD(SSE4_1) && WJR_HAS_SIMD(X86_SIMD)
+#define WJR_HAS_BUILTIN_TO_CHARS_UNROLL_8_FAST WJR_HAS_DEF
 
-template <>
-class __to_chars_unroll_4_fast_fn_impl<16>
-    : public __to_chars_unroll_4_fast_fn_impl_base<16> {};
+#define WJR_HAS_BUILTIN_FROM_CHARS_UNROLL_8_FAST WJR_HAS_DEF
+#define WJR_HAS_BUILTIN_FROM_CHARS_UNROLL_16_FAST WJR_HAS_DEF
+#endif
 
-template <uint64_t Base>
-class __to_chars_unroll_8_fast_fn_impl_base {
 #if WJR_HAS_BUILTIN(TO_CHARS_UNROLL_8_FAST)
-public:
-    template <typename Converter>
-    WJR_INTRINSIC_INLINE static void __fast_conv(void *ptr, uint64_t val,
-                                                 Converter conv) noexcept {
-        builtin_to_chars_unroll_8_fast<Base>(ptr, val, conv);
-    }
-#endif
-};
 
-template <uint64_t Base>
-class __to_chars_unroll_8_fast_fn_impl {};
+namespace to_chars_details {
 
-template <>
-class __to_chars_unroll_8_fast_fn_impl<10>
-    : public __to_chars_unroll_8_fast_fn_impl_base<10> {};
+const static __m128i mul10p4 = simd_cast<uint32_t, __m128i_t>(3518437209);
+const static __m128i mul10p4x = simd_cast<uint32_t, __m128i_t>(10000);
+const static __m128i mul10p2 = sse::set1_epi16(5243);
+const static __m128i mul10p2x = sse::set1_epi16(100);
+const static __m128i mul10p1 = sse::set1_epi16((short)52429u);
+const static __m128i mul10p1x = sse::set1_epi16(10);
 
-template <uint64_t Base>
-class __to_chars_unroll_2_fn : public __to_chars_unroll_2_fast_fn_impl<Base> {
-    using Mybase = __to_chars_unroll_2_fast_fn_impl<Base>;
+const static __m128i shuf =
+    sse::setr_epi8(0, 8, 4, 12, 2, 10, 6, 14, 1, 1, 1, 1, 1, 1, 1, 1);
 
-public:
-    template <typename Converter>
-    WJR_INTRINSIC_INLINE void operator()(uint8_t *ptr, uint32_t val,
-                                         Converter conv) const noexcept {
-        if constexpr (convert_details::has_to_chars_fast_fn_fast_conv_v<Mybase, uint32_t,
-                                                                        Converter>) {
-            Mybase::__fast_conv(ptr, val, conv);
-        } else {
-            ptr[0] = conv.template to<Base>(val / Base);
-            ptr[1] = conv.template to<Base>(val % Base);
-        }
-    }
-};
+} // namespace to_chars_details
 
-template <uint64_t Base>
-inline constexpr __to_chars_unroll_2_fn<Base> __to_chars_unroll_2{};
+#endif
 
-template <uint64_t Base>
-class __to_chars_unroll_4_fn_impl : public __to_chars_unroll_4_fast_fn_impl<Base> {
-    using Mybase = __to_chars_unroll_4_fast_fn_impl<Base>;
+#if WJR_HAS_BUILTIN(TO_CHARS_UNROLL_8_FAST)
 
-public:
-    template <typename Converter>
-    WJR_INTRINSIC_INLINE void operator()(uint8_t *ptr, uint32_t val,
-                                         Converter conv) const noexcept {
-        if constexpr (convert_details::has_to_chars_fast_fn_fast_conv_v<Mybase, uint32_t,
-                                                                        Converter>) {
-            Mybase::__fast_conv(ptr, val, conv);
-        } else {
-            constexpr auto Base2 = Base * Base;
-            __to_chars_unroll_2<Base>(ptr, val / Base2, conv);
-            __to_chars_unroll_2<Base>(ptr + 2, val % Base2, conv);
-        }
-    }
-};
+inline uint64_t builtin_to_chars_unroll_8_fast_10(uint32_t in) noexcept {
 
-template <uint64_t Base>
-inline constexpr __to_chars_unroll_4_fn_impl<Base> __to_chars_unroll_4{};
+    __m128i x = simd_cast<uint32_t, __m128i_t>(in);
+    __m128i q, r;
 
-template <uint64_t Base>
-class __to_chars_unroll_8_fn_impl : public __to_chars_unroll_8_fast_fn_impl<Base> {
-    using Mybase = __to_chars_unroll_8_fast_fn_impl<Base>;
+    q = _mm_mul_epu32(x, to_chars_details::mul10p4);
+    q = _mm_srli_epi64(q, 45);
 
-public:
-    template <typename Converter>
-    WJR_INTRINSIC_INLINE void operator()(uint8_t *ptr, uint64_t val,
-                                         Converter conv) const noexcept {
-        if constexpr (convert_details::has_to_chars_fast_fn_fast_conv_v<Mybase, uint64_t,
-                                                                        Converter>) {
-            Mybase::__fast_conv(ptr, val, conv);
-        } else {
-            constexpr auto Base4 = Base * Base * Base * Base;
-            __to_chars_unroll_4<Base>(ptr, val / Base4, conv);
-            __to_chars_unroll_4<Base>(ptr + 4, val % Base4, conv);
-        }
-    }
-};
+    r = _mm_sub_epi32(x, _mm_mul_epu32(q, to_chars_details::mul10p4x));
+    x = _mm_packus_epi32(q, r);
 
-template <uint64_t Base>
-inline constexpr __to_chars_unroll_8_fn_impl<Base> __to_chars_unroll_8{};
+    q = _mm_mulhi_epu16(x, to_chars_details::mul10p2);
+    q = _mm_srli_epi16(q, 3);
 
-template <uint64_t Base>
-class __from_chars_unroll_4_fast_fn_impl_base {
-protected:
-    WJR_CONST WJR_INTRINSIC_INLINE static uint32_t __fast_conv(uint32_t val) noexcept {
-        return digits_literal_details::__fast_conv_4<Base>(val);
-    }
+    r = _mm_sub_epi16(x, _mm_mullo_epi16(q, to_chars_details::mul10p2x));
+    x = _mm_packus_epi16(q, r);
 
-public:
-    WJR_PURE WJR_INTRINSIC_INLINE static uint32_t __fast_conv(const void *ptr,
-                                                              char_converter_t) noexcept {
-        return __fast_conv(read_memory<uint32_t>(ptr) - 0x30303030u);
-    }
+    q = _mm_mulhi_epu16(x, to_chars_details::mul10p1);
+    q = _mm_srli_epi16(q, 3);
 
-    WJR_PURE WJR_INTRINSIC_INLINE static uint32_t
-    __fast_conv(const void *ptr, origin_converter_t) noexcept {
-        return __fast_conv(read_memory<uint32_t>(ptr));
-    }
-};
+    r = _mm_sub_epi16(x, _mm_mullo_epi16(q, to_chars_details::mul10p1x));
+    x = _mm_packus_epi16(q, r);
 
-template <uint64_t Base>
-class __from_chars_unroll_8_fast_fn_impl_base {
-protected:
-    WJR_CONST WJR_INTRINSIC_INLINE static uint32_t __fast_conv(uint64_t val) noexcept {
-        return digits_literal_details::__fast_conv_8<Base>(val);
-    }
+    return simd_cast<__m128i_t, uint64_t>(sse::shuffle_epi8(x, to_chars_details::shuf));
+}
 
-public:
-    WJR_PURE WJR_INTRINSIC_INLINE static uint32_t
-    __fast_conv(const void *ptr, WJR_MAYBE_UNUSED char_converter_t conv) noexcept {
-#if WJR_HAS_BUILTIN(FROM_CHARS_UNROLL_8_FAST)
-        return builtin_from_chars_unroll_8_fast<Base>(ptr, conv);
-#else
-        return __fast_conv(read_memory<uint64_t>(ptr) - 0x3030303030303030ull);
-#endif
+template <uint64_t Base>
+uint64_t builtin_to_chars_unroll_8_fast(uint32_t in) noexcept {
+    if constexpr (Base == 10) {
+        return builtin_to_chars_unroll_8_fast_10(in);
+    } else {
+        static_assert(Base == 10, "");
     }
+}
 
-    WJR_PURE WJR_INTRINSIC_INLINE static uint32_t
-    __fast_conv(const void *ptr, WJR_MAYBE_UNUSED origin_converter_t conv) noexcept {
-#if WJR_HAS_BUILTIN(FROM_CHARS_UNROLL_8_FAST)
-        return builtin_from_chars_unroll_8_fast<Base>(ptr, conv);
-#else
-        return __fast_conv(read_memory<uint64_t>(ptr));
-#endif
-    }
-};
+template <uint64_t Base>
+void builtin_to_chars_unroll_8_fast(void *ptr, uint32_t in, char_converter_t) noexcept {
+    const uint64_t x = builtin_to_chars_unroll_8_fast<Base>(in) + 0x3030303030303030ull;
+    write_memory<uint64_t>(ptr, x);
+}
 
 template <uint64_t Base>
-class __from_chars_unroll_16_fast_fn_impl_base {
-#if WJR_HAS_BUILTIN(FROM_CHARS_UNROLL_16_FAST)
-public:
-    template <typename Converter>
-    WJR_PURE WJR_INTRINSIC_INLINE static uint64_t __fast_conv(const void *ptr,
-                                                              Converter conv) noexcept {
-        return builtin_from_chars_unroll_16_fast<Base>(ptr, conv);
-    }
+void builtin_to_chars_unroll_8_fast(void *ptr, uint32_t in, origin_converter_t) noexcept {
+    const uint64_t x = builtin_to_chars_unroll_8_fast<Base>(in);
+    write_memory<uint64_t>(ptr, x);
+}
+
 #endif
-};
 
-template <uint64_t Base>
-class __from_chars_unroll_4_fast_fn_impl {};
+#if WJR_HAS_BUILTIN(FROM_CHARS_UNROLL_8_FAST) ||                                         \
+    WJR_HAS_BUILTIN(FROM_CHARS_UNROLL_16_FAST)
 
-template <>
-class __from_chars_unroll_4_fast_fn_impl<2>
-    : public __from_chars_unroll_4_fast_fn_impl_base<2> {};
+namespace from_chars_details {
 
-template <>
-class __from_chars_unroll_4_fast_fn_impl<8>
-    : public __from_chars_unroll_4_fast_fn_impl_base<8> {};
+/// @private
+template <uint64_t Base>
+inline constexpr uint64_t __base2 = Base * Base;
 
-template <>
-class __from_chars_unroll_4_fast_fn_impl<10>
-    : public __from_chars_unroll_4_fast_fn_impl_base<10> {};
+/// @private
+template <uint64_t Base>
+inline constexpr uint64_t __base4 = __base2<Base> * __base2<Base>;
 
+/// @private
 template <uint64_t Base>
-class __from_chars_unroll_8_fast_fn_impl {};
+inline constexpr uint64_t __base8 = __base4<Base> * __base4<Base>;
 
-template <>
-class __from_chars_unroll_8_fast_fn_impl<2>
-    : public __from_chars_unroll_8_fast_fn_impl_base<2> {};
+/// @private
+template <uint64_t Base>
+const static __m128i mulp1x = sse::setr_epi8(Base, 1, Base, 1, Base, 1, Base, 1, Base, 1,
+                                             Base, 1, Base, 1, Base, 1);
 
-template <>
-class __from_chars_unroll_8_fast_fn_impl<8>
-    : public __from_chars_unroll_8_fast_fn_impl_base<8> {};
+/// @private
+template <uint64_t Base>
+const static __m128i mulp2x = sse::setr_epi16(__base2<Base>, 1, __base2<Base>, 1,
+                                              __base2<Base>, 1, __base2<Base>, 1);
 
-template <>
-class __from_chars_unroll_8_fast_fn_impl<10>
-    : public __from_chars_unroll_8_fast_fn_impl_base<10> {};
+/// @private
+template <uint64_t Base>
+const static __m128i mulp4x = sse::setr_epi16(__base4<Base>, 1, __base4<Base>, 1,
+                                              __base4<Base>, 1, __base4<Base>, 1);
 
+/// @private
 template <uint64_t Base>
-class __from_chars_unroll_16_fast_fn_impl {};
+const static __m128i baseu8 =
+    sse::setr_epi8(Base, Base, Base, Base, Base, Base, Base, 0xff, 0xff, 0xff, 0xff, 0xff,
+                   0xff, 0xff, 0xff, 0xff);
 
-template <>
-class __from_chars_unroll_16_fast_fn_impl<2>
-    : public __from_chars_unroll_16_fast_fn_impl_base<2> {};
+/// @private
+static __m128i ascii = sse::set1_epi8(0x30);
 
-template <>
-class __from_chars_unroll_16_fast_fn_impl<8>
-    : public __from_chars_unroll_16_fast_fn_impl_base<8> {};
+} // namespace from_chars_details
 
-template <>
-class __from_chars_unroll_16_fast_fn_impl<10>
-    : public __from_chars_unroll_16_fast_fn_impl_base<10> {};
+#endif
+
+#if WJR_HAS_BUILTIN(FROM_CHARS_UNROLL_8_FAST)
 
 template <uint64_t Base>
-class __from_chars_unroll_4_fn : public __from_chars_unroll_4_fast_fn_impl<Base> {
-    using Mybase = __from_chars_unroll_4_fast_fn_impl<Base>;
+uint32_t builtin_from_chars_unroll_8_fast(__m128i in) noexcept {
+    const __m128i t1 = _mm_maddubs_epi16(in, from_chars_details::mulp1x<Base>);
+    const __m128i t2 = _mm_madd_epi16(t1, from_chars_details::mulp2x<Base>);
+    const __m128i t3 = _mm_packus_epi32(t2, t2);
+    const __m128i t4 = _mm_madd_epi16(t3, from_chars_details::mulp4x<Base>);
 
-public:
-    template <typename Converter>
-    WJR_PURE WJR_INTRINSIC_INLINE uint64_t operator()(const uint8_t *ptr,
-                                                      Converter conv) const noexcept {
-        if constexpr (convert_details::has_from_chars_fast_fn_fast_conv_v<Mybase,
-                                                                          Converter>) {
-            return Mybase::__fast_conv(ptr, conv);
-        } else {
-            uint64_t value = 0;
-            value = conv.template from<Base>(*ptr++);
-            value = value * Base + conv.template from<Base>(*ptr++);
-            value = value * Base + conv.template from<Base>(*ptr++);
-            return value * Base + conv.template from<Base>(*ptr++);
-        }
-    }
-};
+    return simd_cast<__m128i_t, uint32_t>(t4);
+}
 
 template <uint64_t Base>
-inline constexpr __from_chars_unroll_4_fn<Base> __from_chars_unroll_4{};
+uint32_t builtin_from_chars_unroll_8_fast(const void *ptr, char_converter_t) noexcept {
+    static_assert(Base <= 10, "");
+    const __m128i in = _mm_sub_epi8(sse::loadu_si64(ptr), from_chars_details::ascii);
+    return builtin_from_chars_unroll_8_fast<Base>(in);
+}
 
 template <uint64_t Base>
-class __from_chars_unroll_8_fn : public __from_chars_unroll_8_fast_fn_impl<Base> {
-    using Mybase = __from_chars_unroll_8_fast_fn_impl<Base>;
+uint32_t builtin_from_chars_unroll_8_fast(const void *ptr, origin_converter_t) noexcept {
+    static_assert(Base <= 10, "");
+    const __m128i in = sse::loadu_si64(ptr);
+    return builtin_from_chars_unroll_8_fast<Base>(in);
+}
 
-public:
-    template <typename Converter>
-    WJR_PURE WJR_INTRINSIC_INLINE uint64_t operator()(const uint8_t *ptr,
-                                                      Converter conv) const noexcept {
-        if constexpr (convert_details::has_from_chars_fast_fn_fast_conv_v<Mybase,
-                                                                          Converter>) {
-            return Mybase::__fast_conv(ptr, conv);
-        } else {
-            constexpr uint64_t Base4 = Base * Base * Base * Base;
-            return __from_chars_unroll_4<Base>(ptr, conv) * Base4 +
-                   __from_chars_unroll_4<Base>(ptr + 4, conv);
-        }
-    }
-};
+#endif
 
-template <uint64_t Base>
-inline constexpr __from_chars_unroll_8_fn<Base> __from_chars_unroll_8{};
+#if WJR_HAS_BUILTIN(FROM_CHARS_UNROLL_16_FAST)
 
 template <uint64_t Base>
-class __from_chars_unroll_16_fn : public __from_chars_unroll_16_fast_fn_impl<Base> {
-    using Mybase = __from_chars_unroll_16_fast_fn_impl<Base>;
+uint64_t builtin_from_chars_unroll_16_fast(__m128i in) noexcept {
+    const __m128i t1 = _mm_maddubs_epi16(in, from_chars_details::mulp1x<Base>);
+    const __m128i t2 = _mm_madd_epi16(t1, from_chars_details::mulp2x<Base>);
+    const __m128i t3 = _mm_packus_epi32(t2, t2);
+    const __m128i t4 = _mm_madd_epi16(t3, from_chars_details::mulp4x<Base>);
 
-public:
-    template <typename Converter>
-    WJR_PURE WJR_INTRINSIC_INLINE uint64_t operator()(const uint8_t *ptr,
-                                                      Converter conv) const noexcept {
-        if constexpr (convert_details::has_from_chars_fast_fn_fast_conv_v<Mybase,
-                                                                          Converter>) {
-            return Mybase::__fast_conv(ptr, conv);
-        } else {
-            constexpr uint64_t Base4 = Base * Base * Base * Base;
-            constexpr uint64_t Base8 = Base4 * Base4;
-            return __from_chars_unroll_8<Base>(ptr, conv) * Base8 +
-                   __from_chars_unroll_8<Base>(ptr + 8, conv);
-        }
-    }
-};
+    const uint64_t val = simd_cast<__m128i_t, uint64_t>(t4);
+    const uint32_t lo = val;
+    const uint32_t hi = val >> 32;
 
-template <uint64_t Base>
-inline constexpr __from_chars_unroll_16_fn<Base> __from_chars_unroll_16{};
+    return lo * from_chars_details::__base8<Base> + hi;
+}
 
-template <typename UnsignedValue>
-constexpr int fallback_count_digits10(UnsignedValue n) noexcept {
-    int count = 1;
+template <uint64_t Base>
+uint64_t builtin_from_chars_unroll_16_fast(const void *ptr, char_converter_t) noexcept {
+    static_assert(Base <= 10, "");
+    const __m128i in =
+        _mm_sub_epi8(sse::loadu((__m128i *)(ptr)), from_chars_details::ascii);
+    return builtin_from_chars_unroll_16_fast<Base>(in);
+}
 
-    if (WJR_UNLIKELY(n >= 1000)) {
-        do {
-            n /= 10000;
-            count += 4;
-        } while (n >= 1000);
+template <uint64_t Base>
+uint64_t builtin_from_chars_unroll_16_fast(const void *ptr, origin_converter_t) noexcept {
+    static_assert(Base <= 10, "");
+    const __m128i in = sse::loadu((__m128i *)(ptr));
+    return builtin_from_chars_unroll_16_fast<Base>(in);
+}
 
-        if (n == 0) {
-            return count;
-        }
-    }
+#endif
 
-    if (n < 10) {
-        return count;
-    }
+} // namespace wjr
 
-    if (n < 100) {
-        return count + 1;
-    }
+#endif // WJR_X86_MATH_CONVERT_HPP__
+#endif
 
-    return count + 3;
-}
+namespace wjr {
 
-inline int builtin_count_digits10_u32(uint32_t n) noexcept {
-#define WJR_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
-    static constexpr uint64_t table[] = {
-        WJR_INC(0),          WJR_INC(0),          WJR_INC(0),          // 8
-        WJR_INC(10),         WJR_INC(10),         WJR_INC(10),         // 64
-        WJR_INC(100),        WJR_INC(100),        WJR_INC(100),        // 512
-        WJR_INC(1000),       WJR_INC(1000),       WJR_INC(1000),       // 4096
-        WJR_INC(10000),      WJR_INC(10000),      WJR_INC(10000),      // 32k
-        WJR_INC(100000),     WJR_INC(100000),     WJR_INC(100000),     // 256k
-        WJR_INC(1000000),    WJR_INC(1000000),    WJR_INC(1000000),    // 2048k
-        WJR_INC(10000000),   WJR_INC(10000000),   WJR_INC(10000000),   // 16M
-        WJR_INC(100000000),  WJR_INC(100000000),  WJR_INC(100000000),  // 128M
-        WJR_INC(1000000000), WJR_INC(1000000000), WJR_INC(1000000000), // 1024M
-        WJR_INC(1000000000), WJR_INC(1000000000)                       // 4B
-    };
-    const auto inc = table[clz(n | 1) ^ 31];
-    return static_cast<int>((n + inc) >> 32);
-#undef WJR_INC
-}
+inline constexpr size_t dc_bignum_to_chars_threshold = WJR_DC_BIGNUM_TO_CHARS_THRESHOLD;
+inline constexpr size_t dc_bignum_to_chars_precompute_threshold =
+    WJR_DC_BIGNUM_TO_CHARS_THRESHOLD;
 
-inline int builtin_count_digits10_u64(uint64_t n) noexcept {
-#define WJR_POWERS_OF_10(factor)                                                         \
-    factor * 10, (factor)*100, (factor)*1000, (factor)*10000, (factor)*100000,           \
-        (factor)*1000000, (factor)*10000000, (factor)*100000000, (factor)*1000000000
-    static constexpr uint8_t bsr2log10[] = {
-        1,  1,  1,  2,  2,  2,  3,  3,  3,  4,  4,  4,  4,  5,  5,  5,
-        6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  9,  9,  9,  10, 10, 10,
-        10, 11, 11, 11, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 15, 15,
-        15, 16, 16, 16, 16, 17, 17, 17, 18, 18, 18, 19, 19, 19, 19, 20};
-    const auto t = bsr2log10[clz(n | 1) ^ 63];
-    static constexpr const uint64_t zero_or_powers_of_10[] = {
-        0, 0, WJR_POWERS_OF_10(1U), WJR_POWERS_OF_10(1000000000ULL),
-        10000000000000000000ULL};
-    return t - (n < zero_or_powers_of_10[t]);
-#undef WJR_POWERS_OF_10
-}
+inline constexpr size_t dc_bignum_from_chars_threshold =
+    WJR_DC_BIGNUM_FROM_CHARS_THRESHOLD;
+inline constexpr size_t dc_bignum_from_chars_precompute_threshold =
+    WJR_DC_BIGNUM_FROM_CHARS_PRECOMPUTE_THRESHOLD;
 
-template <typename T>
-WJR_CONSTEXPR_E int count_digits10_impl(T n) noexcept {
-    if (is_constant_evaluated() || WJR_BUILTIN_CONSTANT_P(n)) {
-        return fallback_count_digits10(n);
-    }
+inline constexpr auto div2by1_divider_noshift_of_big_base_10 =
+    div2by1_divider_noshift<uint64_t>(10'000'000'000'000'000'000ull,
+                                      15'581'492'618'384'294'730ull);
 
-    if constexpr (sizeof(T) <= sizeof(uint32_t)) {
-        return builtin_count_digits10_u32(static_cast<uint32_t>(n));
-    } else {
-        return builtin_count_digits10_u64(static_cast<uint64_t>(n));
-    }
-}
+inline constexpr auto div3by2_divider_shift_of_big_base_10 = div3by2_divider<uint64_t>(
+    1374799102801346560ull, 10842021724855044340ull, 12'938'764'603'223'852'203ull, 1);
 
-template <uint64_t Base>
-struct count_digits_fn {};
+namespace convert_details {
 
-template <uint64_t Base>
-inline constexpr count_digits_fn<Base> count_digits{};
+WJR_CONST constexpr bool __isspace(uint8_t ch) noexcept {
+    return char_converter.from(ch) == 64;
+}
 
-template <>
-struct count_digits_fn<2> {
-    template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-    WJR_CONST WJR_INTRINSIC_CONSTEXPR_E int operator()(T n) const noexcept {
-        return bit_width(n);
-    }
-};
+template <typename T>
+struct __is_fast_convert_value
+    : std::conjunction<std::is_trivial<T>, std::bool_constant<sizeof(T) == 1>> {};
 
-template <>
-struct count_digits_fn<8> {
-    template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-    WJR_CONST WJR_INTRINSIC_CONSTEXPR_E int operator()(T n) const noexcept {
-        return __ceil_div(to_unsigned(bit_width(n)), 3);
-    }
-};
+template <typename T>
+inline constexpr bool __is_fast_convert_value_v = __is_fast_convert_value<T>::value;
 
-template <>
-struct count_digits_fn<16> {
-    template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-    WJR_CONST WJR_INTRINSIC_CONSTEXPR_E int operator()(T n) const noexcept {
-        return __ceil_div(to_unsigned(bit_width(n)), 4);
-    }
-};
+template <typename Iter, typename = void>
+struct __is_fast_convert_iterator_helper : std::false_type {};
 
-template <>
-struct count_digits_fn<1> {
-    template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-    WJR_CONST WJR_INTRINSIC_CONSTEXPR_E int operator()(T n, int bits) const noexcept {
-        return (bit_width(n) + bits - 1) / bits;
-    }
-};
+template <typename Iter>
+struct __is_fast_convert_iterator_helper<Iter,
+                                         std::enable_if_t<is_contiguous_iterator_v<Iter>>>
+    : __is_fast_convert_value<iterator_contiguous_value_t<Iter>> {};
 
-template <>
-struct count_digits_fn<10> {
-    template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-    WJR_CONST WJR_INTRINSIC_CONSTEXPR_E int operator()(T n) const noexcept {
-        const int ret = count_digits10_impl(n);
-        WJR_ASSUME(1 <= ret && ret <= std::numeric_limits<T>::digits10 + 1);
-        return ret;
-    }
-};
+template <typename Iter>
+struct __is_fast_convert_iterator : __is_fast_convert_iterator_helper<Iter> {};
 
+/**
+ * @brief Iterator concept that can be used in fast_convert.
+ *
+ * @details The iterator must be contiguous iterator and the value_type must be
+ * trivial and sizeof(value_type) == 1. Cast to_address(iter) to uint8_t*(to_chars)/const
+ * uint8_t*(from_chars) in fast_convert.
+ *
+ */
 template <typename Iter>
-struct to_chars_result {
-    Iter ptr;
-    std::errc ec;
+inline constexpr bool __is_fast_convert_iterator_v =
+    __is_fast_convert_iterator<Iter>::value;
 
-    friend bool operator==(const to_chars_result &lhs,
-                           const to_chars_result &rhs) noexcept {
-        return lhs.ptr == rhs.ptr && lhs.ec == rhs.ec;
-    }
+template <typename Value, typename Converter>
+struct __is_valid_converter
+    : std::disjunction<std::conjunction<std::is_same<Converter, char_converter_t>,
+                                        is_nonbool_integral<Value>>,
+                       std::conjunction<std::is_same<Converter, origin_converter_t>,
+                                        is_nonbool_unsigned_integral<Value>>> {};
 
-    constexpr explicit operator bool() const noexcept { return ec == std::errc{}; }
-};
+template <typename Value, typename Converter>
+inline constexpr bool __is_valid_converter_v =
+    __is_valid_converter<Value, Converter>::value;
 
-template <typename Iter = const char *>
-struct from_chars_result {
-    Iter ptr;
-    std::errc ec;
+WJR_REGISTER_HAS_TYPE(to_chars_fast_fn_fast_conv,
+                      Base::__fast_conv(std::declval<void *>(), std::declval<Args>()...),
+                      Base);
 
-    friend bool operator==(const from_chars_result &lhs,
-                           const from_chars_result &rhs) noexcept {
-        return lhs.ptr == rhs.ptr && lhs.ec == rhs.ec;
-    }
+WJR_REGISTER_HAS_TYPE(from_chars_fast_fn_fast_conv,
+                      Base::__fast_conv(std::declval<const void *>(),
+                                        std::declval<Args>()...),
+                      Base);
 
-    constexpr explicit operator bool() const noexcept { return ec == std::errc{}; }
+template <typename Iter, typename = void>
+struct fast_buffer {
+private:
+    using value_type = iterator_value_t<Iter>;
+
+public:
+    using type =
+        std::conditional_t<__is_fast_convert_value_v<value_type>, value_type, char>;
 };
 
-// Base :
-// 0 : dynamic base
-// 1 : base is power of two
-template <uint64_t Base>
-class __unsigned_to_chars_backward_unchecked_fn {};
+// back_inserter or inserter
+template <typename Iter>
+struct fast_buffer<Iter, std::void_t<decltype(std::declval<std::enable_if_t<
+                                                  is_any_insert_iterator_v<Iter>>>())>> {
+private:
+    using value_type = typename Iter::container_type::value_type;
 
-template <uint64_t Base>
-inline constexpr __unsigned_to_chars_backward_unchecked_fn<Base>
-    __unsigned_to_chars_backward_unchecked{};
+public:
+    using type =
+        std::conditional_t<__is_fast_convert_value_v<value_type>, value_type, char>;
+};
 
-template <>
-class __unsigned_to_chars_backward_unchecked_fn<2> {
-    template <typename UnsignedValue, typename Converter>
-    static uint8_t *fn(uint8_t *ptr, int n, UnsignedValue x, Converter conv) noexcept {
-        constexpr auto nd = std::numeric_limits<UnsignedValue>::digits;
-        WJR_ASSERT_L2(x != 0);
-        WJR_ASSERT_ASSUME(1 <= n && n <= nd);
-        (void)(nd);
+template <typename Iter>
+using fast_buffer_t = typename fast_buffer<Iter>::type;
 
-        if (WJR_UNLIKELY(n >= 4)) {
-            do {
-                __to_chars_unroll_4<2>(ptr - 4, x & 0x0f, conv);
-                ptr -= 4;
-                x >>= 4;
-                n -= 4;
-            } while (WJR_LIKELY(n >= 4));
+template <typename Container>
+struct __fast_container_inserter_test {
+private:
+    using traits_type = container_traits<Container>;
 
-            if (n == 0) {
-                return ptr;
-            }
-        }
+public:
+    static constexpr int value =
+        traits_type::is_trivially_contiguous_v &&
+                has_container_resize_v<Container, size_t>
+            ? (has_container_resize_v<Container, size_t, dctor_t> ? 2 : 1)
+            : 0;
 
-        switch (n) {
-        case 3: {
-            *--ptr = conv.template to<2>(x & 1);
-            x >>= 1;
-            WJR_FALLTHROUGH;
-        }
-        case 2: {
-            __to_chars_unroll_2<2>(ptr - 2, x, conv);
-            ptr -= 2;
-            break;
-        }
-        case 1: {
-            *--ptr = conv.template to<2>(x);
-            break;
-        }
-        default: {
-            WJR_UNREACHABLE();
-            break;
-        }
-        }
+    static_assert(value != 2 || has_container_append_v<Container, size_t, dctor_t>, "");
+};
 
-        return ptr;
-    }
+template <typename Iter, typename = void>
+struct __is_fast_container_inserter {
+    static constexpr int value = 0;
+};
+
+template <typename Iter>
+struct __is_fast_container_inserter<
+    Iter,
+    std::void_t<
+        decltype(std::declval<std::enable_if_t<is_any_insert_iterator_v<Iter>>>(),
+                 __fast_container_inserter_test<typename Iter::container_type>::value)>> {
+private:
+    using container_type = typename Iter::container_type;
 
 public:
-    template <typename UnsignedValue, typename Converter,
-              WJR_REQUIRES(is_nonbool_unsigned_integral_v<UnsignedValue>)>
-    uint8_t *operator()(uint8_t *ptr, int n, UnsignedValue x,
-                        Converter conv) const noexcept {
-        return fn(ptr, n, x, conv);
-    }
+    static constexpr int value =
+        __is_fast_convert_value_v<typename container_type::value_type> &&
+                is_trivially_allocator_constructible_v<
+                    typename container_type::allocator_type>
+            ? __fast_container_inserter_test<container_type>::value
+            : 0;
 };
 
-template <>
-class __unsigned_to_chars_backward_unchecked_fn<8> {
-    template <typename UnsignedValue, typename Converter>
-    static uint8_t *fn(uint8_t *ptr, int n, UnsignedValue x, Converter conv) noexcept {
-        constexpr auto nd = std::numeric_limits<UnsignedValue>::digits;
-        WJR_ASSERT_L2(x != 0);
-        WJR_ASSERT_ASSUME(1 <= n && n <= (nd + 2) / 3);
+template <typename Iter>
+inline constexpr int is_fast_container_inserter_v =
+    __is_fast_container_inserter<Iter>::value;
 
-        if constexpr (nd >= 16) {
-            if (WJR_UNLIKELY(n >= 4)) {
-                do {
-                    __to_chars_unroll_4<8>(ptr - 4, x & 0x0fff, conv);
-                    ptr -= 4;
-                    x >>= 12;
-                    n -= 4;
-                } while (WJR_LIKELY(n >= 4));
+} // namespace convert_details
 
-                if (n == 0) {
-                    return ptr;
-                }
-            }
-        }
+// require operator() of Converter is constexpr
+template <typename Converter, uint64_t Base, int Unroll>
+class __char_converter_table_t {
+    static constexpr uint64_t pw2 = Unroll == 2 ? Base * Base : Base * Base * Base * Base;
 
-        switch (n) {
-        case 3: {
-            *--ptr = conv.template to<8>(x & 0x07);
-            x >>= 3;
-            WJR_FALLTHROUGH;
-        }
-        case 2: {
-            __to_chars_unroll_2<8>(ptr - 2, x, conv);
-            ptr -= 2;
-            break;
-        }
-        case 1: {
-            *--ptr = conv.template to<8>(x);
-            break;
-        }
-        default: {
-            WJR_UNREACHABLE();
-            break;
-        }
+public:
+    constexpr __char_converter_table_t() : table() {
+        for (uint64_t i = 0, j = 0; i < pw2; ++i, j += Unroll) {
+            int x = i;
+            for (int k = Unroll - 1; ~k; --k) {
+                table[j + k] = Converter::to(x % Base);
+                x /= Base;
+            }
         }
+    }
 
-        return ptr;
+    WJR_CONST constexpr char operator[](unsigned int idx) const noexcept {
+        return table[idx];
     }
 
+    WJR_CONST constexpr const char *data() const noexcept { return table.data(); }
+
+private:
+    std::array<char, pw2 * Unroll> table;
+};
+
+template <typename Converter, uint64_t Base, int Unroll>
+inline constexpr __char_converter_table_t<Converter, Base, Unroll>
+    __char_converter_table{};
+
+template <uint64_t Base>
+class __to_chars_unroll_2_fast_fn_impl_base {
 public:
-    template <typename UnsignedValue, typename Converter,
-              WJR_REQUIRES(is_nonbool_unsigned_integral_v<UnsignedValue>)>
-    uint8_t *operator()(uint8_t *ptr, int n, UnsignedValue x,
-                        Converter conv) const noexcept {
-        return fn(ptr, n, x, conv);
+    template <typename Converter>
+    WJR_INTRINSIC_INLINE static void __fast_conv(void *ptr, uint32_t val,
+                                                 Converter) noexcept {
+        auto str = (char *)ptr;
+        if constexpr (Base * Base <= 16) {
+            constexpr auto &table = __char_converter_table<Converter, Base, 4>;
+            std::memcpy(str, table.data() + val * 4 + 2, 2);
+        } else {
+            constexpr auto &table = __char_converter_table<Converter, Base, 2>;
+            std::memcpy(str, table.data() + val * 2, 2);
+        }
     }
 };
 
+template <uint64_t Base>
+class __to_chars_unroll_2_fast_fn_impl {};
+
 template <>
-class __unsigned_to_chars_backward_unchecked_fn<16> {
-    template <typename UnsignedValue, typename Converter>
-    static uint8_t *fn(uint8_t *ptr, int n, UnsignedValue x, Converter conv) noexcept {
-        constexpr auto nd = std::numeric_limits<UnsignedValue>::digits;
-        WJR_ASSERT_L2(x != 0);
-        WJR_ASSERT_ASSUME(1 <= n && n <= (nd + 3) / 4);
+class __to_chars_unroll_2_fast_fn_impl<2>
+    : public __to_chars_unroll_2_fast_fn_impl_base<2> {};
 
-        if constexpr (nd >= 16) {
-            if (WJR_UNLIKELY(n >= 4)) {
-                do {
-                    __to_chars_unroll_4<16>(ptr - 4, x & 0xffff, conv);
-                    ptr -= 4;
-                    x >>= 16;
-                    n -= 4;
-                } while (WJR_LIKELY(n >= 4));
+template <>
+class __to_chars_unroll_2_fast_fn_impl<8>
+    : public __to_chars_unroll_2_fast_fn_impl_base<8> {};
 
-                if (n == 0) {
-                    return ptr;
-                }
-            }
-        }
+template <>
+class __to_chars_unroll_2_fast_fn_impl<10>
+    : public __to_chars_unroll_2_fast_fn_impl_base<10> {};
 
-        switch (n) {
-        case 3: {
-            *--ptr = conv.to(x & 0x0f);
-            x >>= 4;
-            WJR_FALLTHROUGH;
-        }
-        case 2: {
-            __to_chars_unroll_2<16>(ptr - 2, x, conv);
-            ptr -= 2;
-            break;
-        }
-        case 1: {
-            *--ptr = conv.to(x);
-            break;
-        }
-        default: {
-            WJR_UNREACHABLE();
-            break;
-        }
-        }
-
-        return ptr;
-    }
+template <>
+class __to_chars_unroll_2_fast_fn_impl<16>
+    : public __to_chars_unroll_2_fast_fn_impl_base<16> {};
 
+template <uint64_t Base>
+class __to_chars_unroll_4_fast_fn_impl_base {
 public:
-    template <typename UnsignedValue, typename Converter,
-              WJR_REQUIRES(is_nonbool_unsigned_integral_v<UnsignedValue>)>
-    uint8_t *operator()(uint8_t *ptr, int n, UnsignedValue x,
-                        Converter conv) const noexcept {
-        return fn(ptr, n, x, conv);
+    template <typename Converter>
+    WJR_INTRINSIC_INLINE static void __fast_conv(void *ptr, uint32_t val,
+                                                 Converter) noexcept {
+        auto str = (char *)ptr;
+        if constexpr (Base * Base <= 16) {
+            constexpr auto &table = __char_converter_table<Converter, Base, 4>;
+            std::memcpy(str, table.data() + val * 4, 4);
+        } else {
+            constexpr auto &table = __char_converter_table<Converter, Base, 2>;
+            constexpr auto Base2 = Base * Base;
+            const uint32_t hi = val / Base2;
+            const uint32_t lo = val % Base2;
+
+            std::memcpy(str, table.data() + hi * 2, 2);
+            std::memcpy(str + 2, table.data() + lo * 2, 2);
+        }
     }
 };
 
+template <uint64_t Base>
+class __to_chars_unroll_4_fast_fn_impl {};
+
 template <>
-class __unsigned_to_chars_backward_unchecked_fn<1> {
-private:
-    template <typename UnsignedValue, typename Converter>
-    static uint8_t *fn(uint8_t *ptr, int n, UnsignedValue x, int bits,
-                       Converter conv) noexcept {
-        WJR_ASSERT_L2(x != 0);
-        WJR_ASSERT_ASSUME(1 <= n && n <= std::numeric_limits<UnsignedValue>::digits);
+class __to_chars_unroll_4_fast_fn_impl<2>
+    : public __to_chars_unroll_4_fast_fn_impl_base<2> {};
 
-        const unsigned int mask = (1u << bits) - 1;
+template <>
+class __to_chars_unroll_4_fast_fn_impl<8>
+    : public __to_chars_unroll_4_fast_fn_impl_base<8> {};
 
-        do {
-            *--ptr = conv.to(x & mask);
-            x >>= bits;
-            --n;
-        } while (WJR_LIKELY(n != 0));
+template <>
+class __to_chars_unroll_4_fast_fn_impl<10>
+    : public __to_chars_unroll_4_fast_fn_impl_base<10> {};
 
-        return ptr;
-    }
+template <>
+class __to_chars_unroll_4_fast_fn_impl<16>
+    : public __to_chars_unroll_4_fast_fn_impl_base<16> {};
 
+template <uint64_t Base>
+class __to_chars_unroll_8_fast_fn_impl_base {
+#if WJR_HAS_BUILTIN(TO_CHARS_UNROLL_8_FAST)
 public:
-    template <typename UnsignedValue, typename Converter,
-              WJR_REQUIRES(is_nonbool_unsigned_integral_v<UnsignedValue>)>
-    uint8_t *operator()(uint8_t *ptr, int n, UnsignedValue x, int bits,
-                        Converter conv) const noexcept {
-        return fn(ptr, n, x, bits, conv);
+    template <typename Converter>
+    WJR_INTRINSIC_INLINE static void __fast_conv(void *ptr, uint64_t val,
+                                                 Converter conv) noexcept {
+        builtin_to_chars_unroll_8_fast<Base>(ptr, val, conv);
     }
+#endif
 };
 
+template <uint64_t Base>
+class __to_chars_unroll_8_fast_fn_impl {};
+
 template <>
-class __unsigned_to_chars_backward_unchecked_fn<10> {
-private:
-    template <typename UnsignedValue, typename Converter,
-              WJR_REQUIRES(is_nonbool_unsigned_integral_v<UnsignedValue>)>
-    static uint8_t *fn(uint8_t *ptr, UnsignedValue val, Converter conv) noexcept {
-        WJR_ASSERT_ASSUME(val != 0);
+class __to_chars_unroll_8_fast_fn_impl<10>
+    : public __to_chars_unroll_8_fast_fn_impl_base<10> {};
 
-        if (WJR_LIKELY(val >= 100)) {
-            do {
-                __to_chars_unroll_2<10>(ptr - 2, val % 100, conv);
-                ptr -= 2;
-                val /= 100;
-            } while (WJR_LIKELY(val >= 100));
-        }
+template <uint64_t Base>
+class __to_chars_unroll_2_fn : public __to_chars_unroll_2_fast_fn_impl<Base> {
+    using Mybase = __to_chars_unroll_2_fast_fn_impl<Base>;
 
-        if (val < 10) {
-            *--ptr = conv.template to<10>(val);
-            return ptr;
+public:
+    template <typename Converter>
+    WJR_INTRINSIC_INLINE void operator()(uint8_t *ptr, uint32_t val,
+                                         Converter conv) const noexcept {
+        if constexpr (convert_details::has_to_chars_fast_fn_fast_conv_v<Mybase, uint32_t,
+                                                                        Converter>) {
+            Mybase::__fast_conv(ptr, val, conv);
+        } else {
+            ptr[0] = conv.template to<Base>(val / Base);
+            ptr[1] = conv.template to<Base>(val % Base);
         }
-
-        __to_chars_unroll_2<10>(ptr - 2, val, conv);
-        ptr -= 2;
-        return ptr;
     }
+};
+
+template <uint64_t Base>
+inline constexpr __to_chars_unroll_2_fn<Base> __to_chars_unroll_2{};
+
+template <uint64_t Base>
+class __to_chars_unroll_4_fn_impl : public __to_chars_unroll_4_fast_fn_impl<Base> {
+    using Mybase = __to_chars_unroll_4_fast_fn_impl<Base>;
 
 public:
-    template <typename UnsignedValue, typename Converter,
-              WJR_REQUIRES(is_nonbool_unsigned_integral_v<UnsignedValue>)>
-    uint8_t *operator()(uint8_t *ptr, UnsignedValue val, Converter conv) const noexcept {
-        return fn(ptr, val, conv);
+    template <typename Converter>
+    WJR_INTRINSIC_INLINE void operator()(uint8_t *ptr, uint32_t val,
+                                         Converter conv) const noexcept {
+        if constexpr (convert_details::has_to_chars_fast_fn_fast_conv_v<Mybase, uint32_t,
+                                                                        Converter>) {
+            Mybase::__fast_conv(ptr, val, conv);
+        } else {
+            constexpr auto Base2 = Base * Base;
+            __to_chars_unroll_2<Base>(ptr, val / Base2, conv);
+            __to_chars_unroll_2<Base>(ptr + 2, val % Base2, conv);
+        }
     }
 };
 
-template <typename Value, typename IBase, typename Converter>
-uint8_t *__fast_to_chars_backward_unchecked_impl(uint8_t *ptr, Value val, IBase ibase,
-                                                 Converter conv) noexcept {
-    if (WJR_UNLIKELY(val == 0)) {
-        *--ptr = conv.template to<1>(0);
-        return ptr;
-    }
+template <uint64_t Base>
+inline constexpr __to_chars_unroll_4_fn_impl<Base> __to_chars_unroll_4{};
 
-    auto uVal = to_unsigned(val);
-    int sign = 0;
+template <uint64_t Base>
+class __to_chars_unroll_8_fn_impl : public __to_chars_unroll_8_fast_fn_impl<Base> {
+    using Mybase = __to_chars_unroll_8_fast_fn_impl<Base>;
 
-    if constexpr (std::is_signed_v<Value>) {
-        if (val < 0) {
-            sign = 1;
-            uVal = -val;
+public:
+    template <typename Converter>
+    WJR_INTRINSIC_INLINE void operator()(uint8_t *ptr, uint64_t val,
+                                         Converter conv) const noexcept {
+        if constexpr (convert_details::has_to_chars_fast_fn_fast_conv_v<Mybase, uint64_t,
+                                                                        Converter>) {
+            Mybase::__fast_conv(ptr, val, conv);
+        } else {
+            constexpr auto Base4 = Base * Base * Base * Base;
+            __to_chars_unroll_4<Base>(ptr, val / Base4, conv);
+            __to_chars_unroll_4<Base>(ptr + 4, val % Base4, conv);
         }
     }
+};
 
-    const unsigned int base = ibase;
+template <uint64_t Base>
+inline constexpr __to_chars_unroll_8_fn_impl<Base> __to_chars_unroll_8{};
 
-    switch (base) {
-    case 2: {
-        ptr = __unsigned_to_chars_backward_unchecked<2>(ptr, count_digits<2>(uVal), uVal,
-                                                        conv);
-        break;
-    }
-    case 8: {
-        ptr = __unsigned_to_chars_backward_unchecked<8>(ptr, count_digits<8>(uVal), uVal,
-                                                        conv);
-        break;
-    }
-    case 16: {
-        ptr = __unsigned_to_chars_backward_unchecked<16>(ptr, count_digits<16>(uVal),
-                                                         uVal, conv);
-        break;
-    }
-    case 4:
-    case 32: {
-        const int bits = base == 4 ? 2 : 5;
-        ptr = __unsigned_to_chars_backward_unchecked<1>(ptr, count_digits<1>(uVal, bits),
-                                                        uVal, bits, conv);
-        break;
+template <uint64_t Base>
+class __from_chars_unroll_4_fast_fn_impl_base {
+protected:
+    WJR_CONST WJR_INTRINSIC_INLINE static uint32_t __fast_conv(uint32_t val) noexcept {
+        return digits_literal_details::__fast_conv_4<Base>(val);
     }
-    case 10: {
-        ptr = __unsigned_to_chars_backward_unchecked<10>(ptr, uVal, conv);
-        break;
+
+public:
+    WJR_PURE WJR_INTRINSIC_INLINE static uint32_t __fast_conv(const void *ptr,
+                                                              char_converter_t) noexcept {
+        return __fast_conv(read_memory<uint32_t>(ptr) - 0x30303030u);
     }
-    default: {
-        WJR_UNREACHABLE();
-        return ptr;
+
+    WJR_PURE WJR_INTRINSIC_INLINE static uint32_t
+    __fast_conv(const void *ptr, origin_converter_t) noexcept {
+        return __fast_conv(read_memory<uint32_t>(ptr));
     }
+};
+
+template <uint64_t Base>
+class __from_chars_unroll_8_fast_fn_impl_base {
+protected:
+    WJR_CONST WJR_INTRINSIC_INLINE static uint32_t __fast_conv(uint64_t val) noexcept {
+        return digits_literal_details::__fast_conv_8<Base>(val);
     }
 
-    if constexpr (std::is_signed_v<Value>) {
-        if (sign) {
-            *--ptr = '-';
-        }
+public:
+    WJR_PURE WJR_INTRINSIC_INLINE static uint32_t
+    __fast_conv(const void *ptr, WJR_MAYBE_UNUSED char_converter_t conv) noexcept {
+#if WJR_HAS_BUILTIN(FROM_CHARS_UNROLL_8_FAST)
+        return builtin_from_chars_unroll_8_fast<Base>(ptr, conv);
+#else
+        return __fast_conv(read_memory<uint64_t>(ptr) - 0x3030303030303030ull);
+#endif
     }
 
-    return ptr;
-}
+    WJR_PURE WJR_INTRINSIC_INLINE static uint32_t
+    __fast_conv(const void *ptr, WJR_MAYBE_UNUSED origin_converter_t conv) noexcept {
+#if WJR_HAS_BUILTIN(FROM_CHARS_UNROLL_8_FAST)
+        return builtin_from_chars_unroll_8_fast<Base>(ptr, conv);
+#else
+        return __fast_conv(read_memory<uint64_t>(ptr));
+#endif
+    }
+};
 
-template <typename Iter, typename Value, typename IBase, typename Converter>
-Iter __to_chars_backward_unchecked_impl(Iter first, Value val, IBase ibase,
-                                        Converter conv) noexcept {
-    const auto __ptr = reinterpret_cast<uint8_t *>((to_address)(first));
-    const auto __end = __fast_to_chars_backward_unchecked_impl(__ptr, val, ibase, conv);
-    return first + std::distance(__ptr, __end);
-}
+template <uint64_t Base>
+class __from_chars_unroll_16_fast_fn_impl_base {
+#if WJR_HAS_BUILTIN(FROM_CHARS_UNROLL_16_FAST)
+public:
+    template <typename Converter>
+    WJR_PURE WJR_INTRINSIC_INLINE static uint64_t __fast_conv(const void *ptr,
+                                                              Converter conv) noexcept {
+        return builtin_from_chars_unroll_16_fast<Base>(ptr, conv);
+    }
+#endif
+};
 
-/**
- * @brief Convert an unsigned integer to a string in reverse order without checking
- * buf size.
- *
- * @details Only use fast_convert mode.
- *
- */
-template <typename Iter, typename Value, typename BaseType = unsigned int,
-          BaseType IBase = 10, typename Converter = char_converter_t,
-          WJR_REQUIRES(convert_details::__is_fast_convert_iterator_v<Iter>
-                           &&convert_details::__is_valid_converter_v<Value, Converter>)>
-Iter to_chars_backward_unchecked(Iter first, Value val,
-                                 std::integral_constant<BaseType, IBase> = {},
-                                 Converter conv = {}) noexcept {
-    return __to_chars_backward_unchecked_impl(
-        first, val, std::integral_constant<unsigned int, IBase>(), conv);
-}
+template <uint64_t Base>
+class __from_chars_unroll_4_fast_fn_impl {};
 
-/**
- * @brief Convert an unsigned integer to a string in reverse order without checking
- * buf size.
- *
- *
- */
-template <typename Iter, typename Value, typename Converter = char_converter_t,
-          WJR_REQUIRES(convert_details::__is_fast_convert_iterator_v<Iter>
-                           &&convert_details::__is_valid_converter_v<Value, Converter>)>
-Iter to_chars_backward_unchecked(Iter first, Value val, unsigned int base,
-                                 Converter conv = {}) noexcept {
-    if (WJR_BUILTIN_CONSTANT_P(base)) {
-        switch (base) {
-        case 2: {
-            return to_chars_backward_unchecked(first, val, 2_u, conv);
-        }
-        case 8: {
-            return to_chars_backward_unchecked(first, val, 8_u, conv);
-        }
-        case 16: {
-            return to_chars_backward_unchecked(first, val, 16_u, conv);
-        }
-        case 10: {
-            return to_chars_backward_unchecked(first, val, 10_u, conv);
-        }
-        default: {
-            break;
-        }
-        }
-    }
+template <>
+class __from_chars_unroll_4_fast_fn_impl<2>
+    : public __from_chars_unroll_4_fast_fn_impl_base<2> {};
 
-    return __to_chars_backward_unchecked_impl(first, val, base, conv);
-}
+template <>
+class __from_chars_unroll_4_fast_fn_impl<8>
+    : public __from_chars_unroll_4_fast_fn_impl_base<8> {};
 
-template <typename Value, typename IBase, typename Converter>
-to_chars_result<uint8_t *> __fast_to_chars_impl(uint8_t *first, uint8_t *last, Value val,
-                                                IBase ibase, Converter conv) noexcept {
-    if (WJR_UNLIKELY(val == 0)) {
-        if (WJR_UNLIKELY(first == last)) {
-            return {last, std::errc::value_too_large};
-        }
+template <>
+class __from_chars_unroll_4_fast_fn_impl<10>
+    : public __from_chars_unroll_4_fast_fn_impl_base<10> {};
 
-        *first++ = conv.template to<1>(0);
-        return {first, std::errc{}};
-    }
+template <uint64_t Base>
+class __from_chars_unroll_8_fast_fn_impl {};
 
-    auto uVal = to_unsigned(val);
+template <>
+class __from_chars_unroll_8_fast_fn_impl<2>
+    : public __from_chars_unroll_8_fast_fn_impl_base<2> {};
 
-    if constexpr (std::is_signed_v<Value>) {
-        if (val < 0) {
-            if (WJR_UNLIKELY(first == last)) {
-                return {last, std::errc::value_too_large};
-            }
+template <>
+class __from_chars_unroll_8_fast_fn_impl<8>
+    : public __from_chars_unroll_8_fast_fn_impl_base<8> {};
 
-            *first++ = '-';
-            uVal = -val;
+template <>
+class __from_chars_unroll_8_fast_fn_impl<10>
+    : public __from_chars_unroll_8_fast_fn_impl_base<10> {};
+
+template <uint64_t Base>
+class __from_chars_unroll_16_fast_fn_impl {};
+
+template <>
+class __from_chars_unroll_16_fast_fn_impl<2>
+    : public __from_chars_unroll_16_fast_fn_impl_base<2> {};
+
+template <>
+class __from_chars_unroll_16_fast_fn_impl<8>
+    : public __from_chars_unroll_16_fast_fn_impl_base<8> {};
+
+template <>
+class __from_chars_unroll_16_fast_fn_impl<10>
+    : public __from_chars_unroll_16_fast_fn_impl_base<10> {};
+
+template <uint64_t Base>
+class __from_chars_unroll_4_fn : public __from_chars_unroll_4_fast_fn_impl<Base> {
+    using Mybase = __from_chars_unroll_4_fast_fn_impl<Base>;
+
+public:
+    template <typename Converter>
+    WJR_PURE WJR_INTRINSIC_INLINE uint64_t operator()(const uint8_t *ptr,
+                                                      Converter conv) const noexcept {
+        if constexpr (convert_details::has_from_chars_fast_fn_fast_conv_v<Mybase,
+                                                                          Converter>) {
+            return Mybase::__fast_conv(ptr, conv);
+        } else {
+            uint64_t value = 0;
+            value = conv.template from<Base>(*ptr++);
+            value = value * Base + conv.template from<Base>(*ptr++);
+            value = value * Base + conv.template from<Base>(*ptr++);
+            return value * Base + conv.template from<Base>(*ptr++);
         }
     }
+};
 
-    const unsigned int base = ibase;
-    const auto size = std::distance(first, last);
+template <uint64_t Base>
+inline constexpr __from_chars_unroll_4_fn<Base> __from_chars_unroll_4{};
 
-#define WJR_TO_CHARS_VALIDATE_IMPL(BASE, DIGITS, CALL)                                   \
-    const int n = count_digits<BASE> DIGITS;                                             \
-    if (WJR_LIKELY(n <= size)) {                                                         \
-        first += n;                                                                      \
-        (void)__unsigned_to_chars_backward_unchecked<BASE>(                              \
-            first, WJR_PP_QUEUE_EXPAND(CALL), conv);                                     \
-        return {first, std::errc{}};                                                     \
-    }                                                                                    \
-    return { last, std::errc::value_too_large }
+template <uint64_t Base>
+class __from_chars_unroll_8_fn : public __from_chars_unroll_8_fast_fn_impl<Base> {
+    using Mybase = __from_chars_unroll_8_fast_fn_impl<Base>;
 
-    switch (base) {
-    case 2: {
-        WJR_TO_CHARS_VALIDATE_IMPL(2, (uVal), (n, uVal));
-    }
-    case 8: {
-        WJR_TO_CHARS_VALIDATE_IMPL(8, (uVal), (n, uVal));
-    }
-    case 16: {
-        WJR_TO_CHARS_VALIDATE_IMPL(16, (uVal), (n, uVal));
-    }
-    case 4:
-    case 32: {
-        const int bits = base == 4 ? 2 : 5;
-        WJR_TO_CHARS_VALIDATE_IMPL(1, (uVal, bits), (n, uVal, bits));
-    }
-    case 10: {
-        WJR_TO_CHARS_VALIDATE_IMPL(10, (uVal), (uVal));
-    }
-    default: {
-        WJR_UNREACHABLE();
-        return {last, std::errc::invalid_argument};
-    }
+public:
+    template <typename Converter>
+    WJR_PURE WJR_INTRINSIC_INLINE uint64_t operator()(const uint8_t *ptr,
+                                                      Converter conv) const noexcept {
+        if constexpr (convert_details::has_from_chars_fast_fn_fast_conv_v<Mybase,
+                                                                          Converter>) {
+            return Mybase::__fast_conv(ptr, conv);
+        } else {
+            constexpr uint64_t Base4 = Base * Base * Base * Base;
+            return __from_chars_unroll_4<Base>(ptr, conv) * Base4 +
+                   __from_chars_unroll_4<Base>(ptr + 4, conv);
+        }
     }
+};
 
-#undef WJR_TO_CHARS_VALIDATE_IMPL
-}
+template <uint64_t Base>
+inline constexpr __from_chars_unroll_8_fn<Base> __from_chars_unroll_8{};
 
-template <typename Iter, typename Value, typename IBase, typename Converter>
-to_chars_result<Iter> __fallback_to_chars_impl(Iter first, Iter last, Value val,
-                                               IBase ibase, Converter conv) noexcept {
-    constexpr auto is_signed = std::is_signed_v<Value>;
-    constexpr auto base_2_table = std::numeric_limits<Value>::digits;
-    constexpr auto base_10_table = std::numeric_limits<Value>::digits10 + 1;
-    constexpr auto is_random_access = is_random_access_iterator_v<Iter>;
+template <uint64_t Base>
+class __from_chars_unroll_16_fn : public __from_chars_unroll_16_fast_fn_impl<Base> {
+    using Mybase = __from_chars_unroll_16_fast_fn_impl<Base>;
 
-    if (WJR_UNLIKELY(val == 0)) {
-        if (WJR_UNLIKELY(first == last)) {
-            return {last, std::errc::value_too_large};
+public:
+    template <typename Converter>
+    WJR_PURE WJR_INTRINSIC_INLINE uint64_t operator()(const uint8_t *ptr,
+                                                      Converter conv) const noexcept {
+        if constexpr (convert_details::has_from_chars_fast_fn_fast_conv_v<Mybase,
+                                                                          Converter>) {
+            return Mybase::__fast_conv(ptr, conv);
+        } else {
+            constexpr uint64_t Base4 = Base * Base * Base * Base;
+            constexpr uint64_t Base8 = Base4 * Base4;
+            return __from_chars_unroll_8<Base>(ptr, conv) * Base8 +
+                   __from_chars_unroll_8<Base>(ptr + 8, conv);
         }
-
-        *first++ = conv.template to<1>(0);
-        return {first, std::errc{}};
     }
+};
 
-    auto uVal = to_unsigned(val);
-    int sign = 0;
+template <uint64_t Base>
+inline constexpr __from_chars_unroll_16_fn<Base> __from_chars_unroll_16{};
 
-    if constexpr (is_signed) {
-        if constexpr (is_random_access) {
-            if (val < 0) {
-                if (WJR_UNLIKELY(first == last)) {
-                    return {last, std::errc::value_too_large};
-                }
+template <typename UnsignedValue>
+constexpr int fallback_count_digits10(UnsignedValue n) noexcept {
+    int count = 1;
 
-                sign = 1;
-                uVal = -val;
-            }
-        } else {
-            if (val < 0) {
-                if (WJR_UNLIKELY(first == last)) {
-                    return {last, std::errc::value_too_large};
-                }
+    if (WJR_UNLIKELY(n >= 1000)) {
+        do {
+            n /= 10000;
+            count += 4;
+        } while (n >= 1000);
 
-                *first++ = '-';
-                uVal = -val;
-            }
+        if (n == 0) {
+            return count;
         }
     }
 
-    const unsigned int base = ibase;
-
-#define WJR_TO_CHARS_VALIDATE_IMPL(BASE, TABLE, CALL)                                    \
-    if constexpr (is_random_access) {                                                    \
-        const auto size = std::distance(first, last);                                    \
-        WJR_PP_QUEUE_EXPAND(                                                             \
-            WJR_PP_BOOL_IF(WJR_PP_NE(BASE, 10),                                          \
-                           (                                                             \
-                               if constexpr (is_signed) {                                \
-                                   if (WJR_UNLIKELY(n + sign > size)) {                  \
-                                       return {last, std::errc::value_too_large};        \
-                                   }                                                     \
-                               } else {                                                  \
-                                   if (WJR_UNLIKELY(n > size)) {                         \
-                                       return {last, std::errc::value_too_large};        \
-                                   }                                                     \
-                               }),                                                       \
-                           ()))                                                          \
-                                                                                         \
-        convert_details::fast_buffer_t<Iter> buffer[TABLE + is_signed];                  \
-        const auto __end = buffer + TABLE + is_signed;                                   \
-        auto __ptr = (convert_details::fast_buffer_t<Iter> *)                            \
-            __unsigned_to_chars_backward_unchecked<BASE>(                                \
-                (uint8_t *)__end, WJR_PP_QUEUE_EXPAND(CALL), conv);                      \
-                                                                                         \
-        WJR_PP_QUEUE_EXPAND(                                                             \
-            WJR_PP_BOOL_IF(WJR_PP_EQ(BASE, 10),                                          \
-                           (                                                             \
-                               const auto n = __end - __ptr;                             \
-                                                                                         \
-                               if constexpr (is_signed) {                                \
-                                   if (WJR_UNLIKELY(n + sign > size)) {                  \
-                                       return {last, std::errc::value_too_large};        \
-                                   }                                                     \
-                               } else {                                                  \
-                                   if (WJR_UNLIKELY(n > size)) {                         \
-                                       return {last, std::errc::value_too_large};        \
-                                   }                                                     \
-                               }),                                                       \
-                           ()))                                                          \
-                                                                                         \
-        if constexpr (is_signed) {                                                       \
-            if (sign) {                                                                  \
-                *--__ptr = '-';                                                          \
-            }                                                                            \
-        }                                                                                \
-                                                                                         \
-        return wjr::copy(__ptr, __end, first);                                           \
-    } else {                                                                             \
-        convert_details::fast_buffer_t<Iter> buffer[TABLE];                              \
-        const auto __end = buffer + TABLE;                                               \
-        auto __ptr = (convert_details::fast_buffer_t<Iter> *)                            \
-            __unsigned_to_chars_backward_unchecked<BASE>(                                \
-                (uint8_t *)__end, WJR_PP_QUEUE_EXPAND(CALL), conv);                      \
-                                                                                         \
-        do {                                                                             \
-            if (WJR_UNLIKELY(first == last)) {                                           \
-                return {last, std::errc::value_too_large};                               \
-            }                                                                            \
-                                                                                         \
-            *first++ = *__ptr++;                                                         \
-        } while (__ptr != __end);                                                        \
-                                                                                         \
-        return {first, std::errc{}};                                                     \
+    if (n < 10) {
+        return count;
     }
 
-    switch (base) {
-    case 2: {
-        const int n = count_digits<2>(uVal);
-        WJR_TO_CHARS_VALIDATE_IMPL(2, base_2_table, (n, uVal));
-    }
-    case 8: {
-        const int n = count_digits<8>(uVal);
-        WJR_TO_CHARS_VALIDATE_IMPL(8, (base_2_table + 2) / 3, (n, uVal));
-    }
-    case 16: {
-        const int n = count_digits<16>(uVal);
-        WJR_TO_CHARS_VALIDATE_IMPL(16, (base_2_table + 3) / 4, (n, uVal));
-    }
-    case 4:
-    case 32: {
-        const int bits = base == 4 ? 2 : 5;
-        const int n = count_digits<1>(uVal, bits);
-        WJR_TO_CHARS_VALIDATE_IMPL(1, (base_2_table + bits - 1) / bits, (n, uVal, bits));
-    }
-    case 10: {
-        WJR_TO_CHARS_VALIDATE_IMPL(10, base_10_table, (uVal));
-    }
-    default: {
-        WJR_UNREACHABLE();
-        return {last, std::errc::invalid_argument};
-    }
+    if (n < 100) {
+        return count + 1;
     }
 
-#undef WJR_TO_CHARS_VALIDATE_IMPL
+    return count + 3;
 }
 
-template <typename Iter, typename Value, typename IBase, typename Converter>
-to_chars_result<Iter> __to_chars_impl(Iter first, Iter last, Value val, IBase ibase,
-                                      Converter conv) noexcept {
-    if constexpr (convert_details::__is_fast_convert_iterator_v<Iter>) {
-        const auto __first = reinterpret_cast<uint8_t *>((to_address)(first));
-        const auto __last = reinterpret_cast<uint8_t *>((to_address)(last));
-        const auto __result = __fast_to_chars_impl(__first, __last, val, ibase, conv);
-        return {first + std::distance(__first, __result.ptr), __result.ec};
-    } else {
-        return __fallback_to_chars_impl(first, last, val, ibase, conv);
-    }
+inline int builtin_count_digits10_u32(uint32_t n) noexcept {
+#define WJR_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
+    static constexpr uint64_t table[] = {
+        WJR_INC(0),          WJR_INC(0),          WJR_INC(0),          // 8
+        WJR_INC(10),         WJR_INC(10),         WJR_INC(10),         // 64
+        WJR_INC(100),        WJR_INC(100),        WJR_INC(100),        // 512
+        WJR_INC(1000),       WJR_INC(1000),       WJR_INC(1000),       // 4096
+        WJR_INC(10000),      WJR_INC(10000),      WJR_INC(10000),      // 32k
+        WJR_INC(100000),     WJR_INC(100000),     WJR_INC(100000),     // 256k
+        WJR_INC(1000000),    WJR_INC(1000000),    WJR_INC(1000000),    // 2048k
+        WJR_INC(10000000),   WJR_INC(10000000),   WJR_INC(10000000),   // 16M
+        WJR_INC(100000000),  WJR_INC(100000000),  WJR_INC(100000000),  // 128M
+        WJR_INC(1000000000), WJR_INC(1000000000), WJR_INC(1000000000), // 1024M
+        WJR_INC(1000000000), WJR_INC(1000000000)                       // 4B
+    };
+    const auto inc = table[clz(n | 1) ^ 31];
+    return static_cast<int>((n + inc) >> 32);
+#undef WJR_INC
 }
 
-template <typename Value, typename IBase, typename Converter>
-uint8_t *__fast_to_chars_unchecked_impl(uint8_t *ptr, Value val, IBase ibase,
-                                        Converter conv) noexcept {
-    if (WJR_UNLIKELY(val == 0)) {
-        *ptr++ = conv.template to<1>(0);
-        return ptr;
-    }
+inline int builtin_count_digits10_u64(uint64_t n) noexcept {
+#define WJR_POWERS_OF_10(factor)                                                         \
+    factor * 10, (factor)*100, (factor)*1000, (factor)*10000, (factor)*100000,           \
+        (factor)*1000000, (factor)*10000000, (factor)*100000000, (factor)*1000000000
+    static constexpr uint8_t bsr2log10[] = {
+        1,  1,  1,  2,  2,  2,  3,  3,  3,  4,  4,  4,  4,  5,  5,  5,
+        6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  9,  9,  9,  10, 10, 10,
+        10, 11, 11, 11, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 15, 15,
+        15, 16, 16, 16, 16, 17, 17, 17, 18, 18, 18, 19, 19, 19, 19, 20};
+    const auto t = bsr2log10[clz(n | 1) ^ 63];
+    static constexpr const uint64_t zero_or_powers_of_10[] = {
+        0, 0, WJR_POWERS_OF_10(1U), WJR_POWERS_OF_10(1000000000ULL),
+        10000000000000000000ULL};
+    return t - (n < zero_or_powers_of_10[t]);
+#undef WJR_POWERS_OF_10
+}
 
-    auto uVal = to_unsigned(val);
+template <typename T>
+WJR_CONSTEXPR_E int count_digits10_impl(T n) noexcept {
+    if (is_constant_evaluated() || WJR_BUILTIN_CONSTANT_P(n)) {
+        return fallback_count_digits10(n);
+    }
 
-    if constexpr (std::is_signed_v<Value>) {
-        if (val < 0) {
-            *ptr++ = '-';
-            uVal = -val;
-        }
+    if constexpr (sizeof(T) <= sizeof(uint32_t)) {
+        return builtin_count_digits10_u32(static_cast<uint32_t>(n));
+    } else {
+        return builtin_count_digits10_u64(static_cast<uint64_t>(n));
     }
+}
 
-    const unsigned int base = ibase;
+template <uint64_t Base>
+struct count_digits_fn {};
 
-    switch (base) {
-    case 2: {
-        const int n = count_digits<2>(uVal);
-        ptr += n;
-        (void)__unsigned_to_chars_backward_unchecked<2>(ptr, n, uVal, conv);
-        return ptr;
-    }
-    case 8: {
-        const int n = count_digits<8>(uVal);
-        ptr += n;
-        (void)__unsigned_to_chars_backward_unchecked<8>(ptr, n, uVal, conv);
-        return ptr;
-    }
-    case 16: {
-        const int n = count_digits<16>(uVal);
-        ptr += n;
-        (void)__unsigned_to_chars_backward_unchecked<16>(ptr, n, uVal, conv);
-        return ptr;
+template <uint64_t Base>
+inline constexpr count_digits_fn<Base> count_digits{};
+
+template <>
+struct count_digits_fn<2> {
+    template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
+    WJR_CONST WJR_INTRINSIC_CONSTEXPR_E int operator()(T n) const noexcept {
+        return bit_width(n);
     }
-    case 4:
-    case 32: {
-        const int bits = base == 4 ? 2 : 5;
-        const int n = count_digits<1>(uVal, bits);
-        ptr += n;
-        (void)__unsigned_to_chars_backward_unchecked<1>(ptr, n, uVal, bits, conv);
-        return ptr;
+};
+
+template <>
+struct count_digits_fn<8> {
+    template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
+    WJR_CONST WJR_INTRINSIC_CONSTEXPR_E int operator()(T n) const noexcept {
+        return __ceil_div(to_unsigned(bit_width(n)), 3);
     }
-    case 10: {
-        const int n = count_digits<10>(uVal);
-        ptr += n;
-        (void)__unsigned_to_chars_backward_unchecked<10>(ptr, uVal, conv);
-        return ptr;
+};
+
+template <>
+struct count_digits_fn<16> {
+    template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
+    WJR_CONST WJR_INTRINSIC_CONSTEXPR_E int operator()(T n) const noexcept {
+        return __ceil_div(to_unsigned(bit_width(n)), 4);
     }
-    default: {
-        WJR_UNREACHABLE();
-        return ptr;
+};
+
+template <>
+struct count_digits_fn<1> {
+    template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
+    WJR_CONST WJR_INTRINSIC_CONSTEXPR_E int operator()(T n, int bits) const noexcept {
+        return (bit_width(n) + bits - 1) / bits;
     }
+};
+
+template <>
+struct count_digits_fn<10> {
+    template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
+    WJR_CONST WJR_INTRINSIC_CONSTEXPR_E int operator()(T n) const noexcept {
+        const int ret = count_digits10_impl(n);
+        WJR_ASSUME(1 <= ret && ret <= std::numeric_limits<T>::digits10 + 1);
+        return ret;
     }
-}
+};
 
-template <typename Iter, typename Value, typename IBase, typename Converter>
-Iter __fallback_to_chars_unchecked_impl(Iter ptr, Value val, IBase ibase,
-                                        Converter conv) noexcept {
-    constexpr auto is_signed = std::is_signed_v<Value>;
-    constexpr auto base_2_table = std::numeric_limits<Value>::digits;
-    constexpr auto base_10_table = std::numeric_limits<Value>::digits10 + 1;
+template <typename Iter>
+struct to_chars_result {
+    Iter ptr;
+    std::errc ec;
 
-    if (WJR_UNLIKELY(val == 0)) {
-        *ptr++ = conv.template to<1>(0);
-        return ptr;
+    friend bool operator==(const to_chars_result &lhs,
+                           const to_chars_result &rhs) noexcept {
+        return lhs.ptr == rhs.ptr && lhs.ec == rhs.ec;
     }
 
-    auto uVal = to_unsigned(val);
-    int sign = 0;
-
-    if constexpr (is_signed) {
-        if (val < 0) {
-            sign = 1;
-            uVal = -val;
-        }
-    }
+    constexpr explicit operator bool() const noexcept { return ec == std::errc{}; }
+};
 
-    const unsigned int base = ibase;
+template <typename Iter = const char *>
+struct from_chars_result {
+    Iter ptr;
+    std::errc ec;
 
-#define WJR_TO_CHARS_IMPL(BASE, TABLE, CALL)                                             \
-    constexpr auto __fast_container_inserter_v =                                         \
-        convert_details::is_fast_container_inserter_v<Iter>;                             \
-    if constexpr (__fast_container_inserter_v != 0) {                                    \
-        WJR_PP_BOOL_IF(WJR_PP_EQ(BASE, 10), const int n = count_digits<10>(uVal), );     \
-        auto &cont = get_inserter_container(ptr);                                        \
-        if constexpr (__fast_container_inserter_v == 1) {                                \
-            resize(cont, cont.size() + n + sign);                                        \
-        } else {                                                                         \
-            append(cont, n + sign, dctor);                                               \
-        }                                                                                \
-        const auto __end = (to_address)(cont.data() + cont.size());                      \
-        auto __ptr = (convert_details::fast_buffer_t<Iter> *)                            \
-            __unsigned_to_chars_backward_unchecked<BASE>(                                \
-                (uint8_t *)__end, WJR_PP_QUEUE_EXPAND(CALL), conv);                      \
-                                                                                         \
-        if constexpr (is_signed) {                                                       \
-            if (sign) {                                                                  \
-                *--__ptr = '-';                                                          \
-            }                                                                            \
-        }                                                                                \
-                                                                                         \
-        return ptr;                                                                      \
-    } else {                                                                             \
-        convert_details::fast_buffer_t<Iter> buffer[TABLE + is_signed];                  \
-        const auto __end = buffer + TABLE + is_signed;                                   \
-        auto __ptr = (convert_details::fast_buffer_t<Iter> *)                            \
-            __unsigned_to_chars_backward_unchecked<BASE>(                                \
-                (uint8_t *)__end, WJR_PP_QUEUE_EXPAND(CALL), conv);                      \
-                                                                                         \
-        if constexpr (is_signed) {                                                       \
-            if (sign) {                                                                  \
-                *--__ptr = '-';                                                          \
-            }                                                                            \
-        }                                                                                \
-                                                                                         \
-        return wjr::copy(__ptr, __end, ptr);                                             \
+    friend bool operator==(const from_chars_result &lhs,
+                           const from_chars_result &rhs) noexcept {
+        return lhs.ptr == rhs.ptr && lhs.ec == rhs.ec;
     }
 
-    switch (base) {
-    case 2: {
-        const int n = count_digits<2>(uVal);
-        WJR_TO_CHARS_IMPL(2, base_2_table, (n, uVal));
-    }
-    case 8: {
-        const int n = count_digits<8>(uVal);
-        WJR_TO_CHARS_IMPL(8, (base_2_table + 2) / 3, (n, uVal));
-    }
-    case 16: {
-        const int n = count_digits<16>(uVal);
-        WJR_TO_CHARS_IMPL(16, (base_2_table + 3) / 4, (n, uVal));
-    }
-    case 4:
-    case 32: {
-        const int bits = base == 4 ? 2 : 5;
-        const int n = count_digits<1>(uVal, bits);
-        WJR_TO_CHARS_IMPL(1, (base_2_table + bits - 1) / bits, (n, uVal, bits));
-    }
-    case 10: {
-        WJR_TO_CHARS_IMPL(10, base_10_table, (uVal));
-    }
-    default: {
-        WJR_UNREACHABLE();
-        return ptr;
-    }
-    }
+    constexpr explicit operator bool() const noexcept { return ec == std::errc{}; }
+};
 
-#undef WJR_TO_CHARS_IMPL
-}
+// Base :
+// 0 : dynamic base
+// 1 : base is power of two
+template <uint64_t Base>
+class __unsigned_to_chars_backward_unchecked_fn {};
 
-template <typename Iter, typename Value, typename IBase, typename Converter>
-Iter __to_chars_unchecked_impl(Iter ptr, Value val, IBase ibase,
-                               Converter conv) noexcept {
-    if constexpr (convert_details::__is_fast_convert_iterator_v<Iter>) {
-        const auto __ptr = reinterpret_cast<uint8_t *>((to_address)(ptr));
-        const auto __result = __fast_to_chars_unchecked_impl(__ptr, val, ibase, conv);
-        return ptr + std::distance(__ptr, __result);
-    } else {
-        return __fallback_to_chars_unchecked_impl(ptr, val, ibase, conv);
-    }
-}
-/**
- * @brief Convert an unsigned integer to a string with checking buf size.
- *
- *
- * @return to_chars_result<Iter> If the conversion is successful, return {ans,
- * std::errc{}}. Otherwise, return {last, std::errc::value_too_large}.
- *
- */
-template <typename Iter, typename Value, typename BaseType = unsigned int,
-          BaseType IBase = 10, typename Converter = char_converter_t,
-          WJR_REQUIRES(convert_details::__is_valid_converter_v<Value, Converter>)>
-to_chars_result<Iter> to_chars(Iter ptr, Iter last, Value val,
-                               std::integral_constant<BaseType, IBase> = {},
-                               Converter conv = {}) noexcept {
-    return __to_chars_impl(ptr, last, val, std::integral_constant<unsigned int, IBase>(),
-                           conv);
-}
+template <uint64_t Base>
+inline constexpr __unsigned_to_chars_backward_unchecked_fn<Base>
+    __unsigned_to_chars_backward_unchecked{};
 
-/**
- * @brief Convert an unsigned integer to a string with checking buf size.
- *
- * @return to_chars_result<Iter> If the conversion is successful, return {ans,
- * std::errc{}}. Otherwise, return {last, std::errc::value_too_large}.
- *
- */
-template <typename Iter, typename Value, typename Converter = char_converter_t,
-          WJR_REQUIRES(convert_details::__is_valid_converter_v<Value, Converter>)>
-to_chars_result<Iter> to_chars(Iter ptr, Iter last, Value val, unsigned int base,
-                               Converter conv = {}) noexcept {
-    if (WJR_BUILTIN_CONSTANT_P(base)) {
-        switch (base) {
-        case 2: {
-            return to_chars(ptr, last, val, 2_u, conv);
+template <>
+class __unsigned_to_chars_backward_unchecked_fn<2> {
+    template <typename UnsignedValue, typename Converter>
+    static uint8_t *fn(uint8_t *ptr, int n, UnsignedValue x, Converter conv) noexcept {
+        constexpr auto nd = std::numeric_limits<UnsignedValue>::digits;
+        WJR_ASSERT_L2(x != 0);
+        WJR_ASSERT_ASSUME(1 <= n && n <= nd);
+        (void)(nd);
+
+        if (WJR_UNLIKELY(n >= 4)) {
+            do {
+                __to_chars_unroll_4<2>(ptr - 4, x & 0x0f, conv);
+                ptr -= 4;
+                x >>= 4;
+                n -= 4;
+            } while (WJR_LIKELY(n >= 4));
+
+            if (n == 0) {
+                return ptr;
+            }
         }
-        case 8: {
-            return to_chars(ptr, last, val, 8_u, conv);
+
+        switch (n) {
+        case 3: {
+            *--ptr = conv.template to<2>(x & 1);
+            x >>= 1;
+            WJR_FALLTHROUGH;
         }
-        case 16: {
-            return to_chars(ptr, last, val, 16_u, conv);
+        case 2: {
+            __to_chars_unroll_2<2>(ptr - 2, x, conv);
+            ptr -= 2;
+            break;
         }
-        case 10: {
-            return to_chars(ptr, last, val, 10_u, conv);
+        case 1: {
+            *--ptr = conv.template to<2>(x);
+            break;
         }
         default: {
+            WJR_UNREACHABLE();
             break;
         }
         }
+
+        return ptr;
     }
 
-    return __to_chars_impl(ptr, last, val, base, conv);
-}
+public:
+    template <typename UnsignedValue, typename Converter,
+              WJR_REQUIRES(is_nonbool_unsigned_integral_v<UnsignedValue>)>
+    uint8_t *operator()(uint8_t *ptr, int n, UnsignedValue x,
+                        Converter conv) const noexcept {
+        return fn(ptr, n, x, conv);
+    }
+};
 
-/**
- * @brief Convert an unsigned integer to a string without checking buf size.
- *
- * @details Iter can be any output iterator. Support fast_convert mode and fallback mode.
- * \n fast_convert mode : \n fast_convert mode is used when
- * __is_fast_convert_iterator_v<Iter> is true. \n caclulate the number of digits and
- * convert the integer to a string in reverse order. \n fallback mode : \n use buffer to
- * store the result and use @ref wjr::copy to copy the result to the output iterator. \n
- *
- */
-template <typename Iter, typename Value, typename BaseType = unsigned int,
-          BaseType IBase = 10, typename Converter = char_converter_t,
-          WJR_REQUIRES(convert_details::__is_valid_converter_v<Value, Converter>)>
-Iter to_chars_unchecked(Iter ptr, Value val, std::integral_constant<BaseType, IBase> = {},
-                        Converter conv = {}) noexcept {
-    return __to_chars_unchecked_impl(ptr, val,
-                                     std::integral_constant<unsigned int, IBase>(), conv);
-}
+template <>
+class __unsigned_to_chars_backward_unchecked_fn<8> {
+    template <typename UnsignedValue, typename Converter>
+    static uint8_t *fn(uint8_t *ptr, int n, UnsignedValue x, Converter conv) noexcept {
+        constexpr auto nd = std::numeric_limits<UnsignedValue>::digits;
+        WJR_ASSERT_L2(x != 0);
+        WJR_ASSERT_ASSUME(1 <= n && n <= (nd + 2) / 3);
 
-/**
- * @brief Convert an unsigned integer to a string without checking buf size.
- *
- * @tparam Iter The iterator type. Must be random access iterator.
- * @tparam Value The value type. If Converter is origin_converter_t, Value must be
- * non-bool unsigned integral type. Otherwise, Value must be non-bool integral type.
- *
- */
-template <typename Iter, typename Value, typename Converter = char_converter_t,
-          WJR_REQUIRES(convert_details::__is_valid_converter_v<Value, Converter>)>
-Iter to_chars_unchecked(Iter ptr, Value val, unsigned int base,
-                        Converter conv = {}) noexcept {
-    if (WJR_BUILTIN_CONSTANT_P(base)) {
-        switch (base) {
-        case 2: {
-            return to_chars_unchecked(ptr, val, 2_u, conv);
+        if constexpr (nd >= 16) {
+            if (WJR_UNLIKELY(n >= 4)) {
+                do {
+                    __to_chars_unroll_4<8>(ptr - 4, x & 0x0fff, conv);
+                    ptr -= 4;
+                    x >>= 12;
+                    n -= 4;
+                } while (WJR_LIKELY(n >= 4));
+
+                if (n == 0) {
+                    return ptr;
+                }
+            }
         }
-        case 8: {
-            return to_chars_unchecked(ptr, val, 8_u, conv);
+
+        switch (n) {
+        case 3: {
+            *--ptr = conv.template to<8>(x & 0x07);
+            x >>= 3;
+            WJR_FALLTHROUGH;
         }
-        case 16: {
-            return to_chars_unchecked(ptr, val, 16_u, conv);
+        case 2: {
+            __to_chars_unroll_2<8>(ptr - 2, x, conv);
+            ptr -= 2;
+            break;
         }
-        case 10: {
-            return to_chars_unchecked(ptr, val, 10_u, conv);
+        case 1: {
+            *--ptr = conv.template to<8>(x);
+            break;
         }
         default: {
+            WJR_UNREACHABLE();
             break;
         }
         }
-    }
-
-    return __to_chars_unchecked_impl(ptr, val, base, conv);
-}
 
-template <typename Converter>
-size_t __biginteger_to_chars_2_impl(uint8_t *first, const uint64_t *up, size_t n,
-                                    Converter conv) noexcept {
-    WJR_ASSERT_L2(up[n - 1] != 0);
-    WJR_ASSERT_ASSUME(n >= 2);
+        return ptr;
+    }
 
-    uint64_t x = up[n - 1];
-    --n;
-    const int pc = clz(x);
-    const int hbits = 64 - pc;
-    WJR_ASSUME(1 <= hbits && hbits <= 64);
+public:
+    template <typename UnsignedValue, typename Converter,
+              WJR_REQUIRES(is_nonbool_unsigned_integral_v<UnsignedValue>)>
+    uint8_t *operator()(uint8_t *ptr, int n, UnsignedValue x,
+                        Converter conv) const noexcept {
+        return fn(ptr, n, x, conv);
+    }
+};
 
-    size_t len = hbits + 64 * n;
-    first += len;
+template <>
+class __unsigned_to_chars_backward_unchecked_fn<16> {
+    template <typename UnsignedValue, typename Converter>
+    static uint8_t *fn(uint8_t *ptr, int n, UnsignedValue x, Converter conv) noexcept {
+        constexpr auto nd = std::numeric_limits<UnsignedValue>::digits;
+        WJR_ASSERT_L2(x != 0);
+        WJR_ASSERT_ASSUME(1 <= n && n <= (nd + 3) / 4);
 
-    do {
-        x = *up;
+        if constexpr (nd >= 16) {
+            if (WJR_UNLIKELY(n >= 4)) {
+                do {
+                    __to_chars_unroll_4<16>(ptr - 4, x & 0xffff, conv);
+                    ptr -= 4;
+                    x >>= 16;
+                    n -= 4;
+                } while (WJR_LIKELY(n >= 4));
 
-        for (int i = 0; i < 8; ++i) {
-            __to_chars_unroll_8<2>(first - 8, x & 0xff, conv);
-            first -= 8;
-            x >>= 8;
+                if (n == 0) {
+                    return ptr;
+                }
+            }
         }
 
-        ++up;
-        --n;
-    } while (n);
-    x = *up;
-
-    (void)__unsigned_to_chars_backward_unchecked<2>(first, hbits, x, conv);
-    return len;
-}
-
-template <typename Converter>
-size_t __biginteger_to_chars_8_impl(uint8_t *first, const uint64_t *up, size_t n,
-                                    Converter conv) noexcept {
-    WJR_ASSERT_L2(up[n - 1] != 0);
-    WJR_ASSERT_ASSUME(n >= 2);
-
-    uint64_t x = up[n - 1];
-    --n;
-    const int pc = clz(x);
-    int hbits = 64 - pc;
-    WJR_ASSUME(1 <= hbits && hbits <= 64);
-
-    const size_t len = (hbits + 64 * n + 2) / 3;
-    first += len;
-
-    int rest = 0;
-    unsigned int last = 0;
-
-    do {
-        x = *up;
-
-        switch (rest) {
-        case 0: {
-            rest = 2;
-            break;
+        switch (n) {
+        case 3: {
+            *--ptr = conv.to(x & 0x0f);
+            x >>= 4;
+            WJR_FALLTHROUGH;
         }
         case 2: {
-            __to_chars_unroll_2<8>(first - 2, last | ((x & 0x03) << 4), conv);
-            first -= 2;
-            x >>= 2;
-            rest = 4;
+            __to_chars_unroll_2<16>(ptr - 2, x, conv);
+            ptr -= 2;
             break;
         }
-        case 4: {
-            __to_chars_unroll_2<8>(first - 2, last | ((x & 0x0f) << 2), conv);
-            first -= 2;
-            x >>= 4;
-            rest = 0;
+        case 1: {
+            *--ptr = conv.to(x);
             break;
         }
         default: {
@@ -27374,696 +26999,761 @@ size_t __biginteger_to_chars_8_impl(uint8_t *first, const uint64_t *up, size_t n
         }
         }
 
-        __to_chars_unroll_8<8>(first - 8, x & 0xff'ffff, conv);
-        x >>= 24;
-        __to_chars_unroll_8<8>(first - 16, x & 0xff'ffff, conv);
-        x >>= 24;
-        __to_chars_unroll_4<8>(first - 20, x & 0x0fff, conv);
-        x >>= 12;
-        first -= 20;
+        return ptr;
+    }
 
-        last = x;
+public:
+    template <typename UnsignedValue, typename Converter,
+              WJR_REQUIRES(is_nonbool_unsigned_integral_v<UnsignedValue>)>
+    uint8_t *operator()(uint8_t *ptr, int n, UnsignedValue x,
+                        Converter conv) const noexcept {
+        return fn(ptr, n, x, conv);
+    }
+};
 
-        ++up;
-        --n;
-    } while (n);
-    x = *up;
+template <>
+class __unsigned_to_chars_backward_unchecked_fn<1> {
+private:
+    template <typename UnsignedValue, typename Converter>
+    static uint8_t *fn(uint8_t *ptr, int n, UnsignedValue x, int bits,
+                       Converter conv) noexcept {
+        WJR_ASSERT_L2(x != 0);
+        WJR_ASSERT_ASSUME(1 <= n && n <= std::numeric_limits<UnsignedValue>::digits);
 
-    switch (rest) {
-    case 0: {
-        break;
+        const unsigned int mask = (1u << bits) - 1;
+
+        do {
+            *--ptr = conv.to(x & mask);
+            x >>= bits;
+            --n;
+        } while (WJR_LIKELY(n != 0));
+
+        return ptr;
     }
-    case 2: {
-        __to_chars_unroll_2<8>(first - 2, last | ((x & 0x03) << 4), conv);
-        first -= 2;
-        if (hbits <= 2) {
-            goto DONE;
-        }
-        hbits -= 2;
-        x >>= 2;
-        break;
+
+public:
+    template <typename UnsignedValue, typename Converter,
+              WJR_REQUIRES(is_nonbool_unsigned_integral_v<UnsignedValue>)>
+    uint8_t *operator()(uint8_t *ptr, int n, UnsignedValue x, int bits,
+                        Converter conv) const noexcept {
+        return fn(ptr, n, x, bits, conv);
     }
-    case 4: {
-        if (WJR_UNLIKELY(hbits == 1)) {
-            *--first = conv.template to<8>(x << 2 | last);
-            goto DONE;
+};
+
+template <>
+class __unsigned_to_chars_backward_unchecked_fn<10> {
+private:
+    template <typename UnsignedValue, typename Converter,
+              WJR_REQUIRES(is_nonbool_unsigned_integral_v<UnsignedValue>)>
+    static uint8_t *fn(uint8_t *ptr, UnsignedValue val, Converter conv) noexcept {
+        WJR_ASSERT_ASSUME(val != 0);
+
+        if (WJR_LIKELY(val >= 100)) {
+            do {
+                __to_chars_unroll_2<10>(ptr - 2, val % 100, conv);
+                ptr -= 2;
+                val /= 100;
+            } while (WJR_LIKELY(val >= 100));
         }
 
-        __to_chars_unroll_2<8>(first - 2, last | ((x & 0x0f) << 2), conv);
-        first -= 2;
-        if (hbits <= 4) {
-            goto DONE;
+        if (val < 10) {
+            *--ptr = conv.template to<10>(val);
+            return ptr;
         }
-        hbits -= 4;
-        x >>= 4;
-        break;
-    }
-    default: {
-        WJR_UNREACHABLE();
-        break;
+
+        __to_chars_unroll_2<10>(ptr - 2, val, conv);
+        ptr -= 2;
+        return ptr;
     }
+
+public:
+    template <typename UnsignedValue, typename Converter,
+              WJR_REQUIRES(is_nonbool_unsigned_integral_v<UnsignedValue>)>
+    uint8_t *operator()(uint8_t *ptr, UnsignedValue val, Converter conv) const noexcept {
+        return fn(ptr, val, conv);
     }
+};
 
-    if (WJR_LIKELY(hbits + 2 >= 12)) {
-        do {
-            __to_chars_unroll_4<8>(first - 4, x & 0x0fff, conv);
-            first -= 4;
-            x >>= 12;
-            hbits -= 12;
-        } while (WJR_LIKELY(hbits + 2 >= 12));
+template <typename Value, typename IBase, typename Converter>
+uint8_t *__fast_to_chars_backward_unchecked_impl(uint8_t *ptr, Value val, IBase ibase,
+                                                 Converter conv) noexcept {
+    if (WJR_UNLIKELY(val == 0)) {
+        *--ptr = conv.template to<1>(0);
+        return ptr;
     }
 
-    switch ((hbits + 2) / 3) {
-    case 3: {
-        *--first = conv.template to<8>(x & 0x07);
-        x >>= 3;
-        WJR_FALLTHROUGH;
+    auto uVal = to_unsigned(val);
+    int sign = 0;
+
+    if constexpr (std::is_signed_v<Value>) {
+        if (val < 0) {
+            sign = 1;
+            uVal = -val;
+        }
     }
+
+    const unsigned int base = ibase;
+
+    switch (base) {
     case 2: {
-        __to_chars_unroll_2<8>(first - 2, x, conv);
+        ptr = __unsigned_to_chars_backward_unchecked<2>(ptr, count_digits<2>(uVal), uVal,
+                                                        conv);
         break;
     }
-    case 1: {
-        *--first = conv.template to<8>(x);
-        WJR_FALLTHROUGH;
+    case 8: {
+        ptr = __unsigned_to_chars_backward_unchecked<8>(ptr, count_digits<8>(uVal), uVal,
+                                                        conv);
+        break;
     }
-    case 0: {
+    case 16: {
+        ptr = __unsigned_to_chars_backward_unchecked<16>(ptr, count_digits<16>(uVal),
+                                                         uVal, conv);
         break;
     }
-    default: {
-        WJR_UNREACHABLE();
+    case 4:
+    case 32: {
+        const int bits = base == 4 ? 2 : 5;
+        ptr = __unsigned_to_chars_backward_unchecked<1>(ptr, count_digits<1>(uVal, bits),
+                                                        uVal, bits, conv);
+        break;
+    }
+    case 10: {
+        ptr = __unsigned_to_chars_backward_unchecked<10>(ptr, uVal, conv);
         break;
     }
+    default: {
+        WJR_UNREACHABLE();
+        return ptr;
+    }
     }
 
-DONE:
-    return len;
+    if constexpr (std::is_signed_v<Value>) {
+        if (sign) {
+            *--ptr = '-';
+        }
+    }
+
+    return ptr;
 }
 
-template <typename Converter>
-size_t __biginteger_to_chars_16_impl(uint8_t *first, const uint64_t *up, size_t n,
-                                     Converter conv) noexcept {
-    WJR_ASSERT_L2(up[n - 1] != 0);
-    WJR_ASSERT_ASSUME(n >= 2);
+template <typename Iter, typename Value, typename IBase, typename Converter>
+Iter __to_chars_backward_unchecked_impl(Iter first, Value val, IBase ibase,
+                                        Converter conv) noexcept {
+    const auto __ptr = reinterpret_cast<uint8_t *>((to_address)(first));
+    const auto __end = __fast_to_chars_backward_unchecked_impl(__ptr, val, ibase, conv);
+    return first + std::distance(__ptr, __end);
+}
 
-    uint64_t x = up[n - 1];
-    --n;
-    const int pc = clz(x);
-    int hbits = 64 - pc;
-    WJR_ASSUME(1 <= hbits && hbits <= 64);
-    hbits = (hbits + 3) / 4;
+/**
+ * @brief Convert an unsigned integer to a string in reverse order without checking
+ * buf size.
+ *
+ * @details Only use fast_convert mode.
+ *
+ */
+template <typename Iter, typename Value, typename BaseType = unsigned int,
+          BaseType IBase = 10, typename Converter = char_converter_t,
+          WJR_REQUIRES(convert_details::__is_fast_convert_iterator_v<Iter>
+                           &&convert_details::__is_valid_converter_v<Value, Converter>)>
+Iter to_chars_backward_unchecked(Iter first, Value val,
+                                 std::integral_constant<BaseType, IBase> = {},
+                                 Converter conv = {}) noexcept {
+    return __to_chars_backward_unchecked_impl(
+        first, val, std::integral_constant<unsigned int, IBase>(), conv);
+}
 
-    const size_t len = hbits + 16 * n;
-    first += len;
+/**
+ * @brief Convert an unsigned integer to a string in reverse order without checking
+ * buf size.
+ *
+ *
+ */
+template <typename Iter, typename Value, typename Converter = char_converter_t,
+          WJR_REQUIRES(convert_details::__is_fast_convert_iterator_v<Iter>
+                           &&convert_details::__is_valid_converter_v<Value, Converter>)>
+Iter to_chars_backward_unchecked(Iter first, Value val, unsigned int base,
+                                 Converter conv = {}) noexcept {
+    if (WJR_BUILTIN_CONSTANT_P(base)) {
+        switch (base) {
+        case 2: {
+            return to_chars_backward_unchecked(first, val, 2_u, conv);
+        }
+        case 8: {
+            return to_chars_backward_unchecked(first, val, 8_u, conv);
+        }
+        case 16: {
+            return to_chars_backward_unchecked(first, val, 16_u, conv);
+        }
+        case 10: {
+            return to_chars_backward_unchecked(first, val, 10_u, conv);
+        }
+        default: {
+            break;
+        }
+        }
+    }
 
-    do {
-        x = *up;
+    return __to_chars_backward_unchecked_impl(first, val, base, conv);
+}
 
-        __to_chars_unroll_8<16>(first - 8, x & 0xffff'ffff, conv);
-        __to_chars_unroll_8<16>(first - 16, x >> 32, conv);
-        first -= 16;
+template <typename Value, typename IBase, typename Converter>
+to_chars_result<uint8_t *> __fast_to_chars_impl(uint8_t *first, uint8_t *last, Value val,
+                                                IBase ibase, Converter conv) noexcept {
+    if (WJR_UNLIKELY(val == 0)) {
+        if (WJR_UNLIKELY(first == last)) {
+            return {last, std::errc::value_too_large};
+        }
 
-        ++up;
-        --n;
-    } while (n);
-    x = *up;
+        *first++ = conv.template to<1>(0);
+        return {first, std::errc{}};
+    }
 
-    (void)__unsigned_to_chars_backward_unchecked<16>(first, hbits, x, conv);
+    auto uVal = to_unsigned(val);
 
-    return len;
-}
+    if constexpr (std::is_signed_v<Value>) {
+        if (val < 0) {
+            if (WJR_UNLIKELY(first == last)) {
+                return {last, std::errc::value_too_large};
+            }
 
-template <typename Converter>
-size_t __biginteger_to_chars_power_of_two_impl(uint8_t *first, const uint64_t *up,
-                                               size_t n, unsigned int base,
-                                               Converter conv) noexcept {
-    WJR_ASSERT_L2(up[n - 1] != 0);
-    WJR_ASSERT_ASSUME(n >= 2);
+            *first++ = '-';
+            uVal = -val;
+        }
+    }
 
-    const int bits = ctz(base);
-    const unsigned int mask = (1u << bits) - 1;
+    const unsigned int base = ibase;
+    const auto size = std::distance(first, last);
 
-    uint64_t x = up[n - 1];
-    --n;
-    const int pc = clz(x);
-    const int hbits = 64 - pc;
-    WJR_ASSUME(1 <= hbits && hbits <= 64);
+#define WJR_TO_CHARS_VALIDATE_IMPL(BASE, DIGITS, CALL)                                   \
+    const int n = count_digits<BASE> DIGITS;                                             \
+    if (WJR_LIKELY(n <= size)) {                                                         \
+        first += n;                                                                      \
+        (void)__unsigned_to_chars_backward_unchecked<BASE>(                              \
+            first, WJR_PP_QUEUE_EXPAND(CALL), conv);                                     \
+        return {first, std::errc{}};                                                     \
+    }                                                                                    \
+    return { last, std::errc::value_too_large }
 
-    const size_t len = (hbits + 64 * n + bits - 1) / bits;
-    first += len;
+    switch (base) {
+    case 2: {
+        WJR_TO_CHARS_VALIDATE_IMPL(2, (uVal), (n, uVal));
+    }
+    case 8: {
+        WJR_TO_CHARS_VALIDATE_IMPL(8, (uVal), (n, uVal));
+    }
+    case 16: {
+        WJR_TO_CHARS_VALIDATE_IMPL(16, (uVal), (n, uVal));
+    }
+    case 4:
+    case 32: {
+        const int bits = base == 4 ? 2 : 5;
+        WJR_TO_CHARS_VALIDATE_IMPL(1, (uVal, bits), (n, uVal, bits));
+    }
+    case 10: {
+        WJR_TO_CHARS_VALIDATE_IMPL(10, (uVal), (uVal));
+    }
+    default: {
+        WJR_UNREACHABLE();
+        return {last, std::errc::invalid_argument};
+    }
+    }
 
-    int rest = 0;
-    unsigned int last = 0;
+#undef WJR_TO_CHARS_VALIDATE_IMPL
+}
 
-    do {
-        x = *up;
+template <typename Iter, typename Value, typename IBase, typename Converter>
+to_chars_result<Iter> __fallback_to_chars_impl(Iter first, Iter last, Value val,
+                                               IBase ibase, Converter conv) noexcept {
+    constexpr auto is_signed = std::is_signed_v<Value>;
+    constexpr auto base_2_table = std::numeric_limits<Value>::digits;
+    constexpr auto base_10_table = std::numeric_limits<Value>::digits10 + 1;
+    constexpr auto is_random_access = is_random_access_iterator_v<Iter>;
 
-        if (rest) {
-            int fix = bits - rest;
-            unsigned int val = ((x & ((1u << fix) - 1)) << rest) | last;
-            x >>= fix;
-            rest = 64 - fix;
-            *--first = conv.to(val);
-        } else {
-            rest = 64;
+    if (WJR_UNLIKELY(val == 0)) {
+        if (WJR_UNLIKELY(first == last)) {
+            return {last, std::errc::value_too_large};
         }
 
-        do {
-            *--first = conv.to(x & mask);
-            x >>= bits;
-            rest -= bits;
-        } while (rest >= bits);
+        *first++ = conv.template to<1>(0);
+        return {first, std::errc{}};
+    }
 
-        last = x;
+    auto uVal = to_unsigned(val);
+    int sign = 0;
 
-        ++up;
-        --n;
-    } while (n);
-    x = *up;
+    if constexpr (is_signed) {
+        if constexpr (is_random_access) {
+            if (val < 0) {
+                if (WJR_UNLIKELY(first == last)) {
+                    return {last, std::errc::value_too_large};
+                }
 
-    WJR_ASSERT_ASSUME(rest < bits);
+                sign = 1;
+                uVal = -val;
+            }
+        } else {
+            if (val < 0) {
+                if (WJR_UNLIKELY(first == last)) {
+                    return {last, std::errc::value_too_large};
+                }
 
-    if (WJR_UNLIKELY(rest != 0)) {
-        int fix = bits - rest;
-        unsigned int val = ((x & ((1u << fix) - 1)) << rest) | last;
-        x >>= fix;
-        *--first = conv.to(val);
-        rest = hbits - fix;
-        if (WJR_UNLIKELY(rest == 0)) {
-            goto DONE;
+                *first++ = '-';
+                uVal = -val;
+            }
         }
-    } else {
-        rest = hbits;
     }
 
-    do {
-        *--first = conv.to(x & mask);
-        x >>= bits;
-        rest -= bits;
-    } while (WJR_LIKELY(rest > 0));
-
-DONE:
-    return len;
-}
-
-template <typename Converter>
-uint8_t *basecase_to_chars_10(uint8_t *buf, uint64_t *up, size_t n,
-                              Converter conv) noexcept {
+    const unsigned int base = ibase;
 
-    if (n > 4) {
-        do {
-            uint64_t q;
-            uint64_t rem[2];
-            q = div_qr_2_shift(up, rem, up, n, div3by2_divider_shift_of_big_base_10);
-            if (q != 0) {
-                up[n - 2] = q;
-                n -= 1;
-            } else {
-                n -= 2;
-            }
-
-            uint64_t lo, hi;
-            hi = div128by64to64_noshift(lo, rem[0], rem[1],
-                                        div2by1_divider_noshift_of_big_base_10);
-
-            __to_chars_unroll_8<10>(buf - 8, lo % 1'0000'0000, conv);
-            lo /= 1'0000'0000;
-            __to_chars_unroll_8<10>(buf - 16, lo % 1'0000'0000, conv);
-            lo /= 1'0000'0000;
-            __to_chars_unroll_2<10>(buf - 18, lo % 100, conv);
-            lo /= 100;
-            buf[-19] = conv.template to<10>(lo);
-            buf -= 19;
-
-            __to_chars_unroll_8<10>(buf - 8, hi % 1'0000'0000, conv);
-            hi /= 1'0000'0000;
-            __to_chars_unroll_8<10>(buf - 16, hi % 1'0000'0000, conv);
-            hi /= 1'0000'0000;
-            __to_chars_unroll_2<10>(buf - 18, hi % 100, conv);
-            hi /= 100;
-            buf[-19] = conv.template to<10>(hi);
-            buf -= 19;
-
-        } while (n > 4);
+#define WJR_TO_CHARS_VALIDATE_IMPL(BASE, TABLE, CALL)                                    \
+    if constexpr (is_random_access) {                                                    \
+        const auto size = std::distance(first, last);                                    \
+        WJR_PP_QUEUE_EXPAND(                                                             \
+            WJR_PP_BOOL_IF(WJR_PP_NE(BASE, 10),                                          \
+                           (                                                             \
+                               if constexpr (is_signed) {                                \
+                                   if (WJR_UNLIKELY(n + sign > size)) {                  \
+                                       return {last, std::errc::value_too_large};        \
+                                   }                                                     \
+                               } else {                                                  \
+                                   if (WJR_UNLIKELY(n > size)) {                         \
+                                       return {last, std::errc::value_too_large};        \
+                                   }                                                     \
+                               }),                                                       \
+                           ()))                                                          \
+                                                                                         \
+        convert_details::fast_buffer_t<Iter> buffer[TABLE + is_signed];                  \
+        const auto __end = buffer + TABLE + is_signed;                                   \
+        auto __ptr = (convert_details::fast_buffer_t<Iter> *)                            \
+            __unsigned_to_chars_backward_unchecked<BASE>(                                \
+                (uint8_t *)__end, WJR_PP_QUEUE_EXPAND(CALL), conv);                      \
+                                                                                         \
+        WJR_PP_QUEUE_EXPAND(                                                             \
+            WJR_PP_BOOL_IF(WJR_PP_EQ(BASE, 10),                                          \
+                           (                                                             \
+                               const auto n = __end - __ptr;                             \
+                                                                                         \
+                               if constexpr (is_signed) {                                \
+                                   if (WJR_UNLIKELY(n + sign > size)) {                  \
+                                       return {last, std::errc::value_too_large};        \
+                                   }                                                     \
+                               } else {                                                  \
+                                   if (WJR_UNLIKELY(n > size)) {                         \
+                                       return {last, std::errc::value_too_large};        \
+                                   }                                                     \
+                               }),                                                       \
+                           ()))                                                          \
+                                                                                         \
+        if constexpr (is_signed) {                                                       \
+            if (sign) {                                                                  \
+                *--__ptr = '-';                                                          \
+            }                                                                            \
+        }                                                                                \
+                                                                                         \
+        return wjr::copy(__ptr, __end, first);                                           \
+    } else {                                                                             \
+        convert_details::fast_buffer_t<Iter> buffer[TABLE];                              \
+        const auto __end = buffer + TABLE;                                               \
+        auto __ptr = (convert_details::fast_buffer_t<Iter> *)                            \
+            __unsigned_to_chars_backward_unchecked<BASE>(                                \
+                (uint8_t *)__end, WJR_PP_QUEUE_EXPAND(CALL), conv);                      \
+                                                                                         \
+        do {                                                                             \
+            if (WJR_UNLIKELY(first == last)) {                                           \
+                return {last, std::errc::value_too_large};                               \
+            }                                                                            \
+                                                                                         \
+            *first++ = *__ptr++;                                                         \
+        } while (__ptr != __end);                                                        \
+                                                                                         \
+        return {first, std::errc{}};                                                     \
     }
 
-    do {
-        if (WJR_UNLIKELY(n == 1)) {
-            return __unsigned_to_chars_backward_unchecked<10>(buf, up[0], conv);
-        }
-
-        uint64_t q, rem;
-
-        q = div_qr_1_noshift(up, rem, up, n, div2by1_divider_noshift_of_big_base_10);
-        n -= q == 0;
-        if (q != 0) {
-            up[n - 1] = q;
-        }
-
-        __to_chars_unroll_8<10>(buf - 8, rem % 1'0000'0000, conv);
-        rem /= 1'0000'0000;
-        __to_chars_unroll_8<10>(buf - 16, rem % 1'0000'0000, conv);
-        rem /= 1'0000'0000;
-        __to_chars_unroll_2<10>(buf - 18, rem % 100, conv);
-        rem /= 100;
-        buf[-19] = conv.template to<10>(rem);
-
-        buf -= 19;
-    } while (n);
-
-    WJR_UNREACHABLE();
-
-    return buf;
-}
-
-template <typename Converter>
-uint8_t *basecase_to_chars(uint8_t *first, size_t len, uint64_t *up, size_t n,
-                           unsigned int base, Converter conv) noexcept {
-    constexpr size_t buf_len = dc_bignum_to_chars_precompute_threshold * 64 * 7 / 11;
-    uint8_t buf[buf_len];
-    uint8_t *end = buf + buf_len;
-    uint8_t *start;
-
-    if (WJR_LIKELY(base == 10)) {
-        start = basecase_to_chars_10(end, up, n, conv);
-    } else {
-        start = end;
+    switch (base) {
+    case 2: {
+        const int n = count_digits<2>(uVal);
+        WJR_TO_CHARS_VALIDATE_IMPL(2, base_2_table, (n, uVal));
+    }
+    case 8: {
+        const int n = count_digits<8>(uVal);
+        WJR_TO_CHARS_VALIDATE_IMPL(8, (base_2_table + 2) / 3, (n, uVal));
+    }
+    case 16: {
+        const int n = count_digits<16>(uVal);
+        WJR_TO_CHARS_VALIDATE_IMPL(16, (base_2_table + 3) / 4, (n, uVal));
+    }
+    case 4:
+    case 32: {
+        const int bits = base == 4 ? 2 : 5;
+        const int n = count_digits<1>(uVal, bits);
+        WJR_TO_CHARS_VALIDATE_IMPL(1, (base_2_table + bits - 1) / bits, (n, uVal, bits));
+    }
+    case 10: {
+        WJR_TO_CHARS_VALIDATE_IMPL(10, base_10_table, (uVal));
+    }
+    default: {
+        WJR_UNREACHABLE();
+        return {last, std::errc::invalid_argument};
     }
-
-    size_t rlen = end - start;
-    if (len > rlen) {
-        first = std::fill_n(first, len - rlen, conv.template to<1>(0));
     }
 
-    return std::copy(start, end, first);
+#undef WJR_TO_CHARS_VALIDATE_IMPL
 }
 
-template <typename Converter>
-uint8_t *dc_to_chars(uint8_t *first, size_t len, uint64_t *up, size_t n,
-                     precompute_chars_convert_t *pre, uint64_t *stk,
-                     Converter conv) noexcept {
-    WJR_ASSERT_ASSUME(n >= 1);
-    if (n < dc_bignum_to_chars_threshold) {
-        return basecase_to_chars(first, len, up, n, pre->base, conv);
+template <typename Iter, typename Value, typename IBase, typename Converter>
+to_chars_result<Iter> __to_chars_impl(Iter first, Iter last, Value val, IBase ibase,
+                                      Converter conv) noexcept {
+    if constexpr (convert_details::__is_fast_convert_iterator_v<Iter>) {
+        const auto __first = reinterpret_cast<uint8_t *>((to_address)(first));
+        const auto __last = reinterpret_cast<uint8_t *>((to_address)(last));
+        const auto __result = __fast_to_chars_impl(__first, __last, val, ibase, conv);
+        return {first + std::distance(__first, __result.ptr), __result.ec};
     } else {
-        const auto pp = pre->ptr;
-        const auto pn = pre->n;
-        const auto ps = pre->shift;
-
-        WJR_ASSERT((pn + ps) * 5 >= n * 2);
-
-        if (n < pn + ps || (n == pn + ps && reverse_compare_n(up + ps, pp, pn) < 0)) {
-            return dc_to_chars(first, len, up, n, pre - 1, stk, conv);
-        }
-
-        const auto pd = pre->digits_in_base;
-        auto qp = stk;
-
-        div_qr_s(qp, up + ps, up + ps, n - ps, pp, pn);
-
-        size_t qn = n - pn - ps;
-        qn += qp[qn] != 0;
-
-        if (len != 0) {
-            len = len - pd;
-        }
-
-        pre -= qn * 2 <= n;
-
-        first = dc_to_chars(first, len, qp, qn, pre, stk + qn, conv);
-        first = dc_to_chars(first, pd, up, pn + ps, pre, stk, conv);
-        return first;
+        return __fallback_to_chars_impl(first, last, val, ibase, conv);
     }
 }
 
-template <typename Converter>
-uint8_t *__biginteger_basecase_to_chars(uint8_t *first, const uint64_t *up, size_t n,
-                                        unsigned int base, Converter conv) noexcept {
-    if (WJR_LIKELY(n < dc_bignum_to_chars_precompute_threshold)) {
-        uint64_t upbuf[dc_bignum_to_chars_precompute_threshold];
-        std::copy_n(up, n, upbuf);
-        return basecase_to_chars(first, 0, upbuf, n, base, conv);
+template <typename Value, typename IBase, typename Converter>
+uint8_t *__fast_to_chars_unchecked_impl(uint8_t *ptr, Value val, IBase ibase,
+                                        Converter conv) noexcept {
+    if (WJR_UNLIKELY(val == 0)) {
+        *ptr++ = conv.template to<1>(0);
+        return ptr;
     }
 
-    precompute_chars_convert_t pre[64 - 3];
+    auto uVal = to_unsigned(val);
 
-    unique_stack_allocator stkal(math_details::stack_alloc);
-    auto stk =
-        static_cast<uint64_t *>(stkal.allocate((n * 18 / 5 + 192) * sizeof(uint64_t)));
-    const auto __up = stk;
-    std::copy_n(up, n, __up);
-    stk += n;
-    const auto mpre = precompute_chars_convert(pre, n, base, stk);
-    stk += n * 8 / 5 + 128;
-    return dc_to_chars(first, 0, __up, n, mpre, stk, conv);
-}
+    if constexpr (std::is_signed_v<Value>) {
+        if (val < 0) {
+            *ptr++ = '-';
+            uVal = -val;
+        }
+    }
 
-template <typename Converter>
-uint8_t *__fast_biginteger_large_to_chars_impl(uint8_t *first, const uint64_t *up,
-                                               size_t n, unsigned int base,
-                                               Converter conv) noexcept {
+    const unsigned int base = ibase;
 
     switch (base) {
     case 2: {
-        return first + __biginteger_to_chars_2_impl(first, up, n, conv);
+        const int n = count_digits<2>(uVal);
+        ptr += n;
+        (void)__unsigned_to_chars_backward_unchecked<2>(ptr, n, uVal, conv);
+        return ptr;
     }
     case 8: {
-        return first + __biginteger_to_chars_8_impl(first, up, n, conv);
+        const int n = count_digits<8>(uVal);
+        ptr += n;
+        (void)__unsigned_to_chars_backward_unchecked<8>(ptr, n, uVal, conv);
+        return ptr;
     }
     case 16: {
-        return first + __biginteger_to_chars_16_impl(first, up, n, conv);
+        const int n = count_digits<16>(uVal);
+        ptr += n;
+        (void)__unsigned_to_chars_backward_unchecked<16>(ptr, n, uVal, conv);
+        return ptr;
     }
     case 4:
     case 32: {
-        return first + __biginteger_to_chars_power_of_two_impl(first, up, n, base, conv);
+        const int bits = base == 4 ? 2 : 5;
+        const int n = count_digits<1>(uVal, bits);
+        ptr += n;
+        (void)__unsigned_to_chars_backward_unchecked<1>(ptr, n, uVal, bits, conv);
+        return ptr;
+    }
+    case 10: {
+        const int n = count_digits<10>(uVal);
+        ptr += n;
+        (void)__unsigned_to_chars_backward_unchecked<10>(ptr, uVal, conv);
+        return ptr;
     }
     default: {
-        break;
+        WJR_UNREACHABLE();
+        return ptr;
     }
     }
-
-    return __biginteger_basecase_to_chars(first, up, n, base, conv);
 }
 
-template <typename Iter, typename Converter>
-Iter __fallback_biginteger_large_to_chars_impl(Iter ptr, const uint64_t *up, size_t n,
-                                               unsigned int base,
-                                               Converter conv) noexcept {
-#define WJR_BIGINTEGER_TO_CHARS_IMPL(BASE, NAME, TAIL, SIZE, CALL)                       \
+template <typename Iter, typename Value, typename IBase, typename Converter>
+Iter __fallback_to_chars_unchecked_impl(Iter ptr, Value val, IBase ibase,
+                                        Converter conv) noexcept {
+    constexpr auto is_signed = std::is_signed_v<Value>;
+    constexpr auto base_2_table = std::numeric_limits<Value>::digits;
+    constexpr auto base_10_table = std::numeric_limits<Value>::digits10 + 1;
+
+    if (WJR_UNLIKELY(val == 0)) {
+        *ptr++ = conv.template to<1>(0);
+        return ptr;
+    }
+
+    auto uVal = to_unsigned(val);
+    int sign = 0;
+
+    if constexpr (is_signed) {
+        if (val < 0) {
+            sign = 1;
+            uVal = -val;
+        }
+    }
+
+    const unsigned int base = ibase;
+
+#define WJR_TO_CHARS_IMPL(BASE, TABLE, CALL)                                             \
     constexpr auto __fast_container_inserter_v =                                         \
         convert_details::is_fast_container_inserter_v<Iter>;                             \
     if constexpr (__fast_container_inserter_v != 0) {                                    \
+        WJR_PP_BOOL_IF(WJR_PP_EQ(BASE, 10), const int n = count_digits<10>(uVal), );     \
         auto &cont = get_inserter_container(ptr);                                        \
-        const auto __presize = cont.size();                                              \
         if constexpr (__fast_container_inserter_v == 1) {                                \
-            resize(cont, __presize + SIZE);                                              \
+            resize(cont, cont.size() + n + sign);                                        \
         } else {                                                                         \
-            append(cont, SIZE, dctor);                                                   \
+            append(cont, n + sign, dctor);                                               \
         }                                                                                \
-        const auto __ptr = (uint8_t *)(to_address)(cont.data()) + __presize;             \
-        const auto __size = NAME(__ptr, WJR_PP_QUEUE_EXPAND(CALL), conv) TAIL;           \
-        WJR_ASSERT((size_t)__size <= SIZE);                                              \
-        if constexpr (__fast_container_inserter_v == 1) {                                \
-            resize(cont, __presize + __size);                                            \
-        } else {                                                                         \
-            resize(cont, __presize + __size, wjr::dctor);                                \
+        const auto __end = (to_address)(cont.data() + cont.size());                      \
+        auto __ptr = (convert_details::fast_buffer_t<Iter> *)                            \
+            __unsigned_to_chars_backward_unchecked<BASE>(                                \
+                (uint8_t *)__end, WJR_PP_QUEUE_EXPAND(CALL), conv);                      \
+                                                                                         \
+        if constexpr (is_signed) {                                                       \
+            if (sign) {                                                                  \
+                *--__ptr = '-';                                                          \
+            }                                                                            \
         }                                                                                \
                                                                                          \
         return ptr;                                                                      \
     } else {                                                                             \
-        unique_stack_allocator stkal(math_details::stack_alloc);                         \
-        const auto __ptr = (uint8_t *)stkal.allocate(SIZE * sizeof(uint64_t));           \
-        const auto __size = NAME(__ptr, WJR_PP_QUEUE_EXPAND(CALL), conv) TAIL;           \
+        convert_details::fast_buffer_t<Iter> buffer[TABLE + is_signed];                  \
+        const auto __end = buffer + TABLE + is_signed;                                   \
+        auto __ptr = (convert_details::fast_buffer_t<Iter> *)                            \
+            __unsigned_to_chars_backward_unchecked<BASE>(                                \
+                (uint8_t *)__end, WJR_PP_QUEUE_EXPAND(CALL), conv);                      \
                                                                                          \
-        return wjr::copy_n((convert_details::fast_buffer_t<Iter> *)__ptr, __size, ptr);  \
+        if constexpr (is_signed) {                                                       \
+            if (sign) {                                                                  \
+                *--__ptr = '-';                                                          \
+            }                                                                            \
+        }                                                                                \
+                                                                                         \
+        return wjr::copy(__ptr, __end, ptr);                                             \
     }
 
     switch (base) {
     case 2: {
-        const size_t capacity = 64 * n;
-        WJR_BIGINTEGER_TO_CHARS_IMPL(2, __biginteger_to_chars_2_impl, , capacity,
-                                     (up, n));
+        const int n = count_digits<2>(uVal);
+        WJR_TO_CHARS_IMPL(2, base_2_table, (n, uVal));
     }
     case 8: {
-        const size_t capacity = (64 * n + 2) / 3;
-        WJR_BIGINTEGER_TO_CHARS_IMPL(8, __biginteger_to_chars_8_impl, , capacity,
-                                     (up, n));
+        const int n = count_digits<8>(uVal);
+        WJR_TO_CHARS_IMPL(8, (base_2_table + 2) / 3, (n, uVal));
     }
     case 16: {
-        const size_t capacity = (64 * n + 3) / 4;
-        WJR_BIGINTEGER_TO_CHARS_IMPL(16, __biginteger_to_chars_16_impl, , capacity,
-                                     (up, n));
+        const int n = count_digits<16>(uVal);
+        WJR_TO_CHARS_IMPL(16, (base_2_table + 3) / 4, (n, uVal));
     }
     case 4:
     case 32: {
         const int bits = base == 4 ? 2 : 5;
-        const size_t capacity = (64 * n + bits - 1) / bits;
-        WJR_BIGINTEGER_TO_CHARS_IMPL(base, __biginteger_to_chars_power_of_two_impl, ,
-                                     capacity, (up, n, base));
+        const int n = count_digits<1>(uVal, bits);
+        WJR_TO_CHARS_IMPL(1, (base_2_table + bits - 1) / bits, (n, uVal, bits));
+    }
+    case 10: {
+        WJR_TO_CHARS_IMPL(10, base_10_table, (uVal));
     }
     default: {
-        break;
+        WJR_UNREACHABLE();
+        return ptr;
     }
     }
 
-    const size_t capacity = ((64 * n) * 4 + 12) / 13;
-    WJR_BIGINTEGER_TO_CHARS_IMPL(base, __biginteger_basecase_to_chars, -__ptr, capacity,
-                                 (up, n, base));
-
-#undef WJR_BIGINTEGER_TO_CHARS_IMPL
+#undef WJR_TO_CHARS_IMPL
 }
 
-template <typename Iter, typename Converter>
-Iter __biginteger_to_chars_impl(Iter first, const uint64_t *up, size_t n,
-                                unsigned int base, Converter conv) noexcept {
-    if (n == 1) {
-        return to_chars_unchecked(first, up[0], base, conv);
-    }
-
+template <typename Iter, typename Value, typename IBase, typename Converter>
+Iter __to_chars_unchecked_impl(Iter ptr, Value val, IBase ibase,
+                               Converter conv) noexcept {
     if constexpr (convert_details::__is_fast_convert_iterator_v<Iter>) {
-        const auto __first = reinterpret_cast<uint8_t *>((to_address)(first));
-        const auto __result =
-            __fast_biginteger_large_to_chars_impl(__first, up, n, base, conv);
-        return first + std::distance(__first, __result);
+        const auto __ptr = reinterpret_cast<uint8_t *>((to_address)(ptr));
+        const auto __result = __fast_to_chars_unchecked_impl(__ptr, val, ibase, conv);
+        return ptr + std::distance(__ptr, __result);
     } else {
-        return __fallback_biginteger_large_to_chars_impl(first, up, n, base, conv);
+        return __fallback_to_chars_unchecked_impl(ptr, val, ibase, conv);
     }
 }
-
 /**
- * @brief Convert a biginteger to a string by a given base.
+ * @brief Convert an unsigned integer to a string with checking buf size.
+ *
+ *
+ * @return to_chars_result<Iter> If the conversion is successful, return {ans,
+ * std::errc{}}. Otherwise, return {last, std::errc::value_too_large}.
  *
- * @tparam Iter Output iterator type
- * @param[out] first Output iterator
- * @param[in] up Pointer to the biginteger
- * @param[in] n Length of the biginteger
- * @param[in] base Base of the output string. Range: `[2, 36]`,
- * Only support 10 and power of two currently.
- * @return Output iterator after the conversion
  */
-template <typename Iter, typename Converter = char_converter_t>
-Iter biginteger_to_chars(Iter first, const uint64_t *up, size_t n, unsigned int base = 10,
-                         Converter conv = {}) noexcept {
-    WJR_ASSERT(base <= 36 && (is_zero_or_single_bit(base) || base == 10));
-    WJR_ASSERT_ASSUME(up[n - 1] != 0);
-
-    return __biginteger_to_chars_impl(first, up, n, base, conv);
+template <typename Iter, typename Value, typename BaseType = unsigned int,
+          BaseType IBase = 10, typename Converter = char_converter_t,
+          WJR_REQUIRES(convert_details::__is_valid_converter_v<Value, Converter>)>
+to_chars_result<Iter> to_chars(Iter ptr, Iter last, Value val,
+                               std::integral_constant<BaseType, IBase> = {},
+                               Converter conv = {}) noexcept {
+    return __to_chars_impl(ptr, last, val, std::integral_constant<unsigned int, IBase>(),
+                           conv);
 }
 
-template <uint64_t Base>
-class __unsigned_from_chars_unchecked_fn {};
-
-template <uint64_t Base>
-inline constexpr __unsigned_from_chars_unchecked_fn<Base>
-    __unsigned_from_chars_unchecked{};
-
-template <>
-class __unsigned_from_chars_unchecked_fn<2> {
-    template <typename UnsignedValue, typename Converter>
-    static void fn(const uint8_t *first, const uint8_t *last, UnsignedValue &val,
-                   Converter conv) noexcept {
-        constexpr auto nd = std::numeric_limits<UnsignedValue>::digits;
-
-        auto n = std::distance(first, last);
-        WJR_ASSERT_ASSUME(1 <= n && n <= nd);
-
-        if constexpr (nd >= 16) {
-            if (WJR_UNLIKELY(n >= 8)) {
-                do {
-                    val = (val << 8) + __from_chars_unroll_8<2>(first, conv);
-                    first += 8;
-                    n -= 8;
-                } while (WJR_LIKELY(n >= 8));
-
-                if (n == 0) {
-                    return;
-                }
-            }
-        } else if constexpr (nd == 8) {
-            if (WJR_UNLIKELY(n == 8)) {
-                val = __from_chars_unroll_8<2>(first, conv);
-                first += 8;
-                return;
-            }
-        }
-
-        switch (n) {
-        case 7: {
-            val = (val << 1) + conv.template from<2>(*first++);
-            WJR_FALLTHROUGH;
-        }
-        case 6: {
-            val = (val << 1) + conv.template from<2>(*first++);
-            WJR_FALLTHROUGH;
-        }
-        case 5: {
-            val = (val << 1) + conv.template from<2>(*first++);
-            WJR_FALLTHROUGH;
-        }
-        case 4: {
-            val <<= 4;
-            val += __from_chars_unroll_4<2>(first, conv);
-            first += 4;
-            break;
+/**
+ * @brief Convert an unsigned integer to a string with checking buf size.
+ *
+ * @return to_chars_result<Iter> If the conversion is successful, return {ans,
+ * std::errc{}}. Otherwise, return {last, std::errc::value_too_large}.
+ *
+ */
+template <typename Iter, typename Value, typename Converter = char_converter_t,
+          WJR_REQUIRES(convert_details::__is_valid_converter_v<Value, Converter>)>
+to_chars_result<Iter> to_chars(Iter ptr, Iter last, Value val, unsigned int base,
+                               Converter conv = {}) noexcept {
+    if (WJR_BUILTIN_CONSTANT_P(base)) {
+        switch (base) {
+        case 2: {
+            return to_chars(ptr, last, val, 2_u, conv);
         }
-        case 3: {
-            val = (val << 1) + conv.template from<2>(*first++);
-            WJR_FALLTHROUGH;
+        case 8: {
+            return to_chars(ptr, last, val, 8_u, conv);
         }
-        case 2: {
-            val = (val << 1) + conv.template from<2>(*first++);
-            WJR_FALLTHROUGH;
+        case 16: {
+            return to_chars(ptr, last, val, 16_u, conv);
         }
-        case 1: {
-            val = (val << 1) + conv.template from<2>(*first++);
-            break;
+        case 10: {
+            return to_chars(ptr, last, val, 10_u, conv);
         }
         default: {
-            WJR_UNREACHABLE();
             break;
         }
         }
     }
 
-public:
-    template <typename UnsignedValue, typename Converter,
-              WJR_REQUIRES(is_nonbool_unsigned_integral_v<UnsignedValue>)>
-    void operator()(const uint8_t *first, const uint8_t *last, UnsignedValue &val,
-                    Converter conv) const noexcept {
-        return fn(first, last, val, conv);
-    }
-};
-
-template <>
-class __unsigned_from_chars_unchecked_fn<8> {
-    template <typename UnsignedValue, typename Converter>
-    static void fn(const uint8_t *first, const uint8_t *last, UnsignedValue &val,
-                   Converter conv) noexcept {
-        constexpr auto nd = std::numeric_limits<UnsignedValue>::digits;
-
-        auto n = std::distance(first, last);
-        WJR_ASSERT_ASSUME(1 <= n && n <= (nd + 2) / 3);
-
-        if constexpr (nd >= 32) {
-            if (WJR_UNLIKELY(n >= 8)) {
-                do {
-                    val = (val << 24) + __from_chars_unroll_8<8>(first, conv);
-                    first += 8;
-                    n -= 8;
-                } while (WJR_LIKELY(n >= 8));
+    return __to_chars_impl(ptr, last, val, base, conv);
+}
 
-                if (n == 0) {
-                    return;
-                }
-            }
-        }
+/**
+ * @brief Convert an unsigned integer to a string without checking buf size.
+ *
+ * @details Iter can be any output iterator. Support fast_convert mode and fallback mode.
+ * \n fast_convert mode : \n fast_convert mode is used when
+ * __is_fast_convert_iterator_v<Iter> is true. \n caclulate the number of digits and
+ * convert the integer to a string in reverse order. \n fallback mode : \n use buffer to
+ * store the result and use @ref wjr::copy to copy the result to the output iterator. \n
+ *
+ */
+template <typename Iter, typename Value, typename BaseType = unsigned int,
+          BaseType IBase = 10, typename Converter = char_converter_t,
+          WJR_REQUIRES(convert_details::__is_valid_converter_v<Value, Converter>)>
+Iter to_chars_unchecked(Iter ptr, Value val, std::integral_constant<BaseType, IBase> = {},
+                        Converter conv = {}) noexcept {
+    return __to_chars_unchecked_impl(ptr, val,
+                                     std::integral_constant<unsigned int, IBase>(), conv);
+}
 
-        switch (n) {
-        case 7: {
-            val = (val << 3) + conv.template from<8>(*first++);
-            WJR_FALLTHROUGH;
-        }
-        case 6: {
-            val = (val << 3) + conv.template from<8>(*first++);
-            WJR_FALLTHROUGH;
-        }
-        case 5: {
-            val = (val << 3) + conv.template from<8>(*first++);
-            WJR_FALLTHROUGH;
-        }
-        case 4: {
-            val <<= 12;
-            val += __from_chars_unroll_4<8>(first, conv);
-            first += 4;
-            break;
+/**
+ * @brief Convert an unsigned integer to a string without checking buf size.
+ *
+ * @tparam Iter The iterator type. Must be random access iterator.
+ * @tparam Value The value type. If Converter is origin_converter_t, Value must be
+ * non-bool unsigned integral type. Otherwise, Value must be non-bool integral type.
+ *
+ */
+template <typename Iter, typename Value, typename Converter = char_converter_t,
+          WJR_REQUIRES(convert_details::__is_valid_converter_v<Value, Converter>)>
+Iter to_chars_unchecked(Iter ptr, Value val, unsigned int base,
+                        Converter conv = {}) noexcept {
+    if (WJR_BUILTIN_CONSTANT_P(base)) {
+        switch (base) {
+        case 2: {
+            return to_chars_unchecked(ptr, val, 2_u, conv);
         }
-        case 3: {
-            val = (val << 3) + conv.template from<8>(*first++);
-            WJR_FALLTHROUGH;
+        case 8: {
+            return to_chars_unchecked(ptr, val, 8_u, conv);
         }
-        case 2: {
-            val = (val << 3) + conv.template from<8>(*first++);
-            WJR_FALLTHROUGH;
+        case 16: {
+            return to_chars_unchecked(ptr, val, 16_u, conv);
         }
-        case 1: {
-            val = (val << 3) + conv.template from<8>(*first++);
-            break;
+        case 10: {
+            return to_chars_unchecked(ptr, val, 10_u, conv);
         }
         default: {
-            WJR_UNREACHABLE();
             break;
         }
         }
     }
 
-public:
-    template <typename UnsignedValue, typename Converter,
-              WJR_REQUIRES(is_nonbool_unsigned_integral_v<UnsignedValue>)>
-    void operator()(const uint8_t *first, const uint8_t *last, UnsignedValue &val,
-                    Converter conv) const noexcept {
-        return fn(first, last, val, conv);
-    }
-};
+    return __to_chars_unchecked_impl(ptr, val, base, conv);
+}
 
-template <>
-class __unsigned_from_chars_unchecked_fn<16> {
-    template <typename UnsignedValue, typename Converter>
-    static void fn(const uint8_t *first, const uint8_t *last, UnsignedValue &val,
-                   Converter conv) noexcept {
-        constexpr auto nd = std::numeric_limits<UnsignedValue>::digits;
+template <typename Converter>
+size_t __biginteger_to_chars_2_impl(uint8_t *first, const uint64_t *up, size_t n,
+                                    Converter conv) noexcept {
+    WJR_ASSERT_L2(up[n - 1] != 0);
+    WJR_ASSERT_ASSUME(n >= 2);
 
-        auto n = std::distance(first, last);
-        WJR_ASSERT_ASSUME(1 <= n && n <= (nd + 3) / 4);
+    uint64_t x = up[n - 1];
+    --n;
+    const int pc = clz(x);
+    const int hbits = 64 - pc;
+    WJR_ASSUME(1 <= hbits && hbits <= 64);
 
-        if constexpr (nd >= 64) {
-            if (WJR_UNLIKELY(n >= 8)) {
-                do {
-                    val = (val << 32) + __from_chars_unroll_8<16>(first, conv);
-                    first += 8;
-                    n -= 8;
-                } while (WJR_LIKELY(n >= 8));
+    size_t len = hbits + 64 * n;
+    first += len;
 
-                if (n == 0) {
-                    return;
-                }
-            }
-        } else if constexpr (nd == 32) {
-            if (WJR_UNLIKELY(n == 8)) {
-                val = __from_chars_unroll_8<16>(first, conv);
-                first += 8;
-                return;
-            }
-        }
+    do {
+        x = *up;
 
-        switch (n) {
-        case 7: {
-            val = (val << 4) + conv.template from<16>(*first++);
-            WJR_FALLTHROUGH;
-        }
-        case 6: {
-            val = (val << 4) + conv.template from<16>(*first++);
-            WJR_FALLTHROUGH;
-        }
-        case 5: {
-            val = (val << 4) + conv.template from<16>(*first++);
-            WJR_FALLTHROUGH;
+        for (int i = 0; i < 8; ++i) {
+            __to_chars_unroll_8<2>(first - 8, x & 0xff, conv);
+            first -= 8;
+            x >>= 8;
         }
-        case 4: {
-            val <<= 16;
-            val += __from_chars_unroll_4<16>(first, conv);
-            first += 4;
+
+        ++up;
+        --n;
+    } while (n);
+    x = *up;
+
+    (void)__unsigned_to_chars_backward_unchecked<2>(first, hbits, x, conv);
+    return len;
+}
+
+template <typename Converter>
+size_t __biginteger_to_chars_8_impl(uint8_t *first, const uint64_t *up, size_t n,
+                                    Converter conv) noexcept {
+    WJR_ASSERT_L2(up[n - 1] != 0);
+    WJR_ASSERT_ASSUME(n >= 2);
+
+    uint64_t x = up[n - 1];
+    --n;
+    const int pc = clz(x);
+    int hbits = 64 - pc;
+    WJR_ASSUME(1 <= hbits && hbits <= 64);
+
+    const size_t len = (hbits + 64 * n + 2) / 3;
+    first += len;
+
+    int rest = 0;
+    unsigned int last = 0;
+
+    do {
+        x = *up;
+
+        switch (rest) {
+        case 0: {
+            rest = 2;
             break;
         }
-        case 3: {
-            val = (val << 4) + conv.template from<16>(*first++);
-            WJR_FALLTHROUGH;
-        }
         case 2: {
-            val = (val << 4) + conv.template from<16>(*first++);
-            WJR_FALLTHROUGH;
+            __to_chars_unroll_2<8>(first - 2, last | ((x & 0x03) << 4), conv);
+            first -= 2;
+            x >>= 2;
+            rest = 4;
+            break;
         }
-        case 1: {
-            val = (val << 4) + conv.template from<16>(*first++);
+        case 4: {
+            __to_chars_unroll_2<8>(first - 2, last | ((x & 0x0f) << 2), conv);
+            first -= 2;
+            x >>= 4;
+            rest = 0;
             break;
         }
         default: {
@@ -28071,130 +27761,81 @@ class __unsigned_from_chars_unchecked_fn<16> {
             break;
         }
         }
-    }
 
-public:
-    template <typename UnsignedValue, typename Converter,
-              WJR_REQUIRES(is_nonbool_unsigned_integral_v<UnsignedValue>)>
-    void operator()(const uint8_t *first, const uint8_t *last, UnsignedValue &val,
-                    Converter conv) const noexcept {
-        return fn(first, last, val, conv);
-    }
-};
-
-template <>
-class __unsigned_from_chars_unchecked_fn<1> {};
+        __to_chars_unroll_8<8>(first - 8, x & 0xff'ffff, conv);
+        x >>= 24;
+        __to_chars_unroll_8<8>(first - 16, x & 0xff'ffff, conv);
+        x >>= 24;
+        __to_chars_unroll_4<8>(first - 20, x & 0x0fff, conv);
+        x >>= 12;
+        first -= 20;
 
-template <>
-class __unsigned_from_chars_unchecked_fn<10> {
-    template <typename UnsignedValue, typename Converter>
-    static void fn(const uint8_t *first, const uint8_t *last, UnsignedValue &val,
-                   Converter conv) noexcept {
-        constexpr auto nd = std::numeric_limits<UnsignedValue>::digits10 + 1;
+        last = x;
 
-        auto n = std::distance(first, last);
-        WJR_ASSUME(1 <= n && n <= nd);
+        ++up;
+        --n;
+    } while (n);
+    x = *up;
 
-        if constexpr (nd >= 8) {
-            if (WJR_UNLIKELY(n >= 8)) {
-                if (WJR_UNLIKELY(n >= 16)) {
-                    val = __from_chars_unroll_16<10>(first, conv);
-                    first += 16;
-                    n -= 16;
-                } else {
-                    val = __from_chars_unroll_8<10>(first, conv);
-                    first += 8;
-                    n -= 8;
-                }
-
-                if (WJR_UNLIKELY(n == 0)) {
-                    return;
-                }
-            }
-        }
-
-        switch (n) {
-        case 7: {
-            val = val * 10 + conv.template from<10>(*first++);
-            WJR_FALLTHROUGH;
-        }
-        case 6: {
-            val = val * 10 + conv.template from<10>(*first++);
-            WJR_FALLTHROUGH;
-        }
-        case 5: {
-            val = val * 10 + conv.template from<10>(*first++);
-            WJR_FALLTHROUGH;
-        }
-        case 4: {
-            val = (val * 10000) + __from_chars_unroll_4<10>(first, conv);
-            break;
-        }
-        case 3: {
-            val = val * 10 + conv.template from<10>(*first++);
-            WJR_FALLTHROUGH;
-        }
-        case 2: {
-            val = val * 10 + conv.template from<10>(*first++);
-            WJR_FALLTHROUGH;
-        }
-        case 1: {
-            val = val * 10 + conv.template from<10>(*first++);
-            WJR_FALLTHROUGH;
-        }
-        case 0: {
-            break;
+    switch (rest) {
+    case 0: {
+        break;
+    }
+    case 2: {
+        __to_chars_unroll_2<8>(first - 2, last | ((x & 0x03) << 4), conv);
+        first -= 2;
+        if (hbits <= 2) {
+            goto DONE;
         }
-        default: {
-            WJR_UNREACHABLE();
-            break;
+        hbits -= 2;
+        x >>= 2;
+        break;
+    }
+    case 4: {
+        if (WJR_UNLIKELY(hbits == 1)) {
+            *--first = conv.template to<8>(x << 2 | last);
+            goto DONE;
         }
+
+        __to_chars_unroll_2<8>(first - 2, last | ((x & 0x0f) << 2), conv);
+        first -= 2;
+        if (hbits <= 4) {
+            goto DONE;
         }
+        hbits -= 4;
+        x >>= 4;
+        break;
     }
-
-public:
-    template <typename UnsignedValue, typename Converter,
-              WJR_REQUIRES(is_nonbool_unsigned_integral_v<UnsignedValue>)>
-    void operator()(const uint8_t *first, const uint8_t *last, UnsignedValue &val,
-                    Converter conv) const noexcept {
-        return fn(first, last, val, conv);
+    default: {
+        WJR_UNREACHABLE();
+        break;
     }
-};
-
-template <typename Value, typename IBase, typename Converter,
-          WJR_REQUIRES(is_nonbool_integral_v<Value>)>
-void __fast_from_chars_unchecked_impl(const uint8_t *first, const uint8_t *last,
-                                      Value &val, IBase ibase, Converter conv) noexcept {
-    int sign = 0;
-
-    if constexpr (std::is_signed_v<Value>) {
-        WJR_ASSERT(first != last);
-
-        if (*first == '-') {
-            ++first;
-            sign = 1;
-        }
     }
 
-    std::make_unsigned_t<Value> uVal = 0;
-
-    const unsigned int base = ibase;
+    if (WJR_LIKELY(hbits + 2 >= 12)) {
+        do {
+            __to_chars_unroll_4<8>(first - 4, x & 0x0fff, conv);
+            first -= 4;
+            x >>= 12;
+            hbits -= 12;
+        } while (WJR_LIKELY(hbits + 2 >= 12));
+    }
 
-    switch (base) {
-    case 2: {
-        __unsigned_from_chars_unchecked<2>(first, last, uVal, conv);
-        break;
+    switch ((hbits + 2) / 3) {
+    case 3: {
+        *--first = conv.template to<8>(x & 0x07);
+        x >>= 3;
+        WJR_FALLTHROUGH;
     }
-    case 8: {
-        __unsigned_from_chars_unchecked<8>(first, last, uVal, conv);
+    case 2: {
+        __to_chars_unroll_2<8>(first - 2, x, conv);
         break;
     }
-    case 16: {
-        __unsigned_from_chars_unchecked<16>(first, last, uVal, conv);
-        break;
+    case 1: {
+        *--first = conv.template to<8>(x);
+        WJR_FALLTHROUGH;
     }
-    case 10: {
-        __unsigned_from_chars_unchecked<10>(first, last, uVal, conv);
+    case 0: {
         break;
     }
     default: {
@@ -28203,6186 +27844,5274 @@ void __fast_from_chars_unchecked_impl(const uint8_t *first, const uint8_t *last,
     }
     }
 
-    if (sign) {
-        val = -static_cast<Value>(uVal);
-    } else {
-        val = static_cast<Value>(uVal);
-    }
-}
-
-template <typename Iter, typename Value, typename IBase, typename Converter,
-          WJR_REQUIRES(is_nonbool_integral_v<Value>)>
-void __from_chars_unchecked_impl(Iter first, Iter last, Value &val, IBase ibase,
-                                 Converter conv) noexcept {
-    const auto __first = reinterpret_cast<const uint8_t *>((to_address)(first));
-    const auto __last = reinterpret_cast<const uint8_t *>((to_address)(last));
-    __fast_from_chars_unchecked_impl(__first, __last, val, ibase, conv);
+DONE:
+    return len;
 }
 
-template <typename Iter, typename Value, typename BaseType = unsigned int,
-          BaseType IBase = 10, typename Converter = char_converter_t,
-          WJR_REQUIRES(convert_details::__is_fast_convert_iterator_v<Iter>
-                           &&convert_details::__is_valid_converter_v<Value, Converter>)>
-void from_chars_unchecked(Iter first, Iter last, Value &val,
-                          std::integral_constant<BaseType, IBase> = {},
-                          Converter conv = {}) noexcept {
-    __from_chars_unchecked_impl(first, last, val,
-                                std::integral_constant<unsigned int, IBase>(), conv);
-}
+template <typename Converter>
+size_t __biginteger_to_chars_16_impl(uint8_t *first, const uint64_t *up, size_t n,
+                                     Converter conv) noexcept {
+    WJR_ASSERT_L2(up[n - 1] != 0);
+    WJR_ASSERT_ASSUME(n >= 2);
 
-template <typename Iter, typename Value, typename Converter,
-          WJR_REQUIRES(convert_details::__is_fast_convert_iterator_v<Iter>
-                           &&convert_details::__is_valid_converter_v<Value, Converter>)>
-void from_chars_unchecked(Iter first, Iter last, Value &val, unsigned int base,
-                          Converter conv = {}) noexcept {
-    if (WJR_BUILTIN_CONSTANT_P(base)) {
-        switch (base) {
-        case 2: {
-            __from_chars_unchecked_impl(first, last, val, 2_u, conv);
-            return;
-        }
-        case 8: {
-            __from_chars_unchecked_impl(first, last, val, 8_u, conv);
-            return;
-        }
-        case 16: {
-            __from_chars_unchecked_impl(first, last, val, 16_u, conv);
-            return;
-        }
-        case 10: {
-            __from_chars_unchecked_impl(first, last, val, 10_u, conv);
-            return;
-        }
-        default: {
-            break;
-        }
-        }
-    }
+    uint64_t x = up[n - 1];
+    --n;
+    const int pc = clz(x);
+    int hbits = 64 - pc;
+    WJR_ASSUME(1 <= hbits && hbits <= 64);
+    hbits = (hbits + 3) / 4;
 
-    __from_chars_unchecked_impl(first, last, val, base, conv);
-}
+    const size_t len = hbits + 16 * n;
+    first += len;
 
-template <uint64_t Base>
-struct __unsigned_from_chars_fn {};
+    do {
+        x = *up;
 
-template <uint64_t Base>
-inline constexpr __unsigned_from_chars_fn<Base> __unsigned_from_chars{};
+        __to_chars_unroll_8<16>(first - 8, x & 0xffff'ffff, conv);
+        __to_chars_unroll_8<16>(first - 16, x >> 32, conv);
+        first -= 16;
 
-template <>
-struct __unsigned_from_chars_fn<2> {
-    template <typename UnsignedValue, typename Converter,
-              WJR_REQUIRES(is_nonbool_unsigned_integral_v<UnsignedValue>)>
-    int operator()(const uint8_t *&first, const uint8_t *last, UnsignedValue &value,
-                   Converter conv) const noexcept {
-        constexpr auto nd = std::numeric_limits<UnsignedValue>::digits;
-        constexpr auto zero = conv.template to<2>(0);
-        constexpr auto one = conv.template to<2>(1);
+        ++up;
+        --n;
+    } while (n);
+    x = *up;
 
-        if (first == last) {
-            return 2;
-        }
+    (void)__unsigned_to_chars_backward_unchecked<16>(first, hbits, x, conv);
 
-        uint8_t ch = first[0];
+    return len;
+}
 
-        if (ch == one) {
-        } else if (ch == zero) {
-            do {
-                ++first;
-                if (first == last) {
-                    return 1;
-                }
+template <typename Converter>
+size_t __biginteger_to_chars_power_of_two_impl(uint8_t *first, const uint64_t *up,
+                                               size_t n, unsigned int base,
+                                               Converter conv) noexcept {
+    WJR_ASSERT_L2(up[n - 1] != 0);
+    WJR_ASSERT_ASSUME(n >= 2);
 
-                ch = first[0];
-            } while (ch == zero);
-            if (ch != one) {
-                return 1;
-            }
-        } else {
-            return 2;
-        }
+    const int bits = ctz(base);
+    const unsigned int mask = (1u << bits) - 1;
 
-        const size_t n = std::distance(first, last);
-        ch = 1;
-        size_t idx = 0;
+    uint64_t x = up[n - 1];
+    --n;
+    const int pc = clz(x);
+    const int hbits = 64 - pc;
+    WJR_ASSUME(1 <= hbits && hbits <= 64);
 
-        do {
-            value = value << 1 | ch;
-            ++idx;
-            if (idx == n) {
-                break;
-            }
+    const size_t len = (hbits + 64 * n + bits - 1) / bits;
+    first += len;
 
-            ch = conv.template from<2>(first[idx]);
-        } while (ch < 2);
+    int rest = 0;
+    unsigned int last = 0;
 
-        first += idx;
-        return idx <= nd;
-    }
-};
+    do {
+        x = *up;
 
-template <>
-struct __unsigned_from_chars_fn<10> {
-    template <typename UnsignedValue, typename Converter,
-              WJR_REQUIRES(is_nonbool_unsigned_integral_v<UnsignedValue>)>
-    int operator()(const uint8_t *&first, const uint8_t *last, UnsignedValue &value,
-                   Converter conv) const noexcept {
-        constexpr auto zero = conv.template to<10>(0);
-        constexpr auto nine = conv.template to<10>(9);
+        if (rest) {
+            int fix = bits - rest;
+            unsigned int val = ((x & ((1u << fix) - 1)) << rest) | last;
+            x >>= fix;
+            rest = 64 - fix;
+            *--first = conv.to(val);
+        } else {
+            rest = 64;
+        }
 
-        constexpr auto __try_matches = [](uint8_t &ch) {
-            if constexpr (zero != 0) {
-                return ch <= nine && !sub_overflow(ch, zero, ch);
-            } else {
-                return ch <= nine;
-            }
-        };
+        do {
+            *--first = conv.to(x & mask);
+            x >>= bits;
+            rest -= bits;
+        } while (rest >= bits);
 
-        constexpr auto __matches = [](uint8_t ch) {
-            if constexpr (zero != 0) {
-                return zero <= ch && ch <= nine;
-            } else {
-                return ch <= nine;
-            }
-        };
+        last = x;
 
-        if (first == last) {
-            return 2;
-        }
+        ++up;
+        --n;
+    } while (n);
+    x = *up;
 
-        uint8_t ch = *first;
+    WJR_ASSERT_ASSUME(rest < bits);
 
-        if (WJR_UNLIKELY(!__try_matches(ch))) {
-            return 2;
+    if (WJR_UNLIKELY(rest != 0)) {
+        int fix = bits - rest;
+        unsigned int val = ((x & ((1u << fix) - 1)) << rest) | last;
+        x >>= fix;
+        *--first = conv.to(val);
+        rest = hbits - fix;
+        if (WJR_UNLIKELY(rest == 0)) {
+            goto DONE;
         }
+    } else {
+        rest = hbits;
+    }
 
-        do {
-            ++first;
-            if (WJR_UNLIKELY(mul_overflow(value, 10, value) ||
-                             add_overflow(value, ch, value))) {
-                while (first != last && __matches(*first)) {
-                    ++first;
-                }
+    do {
+        *--first = conv.to(x & mask);
+        x >>= bits;
+        rest -= bits;
+    } while (WJR_LIKELY(rest > 0));
 
-                return 0;
-            }
+DONE:
+    return len;
+}
 
-            if (first == last) {
-                break;
+template <typename Converter>
+uint8_t *basecase_to_chars_10(uint8_t *buf, uint64_t *up, size_t n,
+                              Converter conv) noexcept {
+
+    if (n > 4) {
+        do {
+            uint64_t q;
+            uint64_t rem[2];
+            q = div_qr_2_shift(up, rem, up, n, div3by2_divider_shift_of_big_base_10);
+            if (q != 0) {
+                up[n - 2] = q;
+                n -= 1;
+            } else {
+                n -= 2;
             }
 
-            ch = *first;
-        } while (__try_matches(ch));
+            uint64_t lo, hi;
+            hi = div128by64to64_noshift(lo, rem[0], rem[1],
+                                        div2by1_divider_noshift_of_big_base_10);
 
-        return 1;
+            __to_chars_unroll_8<10>(buf - 8, lo % 1'0000'0000, conv);
+            lo /= 1'0000'0000;
+            __to_chars_unroll_8<10>(buf - 16, lo % 1'0000'0000, conv);
+            lo /= 1'0000'0000;
+            __to_chars_unroll_2<10>(buf - 18, lo % 100, conv);
+            lo /= 100;
+            buf[-19] = conv.template to<10>(lo);
+            buf -= 19;
+
+            __to_chars_unroll_8<10>(buf - 8, hi % 1'0000'0000, conv);
+            hi /= 1'0000'0000;
+            __to_chars_unroll_8<10>(buf - 16, hi % 1'0000'0000, conv);
+            hi /= 1'0000'0000;
+            __to_chars_unroll_2<10>(buf - 18, hi % 100, conv);
+            hi /= 100;
+            buf[-19] = conv.template to<10>(hi);
+            buf -= 19;
+
+        } while (n > 4);
     }
-};
 
-template <typename Value, typename IBase, typename Converter,
-          WJR_REQUIRES(is_nonbool_integral_v<Value>)>
-from_chars_result<const uint8_t *>
-__fast_from_chars_impl(const uint8_t *first, const uint8_t *last, Value &val, IBase ibase,
-                       Converter conv) noexcept {
-    constexpr auto is_signed = std::is_signed_v<Value>;
+    do {
+        if (WJR_UNLIKELY(n == 1)) {
+            return __unsigned_to_chars_backward_unchecked<10>(buf, up[0], conv);
+        }
 
-    int sign = 0;
+        uint64_t q, rem;
 
-    if constexpr (is_signed) {
-        if (first != last && *first == '-') {
-            ++first;
-            sign = 1;
+        q = div_qr_1_noshift(up, rem, up, n, div2by1_divider_noshift_of_big_base_10);
+        n -= q == 0;
+        if (q != 0) {
+            up[n - 1] = q;
         }
-    }
 
-    using UnsignedValue = std::make_unsigned_t<Value>;
+        __to_chars_unroll_8<10>(buf - 8, rem % 1'0000'0000, conv);
+        rem /= 1'0000'0000;
+        __to_chars_unroll_8<10>(buf - 16, rem % 1'0000'0000, conv);
+        rem /= 1'0000'0000;
+        __to_chars_unroll_2<10>(buf - 18, rem % 100, conv);
+        rem /= 100;
+        buf[-19] = conv.template to<10>(rem);
 
-    UnsignedValue uVal = 0;
+        buf -= 19;
+    } while (n);
 
-    const unsigned int base = ibase;
-    from_chars_result<const uint8_t *> ret{first, std::errc{}};
-    int valid;
+    WJR_UNREACHABLE();
 
-    switch (base) {
-    case 2: {
-        valid = __unsigned_from_chars<2>(first, last, uVal, conv);
-        break;
-    }
-    case 10: {
-        valid = __unsigned_from_chars<10>(first, last, uVal, conv);
-        break;
-    }
-    default: {
-        return {first, std::errc::invalid_argument};
-    }
-    }
+    return buf;
+}
 
-    if (WJR_UNLIKELY(valid == 2)) {
-        ret.ec = std::errc::invalid_argument;
+template <typename Converter>
+uint8_t *basecase_to_chars(uint8_t *first, size_t len, uint64_t *up, size_t n,
+                           unsigned int base, Converter conv) noexcept {
+    constexpr size_t buf_len = dc_bignum_to_chars_precompute_threshold * 64 * 7 / 11;
+    uint8_t buf[buf_len];
+    uint8_t *end = buf + buf_len;
+    uint8_t *start;
+
+    if (WJR_LIKELY(base == 10)) {
+        start = basecase_to_chars_10(end, up, n, conv);
     } else {
-        ret.ptr = first;
-        if (!valid) {
-            ret.ec = std::errc::result_out_of_range;
-        } else {
-            if constexpr (is_signed) {
-                if (sign) {
-                    if (uVal >
-                        static_cast<UnsignedValue>(std::numeric_limits<Value>::min())) {
-                        ret.ec = std::errc::result_out_of_range;
-                    } else {
-                        val = -static_cast<Value>(uVal);
-                    }
-                } else {
-                    if (uVal >
-                        static_cast<UnsignedValue>(std::numeric_limits<Value>::max())) {
-                        ret.ec = std::errc::result_out_of_range;
-                    } else {
-                        val = static_cast<Value>(uVal);
-                    }
-                }
-            } else {
-                val = uVal;
-            }
-        }
+        start = end;
     }
 
-    return ret;
-}
+    size_t rlen = end - start;
+    if (len > rlen) {
+        first = std::fill_n(first, len - rlen, conv.template to<1>(0));
+    }
 
-template <typename Value, typename IBase, typename Converter,
-          WJR_REQUIRES(is_nonbool_integral_v<Value>)>
-from_chars_result<const char *> __from_chars_impl(const char *first, const char *last,
-                                                  Value &val, IBase ibase,
-                                                  Converter conv) noexcept {
-    const auto __first = reinterpret_cast<const uint8_t *>(first);
-    const auto __last = reinterpret_cast<const uint8_t *>(last);
-    const auto ret = __fast_from_chars_impl(__first, __last, val, ibase, conv);
-    return {reinterpret_cast<const char *>(ret.ptr), ret.ec};
-}
-
-template <typename Value, typename BaseType = unsigned int, BaseType IBase = 10,
-          typename Converter = char_converter_t,
-          WJR_REQUIRES(convert_details::__is_valid_converter_v<Value, Converter>)>
-from_chars_result<const char *>
-from_chars(const char *first, const char *last, Value &val,
-           std::integral_constant<BaseType, IBase> = {}, Converter conv = {}) noexcept {
-    return __from_chars_impl(first, last, val,
-                             std::integral_constant<unsigned int, IBase>(), conv);
-}
-
-template <typename Value, typename Converter = char_converter_t,
-          WJR_REQUIRES(convert_details::__is_valid_converter_v<Value, Converter>)>
-from_chars_result<const char *> from_chars(const char *first, const char *last,
-                                           Value &val, unsigned int base,
-                                           Converter conv = {}) noexcept {
-    if (WJR_BUILTIN_CONSTANT_P(base)) {
-        switch (base) {
-        case 2: {
-            return __from_chars_impl(first, last, val, 2_u, conv);
-        }
-        case 10: {
-            return __from_chars_impl(first, last, val, 10_u, conv);
-        }
-        default: {
-            break;
-        }
-        }
-    }
-
-    return __from_chars_impl(first, last, val, base, conv);
+    return std::copy(start, end, first);
 }
 
 template <typename Converter>
-size_t __biginteger_from_chars_2_impl(const uint8_t *first, size_t n, uint64_t *up,
-                                      Converter conv) noexcept {
-    const size_t hbits = (n - 1) % 64 + 1;
-    const size_t len = (n - 1) / 64 + 1;
+uint8_t *dc_to_chars(uint8_t *first, size_t len, uint64_t *up, size_t n,
+                     precompute_chars_convert_t *pre, uint64_t *stk,
+                     Converter conv) noexcept {
+    WJR_ASSERT_ASSUME(n >= 1);
+    if (n < dc_bignum_to_chars_threshold) {
+        return basecase_to_chars(first, len, up, n, pre->base, conv);
+    } else {
+        const auto pp = pre->ptr;
+        const auto pn = pre->n;
+        const auto ps = pre->shift;
 
-    uint64_t x = 0;
-    up += len;
+        WJR_ASSERT((pn + ps) * 5 >= n * 2);
 
-    __unsigned_from_chars_unchecked<2>(first, first + hbits, x, conv);
-    first += hbits;
+        if (n < pn + ps || (n == pn + ps && reverse_compare_n(up + ps, pp, pn) < 0)) {
+            return dc_to_chars(first, len, up, n, pre - 1, stk, conv);
+        }
 
-    *--up = x;
+        const auto pd = pre->digits_in_base;
+        auto qp = stk;
 
-    size_t idx = len - 1;
+        div_qr_s(qp, up + ps, up + ps, n - ps, pp, pn);
 
-    if (idx) {
-        do {
-            x = 0;
+        size_t qn = n - pn - ps;
+        qn += qp[qn] != 0;
 
-            for (int i = 0; i < 4; ++i) {
-                x = (x << 16) + __from_chars_unroll_16<2>(first, conv);
-                first += 16;
-            }
+        if (len != 0) {
+            len = len - pd;
+        }
 
-            *--up = x;
-        } while (WJR_LIKELY(--idx));
-    }
+        pre -= qn * 2 <= n;
 
-    return len;
+        first = dc_to_chars(first, len, qp, qn, pre, stk + qn, conv);
+        first = dc_to_chars(first, pd, up, pn + ps, pre, stk, conv);
+        return first;
+    }
 }
 
 template <typename Converter>
-size_t __biginteger_from_chars_8_impl(const uint8_t *first, size_t n, uint64_t *up,
-                                      Converter conv) noexcept {
-    size_t len = (n * 3 + 63) / 64;
-    size_t lbits = (64 * (len - 1)) / 3;
-    size_t rest = (64 * (len - 1)) % 3;
-    const size_t hbits = n - lbits - 1;
+uint8_t *__biginteger_basecase_to_chars(uint8_t *first, const uint64_t *up, size_t n,
+                                        unsigned int base, Converter conv) noexcept {
+    if (WJR_LIKELY(n < dc_bignum_to_chars_precompute_threshold)) {
+        uint64_t upbuf[dc_bignum_to_chars_precompute_threshold];
+        std::copy_n(up, n, upbuf);
+        return basecase_to_chars(first, 0, upbuf, n, base, conv);
+    }
 
-    auto unroll = [conv](uint64_t &x, auto &first) {
-        auto x0 = conv.template from<8>(first[0]);
-        auto x1 = conv.template from<8>(first[1]);
-        auto x2 = conv.template from<8>(first[2]);
-        auto x3 = conv.template from<8>(first[3]);
+    precompute_chars_convert_t pre[64 - 3];
 
-        x = x << 12 | x0 << 9 | x1 << 6 | x2 << 3 | x3;
-        first += 4;
-    };
+    unique_stack_allocator stkal(math_details::stack_alloc);
+    auto stk =
+        static_cast<uint64_t *>(stkal.allocate((n * 18 / 5 + 192) * sizeof(uint64_t)));
+    const auto __up = stk;
+    std::copy_n(up, n, __up);
+    stk += n;
+    const auto mpre = precompute_chars_convert(pre, n, base, stk);
+    stk += n * 8 / 5 + 128;
+    return dc_to_chars(first, 0, __up, n, mpre, stk, conv);
+}
 
-    uint64_t x = 0;
-    up += len;
-    size_t idx = len - 1;
+template <typename Converter>
+uint8_t *__fast_biginteger_large_to_chars_impl(uint8_t *first, const uint64_t *up,
+                                               size_t n, unsigned int base,
+                                               Converter conv) noexcept {
 
-    if (WJR_UNLIKELY(hbits == 0)) {
-    } else {
-        __unsigned_from_chars_unchecked<8>(first, first + hbits, x, conv);
-        first += hbits;
+    switch (base) {
+    case 2: {
+        return first + __biginteger_to_chars_2_impl(first, up, n, conv);
     }
-
-    uint64_t nx = conv.template from<8>(*first++);
-    switch (rest) {
-    case 0: {
-        *--up = x << 3 | nx;
-        x = 0;
+    case 8: {
+        return first + __biginteger_to_chars_8_impl(first, up, n, conv);
+    }
+    case 16: {
+        return first + __biginteger_to_chars_16_impl(first, up, n, conv);
+    }
+    case 4:
+    case 32: {
+        return first + __biginteger_to_chars_power_of_two_impl(first, up, n, base, conv);
+    }
+    default: {
         break;
     }
-    case 1: {
-        x = x << 2 | nx >> 1;
-        if (WJR_UNLIKELY(x == 0)) {
-            --len;
-        }
+    }
 
-        *--up = x;
-        x = nx & 1;
-        break;
+    return __biginteger_basecase_to_chars(first, up, n, base, conv);
+}
+
+template <typename Iter, typename Converter>
+Iter __fallback_biginteger_large_to_chars_impl(Iter ptr, const uint64_t *up, size_t n,
+                                               unsigned int base,
+                                               Converter conv) noexcept {
+#define WJR_BIGINTEGER_TO_CHARS_IMPL(BASE, NAME, TAIL, SIZE, CALL)                       \
+    constexpr auto __fast_container_inserter_v =                                         \
+        convert_details::is_fast_container_inserter_v<Iter>;                             \
+    if constexpr (__fast_container_inserter_v != 0) {                                    \
+        auto &cont = get_inserter_container(ptr);                                        \
+        const auto __presize = cont.size();                                              \
+        if constexpr (__fast_container_inserter_v == 1) {                                \
+            resize(cont, __presize + SIZE);                                              \
+        } else {                                                                         \
+            append(cont, SIZE, dctor);                                                   \
+        }                                                                                \
+        const auto __ptr = (uint8_t *)(to_address)(cont.data()) + __presize;             \
+        const auto __size = NAME(__ptr, WJR_PP_QUEUE_EXPAND(CALL), conv) TAIL;           \
+        WJR_ASSERT((size_t)__size <= SIZE);                                              \
+        if constexpr (__fast_container_inserter_v == 1) {                                \
+            resize(cont, __presize + __size);                                            \
+        } else {                                                                         \
+            resize(cont, __presize + __size, wjr::dctor);                                \
+        }                                                                                \
+                                                                                         \
+        return ptr;                                                                      \
+    } else {                                                                             \
+        unique_stack_allocator stkal(math_details::stack_alloc);                         \
+        const auto __ptr = (uint8_t *)stkal.allocate(SIZE * sizeof(uint64_t));           \
+        const auto __size = NAME(__ptr, WJR_PP_QUEUE_EXPAND(CALL), conv) TAIL;           \
+                                                                                         \
+        return wjr::copy_n((convert_details::fast_buffer_t<Iter> *)__ptr, __size, ptr);  \
     }
+
+    switch (base) {
     case 2: {
-        x = x << 1 | nx >> 2;
-        if (WJR_UNLIKELY(x == 0)) {
-            --len;
-        }
-        *--up = x;
-        x = nx & 3;
-        break;
+        const size_t capacity = 64 * n;
+        WJR_BIGINTEGER_TO_CHARS_IMPL(2, __biginteger_to_chars_2_impl, , capacity,
+                                     (up, n));
+    }
+    case 8: {
+        const size_t capacity = (64 * n + 2) / 3;
+        WJR_BIGINTEGER_TO_CHARS_IMPL(8, __biginteger_to_chars_8_impl, , capacity,
+                                     (up, n));
+    }
+    case 16: {
+        const size_t capacity = (64 * n + 3) / 4;
+        WJR_BIGINTEGER_TO_CHARS_IMPL(16, __biginteger_to_chars_16_impl, , capacity,
+                                     (up, n));
+    }
+    case 4:
+    case 32: {
+        const int bits = base == 4 ? 2 : 5;
+        const size_t capacity = (64 * n + bits - 1) / bits;
+        WJR_BIGINTEGER_TO_CHARS_IMPL(base, __biginteger_to_chars_power_of_two_impl, ,
+                                     capacity, (up, n, base));
     }
     default: {
-        WJR_UNREACHABLE();
         break;
     }
     }
 
-    if (idx) {
-        do {
-            for (int i = 0; i < 5; ++i) {
-                unroll(x, first);
-            }
+    const size_t capacity = ((64 * n) * 4 + 12) / 13;
+    WJR_BIGINTEGER_TO_CHARS_IMPL(base, __biginteger_basecase_to_chars, -__ptr, capacity,
+                                 (up, n, base));
 
-            switch (rest) {
-            case 0: {
-                x = x << 3 | conv.template from<8>(*first++);
-                uint64_t nx = conv.template from<8>(*first++);
-                x = x << 1 | nx >> 2;
-                *--up = x;
-                x = nx & 3;
-                rest = 2;
-                break;
-            }
-            case 1: {
-                x = x << 3 | conv.template from<8>(*first++);
-                *--up = x;
-                x = 0;
-                rest = 0;
-                break;
-            }
-            case 2: {
-                uint64_t nx = conv.template from<8>(*first++);
-                x = x << 2 | nx >> 1;
-                *--up = x;
-                x = nx & 1;
-                rest = 1;
-                break;
-            }
-            default: {
-                WJR_UNREACHABLE();
-                break;
-            }
-            }
+#undef WJR_BIGINTEGER_TO_CHARS_IMPL
+}
 
-        } while (WJR_LIKELY(--idx));
+template <typename Iter, typename Converter>
+Iter __biginteger_to_chars_impl(Iter first, const uint64_t *up, size_t n,
+                                unsigned int base, Converter conv) noexcept {
+    if (n == 1) {
+        return to_chars_unchecked(first, up[0], base, conv);
     }
 
-    return len;
-}
-
-template <typename Converter>
-size_t __biginteger_from_chars_16_impl(const uint8_t *first, size_t n, uint64_t *up,
-                                       Converter conv) noexcept {
-    const size_t hbits = (n - 1) % 16 + 1;
-    size_t len = (n - 1) / 16 + 1;
-
-    auto unroll = [conv](uint64_t &x, auto &first) {
-        auto x0 = conv.template from<16>(first[0]);
-        auto x1 = conv.template from<16>(first[1]);
-        auto x2 = conv.template from<16>(first[2]);
-        auto x3 = conv.template from<16>(first[3]);
-
-        x = x << 16 | x0 << 12 | x1 << 8 | x2 << 4 | x3;
-        first += 4;
-    };
-
-    uint64_t x = 0;
-    up += len;
-
-    __unsigned_from_chars_unchecked<16>(first, first + hbits, x, conv);
-    first += hbits;
-
-    *--up = x;
-
-    size_t idx = len - 1;
-
-    if (idx) {
-        do {
-            x = 0;
-
-            for (int i = 0; i < 4; ++i) {
-                unroll(x, first);
-            }
-
-            *--up = x;
-        } while (WJR_LIKELY(--idx));
+    if constexpr (convert_details::__is_fast_convert_iterator_v<Iter>) {
+        const auto __first = reinterpret_cast<uint8_t *>((to_address)(first));
+        const auto __result =
+            __fast_biginteger_large_to_chars_impl(__first, up, n, base, conv);
+        return first + std::distance(__first, __result);
+    } else {
+        return __fallback_biginteger_large_to_chars_impl(first, up, n, base, conv);
     }
-
-    return len;
 }
 
-template <typename Converter>
-size_t basecase_from_chars_10(const uint8_t *first, size_t n, uint64_t *up,
-                              Converter conv) noexcept {
-    uint64_t x = 0;
-
-    if (n <= 19) {
-        __unsigned_from_chars_unchecked<10>(first, first + n, x, conv);
-        up[0] = x;
-
-        return up[0] != 0;
-    }
-
-    size_t m = (n - 1) % 19 + 1;
-
-    __unsigned_from_chars_unchecked<10>(first, first + m, x, conv);
-    up[0] = x;
+/**
+ * @brief Convert a biginteger to a string by a given base.
+ *
+ * @tparam Iter Output iterator type
+ * @param[out] first Output iterator
+ * @param[in] up Pointer to the biginteger
+ * @param[in] n Length of the biginteger
+ * @param[in] base Base of the output string. Range: `[2, 36]`,
+ * Only support 10 and power of two currently.
+ * @return Output iterator after the conversion
+ */
+template <typename Iter, typename Converter = char_converter_t>
+Iter biginteger_to_chars(Iter first, const uint64_t *up, size_t n, unsigned int base = 10,
+                         Converter conv = {}) noexcept {
+    WJR_ASSERT(base <= 36 && (is_zero_or_single_bit(base) || base == 10));
+    WJR_ASSERT_ASSUME(up[n - 1] != 0);
 
-    first += m;
-    n -= m;
+    return __biginteger_to_chars_impl(first, up, n, base, conv);
+}
 
-    m = up[0] != 0;
+template <uint64_t Base>
+class __unsigned_from_chars_unchecked_fn {};
 
-    do {
-        x = 0;
+template <uint64_t Base>
+inline constexpr __unsigned_from_chars_unchecked_fn<Base>
+    __unsigned_from_chars_unchecked{};
 
-        x = __from_chars_unroll_16<10>(first, conv);
-        first += 16;
+template <>
+class __unsigned_from_chars_unchecked_fn<2> {
+    template <typename UnsignedValue, typename Converter>
+    static void fn(const uint8_t *first, const uint8_t *last, UnsignedValue &val,
+                   Converter conv) noexcept {
+        constexpr auto nd = std::numeric_limits<UnsignedValue>::digits;
 
-        x = x * 10 + conv.template from<10>(*first++);
-        x = x * 10 + conv.template from<10>(*first++);
-        x = x * 10 + conv.template from<10>(*first++);
+        auto n = std::distance(first, last);
+        WJR_ASSERT_ASSUME(1 <= n && n <= nd);
 
-        uint64_t cf;
+        if constexpr (nd >= 16) {
+            if (WJR_UNLIKELY(n >= 8)) {
+                do {
+                    val = (val << 8) + __from_chars_unroll_8<2>(first, conv);
+                    first += 8;
+                    n -= 8;
+                } while (WJR_LIKELY(n >= 8));
 
-        if (WJR_LIKELY(m == 0)) {
-            cf = x;
-        } else {
-            cf = mul_1(up, up, m, div2by1_divider_noshift_of_big_base_10.get_divisor());
-            cf += addc_1(up, up, m, x);
+                if (n == 0) {
+                    return;
+                }
+            }
+        } else if constexpr (nd == 8) {
+            if (WJR_UNLIKELY(n == 8)) {
+                val = __from_chars_unroll_8<2>(first, conv);
+                first += 8;
+                return;
+            }
         }
 
-        if (WJR_LIKELY(cf != 0)) {
-            up[m++] = cf;
+        switch (n) {
+        case 7: {
+            val = (val << 1) + conv.template from<2>(*first++);
+            WJR_FALLTHROUGH;
         }
-
-        n -= 19;
-    } while (WJR_LIKELY(n != 0));
-
-    return m;
-}
-
-template <typename Converter>
-size_t basecase_from_chars(const uint8_t *first, size_t n, uint64_t *up,
-                           unsigned int base, Converter conv) noexcept {
-    if (base == 10) {
-        return basecase_from_chars_10(first, n, up, conv);
-    } else {
-        return 0;
-    }
-}
-
-template <typename Converter>
-size_t dc_from_chars(const uint8_t *first, size_t n, uint64_t *up,
-                     precompute_chars_convert_t *pre, uint64_t *stk,
-                     Converter conv) noexcept {
-    const size_t lo = pre->digits_in_base;
-    if (n <= lo) {
-        if (n < dc_bignum_from_chars_threshold) {
-            return basecase_from_chars(first, n, up, pre->base, conv);
-        } else {
-            return dc_from_chars(first, n, up, pre - 1, stk, conv);
+        case 6: {
+            val = (val << 1) + conv.template from<2>(*first++);
+            WJR_FALLTHROUGH;
         }
-    }
-
-    const size_t hi = n - lo;
-    size_t hn, ln;
-
-    if (hi < dc_bignum_from_chars_threshold) {
-        hn = basecase_from_chars(first, hi, stk, pre->base, conv);
-    } else {
-        hn = dc_from_chars(first, hi, stk, pre - (lo * 2 >= n), up, conv);
-    }
-
-    const size_t ps = pre->shift;
-    const size_t pn = pre->n;
-
-    if (WJR_LIKELY(hn != 0)) {
-        if (pn >= hn) {
-            mul_s(up + ps, pre->ptr, pn, stk, hn);
-        } else {
-            mul_s(up + ps, stk, hn, pre->ptr, pn);
+        case 5: {
+            val = (val << 1) + conv.template from<2>(*first++);
+            WJR_FALLTHROUGH;
         }
-        set_n(up, 0, ps);
-    }
-
-    std::advance(first, hi);
-    if (lo < dc_bignum_from_chars_threshold) {
-        ln = basecase_from_chars(first, lo, stk, pre->base, conv);
-    } else {
-        ln = dc_from_chars(first, lo, stk, pre - (lo * 2 >= n), stk + pn + ps + 1, conv);
-    }
-
-    WJR_ASSERT(ps + pn + 1 >= ln);
-
-    if (WJR_LIKELY(hn != 0)) {
-        if (WJR_LIKELY(ln != 0)) {
-            auto cf = addc_s(up, up, ps + pn + hn, stk, ln);
-            WJR_ASSERT(cf == 0);
-            (void)(cf);
+        case 4: {
+            val <<= 4;
+            val += __from_chars_unroll_4<2>(first, conv);
+            first += 4;
+            break;
         }
-
-        n = ps + pn + hn;
-        return n - (up[n - 1] == 0);
-    }
-
-    if (WJR_LIKELY(ln != 0)) {
-        std::copy_n(stk, ln, up);
-    }
-
-    return ln;
-}
-
-template <typename Converter>
-uint64_t *__biginteger_from_chars_impl(const uint8_t *first, const uint8_t *last,
-                                       uint64_t *up, unsigned int base,
-                                       Converter conv = {}) noexcept {
-    WJR_ASSERT(base <= 36 && (is_zero_or_single_bit(base) || base == 10));
-
-    const size_t n = std::distance(first, last);
-
-    if (is_zero_or_single_bit(base)) {
-        switch (base) {
-        case 2: {
-            return up + __biginteger_from_chars_2_impl(first, n, up, conv);
+        case 3: {
+            val = (val << 1) + conv.template from<2>(*first++);
+            WJR_FALLTHROUGH;
         }
-        case 8: {
-            return up + __biginteger_from_chars_8_impl(first, n, up, conv);
+        case 2: {
+            val = (val << 1) + conv.template from<2>(*first++);
+            WJR_FALLTHROUGH;
         }
-        case 16: {
-            return up + __biginteger_from_chars_16_impl(first, n, up, conv);
+        case 1: {
+            val = (val << 1) + conv.template from<2>(*first++);
+            break;
         }
         default: {
             WJR_UNREACHABLE();
-            return up;
+            break;
         }
         }
     }
 
-    if (WJR_LIKELY(n < dc_bignum_from_chars_precompute_threshold)) {
-        return up + basecase_from_chars(first, n, up, base, conv);
+public:
+    template <typename UnsignedValue, typename Converter,
+              WJR_REQUIRES(is_nonbool_unsigned_integral_v<UnsignedValue>)>
+    void operator()(const uint8_t *first, const uint8_t *last, UnsignedValue &val,
+                    Converter conv) const noexcept {
+        return fn(first, last, val, conv);
     }
+};
 
-    const auto per_digits = precompute_chars_convert_16n_ptr[base]->digits_in_one_base;
-
-    precompute_chars_convert_t pre[64 - 3];
-
-    unique_stack_allocator stkal(math_details::stack_alloc);
-    const size_t un = n / per_digits + 1;
-    auto stk =
-        static_cast<uint64_t *>(stkal.allocate((un * 16 / 5 + 192) * sizeof(uint64_t)));
-    const auto mpre = precompute_chars_convert(pre, un, base, stk);
-    stk += un * 8 / 5 + 128;
-    return up + dc_from_chars(first, n, up, mpre, stk, conv);
-}
-
-/**
- * @brief Convert a string to a biginteger by a given base.
- *
- * @tparam Iter Input iterator type
- * @param[in] first Input iterator
- * @param[in] last Input iterator
- * @param[out] up Pointer to the biginteger
- * @param[in] base Base of the input string. Range: `[2, 36]`,
- * Only support 10 and power of two currently.
- * @return Pointer after the conversion
- */
-template <typename Iter, typename Converter = char_converter_t,
-          WJR_REQUIRES(convert_details::__is_fast_convert_iterator_v<Iter>)>
-uint64_t *biginteger_from_chars(Iter first, Iter last, uint64_t *up,
-                                unsigned int base = 10, Converter conv = {}) noexcept {
-    WJR_ASSERT(base <= 36 && (is_zero_or_single_bit(base) || base == 10));
-
-    const auto __first = reinterpret_cast<const uint8_t *>((to_address)(first));
-    const auto __last = reinterpret_cast<const uint8_t *>((to_address)(last));
-
-    return __biginteger_from_chars_impl(__first, __last, up, base, conv);
-}
-
-} // namespace wjr
-
-#endif // WJR_MATH_CONVERT_HPP__
-#ifndef WJR_MATH_COPY_HPP__
-#define WJR_MATH_COPY_HPP__
-
-// Already included
-
-namespace wjr {
-
-/// @private
-template <typename InputIt, typename OutputIt>
-struct __is_builtin_copy
-    : std::conjunction<
-          std::is_trivially_copyable<iterator_value_t<InputIt>>,
-          std::is_same<iterator_value_t<InputIt>, iterator_value_t<OutputIt>>,
-          is_contiguous_iterator<InputIt>, is_contiguous_iterator<OutputIt>> {};
-
-/// @private
-template <typename InputIt, typename OutputIt>
-inline constexpr bool __is_builtin_copy_v = __is_builtin_copy<InputIt, OutputIt>::value;
-
-} // namespace wjr
-
-#endif // WJR_MATH_COPY_HPP__
-#ifndef WJR_MATH_NEG_HPP__
-#define WJR_MATH_NEG_HPP__
-
-#ifndef WJR_MATH_NOT_HPP__
-#define WJR_MATH_NOT_HPP__
-
-// Already included
-
-#if defined(WJR_X86)
-#ifndef WJR_X86_MATH_NOT_HPP__
-#define WJR_X86_MATH_NOT_HPP__
-
-// Already included
-// Already included
-
-#ifndef WJR_X86
-#error "x86 required"
-#endif
-
-namespace wjr {
-
-#if WJR_HAS_SIMD(SSE2) && WJR_HAS_SIMD(X86_SIMD)
-#define WJR_HAS_BUILTIN_COMPLEMENT_N WJR_HAS_DEF
-#endif
-
-#if WJR_HAS_BUILTIN(COMPLEMENT_N)
-
-template <typename T>
-WJR_COLD void large_builtin_not_n(T *dst, const T *src, size_t n) noexcept {
-    constexpr auto is_avx = WJR_HAS_SIMD(AVX2);
-
-    using simd = std::conditional_t<is_avx, avx, sse>;
-    using simd_int = typename simd::int_type;
-    constexpr auto simd_width = simd::width();
-    constexpr auto type_width = simd_width / 64;
-
-    const uintptr_t ptr = reinterpret_cast<uintptr_t>(dst);
-    WJR_ASSUME(ptr % sizeof(T) == 0);
-    const size_t offset = __align_up_offset(ptr, 32) / sizeof(T);
-
-    WJR_ASSUME(offset < 4);
-
-    const auto y = sse::ones();
-
-    switch (offset) {
-    case 0: {
-        break;
-    }
-    case 1: {
-        dst[0] = ~src[0];
-
-        ++dst;
-        ++src;
-        --n;
-        break;
-    }
-    case 2: {
-        sse::storeu((__m128i *)(dst), sse::Xor(sse::loadu((__m128i *)(src)), y));
-
-        dst += 2;
-        src += 2;
-        n -= 2;
-        break;
-    }
-
-    case 3: {
-        sse::storeu((__m128i *)(dst), sse::Xor(sse::loadu((__m128i *)(src)), y));
-        dst[2] = ~src[2];
-
-        dst += 3;
-        src += 3;
-        n -= 3;
-        break;
-    }
-
-    default: {
-        WJR_UNREACHABLE();
-    }
-    }
-
-    auto z = broadcast<__m128i_t, typename simd::int_tag_type>(y);
-
-    size_t idx = 0;
-    size_t m = n & (-type_width * 4);
-
-    WJR_ASSUME(idx != m);
-
-    do {
-        auto x0 = simd::loadu((simd_int *)(src + idx));
-        auto x1 = simd::loadu((simd_int *)(src + idx + type_width));
-        auto x2 = simd::loadu((simd_int *)(src + idx + type_width * 2));
-        auto x3 = simd::loadu((simd_int *)(src + idx + type_width * 3));
-
-        simd::store((simd_int *)(dst + idx), simd::Xor(x0, z));
-        simd::store((simd_int *)(dst + idx + type_width), simd::Xor(x1, z));
-        simd::store((simd_int *)(dst + idx + type_width * 2), simd::Xor(x2, z));
-        simd::store((simd_int *)(dst + idx + type_width * 3), simd::Xor(x3, z));
-
-        idx += type_width * 4;
-    } while (idx != m);
-
-    if (WJR_UNLIKELY(n == m)) {
-        return;
-    }
-
-    dst += m;
-    src += m;
-    n -= m;
-
-    m = n / type_width;
-    WJR_ASSUME(m < 4);
-
-    switch (m) {
-    case 3: {
-        simd::store((simd_int *)(dst), simd::Xor(simd::loadu((simd_int *)(src)), z));
-        WJR_FALLTHROUGH;
-    }
-    case 2: {
-        simd::store((simd_int *)(dst + type_width * (m - 2)),
-                    simd::Xor(simd::loadu((simd_int *)(src + type_width * (m - 2))), z));
-        WJR_FALLTHROUGH;
-    }
-    case 1: {
-        simd::store((simd_int *)(dst + type_width * (m - 1)),
-                    simd::Xor(simd::loadu((simd_int *)(src + type_width * (m - 1))), z));
-        WJR_FALLTHROUGH;
-    }
-    case 0: {
-        break;
-    }
-    default: {
-        WJR_UNREACHABLE();
-    }
-    }
-
-    m = n & (-type_width);
-
-    if (WJR_UNLIKELY(n == m)) {
-        return;
-    }
-
-    WJR_ASSUME(n - m < 4);
-
-    switch (n - m) {
-    case 1: {
-        dst[m] = ~src[m];
-        break;
-    }
-    case 2: {
-        sse::store((__m128i *)(dst + m), sse::Xor(sse::loadu((__m128i *)(src + m)), y));
-        break;
-    }
-
-    case 3: {
-        sse::store((__m128i *)(dst + m), sse::Xor(sse::loadu((__m128i *)(src + m)), y));
-        dst[m + 2] = ~src[m + 2];
-        break;
-    }
-
-    default: {
-        WJR_UNREACHABLE();
-    }
-    }
-
-    return;
-}
-
-template <typename T>
-WJR_INTRINSIC_INLINE void builtin_not_n(T *dst, const T *src, size_t n) noexcept {
-    static_assert(sizeof(T) == 8, "");
-
-    if (WJR_UNLIKELY(n < 4)) {
-        switch (n) {
-        case 3: {
-            dst[0] = ~src[0];
-            WJR_FALLTHROUGH;
-        }
-        case 2: {
-            dst[n - 2] = ~src[n - 2];
-            WJR_FALLTHROUGH;
-        }
-        case 1: {
-            dst[n - 1] = ~src[n - 1];
-            WJR_FALLTHROUGH;
-        }
-        case 0: {
-            break;
-        }
-        }
-
-        return;
-    }
-
-    if (WJR_UNLIKELY(n >= 35)) {
-        // Can be aligned
-        // TODO : Align those that cannot be aligned with T through uint8_t
-        if (WJR_LIKELY(reinterpret_cast<uintptr_t>(dst) % sizeof(T) == 0)) {
-            return large_builtin_not_n(dst, src, n);
-        }
-    }
-
-    size_t idx = 0;
-
-    const auto y = sse::ones();
-
-    if (n & 4) {
-        auto x0 = sse::loadu((__m128i *)(src + idx));
-        auto x1 = sse::loadu((__m128i *)(src + idx + 2));
-
-        sse::storeu((__m128i *)(dst + idx), sse::Xor(x0, y));
-        sse::storeu((__m128i *)(dst + idx + 2), sse::Xor(x1, y));
-
-        idx += 4;
-    }
-
-    if (n & 2) {
-        sse::storeu((__m128i *)(dst + idx),
-                    sse::Xor(sse::loadu((__m128i *)(src + idx)), y));
-
-        idx += 2;
-    }
-
-    if (n & 1) {
-        dst[idx] = ~src[idx];
-
-        ++idx;
-    }
-
-    if (WJR_UNLIKELY(idx == n)) {
-        return;
-    }
-
-    WJR_ASSUME((n - idx) % 8 == 0);
-
-    do {
-        auto x0 = sse::loadu((__m128i *)(src + idx));
-        auto x1 = sse::loadu((__m128i *)(src + idx + 2));
-        auto x2 = sse::loadu((__m128i *)(src + idx + 4));
-        auto x3 = sse::loadu((__m128i *)(src + idx + 6));
-
-        sse::storeu((__m128i *)(dst + idx), sse::Xor(x0, y));
-        sse::storeu((__m128i *)(dst + idx + 2), sse::Xor(x1, y));
-        sse::storeu((__m128i *)(dst + idx + 4), sse::Xor(x2, y));
-        sse::storeu((__m128i *)(dst + idx + 6), sse::Xor(x3, y));
-
-        idx += 8;
-    } while (idx != n);
-}
-
-#endif //
-
-} // namespace wjr
-
-#endif // WJR_X86_MATH_NOT_HPP__
-#endif
-
-namespace wjr {
-
-template <typename T>
-WJR_INTRINSIC_CONSTEXPR void fallback_not_n(T *dst, const T *src, size_t n) noexcept {
-    for (size_t i = 0; i < n; ++i) {
-        dst[i] = ~src[i];
-    }
-}
-
-template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-WJR_INTRINSIC_CONSTEXPR_E void not_n(T *dst, const T *src, size_t n) noexcept {
-#if WJR_HAS_BUILTIN(COMPLEMENT_N)
-    if constexpr (sizeof(T) == 8) {
-        if (is_constant_evaluated()) {
-            return fallback_not_n(dst, src, n);
-        }
-
-        return builtin_not_n(dst, src, n);
-    } else {
-        return fallback_not_n(dst, src, n);
-    }
-#else
-    return fallback_not_n(dst, src, n);
-#endif
-}
-
-} // namespace wjr
-
-#endif // WJR_MATH_NOT_HPP__
-// Already included
-
-namespace wjr {
-
-/*
-  return true if src is all zero
-  calculations : stable n instead of not + inc which maybe n * 2
-*/
-template <typename T>
-WJR_INTRINSIC_CONSTEXPR_E bool negate_n(T *dst, const T *src, size_t n) noexcept {
-    size_t idx = replace_find_not(dst, src, n, 0, 0);
-
-    if (idx == n) {
-        return true;
-    }
-
-    dst[idx] = -src[idx];
-    not_n(dst + idx + 1, src + idx + 1, n - idx - 1);
-    return false;
-}
-
-} // namespace wjr
-
-#endif // WJR_MATH_NEG_HPP__
-#ifndef WJR_MATH_PREFIX_XOR_HPP__
-#define WJR_MATH_PREFIX_XOR_HPP__
-
-// Already included
-
-#if defined(WJR_X86)
-#ifndef WJR_X86_MATH_PREFIX_XOR_HPP__
-#define WJR_X86_MATH_PREFIX_XOR_HPP__
-
-// Already included
-// Already included
-
-namespace wjr {
-
-#if WJR_HAS_SIMD(PCLMUL) && WJR_HAS_SIMD(X86_SIMD)
-#define WJR_HAS_BUILTIN_PREFIX_XOR WJR_HAS_DEF
-#endif
-
-#if WJR_HAS_BUILTIN(PREFIX_XOR)
-
-template <typename T>
-T __builtin_prefix_xor(T x) noexcept {
-    const __m128i __result =
-        _mm_clmulepi64_si128((simd_cast<T, __m128i_t>(x)), sse::set1_epi8(0xFF), 0);
-    return simd_cast<__m128i_t, T>(__result);
-}
-
-template <typename T>
-T builtin_prefix_xor(T x) noexcept {
-    constexpr auto nd = std::numeric_limits<T>::digits;
-    if constexpr (nd < 32) {
-        return static_cast<T>(__builtin_prefix_xor(static_cast<uint32_t>(x)));
-    } else {
-        return __builtin_prefix_xor(x);
-    }
-}
-
-#endif
-
-} // namespace wjr
-
-#endif // WJR_X86_MATH_PREFIX_XOR_HPP__
-#endif
-
-namespace wjr {
-
-template <typename T>
-constexpr T fallback_prefix_xor(T x) noexcept {
-    constexpr auto nd = std::numeric_limits<T>::digits;
-    static_assert(nd <= 64, "Type T has more than 64 bits");
-
-    x ^= x << 1;
-    x ^= x << 2;
-    x ^= x << 4;
-    if constexpr (nd > 8) {
-        x ^= x << 8;
-    }
-    if constexpr (nd > 16) {
-        x ^= x << 16;
-    }
-    if constexpr (nd > 32) {
-        x ^= x << 32;
-    }
-
-    return x;
-}
-
-template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-WJR_INTRINSIC_CONSTEXPR_E T prefix_xor(T x) noexcept {
-#if WJR_HAS_BUILTIN(PREFIX_XOR)
-    if (is_constant_evaluated() || WJR_BUILTIN_CONSTANT_P(x)) {
-        return fallback_prefix_xor(x);
-    }
-
-    return builtin_prefix_xor(x);
-#else
-    return fallback_prefix_xor(x);
-#endif
-}
-
-} // namespace wjr
-
-#endif // WJR_MATH_PREFIX_XOR_HPP__
-#ifndef WJR_MATH_RANDOM_HPP__
-#define WJR_MATH_RANDOM_HPP__
-
-#include <algorithm>
-#include <random>
-
-// Already included
-
-namespace wjr {
+template <>
+class __unsigned_from_chars_unchecked_fn<8> {
+    template <typename UnsignedValue, typename Converter>
+    static void fn(const uint8_t *first, const uint8_t *last, UnsignedValue &val,
+                   Converter conv) noexcept {
+        constexpr auto nd = std::numeric_limits<UnsignedValue>::digits;
 
-template <typename Engine, typename = void>
-struct __uniform_random_bit_generator_impl : std::false_type {};
+        auto n = std::distance(first, last);
+        WJR_ASSERT_ASSUME(1 <= n && n <= (nd + 2) / 3);
 
-template <typename Engine>
-struct __uniform_random_bit_generator_impl<Engine,
-                                           std::enable_if_t<has_invocable_v<Engine &>>>
-    : std::conjunction<
-          is_nonbool_unsigned_integral<std::invoke_result_t<Engine &>>,
-          std::is_same<decltype(Engine::min()), std::invoke_result_t<Engine &>>,
-          std::is_same<decltype(Engine::max()), std::invoke_result_t<Engine &>>> {};
+        if constexpr (nd >= 32) {
+            if (WJR_UNLIKELY(n >= 8)) {
+                do {
+                    val = (val << 24) + __from_chars_unroll_8<8>(first, conv);
+                    first += 8;
+                    n -= 8;
+                } while (WJR_LIKELY(n >= 8));
 
-template <typename Engine>
-struct uniform_random_bit_generator : __uniform_random_bit_generator_impl<Engine> {};
+                if (n == 0) {
+                    return;
+                }
+            }
+        }
 
-template <typename Engine>
-inline constexpr bool uniform_random_bit_generator_v =
-    uniform_random_bit_generator<Engine>::value;
+        switch (n) {
+        case 7: {
+            val = (val << 3) + conv.template from<8>(*first++);
+            WJR_FALLTHROUGH;
+        }
+        case 6: {
+            val = (val << 3) + conv.template from<8>(*first++);
+            WJR_FALLTHROUGH;
+        }
+        case 5: {
+            val = (val << 3) + conv.template from<8>(*first++);
+            WJR_FALLTHROUGH;
+        }
+        case 4: {
+            val <<= 12;
+            val += __from_chars_unroll_4<8>(first, conv);
+            first += 4;
+            break;
+        }
+        case 3: {
+            val = (val << 3) + conv.template from<8>(*first++);
+            WJR_FALLTHROUGH;
+        }
+        case 2: {
+            val = (val << 3) + conv.template from<8>(*first++);
+            WJR_FALLTHROUGH;
+        }
+        case 1: {
+            val = (val << 3) + conv.template from<8>(*first++);
+            break;
+        }
+        default: {
+            WJR_UNREACHABLE();
+            break;
+        }
+        }
+    }
 
-template <typename Engine>
-struct biginteger_uniform_random_bit_generator
-    : std::conjunction<
-          __uniform_random_bit_generator_impl<Engine>,
-          std::is_same<std::invoke_result_t<Engine &>, uint64_t>,
-          std::bool_constant<Engine::min() == std::numeric_limits<uint64_t>::min()>,
-          std::bool_constant<Engine::max() == std::numeric_limits<uint64_t>::max()>> {};
+public:
+    template <typename UnsignedValue, typename Converter,
+              WJR_REQUIRES(is_nonbool_unsigned_integral_v<UnsignedValue>)>
+    void operator()(const uint8_t *first, const uint8_t *last, UnsignedValue &val,
+                    Converter conv) const noexcept {
+        return fn(first, last, val, conv);
+    }
+};
 
-template <typename Engine>
-inline constexpr bool biginteger_uniform_random_bit_generator_v =
-    biginteger_uniform_random_bit_generator<Engine>::value;
+template <>
+class __unsigned_from_chars_unchecked_fn<16> {
+    template <typename UnsignedValue, typename Converter>
+    static void fn(const uint8_t *first, const uint8_t *last, UnsignedValue &val,
+                   Converter conv) noexcept {
+        constexpr auto nd = std::numeric_limits<UnsignedValue>::digits;
 
-template <typename Iter, typename Rand>
-void random(Iter first, Iter last, Rand &&rd) {
-    std::generate(first, last, std::ref(rd));
-}
+        auto n = std::distance(first, last);
+        WJR_ASSERT_ASSUME(1 <= n && n <= (nd + 3) / 4);
 
-template <typename Iter, typename Rand>
-void random_n(Iter First, size_t Count, Rand &&rd) {
-    std::generate_n(First, Count, std::ref(rd));
-}
+        if constexpr (nd >= 64) {
+            if (WJR_UNLIKELY(n >= 8)) {
+                do {
+                    val = (val << 32) + __from_chars_unroll_8<16>(first, conv);
+                    first += 8;
+                    n -= 8;
+                } while (WJR_LIKELY(n >= 8));
 
-} // namespace wjr
+                if (n == 0) {
+                    return;
+                }
+            }
+        } else if constexpr (nd == 32) {
+            if (WJR_UNLIKELY(n == 8)) {
+                val = __from_chars_unroll_8<16>(first, conv);
+                first += 8;
+                return;
+            }
+        }
 
-#endif // WJR_MATH_RANDOM_HPP__
+        switch (n) {
+        case 7: {
+            val = (val << 4) + conv.template from<16>(*first++);
+            WJR_FALLTHROUGH;
+        }
+        case 6: {
+            val = (val << 4) + conv.template from<16>(*first++);
+            WJR_FALLTHROUGH;
+        }
+        case 5: {
+            val = (val << 4) + conv.template from<16>(*first++);
+            WJR_FALLTHROUGH;
+        }
+        case 4: {
+            val <<= 16;
+            val += __from_chars_unroll_4<16>(first, conv);
+            first += 4;
+            break;
+        }
+        case 3: {
+            val = (val << 4) + conv.template from<16>(*first++);
+            WJR_FALLTHROUGH;
+        }
+        case 2: {
+            val = (val << 4) + conv.template from<16>(*first++);
+            WJR_FALLTHROUGH;
+        }
+        case 1: {
+            val = (val << 4) + conv.template from<16>(*first++);
+            break;
+        }
+        default: {
+            WJR_UNREACHABLE();
+            break;
+        }
+        }
+    }
 
-#endif // WJR_MATH_HPP__
-// Already included
-// Already included
+public:
+    template <typename UnsignedValue, typename Converter,
+              WJR_REQUIRES(is_nonbool_unsigned_integral_v<UnsignedValue>)>
+    void operator()(const uint8_t *first, const uint8_t *last, UnsignedValue &val,
+                    Converter conv) const noexcept {
+        return fn(first, last, val, conv);
+    }
+};
 
-namespace wjr {
+template <>
+class __unsigned_from_chars_unchecked_fn<1> {};
 
-template <typename Storage>
-struct is_biginteger_storage : std::false_type {};
+template <>
+class __unsigned_from_chars_unchecked_fn<10> {
+    template <typename UnsignedValue, typename Converter>
+    static void fn(const uint8_t *first, const uint8_t *last, UnsignedValue &val,
+                   Converter conv) noexcept {
+        constexpr auto nd = std::numeric_limits<UnsignedValue>::digits10 + 1;
 
-template <typename Storage>
-inline constexpr bool is_biginteger_storage_v = is_biginteger_storage<Storage>::value;
+        auto n = std::distance(first, last);
+        WJR_ASSUME(1 <= n && n <= nd);
 
-namespace biginteger_details {
+        if constexpr (nd >= 8) {
+            if (WJR_UNLIKELY(n >= 8)) {
+                if (WJR_UNLIKELY(n >= 16)) {
+                    val = __from_chars_unroll_16<10>(first, conv);
+                    first += 16;
+                    n -= 16;
+                } else {
+                    val = __from_chars_unroll_8<10>(first, conv);
+                    first += 8;
+                    n -= 8;
+                }
 
-/**
- * @brief Remove leading zeros.
- *
- */
-inline uint32_t normalize(const uint64_t *ptr, uint32_t n) noexcept {
-    return reverse_find_not_n(ptr, 0, n);
-}
+                if (WJR_UNLIKELY(n == 0)) {
+                    return;
+                }
+            }
+        }
 
-} // namespace biginteger_details
+        switch (n) {
+        case 7: {
+            val = val * 10 + conv.template from<10>(*first++);
+            WJR_FALLTHROUGH;
+        }
+        case 6: {
+            val = val * 10 + conv.template from<10>(*first++);
+            WJR_FALLTHROUGH;
+        }
+        case 5: {
+            val = val * 10 + conv.template from<10>(*first++);
+            WJR_FALLTHROUGH;
+        }
+        case 4: {
+            val = (val * 10000) + __from_chars_unroll_4<10>(first, conv);
+            break;
+        }
+        case 3: {
+            val = val * 10 + conv.template from<10>(*first++);
+            WJR_FALLTHROUGH;
+        }
+        case 2: {
+            val = val * 10 + conv.template from<10>(*first++);
+            WJR_FALLTHROUGH;
+        }
+        case 1: {
+            val = val * 10 + conv.template from<10>(*first++);
+            WJR_FALLTHROUGH;
+        }
+        case 0: {
+            break;
+        }
+        default: {
+            WJR_UNREACHABLE();
+            break;
+        }
+        }
+    }
 
-class default_biginteger_size_reference {
 public:
-    default_biginteger_size_reference() = delete;
-    default_biginteger_size_reference(const default_biginteger_size_reference &) = delete;
-    default_biginteger_size_reference(default_biginteger_size_reference &&) = default;
-    default_biginteger_size_reference &
-    operator=(const default_biginteger_size_reference &) = delete;
-    default_biginteger_size_reference &
-    operator=(default_biginteger_size_reference &&) = default;
+    template <typename UnsignedValue, typename Converter,
+              WJR_REQUIRES(is_nonbool_unsigned_integral_v<UnsignedValue>)>
+    void operator()(const uint8_t *first, const uint8_t *last, UnsignedValue &val,
+                    Converter conv) const noexcept {
+        return fn(first, last, val, conv);
+    }
+};
 
-    explicit default_biginteger_size_reference(int32_t &size) noexcept : m_size(&size) {}
-    ~default_biginteger_size_reference() = default;
+template <typename Value, typename IBase, typename Converter,
+          WJR_REQUIRES(is_nonbool_integral_v<Value>)>
+void __fast_from_chars_unchecked_impl(const uint8_t *first, const uint8_t *last,
+                                      Value &val, IBase ibase, Converter conv) noexcept {
+    int sign = 0;
 
-    default_biginteger_size_reference &operator=(uint32_t size) noexcept {
-        *m_size = __fasts_negate_with<int32_t>(*m_size, size);
-        return *this;
+    if constexpr (std::is_signed_v<Value>) {
+        WJR_ASSERT(first != last);
+
+        if (*first == '-') {
+            ++first;
+            sign = 1;
+        }
     }
 
-    WJR_PURE operator uint32_t() const noexcept { return __fasts_abs(*m_size); }
+    std::make_unsigned_t<Value> uVal = 0;
 
-    default_biginteger_size_reference &operator++() noexcept {
-        *m_size = __fasts_increment(*m_size);
-        return *this;
-    }
+    const unsigned int base = ibase;
 
-    default_biginteger_size_reference &operator--() noexcept {
-        *m_size = __fasts_decrement(*m_size);
-        return *this;
+    switch (base) {
+    case 2: {
+        __unsigned_from_chars_unchecked<2>(first, last, uVal, conv);
+        break;
     }
-
-    default_biginteger_size_reference &operator+=(uint32_t size) noexcept {
-        *m_size = __fasts_add(*m_size, size);
-        return *this;
+    case 8: {
+        __unsigned_from_chars_unchecked<8>(first, last, uVal, conv);
+        break;
+    }
+    case 16: {
+        __unsigned_from_chars_unchecked<16>(first, last, uVal, conv);
+        break;
+    }
+    case 10: {
+        __unsigned_from_chars_unchecked<10>(first, last, uVal, conv);
+        break;
+    }
+    default: {
+        WJR_UNREACHABLE();
+        break;
     }
-
-    default_biginteger_size_reference &operator-=(uint32_t size) noexcept {
-        *m_size = __fasts_sub(*m_size, size);
-        return *this;
     }
 
-private:
-    int32_t *m_size;
-};
-
-/// @private
-template <>
-struct __unref_wrapper_helper<default_biginteger_size_reference> {
-    using type = uint32_t &;
-};
-
-/**
- * @brief data_type of biginteger
- *
- * @details View the data of biginteger. Used for type erasure. Manage memory allocation
- * and release on your own.
- *
- */
-struct biginteger_data {
-    WJR_PURE constexpr const uint64_t *data() const noexcept { return m_data; }
-    WJR_PURE constexpr uint32_t size() const noexcept { return __fasts_abs(m_size); }
-
-    WJR_PURE constexpr bool empty() const noexcept { return m_size == 0; }
-    WJR_PURE constexpr bool is_negate() const noexcept { return m_size < 0; }
-
-    WJR_PURE constexpr int32_t get_ssize() const noexcept { return m_size; }
-
-    uint64_t *m_data = nullptr;
-    int32_t m_size = 0;
-    uint32_t m_capacity = 0;
-};
-
-/**
- * @struct biginteger_data
- * @brief The data structure for biginteger
- *
- */
-template <typename Alloc>
-class default_biginteger_vector_storage {
-    using _Alty = typename std::allocator_traits<Alloc>::template rebind_alloc<uint64_t>;
-    using _Alty_traits = std::allocator_traits<_Alty>;
-
-public:
-    using value_type = uint64_t;
-    using pointer = typename _Alty_traits::pointer;
-    using const_pointer = typename _Alty_traits::const_pointer;
-    using size_type = uint32_t;
-    using difference_type = int32_t;
-    using allocator_type = Alloc;
-    using storage_traits_type = vector_storage_traits<uint64_t, Alloc>;
-    using is_reallocatable = std::true_type;
-
-public:
-    default_biginteger_vector_storage() noexcept = default;
+    if (sign) {
+        val = -static_cast<Value>(uVal);
+    } else {
+        val = static_cast<Value>(uVal);
+    }
+}
 
-    default_biginteger_vector_storage(const default_biginteger_vector_storage &) = delete;
-    default_biginteger_vector_storage(default_biginteger_vector_storage &&) noexcept =
-        delete;
-    default_biginteger_vector_storage &
-    operator=(const default_biginteger_vector_storage &) = delete;
-    default_biginteger_vector_storage &
-    operator=(default_biginteger_vector_storage &&) noexcept = delete;
+template <typename Iter, typename Value, typename IBase, typename Converter,
+          WJR_REQUIRES(is_nonbool_integral_v<Value>)>
+void __from_chars_unchecked_impl(Iter first, Iter last, Value &val, IBase ibase,
+                                 Converter conv) noexcept {
+    const auto __first = reinterpret_cast<const uint8_t *>((to_address)(first));
+    const auto __last = reinterpret_cast<const uint8_t *>((to_address)(last));
+    __fast_from_chars_unchecked_impl(__first, __last, val, ibase, conv);
+}
 
-    ~default_biginteger_vector_storage() noexcept = default;
+template <typename Iter, typename Value, typename BaseType = unsigned int,
+          BaseType IBase = 10, typename Converter = char_converter_t,
+          WJR_REQUIRES(convert_details::__is_fast_convert_iterator_v<Iter>
+                           &&convert_details::__is_valid_converter_v<Value, Converter>)>
+void from_chars_unchecked(Iter first, Iter last, Value &val,
+                          std::integral_constant<BaseType, IBase> = {},
+                          Converter conv = {}) noexcept {
+    __from_chars_unchecked_impl(first, last, val,
+                                std::integral_constant<unsigned int, IBase>(), conv);
+}
 
-    void destroy(_Alty &al) noexcept {
-        if (WJR_BUILTIN_CONSTANT_P(data() == nullptr) && data() == nullptr) {
+template <typename Iter, typename Value, typename Converter,
+          WJR_REQUIRES(convert_details::__is_fast_convert_iterator_v<Iter>
+                           &&convert_details::__is_valid_converter_v<Value, Converter>)>
+void from_chars_unchecked(Iter first, Iter last, Value &val, unsigned int base,
+                          Converter conv = {}) noexcept {
+    if (WJR_BUILTIN_CONSTANT_P(base)) {
+        switch (base) {
+        case 2: {
+            __from_chars_unchecked_impl(first, last, val, 2_u, conv);
             return;
         }
-
-        const size_type __size = size();
-
-        if (WJR_BUILTIN_CONSTANT_P(__size == 0) && __size == 0) {
+        case 8: {
+            __from_chars_unchecked_impl(first, last, val, 8_u, conv);
             return;
         }
-
-        destroy_n_using_allocator(data(), __size, al);
-    }
-
-    void destroy_and_deallocate(_Alty &al) noexcept {
-        if (WJR_BUILTIN_CONSTANT_P(capacity() == 0) && capacity() == 0) {
+        case 16: {
+            __from_chars_unchecked_impl(first, last, val, 16_u, conv);
             return;
         }
-
-        if (data()) {
-            WJR_ASSERT_ASSUME_L2(capacity() != 0);
-
-            destroy(al);
-            al.deallocate(data(), capacity());
+        case 10: {
+            __from_chars_unchecked_impl(first, last, val, 10_u, conv);
+            return;
+        }
+        default: {
+            break;
+        }
         }
     }
 
-    void uninitialized_construct(default_biginteger_vector_storage &other, size_type size,
-                                 size_type capacity, _Alty &al) {
-        if (capacity != 0) {
-            auto &storage = other.m_storage;
-            storage.m_data = al.allocate(capacity);
-            storage.m_size = __fasts_negate_with<int32_t>(m_storage.m_size, size);
-            storage.m_capacity = capacity;
+    __from_chars_unchecked_impl(first, last, val, base, conv);
+}
+
+template <uint64_t Base>
+struct __unsigned_from_chars_fn {};
+
+template <uint64_t Base>
+inline constexpr __unsigned_from_chars_fn<Base> __unsigned_from_chars{};
+
+template <>
+struct __unsigned_from_chars_fn<2> {
+    template <typename UnsignedValue, typename Converter,
+              WJR_REQUIRES(is_nonbool_unsigned_integral_v<UnsignedValue>)>
+    int operator()(const uint8_t *&first, const uint8_t *last, UnsignedValue &value,
+                   Converter conv) const noexcept {
+        constexpr auto nd = std::numeric_limits<UnsignedValue>::digits;
+        constexpr auto zero = conv.template to<2>(0);
+        constexpr auto one = conv.template to<2>(1);
+
+        if (first == last) {
+            return 2;
         }
-    }
 
-    void take_storage(default_biginteger_vector_storage &other, _Alty &) noexcept {
-        auto &other_storage = other.m_storage;
-        m_storage = other_storage;
-        other_storage.m_data = nullptr;
-        other_storage.m_size = other_storage.m_capacity = 0;
-    }
+        uint8_t ch = first[0];
 
-    void swap_storage(default_biginteger_vector_storage &other, _Alty &) noexcept {
-        std::swap(m_storage, other.m_storage);
-    }
+        if (ch == one) {
+        } else if (ch == zero) {
+            do {
+                ++first;
+                if (first == last) {
+                    return 1;
+                }
 
-    WJR_PURE default_biginteger_size_reference size() noexcept {
-        return default_biginteger_size_reference(m_storage.m_size);
-    }
+                ch = first[0];
+            } while (ch == zero);
+            if (ch != one) {
+                return 1;
+            }
+        } else {
+            return 2;
+        }
 
-    WJR_PURE size_type size() const noexcept { return __fasts_abs(m_storage.m_size); }
-    WJR_PURE size_type capacity() const noexcept { return m_storage.m_capacity; }
+        const size_t n = std::distance(first, last);
+        ch = 1;
+        size_t idx = 0;
 
-    WJR_PURE pointer data() noexcept { return m_storage.m_data; }
-    WJR_PURE const_pointer data() const noexcept { return m_storage.m_data; }
+        do {
+            value = value << 1 | ch;
+            ++idx;
+            if (idx == n) {
+                break;
+            }
 
-    // extension
+            ch = conv.template from<2>(first[idx]);
+        } while (ch < 2);
 
-    WJR_PURE int32_t get_ssize() const noexcept { return m_storage.m_size; }
-    template <typename T, WJR_REQUIRES(is_any_of_v<T, int32_t>)>
-    void set_ssize(T size) noexcept {
-        WJR_ASSERT_ASSUME(__fasts_abs(size) <= capacity());
-        m_storage.m_size = size;
+        first += idx;
+        return idx <= nd;
     }
+};
 
-    WJR_PURE const biginteger_data *__get_data() const noexcept { return &m_storage; }
+template <>
+struct __unsigned_from_chars_fn<10> {
+    template <typename UnsignedValue, typename Converter,
+              WJR_REQUIRES(is_nonbool_unsigned_integral_v<UnsignedValue>)>
+    int operator()(const uint8_t *&first, const uint8_t *last, UnsignedValue &value,
+                   Converter conv) const noexcept {
+        constexpr auto zero = conv.template to<10>(0);
+        constexpr auto nine = conv.template to<10>(9);
 
-private:
-    biginteger_data m_storage;
-};
+        constexpr auto __try_matches = [](uint8_t &ch) {
+            if constexpr (zero != 0) {
+                return ch <= nine && !sub_overflow(ch, zero, ch);
+            } else {
+                return ch <= nine;
+            }
+        };
 
-template <typename Alloc>
-struct is_biginteger_storage<default_biginteger_vector_storage<Alloc>> : std::true_type {
-};
+        constexpr auto __matches = [](uint8_t ch) {
+            if constexpr (zero != 0) {
+                return zero <= ch && ch <= nine;
+            } else {
+                return ch <= nine;
+            }
+        };
 
-template <typename Storage>
-class basic_biginteger;
+        if (first == last) {
+            return 2;
+        }
 
-namespace biginteger_details {
+        uint8_t ch = *first;
 
-// const basic_biginteger<Storage>* don't need to get allocator
-// use const Storage* instead of const basic_biginteger<Storage>*
+        if (WJR_UNLIKELY(!__try_matches(ch))) {
+            return 2;
+        }
 
-/// @private
-template <typename S>
-from_chars_result<> __from_chars_impl(const char *first, const char *last,
-                                      basic_biginteger<S> *dst,
-                                      unsigned int base) noexcept;
+        do {
+            ++first;
+            if (WJR_UNLIKELY(mul_overflow(value, 10, value) ||
+                             add_overflow(value, ch, value))) {
+                while (first != last && __matches(*first)) {
+                    ++first;
+                }
 
-/// @private
-inline int32_t __compare_impl(const biginteger_data *lhs,
-                              const biginteger_data *rhs) noexcept;
+                return 0;
+            }
 
-/// @private
-inline int32_t __compare_ui_impl(const biginteger_data *lhs, uint64_t rhs) noexcept;
+            if (first == last) {
+                break;
+            }
 
-/// @private
-inline int32_t __compare_si_impl(const biginteger_data *lhs, int64_t rhs) noexcept;
+            ch = *first;
+        } while (__try_matches(ch));
 
-/// @private
-template <typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-int32_t __compare_impl(const biginteger_data *lhs, T rhs) noexcept {
-    if (WJR_BUILTIN_CONSTANT_P(rhs == 0) && rhs == 0) {
-        const int32_t ssize = lhs->get_ssize();
-        return ssize == 0 ? 0 : ssize < 0 ? -1 : 1;
+        return 1;
     }
+};
 
-    if constexpr (std::is_unsigned_v<T>) {
-        return __compare_ui_impl(lhs, rhs);
-    } else {
-        if (WJR_BUILTIN_CONSTANT_P(rhs >= 0) && rhs >= 0) {
-            return __compare_ui_impl(lhs, to_unsigned(rhs));
-        }
+template <typename Value, typename IBase, typename Converter,
+          WJR_REQUIRES(is_nonbool_integral_v<Value>)>
+from_chars_result<const uint8_t *>
+__fast_from_chars_impl(const uint8_t *first, const uint8_t *last, Value &val, IBase ibase,
+                       Converter conv) noexcept {
+    constexpr auto is_signed = std::is_signed_v<Value>;
 
-        return __compare_si_impl(lhs, rhs);
+    int sign = 0;
+
+    if constexpr (is_signed) {
+        if (first != last && *first == '-') {
+            ++first;
+            sign = 1;
+        }
     }
-}
 
-/// @private
-template <bool xsign, typename S>
-void __addsub_impl(basic_biginteger<S> *dst, const biginteger_data *lhs,
-                   uint64_t rhs) noexcept;
+    using UnsignedValue = std::make_unsigned_t<Value>;
 
-/// @private
-template <typename S>
-void __ui_sub_impl(basic_biginteger<S> *dst, uint64_t lhs,
-                   const biginteger_data *rhs) noexcept;
+    UnsignedValue uVal = 0;
 
-/// @private
-template <bool xsign, typename S>
-void __addsub_impl(basic_biginteger<S> *dst, const biginteger_data *lhs,
-                   const biginteger_data *rhs) noexcept;
+    const unsigned int base = ibase;
+    from_chars_result<const uint8_t *> ret{first, std::errc{}};
+    int valid;
 
-/// @private
-template <typename S>
-void __add_impl(basic_biginteger<S> *dst, const biginteger_data *lhs,
-                const biginteger_data *rhs) noexcept {
-    __addsub_impl<false>(dst, lhs, rhs);
-}
+    switch (base) {
+    case 2: {
+        valid = __unsigned_from_chars<2>(first, last, uVal, conv);
+        break;
+    }
+    case 10: {
+        valid = __unsigned_from_chars<10>(first, last, uVal, conv);
+        break;
+    }
+    default: {
+        return {first, std::errc::invalid_argument};
+    }
+    }
 
-/// @private
-template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-void __add_impl(basic_biginteger<S> *dst, const biginteger_data *lhs, T rhs) noexcept {
-    if constexpr (std::is_unsigned_v<T>) {
-        __addsub_impl<false>(dst, lhs, rhs);
+    if (WJR_UNLIKELY(valid == 2)) {
+        ret.ec = std::errc::invalid_argument;
     } else {
-        if (rhs < 0) {
-            __addsub_impl<true>(dst, lhs, -to_unsigned(rhs));
+        ret.ptr = first;
+        if (!valid) {
+            ret.ec = std::errc::result_out_of_range;
         } else {
-            __addsub_impl<false>(dst, lhs, to_unsigned(rhs));
+            if constexpr (is_signed) {
+                if (sign) {
+                    if (uVal >
+                        static_cast<UnsignedValue>(std::numeric_limits<Value>::min())) {
+                        ret.ec = std::errc::result_out_of_range;
+                    } else {
+                        val = -static_cast<Value>(uVal);
+                    }
+                } else {
+                    if (uVal >
+                        static_cast<UnsignedValue>(std::numeric_limits<Value>::max())) {
+                        ret.ec = std::errc::result_out_of_range;
+                    } else {
+                        val = static_cast<Value>(uVal);
+                    }
+                }
+            } else {
+                val = uVal;
+            }
         }
     }
-}
 
-/// @private
-template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-void __add_impl(basic_biginteger<S> *dst, T lhs, const biginteger_data *rhs) noexcept {
-    __add_impl(dst, rhs, lhs);
+    return ret;
 }
 
-/// @private
-template <typename S>
-void __sub_impl(basic_biginteger<S> *dst, const biginteger_data *lhs,
-                const biginteger_data *rhs) noexcept {
-    __addsub_impl<true>(dst, lhs, rhs);
+template <typename Value, typename IBase, typename Converter,
+          WJR_REQUIRES(is_nonbool_integral_v<Value>)>
+from_chars_result<const char *> __from_chars_impl(const char *first, const char *last,
+                                                  Value &val, IBase ibase,
+                                                  Converter conv) noexcept {
+    const auto __first = reinterpret_cast<const uint8_t *>(first);
+    const auto __last = reinterpret_cast<const uint8_t *>(last);
+    const auto ret = __fast_from_chars_impl(__first, __last, val, ibase, conv);
+    return {reinterpret_cast<const char *>(ret.ptr), ret.ec};
 }
 
-/// @private
-template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-void __sub_impl(basic_biginteger<S> *dst, const biginteger_data *lhs, T rhs) noexcept {
-    if constexpr (std::is_unsigned_v<T>) {
-        __addsub_impl<true>(dst, lhs, rhs);
-    } else {
-        if (rhs < 0) {
-            __addsub_impl<false>(dst, lhs, -to_unsigned(rhs));
-        } else {
-            __addsub_impl<true>(dst, lhs, to_unsigned(rhs));
-        }
-    }
+template <typename Value, typename BaseType = unsigned int, BaseType IBase = 10,
+          typename Converter = char_converter_t,
+          WJR_REQUIRES(convert_details::__is_valid_converter_v<Value, Converter>)>
+from_chars_result<const char *>
+from_chars(const char *first, const char *last, Value &val,
+           std::integral_constant<BaseType, IBase> = {}, Converter conv = {}) noexcept {
+    return __from_chars_impl(first, last, val,
+                             std::integral_constant<unsigned int, IBase>(), conv);
 }
 
-/// @private
-template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-void __sub_impl(basic_biginteger<S> *dst, T lhs, const biginteger_data *rhs) noexcept {
-    if constexpr (std::is_unsigned_v<T>) {
-        __ui_sub_impl(dst, lhs, rhs);
-    } else {
-        if (lhs < 0) {
-            __addsub_impl<false>(dst, rhs, -to_unsigned(lhs));
-            dst->negate();
-        } else {
-            __ui_sub_impl(dst, to_unsigned(lhs), rhs);
+template <typename Value, typename Converter = char_converter_t,
+          WJR_REQUIRES(convert_details::__is_valid_converter_v<Value, Converter>)>
+from_chars_result<const char *> from_chars(const char *first, const char *last,
+                                           Value &val, unsigned int base,
+                                           Converter conv = {}) noexcept {
+    if (WJR_BUILTIN_CONSTANT_P(base)) {
+        switch (base) {
+        case 2: {
+            return __from_chars_impl(first, last, val, 2_u, conv);
+        }
+        case 10: {
+            return __from_chars_impl(first, last, val, 10_u, conv);
+        }
+        default: {
+            break;
+        }
         }
     }
+
+    return __from_chars_impl(first, last, val, base, conv);
 }
 
-/// @private
-template <typename S>
-void __mul_ui_impl(basic_biginteger<S> *dst, const biginteger_data *lhs,
-                   uint64_t rhs) noexcept;
+template <typename Converter>
+size_t __biginteger_from_chars_2_impl(const uint8_t *first, size_t n, uint64_t *up,
+                                      Converter conv) noexcept {
+    const size_t hbits = (n - 1) % 64 + 1;
+    const size_t len = (n - 1) / 64 + 1;
+
+    uint64_t x = 0;
+    up += len;
 
-/// @private
-template <typename S>
-void __mul_impl(basic_biginteger<S> *dst, const biginteger_data *lhs,
-                const biginteger_data *rhs) noexcept;
+    __unsigned_from_chars_unchecked<2>(first, first + hbits, x, conv);
+    first += hbits;
 
-/// @private
-template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-void __mul_impl(basic_biginteger<S> *dst, const biginteger_data *lhs, T rhs) noexcept {
-    if constexpr (std::is_unsigned_v<T>) {
-        __mul_ui_impl(dst, lhs, rhs);
-    } else {
-        uint64_t value = to_unsigned(rhs);
-        bool cond = false;
+    *--up = x;
 
-        if (rhs < 0) {
-            value = -value;
-            cond = true;
-        }
+    size_t idx = len - 1;
 
-        __mul_ui_impl(dst, lhs, value);
-        dst->conditional_negate(cond);
+    if (idx) {
+        do {
+            x = 0;
+
+            for (int i = 0; i < 4; ++i) {
+                x = (x << 16) + __from_chars_unroll_16<2>(first, conv);
+                first += 16;
+            }
+
+            *--up = x;
+        } while (WJR_LIKELY(--idx));
     }
+
+    return len;
 }
 
-/// @private
-template <typename S>
-void __sqr_impl(basic_biginteger<S> *dst, const biginteger_data *src) noexcept;
+template <typename Converter>
+size_t __biginteger_from_chars_8_impl(const uint8_t *first, size_t n, uint64_t *up,
+                                      Converter conv) noexcept {
+    size_t len = (n * 3 + 63) / 64;
+    size_t lbits = (64 * (len - 1)) / 3;
+    size_t rest = (64 * (len - 1)) % 3;
+    const size_t hbits = n - lbits - 1;
 
-/// @private
-template <typename S>
-void __addsubmul_impl(basic_biginteger<S> *dst, const biginteger_data *lhs, uint64_t rhs,
-                      int32_t xmask) noexcept;
+    auto unroll = [conv](uint64_t &x, auto &first) {
+        auto x0 = conv.template from<8>(first[0]);
+        auto x1 = conv.template from<8>(first[1]);
+        auto x2 = conv.template from<8>(first[2]);
+        auto x3 = conv.template from<8>(first[3]);
 
-/// @private
-template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-void __addmul_impl(basic_biginteger<S> *dst, const biginteger_data *lhs, T rhs) noexcept {
-    if constexpr (std::is_unsigned_v<T>) {
-        __addsubmul_impl(dst, lhs, rhs, 0);
+        x = x << 12 | x0 << 9 | x1 << 6 | x2 << 3 | x3;
+        first += 4;
+    };
+
+    uint64_t x = 0;
+    up += len;
+    size_t idx = len - 1;
+
+    if (WJR_UNLIKELY(hbits == 0)) {
     } else {
-        uint64_t rvalue = to_unsigned(rhs);
-        int32_t xsign = 0;
+        __unsigned_from_chars_unchecked<8>(first, first + hbits, x, conv);
+        first += hbits;
+    }
 
-        if (rhs < 0) {
-            rvalue = -rvalue;
-            xsign = -1;
+    uint64_t nx = conv.template from<8>(*first++);
+    switch (rest) {
+    case 0: {
+        *--up = x << 3 | nx;
+        x = 0;
+        break;
+    }
+    case 1: {
+        x = x << 2 | nx >> 1;
+        if (WJR_UNLIKELY(x == 0)) {
+            --len;
         }
 
-        __addsubmul_impl(dst, lhs, rvalue, xsign);
+        *--up = x;
+        x = nx & 1;
+        break;
+    }
+    case 2: {
+        x = x << 1 | nx >> 2;
+        if (WJR_UNLIKELY(x == 0)) {
+            --len;
+        }
+        *--up = x;
+        x = nx & 3;
+        break;
+    }
+    default: {
+        WJR_UNREACHABLE();
+        break;
+    }
     }
-}
 
-/// @private
-template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-void __submul_impl(basic_biginteger<S> *dst, const biginteger_data *lhs, T rhs) noexcept {
-    if constexpr (std::is_unsigned_v<T>) {
-        __addsubmul_impl(dst, lhs, rhs, -1);
-    } else {
-        uint64_t rvalue = to_unsigned(rhs);
-        int32_t xsign = -1;
+    if (idx) {
+        do {
+            for (int i = 0; i < 5; ++i) {
+                unroll(x, first);
+            }
 
-        if (rhs < 0) {
-            rvalue = -rvalue;
-            xsign = 0;
-        }
+            switch (rest) {
+            case 0: {
+                x = x << 3 | conv.template from<8>(*first++);
+                uint64_t nx = conv.template from<8>(*first++);
+                x = x << 1 | nx >> 2;
+                *--up = x;
+                x = nx & 3;
+                rest = 2;
+                break;
+            }
+            case 1: {
+                x = x << 3 | conv.template from<8>(*first++);
+                *--up = x;
+                x = 0;
+                rest = 0;
+                break;
+            }
+            case 2: {
+                uint64_t nx = conv.template from<8>(*first++);
+                x = x << 2 | nx >> 1;
+                *--up = x;
+                x = nx & 1;
+                rest = 1;
+                break;
+            }
+            default: {
+                WJR_UNREACHABLE();
+                break;
+            }
+            }
 
-        __addsubmul_impl(dst, lhs, rvalue, xsign);
+        } while (WJR_LIKELY(--idx));
     }
+
+    return len;
 }
 
-/// @private
-template <typename S>
-void __addsubmul_impl(basic_biginteger<S> *dst, const biginteger_data *lhs,
-                      const biginteger_data *rhs, int32_t xmask) noexcept;
+template <typename Converter>
+size_t __biginteger_from_chars_16_impl(const uint8_t *first, size_t n, uint64_t *up,
+                                       Converter conv) noexcept {
+    const size_t hbits = (n - 1) % 16 + 1;
+    size_t len = (n - 1) / 16 + 1;
 
-/// @private
-template <typename S>
-void __addmul_impl(basic_biginteger<S> *dst, const biginteger_data *lhs,
-                   const biginteger_data *rhs) noexcept {
-    __addsubmul_impl(dst, lhs, rhs, 0);
-}
+    auto unroll = [conv](uint64_t &x, auto &first) {
+        auto x0 = conv.template from<16>(first[0]);
+        auto x1 = conv.template from<16>(first[1]);
+        auto x2 = conv.template from<16>(first[2]);
+        auto x3 = conv.template from<16>(first[3]);
 
-/// @private
-template <typename S>
-void __submul_impl(basic_biginteger<S> *dst, const biginteger_data *lhs,
-                   const biginteger_data *rhs) noexcept {
-    __addsubmul_impl(dst, lhs, rhs, -1);
-}
+        x = x << 16 | x0 << 12 | x1 << 8 | x2 << 4 | x3;
+        first += 4;
+    };
 
-/// @private
-template <typename S>
-void __mul_2exp_impl(basic_biginteger<S> *dst, const biginteger_data *lhs,
-                     uint32_t shift) noexcept;
+    uint64_t x = 0;
+    up += len;
 
-/// @private
-template <typename S0, typename S1>
-void __tdiv_qr_impl(basic_biginteger<S0> *quot, basic_biginteger<S1> *rem,
-                    const biginteger_data *num, const biginteger_data *div) noexcept;
+    __unsigned_from_chars_unchecked<16>(first, first + hbits, x, conv);
+    first += hbits;
 
-/// @private
-template <typename S>
-void __tdiv_q_impl(basic_biginteger<S> *quot, const biginteger_data *num,
-                   const biginteger_data *div) noexcept;
+    *--up = x;
 
-/// @private
-template <typename S>
-void __tdiv_r_impl(basic_biginteger<S> *rem, const biginteger_data *num,
-                   const biginteger_data *div) noexcept;
+    size_t idx = len - 1;
 
-/// @private
-template <typename S0, typename S1>
-uint64_t __tdiv_qr_ui_impl(basic_biginteger<S0> *quot, basic_biginteger<S1> *rem,
-                           const biginteger_data *num, uint64_t div) noexcept;
+    if (idx) {
+        do {
+            x = 0;
 
-/// @private
-template <typename S>
-uint64_t __tdiv_q_ui_impl(basic_biginteger<S> *quot, const biginteger_data *num,
-                          uint64_t div) noexcept;
+            for (int i = 0; i < 4; ++i) {
+                unroll(x, first);
+            }
 
-/// @private
-template <typename S>
-uint64_t __tdiv_r_ui_impl(basic_biginteger<S> *rem, const biginteger_data *num,
-                          uint64_t div) noexcept;
+            *--up = x;
+        } while (WJR_LIKELY(--idx));
+    }
+
+    return len;
+}
+
+template <typename Converter>
+size_t basecase_from_chars_10(const uint8_t *first, size_t n, uint64_t *up,
+                              Converter conv) noexcept {
+    uint64_t x = 0;
+
+    if (n <= 19) {
+        __unsigned_from_chars_unchecked<10>(first, first + n, x, conv);
+        up[0] = x;
+
+        return up[0] != 0;
+    }
+
+    size_t m = (n - 1) % 19 + 1;
+
+    __unsigned_from_chars_unchecked<10>(first, first + m, x, conv);
+    up[0] = x;
 
-/// @private
-template <typename S0, typename S1, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-uint64_t __tdiv_qr_impl(basic_biginteger<S0> *quot, basic_biginteger<S1> *rem,
-                        const biginteger_data *num, T div) noexcept;
+    first += m;
+    n -= m;
 
-/// @private
-template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-uint64_t __tdiv_q_impl(basic_biginteger<S> *quot, const biginteger_data *num,
-                       T div) noexcept;
+    m = up[0] != 0;
 
-/// @private
-template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-uint64_t __tdiv_r_impl(basic_biginteger<S> *rem, const biginteger_data *num,
-                       uint64_t div) noexcept;
+    do {
+        x = 0;
 
-/// @private
-template <typename S0, typename S1>
-void __fdiv_qr_impl(basic_biginteger<S0> *quot, basic_biginteger<S1> *rem,
-                    const biginteger_data *num, const biginteger_data *div) noexcept;
+        x = __from_chars_unroll_16<10>(first, conv);
+        first += 16;
 
-/// @private
-template <typename S>
-void __fdiv_q_impl(basic_biginteger<S> *quot, const biginteger_data *num,
-                   const biginteger_data *div) noexcept;
+        x = x * 10 + conv.template from<10>(*first++);
+        x = x * 10 + conv.template from<10>(*first++);
+        x = x * 10 + conv.template from<10>(*first++);
 
-/// @private
-template <typename S>
-void __fdiv_r_impl(basic_biginteger<S> *rem, const biginteger_data *num,
-                   const biginteger_data *div) noexcept;
+        uint64_t cf;
 
-/// @private
-template <typename S0, typename S1, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-uint64_t __fdiv_qr_impl(basic_biginteger<S0> *quot, basic_biginteger<S1> *rem,
-                        const biginteger_data *num, T div) noexcept;
+        if (WJR_LIKELY(m == 0)) {
+            cf = x;
+        } else {
+            cf = mul_1(up, up, m, div2by1_divider_noshift_of_big_base_10.get_divisor());
+            cf += addc_1(up, up, m, x);
+        }
 
-/// @private
-template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-uint64_t __fdiv_q_impl(basic_biginteger<S> *quot, const biginteger_data *num,
-                       T div) noexcept;
+        if (WJR_LIKELY(cf != 0)) {
+            up[m++] = cf;
+        }
 
-/// @private
-template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-uint64_t __fdiv_r_impl(basic_biginteger<S> *rem, const biginteger_data *num,
-                       uint64_t div) noexcept;
+        n -= 19;
+    } while (WJR_LIKELY(n != 0));
 
-/// @private
-template <typename S0, typename S1>
-void __cdiv_qr_impl(basic_biginteger<S0> *quot, basic_biginteger<S1> *rem,
-                    const biginteger_data *num, const biginteger_data *div) noexcept;
+    return m;
+}
 
-/// @private
-template <typename S>
-void __cdiv_q_impl(basic_biginteger<S> *quot, const biginteger_data *num,
-                   const biginteger_data *div) noexcept;
+template <typename Converter>
+size_t basecase_from_chars(const uint8_t *first, size_t n, uint64_t *up,
+                           unsigned int base, Converter conv) noexcept {
+    if (base == 10) {
+        return basecase_from_chars_10(first, n, up, conv);
+    } else {
+        return 0;
+    }
+}
 
-/// @private
-template <typename S>
-void __cdiv_r_impl(basic_biginteger<S> *rem, const biginteger_data *num,
-                   const biginteger_data *div) noexcept;
+template <typename Converter>
+size_t dc_from_chars(const uint8_t *first, size_t n, uint64_t *up,
+                     precompute_chars_convert_t *pre, uint64_t *stk,
+                     Converter conv) noexcept {
+    const size_t lo = pre->digits_in_base;
+    if (n <= lo) {
+        if (n < dc_bignum_from_chars_threshold) {
+            return basecase_from_chars(first, n, up, pre->base, conv);
+        } else {
+            return dc_from_chars(first, n, up, pre - 1, stk, conv);
+        }
+    }
 
-/// @private
-template <typename S0, typename S1, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-uint64_t __cdiv_qr_impl(basic_biginteger<S0> *quot, basic_biginteger<S1> *rem,
-                        const biginteger_data *num, T div) noexcept;
+    const size_t hi = n - lo;
+    size_t hn, ln;
 
-/// @private
-template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-uint64_t __cdiv_q_impl(basic_biginteger<S> *quot, const biginteger_data *num,
-                       T div) noexcept;
+    if (hi < dc_bignum_from_chars_threshold) {
+        hn = basecase_from_chars(first, hi, stk, pre->base, conv);
+    } else {
+        hn = dc_from_chars(first, hi, stk, pre - (lo * 2 >= n), up, conv);
+    }
 
-/// @private
-template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-uint64_t __cdiv_r_impl(basic_biginteger<S> *rem, const biginteger_data *num,
-                       uint64_t div) noexcept;
+    const size_t ps = pre->shift;
+    const size_t pn = pre->n;
 
-/// @private
-template <typename S>
-void __tdiv_q_2exp_impl(basic_biginteger<S> *quot, const biginteger_data *num,
-                        uint32_t shift) noexcept;
+    if (WJR_LIKELY(hn != 0)) {
+        if (pn >= hn) {
+            mul_s(up + ps, pre->ptr, pn, stk, hn);
+        } else {
+            mul_s(up + ps, stk, hn, pre->ptr, pn);
+        }
+        set_n(up, 0, ps);
+    }
 
-/// @private
-template <typename S>
-void __tdiv_r_2exp_impl(basic_biginteger<S> *rem, const biginteger_data *num,
-                        uint32_t shift) noexcept;
+    std::advance(first, hi);
+    if (lo < dc_bignum_from_chars_threshold) {
+        ln = basecase_from_chars(first, lo, stk, pre->base, conv);
+    } else {
+        ln = dc_from_chars(first, lo, stk, pre - (lo * 2 >= n), stk + pn + ps + 1, conv);
+    }
 
-/// @private
-template <typename S>
-void __cfdiv_q_2exp_impl(basic_biginteger<S> *quot, const biginteger_data *num,
-                         uint32_t shift, int32_t xdir) noexcept;
+    WJR_ASSERT(ps + pn + 1 >= ln);
 
-/// @private
-template <typename S>
-void __cdiv_q_2exp_impl(basic_biginteger<S> *quot, const biginteger_data *num,
-                        uint32_t shift) noexcept {
-    __cfdiv_q_2exp_impl(quot, num, shift, 1);
-}
+    if (WJR_LIKELY(hn != 0)) {
+        if (WJR_LIKELY(ln != 0)) {
+            auto cf = addc_s(up, up, ps + pn + hn, stk, ln);
+            WJR_ASSERT(cf == 0);
+            (void)(cf);
+        }
 
-/// @private
-template <typename S>
-void __fdiv_q_2exp_impl(basic_biginteger<S> *quot, const biginteger_data *num,
-                        uint32_t shift) noexcept {
-    __cfdiv_q_2exp_impl(quot, num, shift, -1);
-}
+        n = ps + pn + hn;
+        return n - (up[n - 1] == 0);
+    }
 
-/// @private
-template <typename S>
-void __cfdiv_r_2exp_impl(basic_biginteger<S> *rem, const biginteger_data *num,
-                         uint32_t shift, int32_t xdir) noexcept;
+    if (WJR_LIKELY(ln != 0)) {
+        std::copy_n(stk, ln, up);
+    }
 
-/// @private
-template <typename S>
-void __cdiv_r_2exp_impl(basic_biginteger<S> *rem, const biginteger_data *num,
-                        uint32_t shift) noexcept {
-    __cfdiv_r_2exp_impl(rem, num, shift, 1);
+    return ln;
 }
 
-/// @private
-template <typename S>
-void __fdiv_r_2exp_impl(basic_biginteger<S> *rem, const biginteger_data *num,
-                        uint32_t shift) noexcept {
-    __cfdiv_r_2exp_impl(rem, num, shift, -1);
-}
+template <typename Converter>
+uint64_t *__biginteger_from_chars_impl(const uint8_t *first, const uint8_t *last,
+                                       uint64_t *up, unsigned int base,
+                                       Converter conv = {}) noexcept {
+    WJR_ASSERT(base <= 36 && (is_zero_or_single_bit(base) || base == 10));
 
-/// @private
-template <typename S, typename Engine,
-          WJR_REQUIRES(biginteger_uniform_random_bit_generator_v<Engine>)>
-void __urandom_bit_impl(basic_biginteger<S> *dst, uint32_t size, Engine &engine) noexcept;
+    const size_t n = std::distance(first, last);
 
-/// @private
-template <typename S, typename Engine,
-          WJR_REQUIRES(biginteger_uniform_random_bit_generator_v<Engine>)>
-void __urandom_exact_bit_impl(basic_biginteger<S> *dst, uint32_t size,
-                              Engine &engine) noexcept;
+    if (is_zero_or_single_bit(base)) {
+        switch (base) {
+        case 2: {
+            return up + __biginteger_from_chars_2_impl(first, n, up, conv);
+        }
+        case 8: {
+            return up + __biginteger_from_chars_8_impl(first, n, up, conv);
+        }
+        case 16: {
+            return up + __biginteger_from_chars_16_impl(first, n, up, conv);
+        }
+        default: {
+            WJR_UNREACHABLE();
+            return up;
+        }
+        }
+    }
 
-/// @private
-template <typename S, typename Engine,
-          WJR_REQUIRES(biginteger_uniform_random_bit_generator_v<Engine>)>
-void __urandom_impl(basic_biginteger<S> *dst, const biginteger_data *limit,
-                    Engine &engine) noexcept;
+    if (WJR_LIKELY(n < dc_bignum_from_chars_precompute_threshold)) {
+        return up + basecase_from_chars(first, n, up, base, conv);
+    }
 
-/// @private
-template <typename S, typename Engine,
-          WJR_REQUIRES(biginteger_uniform_random_bit_generator_v<Engine>)>
-void __urandom_exact_impl(basic_biginteger<S> *dst, const biginteger_data *limit,
-                          Engine &engine) noexcept;
+    const auto per_digits = precompute_chars_convert_16n_ptr[base]->digits_in_one_base;
 
-/// @private
-inline uint32_t __bit_width_impl(const biginteger_data *num) noexcept;
+    precompute_chars_convert_t pre[64 - 3];
 
-/// @private
-inline uint32_t __ctz_impl(const biginteger_data *num) noexcept;
+    unique_stack_allocator stkal(math_details::stack_alloc);
+    const size_t un = n / per_digits + 1;
+    auto stk =
+        static_cast<uint64_t *>(stkal.allocate((un * 16 / 5 + 192) * sizeof(uint64_t)));
+    const auto mpre = precompute_chars_convert(pre, un, base, stk);
+    stk += un * 8 / 5 + 128;
+    return up + dc_from_chars(first, n, up, mpre, stk, conv);
+}
+
+/**
+ * @brief Convert a string to a biginteger by a given base.
+ *
+ * @tparam Iter Input iterator type
+ * @param[in] first Input iterator
+ * @param[in] last Input iterator
+ * @param[out] up Pointer to the biginteger
+ * @param[in] base Base of the input string. Range: `[2, 36]`,
+ * Only support 10 and power of two currently.
+ * @return Pointer after the conversion
+ */
+template <typename Iter, typename Converter = char_converter_t,
+          WJR_REQUIRES(convert_details::__is_fast_convert_iterator_v<Iter>)>
+uint64_t *biginteger_from_chars(Iter first, Iter last, uint64_t *up,
+                                unsigned int base = 10, Converter conv = {}) noexcept {
+    WJR_ASSERT(base <= 36 && (is_zero_or_single_bit(base) || base == 10));
 
-/// @private
-template <typename S>
-void __pow_impl(basic_biginteger<S> *dst, const biginteger_data *num,
-                uint32_t exp) noexcept;
+    const auto __first = reinterpret_cast<const uint8_t *>((to_address)(first));
+    const auto __last = reinterpret_cast<const uint8_t *>((to_address)(last));
 
-/// @private
-struct __powmod_iterator {
-    __powmod_iterator(const uint64_t *ptr, uint32_t size) noexcept
-        : ptr(ptr), cache(ptr[0]), size(size) {}
+    return __biginteger_from_chars_impl(__first, __last, up, base, conv);
+}
 
-    constexpr void next() noexcept {
-        if (++offset == 64) {
-            offset = 0;
-            ++pos;
-            WJR_ASSERT(pos != size);
-            cache = ptr[pos];
-        }
-    }
+} // namespace wjr
 
-    constexpr uint64_t get() const noexcept { return (cache >> offset); }
-    constexpr bool end() const noexcept { return pos == size - 1 && get() == 1; }
+#endif // WJR_MATH_CONVERT_HPP__
+#ifndef WJR_MATH_COPY_HPP__
+#define WJR_MATH_COPY_HPP__
 
-    const uint64_t *ptr;
-    uint64_t cache;
-    uint32_t offset = 0;
-    uint32_t pos = 0;
-    uint32_t size;
-};
+// Already included
 
-/// @private
-template <typename S>
-void __powmod_impl(basic_biginteger<S> *dst, const biginteger_data *num,
-                   __powmod_iterator *iter, const biginteger_data *mod) noexcept;
+namespace wjr {
 
 /// @private
-template <typename S>
-void __powmod_impl(basic_biginteger<S> *dst, const biginteger_data *num,
-                   const biginteger_data *exp, const biginteger_data *mod) noexcept;
+template <typename InputIt, typename OutputIt>
+struct __is_builtin_copy
+    : std::conjunction<
+          std::is_trivially_copyable<iterator_value_t<InputIt>>,
+          std::is_same<iterator_value_t<InputIt>, iterator_value_t<OutputIt>>,
+          is_contiguous_iterator<InputIt>, is_contiguous_iterator<OutputIt>> {};
 
 /// @private
-template <typename S>
-void __powmod_impl(basic_biginteger<S> *dst, const biginteger_data *num, uint64_t exp,
-                   const biginteger_data *mod) noexcept;
-
-} // namespace biginteger_details
-
-template <typename S>
-from_chars_result<> from_chars(const char *first, const char *last,
-                               basic_biginteger<S> &dst, unsigned int base = 10) noexcept;
+template <typename InputIt, typename OutputIt>
+inline constexpr bool __is_builtin_copy_v = __is_builtin_copy<InputIt, OutputIt>::value;
 
-template <typename Iter>
-Iter to_chars_unchecked(Iter ptr, const biginteger_data &src,
-                        unsigned int base = 10) noexcept {
-    if (src.empty()) {
-        *ptr++ = '0';
-        return ptr;
-    }
+} // namespace wjr
 
-    if (src.is_negate()) {
-        *ptr++ = '-';
-    }
+#endif // WJR_MATH_COPY_HPP__
+#ifndef WJR_MATH_NEG_HPP__
+#define WJR_MATH_NEG_HPP__
 
-    return biginteger_to_chars(ptr, src.data(), src.size(), base);
-}
+#ifndef WJR_MATH_NOT_HPP__
+#define WJR_MATH_NOT_HPP__
 
-template <typename S>
-std::istream &operator>>(std::istream &is, basic_biginteger<S> &dst) noexcept;
+// Already included
 
-template <typename Traits>
-std::basic_ostream<char, Traits> &operator<<(std::basic_ostream<char, Traits> &os,
-                                             const biginteger_data &src) noexcept;
+#if defined(WJR_X86)
+#ifndef WJR_X86_MATH_NOT_HPP__
+#define WJR_X86_MATH_NOT_HPP__
 
-WJR_NODISCARD WJR_PURE inline int32_t compare(const biginteger_data &lhs,
-                                              const biginteger_data &rhs) noexcept {
-    return biginteger_details::__compare_impl(&lhs, &rhs);
-}
+// Already included
+// Already included
 
-template <typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-WJR_NODISCARD WJR_PURE int32_t compare(const biginteger_data &lhs, T rhs) noexcept {
-    return biginteger_details::__compare_impl(&lhs, rhs);
-}
+#ifndef WJR_X86
+#error "x86 required"
+#endif
 
-template <typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-WJR_NODISCARD WJR_PURE int32_t compare(T lhs, const biginteger_data &rhs) noexcept {
-    return -compare(rhs, lhs);
-}
+namespace wjr {
 
-#define WJR_REGISTER_BIGINTEGER_COMPARE(op)                                              \
-    WJR_NODISCARD WJR_PURE inline bool operator op(                                      \
-        const biginteger_data &lhs, const biginteger_data &rhs) noexcept {               \
-        return compare(lhs, rhs) op 0;                                                   \
-    }                                                                                    \
-    template <typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>                        \
-    WJR_NODISCARD WJR_PURE bool operator op(const biginteger_data &lhs,                  \
-                                            T rhs) noexcept {                            \
-        return compare(lhs, rhs) op 0;                                                   \
-    }                                                                                    \
-    template <typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>                        \
-    WJR_NODISCARD WJR_PURE bool operator op(T lhs,                                       \
-                                            const biginteger_data &rhs) noexcept {       \
-        return compare(lhs, rhs) op 0;                                                   \
-    }
+#if WJR_HAS_SIMD(SSE2) && WJR_HAS_SIMD(X86_SIMD)
+#define WJR_HAS_BUILTIN_COMPLEMENT_N WJR_HAS_DEF
+#endif
 
-WJR_REGISTER_BIGINTEGER_COMPARE(==)
-WJR_REGISTER_BIGINTEGER_COMPARE(!=)
-WJR_REGISTER_BIGINTEGER_COMPARE(<)
-WJR_REGISTER_BIGINTEGER_COMPARE(>)
-WJR_REGISTER_BIGINTEGER_COMPARE(<=)
-WJR_REGISTER_BIGINTEGER_COMPARE(>=)
+#if WJR_HAS_BUILTIN(COMPLEMENT_N)
 
-#undef WJR_REGISTER_BIGINTEGER_COMPARE
+template <typename T>
+WJR_COLD void large_builtin_not_n(T *dst, const T *src, size_t n) noexcept {
+    constexpr auto is_avx = WJR_HAS_SIMD(AVX2);
 
-#define WJR_REGISTER_BIGINTEGER_ADDSUB(ADDSUB)                                           \
-    template <typename S>                                                                \
-    void ADDSUB(basic_biginteger<S> &dst, const biginteger_data &lhs,                    \
-                const biginteger_data &rhs) noexcept {                                   \
-        biginteger_details::WJR_PP_CONCAT(__, WJR_PP_CONCAT(ADDSUB, _impl))(&dst, &lhs,  \
-                                                                            &rhs);       \
-    }                                                                                    \
-    template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>            \
-    void ADDSUB(basic_biginteger<S> &dst, const biginteger_data &lhs, T rhs) noexcept {  \
-        biginteger_details::WJR_PP_CONCAT(__, WJR_PP_CONCAT(ADDSUB, _impl))(&dst, &lhs,  \
-                                                                            rhs);        \
-    }                                                                                    \
-    template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>            \
-    void ADDSUB(basic_biginteger<S> &dst, T lhs, const biginteger_data &rhs) noexcept {  \
-        biginteger_details::WJR_PP_CONCAT(__, WJR_PP_CONCAT(ADDSUB, _impl))(&dst, lhs,   \
-                                                                            &rhs);       \
-    }
+    using simd = std::conditional_t<is_avx, avx, sse>;
+    using simd_int = typename simd::int_type;
+    constexpr auto simd_width = simd::width();
+    constexpr auto type_width = simd_width / 64;
 
-WJR_REGISTER_BIGINTEGER_ADDSUB(add)
-WJR_REGISTER_BIGINTEGER_ADDSUB(sub)
+    const uintptr_t ptr = reinterpret_cast<uintptr_t>(dst);
+    WJR_ASSUME(ptr % sizeof(T) == 0);
+    const size_t offset = __align_up_offset(ptr, 32) / sizeof(T);
 
-#undef WJR_REGISTER_BIGINTEGER_ADDSUB
+    WJR_ASSUME(offset < 4);
 
-template <typename S>
-void increment(basic_biginteger<S> &dst) noexcept {
-    add(dst, dst, 1u);
-}
+    const auto y = sse::ones();
 
-template <typename S>
-void decrement(basic_biginteger<S> &dst) noexcept {
-    sub(dst, dst, 1u);
-}
+    switch (offset) {
+    case 0: {
+        break;
+    }
+    case 1: {
+        dst[0] = ~src[0];
 
-template <typename S>
-void negate(basic_biginteger<S> &dst) noexcept;
+        ++dst;
+        ++src;
+        --n;
+        break;
+    }
+    case 2: {
+        sse::storeu((__m128i *)(dst), sse::Xor(sse::loadu((__m128i *)(src)), y));
 
-template <typename S>
-void absolute(basic_biginteger<S> &dst) noexcept;
+        dst += 2;
+        src += 2;
+        n -= 2;
+        break;
+    }
 
-template <typename S>
-void sqr(basic_biginteger<S> &dst, const biginteger_data &src) noexcept {
-    biginteger_details::__sqr_impl(&dst, &src);
-}
+    case 3: {
+        sse::storeu((__m128i *)(dst), sse::Xor(sse::loadu((__m128i *)(src)), y));
+        dst[2] = ~src[2];
 
-template <typename S>
-void mul(basic_biginteger<S> &dst, const biginteger_data &lhs,
-         const biginteger_data &rhs) noexcept {
-    if (WJR_BUILTIN_CONSTANT_P(std::addressof(lhs) == std::addressof(rhs)) &&
-        std::addressof(lhs) == std::addressof(rhs)) {
-        sqr(dst, lhs);
-        return;
+        dst += 3;
+        src += 3;
+        n -= 3;
+        break;
     }
 
-    biginteger_details::__mul_impl(&dst, &lhs, &rhs);
-}
-
-template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-void mul(basic_biginteger<S> &dst, const biginteger_data &lhs, T rhs) noexcept {
-    biginteger_details::__mul_impl(&dst, &lhs, rhs);
-}
+    default: {
+        WJR_UNREACHABLE();
+    }
+    }
 
-template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-void mul(basic_biginteger<S> &dst, T lhs, const biginteger_data &rhs) noexcept {
-    biginteger_details::__mul_impl(&dst, &rhs, lhs);
-}
+    auto z = broadcast<__m128i_t, typename simd::int_tag_type>(y);
 
-template <typename S>
-void addmul(basic_biginteger<S> &dst, const biginteger_data &lhs,
-            const biginteger_data &rhs) noexcept {
-    biginteger_details::__addmul_impl(&dst, &lhs, &rhs);
-}
+    size_t idx = 0;
+    size_t m = n & (-type_width * 4);
 
-template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-void addmul(basic_biginteger<S> &dst, const biginteger_data &lhs, T rhs) noexcept {
-    biginteger_details::__addmul_impl(&dst, &lhs, rhs);
-}
+    WJR_ASSUME(idx != m);
 
-template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-void addmul(basic_biginteger<S> &dst, T lhs, const biginteger_data &rhs) noexcept {
-    biginteger_details::__addmul_impl(&dst, &rhs, lhs);
-}
+    do {
+        auto x0 = simd::loadu((simd_int *)(src + idx));
+        auto x1 = simd::loadu((simd_int *)(src + idx + type_width));
+        auto x2 = simd::loadu((simd_int *)(src + idx + type_width * 2));
+        auto x3 = simd::loadu((simd_int *)(src + idx + type_width * 3));
 
-template <typename S>
-void submul(basic_biginteger<S> &dst, const biginteger_data &lhs,
-            const biginteger_data &rhs) noexcept {
-    biginteger_details::__submul_impl(&dst, &lhs, &rhs);
-}
+        simd::store((simd_int *)(dst + idx), simd::Xor(x0, z));
+        simd::store((simd_int *)(dst + idx + type_width), simd::Xor(x1, z));
+        simd::store((simd_int *)(dst + idx + type_width * 2), simd::Xor(x2, z));
+        simd::store((simd_int *)(dst + idx + type_width * 3), simd::Xor(x3, z));
 
-template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-void submul(basic_biginteger<S> &dst, const biginteger_data &lhs, T rhs) noexcept {
-    biginteger_details::__submul_impl(&dst, &lhs, rhs);
-}
+        idx += type_width * 4;
+    } while (idx != m);
 
-template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-void submul(basic_biginteger<S> &dst, T lhs, const biginteger_data &rhs) noexcept {
-    biginteger_details::__submul_impl(&dst, &rhs, lhs);
-}
+    if (WJR_UNLIKELY(n == m)) {
+        return;
+    }
 
-template <typename S>
-void mul_2exp(basic_biginteger<S> &dst, const biginteger_data &lhs,
-              uint32_t shift) noexcept {
-    biginteger_details::__mul_2exp_impl(&dst, &lhs, shift);
-}
+    dst += m;
+    src += m;
+    n -= m;
 
-template <typename S0, typename S1>
-void tdiv_qr(basic_biginteger<S0> &quot, basic_biginteger<S1> &rem,
-             const biginteger_data &num, const biginteger_data &div) noexcept {
-    biginteger_details::__tdiv_qr_impl(&quot, &rem, &num, &div);
-}
+    m = n / type_width;
+    WJR_ASSUME(m < 4);
 
-template <typename S>
-void tdiv_q(basic_biginteger<S> &quot, const biginteger_data &num,
-            const biginteger_data &div) noexcept {
-    biginteger_details::__tdiv_q_impl(&quot, &num, &div);
-}
+    switch (m) {
+    case 3: {
+        simd::store((simd_int *)(dst), simd::Xor(simd::loadu((simd_int *)(src)), z));
+        WJR_FALLTHROUGH;
+    }
+    case 2: {
+        simd::store((simd_int *)(dst + type_width * (m - 2)),
+                    simd::Xor(simd::loadu((simd_int *)(src + type_width * (m - 2))), z));
+        WJR_FALLTHROUGH;
+    }
+    case 1: {
+        simd::store((simd_int *)(dst + type_width * (m - 1)),
+                    simd::Xor(simd::loadu((simd_int *)(src + type_width * (m - 1))), z));
+        WJR_FALLTHROUGH;
+    }
+    case 0: {
+        break;
+    }
+    default: {
+        WJR_UNREACHABLE();
+    }
+    }
 
-template <typename S0>
-void tdiv_r(basic_biginteger<S0> &rem, const biginteger_data &num,
-            const biginteger_data &div) noexcept {
-    biginteger_details::__tdiv_r_impl(&rem, &num, &div);
-}
+    m = n & (-type_width);
 
-template <typename S0, typename S1, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-uint64_t tdiv_qr(basic_biginteger<S0> &quot, basic_biginteger<S1> &rem,
-                 const biginteger_data &num, T div) noexcept {
-    return biginteger_details::__tdiv_qr_impl(&quot, &rem, &num, div);
-}
+    if (WJR_UNLIKELY(n == m)) {
+        return;
+    }
 
-template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-uint64_t tdiv_q(basic_biginteger<S> &quot, const biginteger_data &num, T div) noexcept {
-    return biginteger_details::__tdiv_q_impl(&quot, &num, div);
-}
+    WJR_ASSUME(n - m < 4);
 
-template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-uint64_t tdiv_r(basic_biginteger<S> &rem, const biginteger_data &num, T div) noexcept {
-    return biginteger_details::__tdiv_r_impl(&rem, &num, div);
-}
+    switch (n - m) {
+    case 1: {
+        dst[m] = ~src[m];
+        break;
+    }
+    case 2: {
+        sse::store((__m128i *)(dst + m), sse::Xor(sse::loadu((__m128i *)(src + m)), y));
+        break;
+    }
 
-template <typename S0, typename S1>
-void fdiv_qr(basic_biginteger<S0> &quot, basic_biginteger<S1> &rem,
-             const biginteger_data &num, const biginteger_data &div) noexcept {
-    biginteger_details::__fdiv_qr_impl(&quot, &rem, &num, &div);
-}
+    case 3: {
+        sse::store((__m128i *)(dst + m), sse::Xor(sse::loadu((__m128i *)(src + m)), y));
+        dst[m + 2] = ~src[m + 2];
+        break;
+    }
 
-template <typename S>
-void fdiv_q(basic_biginteger<S> &quot, const biginteger_data &num,
-            const biginteger_data &div) noexcept {
-    biginteger_details::__fdiv_q_impl(&quot, &num, &div);
-}
+    default: {
+        WJR_UNREACHABLE();
+    }
+    }
 
-template <typename S0>
-void fdiv_r(basic_biginteger<S0> &rem, const biginteger_data &num,
-            const biginteger_data &div) noexcept {
-    biginteger_details::__fdiv_r_impl(&rem, &num, &div);
+    return;
 }
 
-template <typename S0, typename S1, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-uint64_t fdiv_qr(basic_biginteger<S0> &quot, basic_biginteger<S1> &rem,
-                 const biginteger_data &num, T div) noexcept {
-    return biginteger_details::__fdiv_qr_impl(&quot, &rem, &num, div);
-}
+template <typename T>
+WJR_INTRINSIC_INLINE void builtin_not_n(T *dst, const T *src, size_t n) noexcept {
+    static_assert(sizeof(T) == 8, "");
 
-template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-uint64_t fdiv_q(basic_biginteger<S> &quot, const biginteger_data &num, T div) noexcept {
-    return biginteger_details::__fdiv_q_impl(&quot, &num, div);
-}
+    if (WJR_UNLIKELY(n < 4)) {
+        switch (n) {
+        case 3: {
+            dst[0] = ~src[0];
+            WJR_FALLTHROUGH;
+        }
+        case 2: {
+            dst[n - 2] = ~src[n - 2];
+            WJR_FALLTHROUGH;
+        }
+        case 1: {
+            dst[n - 1] = ~src[n - 1];
+            WJR_FALLTHROUGH;
+        }
+        case 0: {
+            break;
+        }
+        }
 
-template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-uint64_t fdiv_r(basic_biginteger<S> &rem, const biginteger_data &num, T div) noexcept {
-    return biginteger_details::__fdiv_r_impl(&rem, &num, div);
-}
+        return;
+    }
 
-template <typename S0, typename S1>
-void cdiv_qr(basic_biginteger<S0> &quot, basic_biginteger<S1> &rem,
-             const biginteger_data &num, const biginteger_data &div) noexcept {
-    biginteger_details::__cdiv_qr_impl(&quot, &rem, &num, &div);
-}
+    if (WJR_UNLIKELY(n >= 35)) {
+        // Can be aligned
+        // TODO : Align those that cannot be aligned with T through uint8_t
+        if (WJR_LIKELY(reinterpret_cast<uintptr_t>(dst) % sizeof(T) == 0)) {
+            return large_builtin_not_n(dst, src, n);
+        }
+    }
 
-template <typename S>
-void cdiv_q(basic_biginteger<S> &quot, const biginteger_data &num,
-            const biginteger_data &div) noexcept {
-    biginteger_details::__cdiv_q_impl(&quot, &num, &div);
-}
+    size_t idx = 0;
 
-template <typename S0>
-void cdiv_r(basic_biginteger<S0> &rem, const biginteger_data &num,
-            const biginteger_data &div) noexcept {
-    biginteger_details::__cdiv_r_impl(&rem, &num, &div);
-}
+    const auto y = sse::ones();
 
-template <typename S0, typename S1, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-uint64_t cdiv_qr(basic_biginteger<S0> &quot, basic_biginteger<S1> &rem,
-                 const biginteger_data &num, T div) noexcept {
-    return biginteger_details::__cdiv_qr_impl(&quot, &rem, &num, div);
-}
+    if (n & 4) {
+        auto x0 = sse::loadu((__m128i *)(src + idx));
+        auto x1 = sse::loadu((__m128i *)(src + idx + 2));
 
-template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-uint64_t cdiv_q(basic_biginteger<S> &quot, const biginteger_data &num, T div) noexcept {
-    return biginteger_details::__cdiv_q_impl(&quot, &num, div);
-}
+        sse::storeu((__m128i *)(dst + idx), sse::Xor(x0, y));
+        sse::storeu((__m128i *)(dst + idx + 2), sse::Xor(x1, y));
 
-template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-uint64_t cdiv_r(basic_biginteger<S> &rem, const biginteger_data &num, T div) noexcept {
-    return biginteger_details::__cdiv_r_impl(&rem, &num, div);
-}
+        idx += 4;
+    }
 
-template <typename S>
-void tdiv_q_2exp(basic_biginteger<S> &quot, const biginteger_data &num,
-                 uint32_t shift) noexcept {
-    biginteger_details::__tdiv_q_2exp_impl(&quot, &num, shift);
-}
+    if (n & 2) {
+        sse::storeu((__m128i *)(dst + idx),
+                    sse::Xor(sse::loadu((__m128i *)(src + idx)), y));
 
-template <typename S>
-void tdiv_r_2exp(basic_biginteger<S> &rem, const biginteger_data &num,
-                 uint32_t shift) noexcept {
-    biginteger_details::__tdiv_r_2exp_impl(&rem, &num, shift);
-}
+        idx += 2;
+    }
 
-template <typename S>
-void fdiv_q_2exp(basic_biginteger<S> &quot, const biginteger_data &num,
-                 uint32_t shift) noexcept {
-    biginteger_details::__fdiv_q_2exp_impl(&quot, &num, shift);
-}
+    if (n & 1) {
+        dst[idx] = ~src[idx];
 
-template <typename S>
-void cdiv_q_2exp(basic_biginteger<S> &quot, const biginteger_data &num,
-                 uint32_t shift) noexcept {
-    biginteger_details::__cdiv_q_2exp_impl(&quot, &num, shift);
-}
+        ++idx;
+    }
 
-template <typename S>
-void cdiv_r_2exp(basic_biginteger<S> &rem, const biginteger_data &num,
-                 uint32_t shift) noexcept {
-    biginteger_details::__cdiv_r_2exp_impl(&rem, &num, shift);
-}
+    if (WJR_UNLIKELY(idx == n)) {
+        return;
+    }
 
-template <typename S>
-void fdiv_r_2exp(basic_biginteger<S> &rem, const biginteger_data &num,
-                 uint32_t shift) noexcept {
-    biginteger_details::__fdiv_r_2exp_impl(&rem, &num, shift);
-}
+    WJR_ASSUME((n - idx) % 8 == 0);
 
-template <typename S, typename Engine,
-          WJR_REQUIRES(biginteger_uniform_random_bit_generator_v<Engine>)>
-void urandom_bit(basic_biginteger<S> &dst, uint32_t size, Engine &engine) noexcept {
-    biginteger_details::__urandom_bit_impl(&dst, size, engine);
-}
+    do {
+        auto x0 = sse::loadu((__m128i *)(src + idx));
+        auto x1 = sse::loadu((__m128i *)(src + idx + 2));
+        auto x2 = sse::loadu((__m128i *)(src + idx + 4));
+        auto x3 = sse::loadu((__m128i *)(src + idx + 6));
 
-template <typename S, typename Engine,
-          WJR_REQUIRES(biginteger_uniform_random_bit_generator_v<Engine>)>
-void urandom_exact_bit(basic_biginteger<S> &dst, uint32_t size, Engine &engine) noexcept {
-    biginteger_details::__urandom_exact_bit_impl(&dst, size, engine);
+        sse::storeu((__m128i *)(dst + idx), sse::Xor(x0, y));
+        sse::storeu((__m128i *)(dst + idx + 2), sse::Xor(x1, y));
+        sse::storeu((__m128i *)(dst + idx + 4), sse::Xor(x2, y));
+        sse::storeu((__m128i *)(dst + idx + 6), sse::Xor(x3, y));
+
+        idx += 8;
+    } while (idx != n);
 }
 
-template <typename S, typename Engine,
-          WJR_REQUIRES(biginteger_uniform_random_bit_generator_v<Engine>)>
-void urandom(basic_biginteger<S> &dst, const biginteger_data &limit,
-             Engine &engine) noexcept {
-    biginteger_details::__urandom_impl(&dst, &limit, engine);
-}
+#endif //
 
-template <typename S, typename Engine,
-          WJR_REQUIRES(biginteger_uniform_random_bit_generator_v<Engine>)>
-void urandom_exact(basic_biginteger<S> &dst, const biginteger_data &limit,
-                   Engine &engine) noexcept {
-    biginteger_details::__urandom_exact_impl(&dst, &limit, engine);
-}
+} // namespace wjr
 
-inline uint32_t bit_width(const biginteger_data &num) noexcept {
-    return biginteger_details::__bit_width_impl(&num);
-}
+#endif // WJR_X86_MATH_NOT_HPP__
+#endif
 
-inline uint32_t ctz(const biginteger_data &num) noexcept {
-    return biginteger_details::__ctz_impl(&num);
-}
+namespace wjr {
 
-template <typename S>
-void pow(basic_biginteger<S> &dst, const biginteger_data &num, uint32_t exp) noexcept {
-    biginteger_details::__pow_impl(&dst, &num, exp);
+template <typename T>
+WJR_INTRINSIC_CONSTEXPR void fallback_not_n(T *dst, const T *src, size_t n) noexcept {
+    for (size_t i = 0; i < n; ++i) {
+        dst[i] = ~src[i];
+    }
 }
 
-/**
- * @todo Need to optimize
- */
-template <typename S>
-void powmod(basic_biginteger<S> &dst, const biginteger_data &num,
-            const biginteger_data &exp, const biginteger_data &mod) noexcept {
-    biginteger_details::__powmod_impl(&dst, &num, &exp, &mod);
-}
+template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
+WJR_INTRINSIC_CONSTEXPR_E void not_n(T *dst, const T *src, size_t n) noexcept {
+#if WJR_HAS_BUILTIN(COMPLEMENT_N)
+    if constexpr (sizeof(T) == 8) {
+        if (is_constant_evaluated()) {
+            return fallback_not_n(dst, src, n);
+        }
 
-/**
- * @todo Need to optimize
- */
-template <typename S>
-void powmod(basic_biginteger<S> &dst, const biginteger_data &num, uint64_t exp,
-            const biginteger_data &mod) noexcept {
-    biginteger_details::__powmod_impl(&dst, &num, exp, &mod);
+        return builtin_not_n(dst, src, n);
+    } else {
+        return fallback_not_n(dst, src, n);
+    }
+#else
+    return fallback_not_n(dst, src, n);
+#endif
 }
 
-template <typename Storage>
-class basic_biginteger {
-
-public:
-    using storage_type = Storage;
-    using vector_type = basic_vector<storage_type>;
+} // namespace wjr
 
-    using value_type = typename vector_type::value_type;
-    using size_type = typename vector_type::size_type;
-    using difference_type = typename vector_type::difference_type;
-    using reference = typename vector_type::reference;
-    using const_reference = typename vector_type::const_reference;
-    using pointer = typename vector_type::pointer;
-    using const_pointer = typename vector_type::const_pointer;
-    using iterator = typename vector_type::iterator;
-    using const_iterator = typename vector_type::const_iterator;
-    using reverse_iterator = typename vector_type::reverse_iterator;
-    using const_reverse_iterator = typename vector_type::const_reverse_iterator;
-    using allocator_type = typename vector_type::allocator_type;
+#endif // WJR_MATH_NOT_HPP__
+// Already included
 
-    static_assert(std::is_same_v<value_type, uint64_t>, "value_type must be uint64_t");
-    static_assert(std::is_same_v<pointer, uint64_t *>, "pointer must be uint64_t *");
-    static_assert(std::is_same_v<const_pointer, const uint64_t *>,
-                  "const_pointer must be const uint64_t *");
-    static_assert(std::is_same_v<size_type, uint32_t>, "size_type must be uint32_t");
-    static_assert(std::is_same_v<difference_type, int32_t>,
-                  "difference_type must be int32_t");
+namespace wjr {
 
-    basic_biginteger() = default;
-    basic_biginteger(basic_biginteger &&other) = default;
-    basic_biginteger &operator=(basic_biginteger &&other) = default;
-    ~basic_biginteger() = default;
+/*
+  return true if src is all zero
+  calculations : stable n instead of not + inc which maybe n * 2
+*/
+template <typename T>
+WJR_INTRINSIC_CONSTEXPR_E bool negate_n(T *dst, const T *src, size_t n) noexcept {
+    size_t idx = replace_find_not(dst, src, n, 0, 0);
 
-    basic_biginteger(const basic_biginteger &other,
-                     const allocator_type &al = allocator_type())
-        : m_vec(other.m_vec, al) {
-        set_ssize(other.get_ssize());
+    if (idx == n) {
+        return true;
     }
 
-    basic_biginteger(size_type n, in_place_reserve_t,
-                     const allocator_type &al = allocator_type())
-        : m_vec(n, in_place_reserve, al) {}
-
-    explicit basic_biginteger(const allocator_type &al) : m_vec(al) {}
+    dst[idx] = -src[idx];
+    not_n(dst + idx + 1, src + idx + 1, n - idx - 1);
+    return false;
+}
 
-    basic_biginteger(basic_biginteger &&other, const allocator_type &al)
-        : m_vec(std::move(other.m_vec), al) {}
+} // namespace wjr
 
-    template <typename UnsignedValue,
-              WJR_REQUIRES(is_nonbool_unsigned_integral_v<UnsignedValue>)>
-    explicit basic_biginteger(UnsignedValue value,
-                              const allocator_type &al = allocator_type())
-        : m_vec(value != 0, value, al) {}
+#endif // WJR_MATH_NEG_HPP__
+#ifndef WJR_MATH_PREFIX_XOR_HPP__
+#define WJR_MATH_PREFIX_XOR_HPP__
 
-    template <typename SignedValue,
-              WJR_REQUIRES(is_nonbool_signed_integral_v<SignedValue>)>
-    explicit basic_biginteger(SignedValue value,
-                              const allocator_type &al = allocator_type())
-        : m_vec(al) {
-        if (value != 0) {
-            m_vec.emplace_back(value < 0 ? -to_unsigned(value) : to_unsigned(value));
-            set_ssize(__fasts_conditional_negate<int32_t>(value < 0, 1));
-        }
-    }
+// Already included
 
-    explicit basic_biginteger(span<const char> sp, unsigned int base = 10,
-                              const allocator_type &al = allocator_type())
-        : m_vec(al) {
-        from_string(sp, base);
-    }
+#if defined(WJR_X86)
+#ifndef WJR_X86_MATH_PREFIX_XOR_HPP__
+#define WJR_X86_MATH_PREFIX_XOR_HPP__
 
-    template <typename OthterStorage>
-    explicit basic_biginteger(const basic_biginteger<OthterStorage> &other,
-                              const allocator_type &al = allocator_type())
-        : m_vec(other.begin(), other.end(), al) {
-        set_ssize(other.get_ssize());
-    }
+// Already included
+// Already included
 
-    explicit basic_biginteger(const biginteger_data &data,
-                              const allocator_type &al = allocator_type())
-        : m_vec(data.data(), data.data() + data.size(), al) {
-        set_ssize(data.get_ssize());
-    }
+namespace wjr {
 
-    basic_biginteger &operator=(const basic_biginteger &other) {
-        if (WJR_UNLIKELY(this == std::addressof(other))) {
-            return *this;
-        }
+#if WJR_HAS_SIMD(PCLMUL) && WJR_HAS_SIMD(X86_SIMD)
+#define WJR_HAS_BUILTIN_PREFIX_XOR WJR_HAS_DEF
+#endif
 
-        m_vec = other.m_vec;
-        set_ssize(other.get_ssize());
-        return *this;
-    }
+#if WJR_HAS_BUILTIN(PREFIX_XOR)
 
-    template <typename UnsignedValue,
-              WJR_REQUIRES(is_nonbool_unsigned_integral_v<UnsignedValue>)>
-    basic_biginteger &operator=(UnsignedValue value) {
-        clear();
-        if (value != 0) {
-            m_vec.emplace_back(value);
-        }
-        return *this;
-    }
+template <typename T>
+T __builtin_prefix_xor(T x) noexcept {
+    const __m128i __result =
+        _mm_clmulepi64_si128((simd_cast<T, __m128i_t>(x)), sse::set1_epi8(0xFF), 0);
+    return simd_cast<__m128i_t, T>(__result);
+}
 
-    template <typename SignedValue,
-              WJR_REQUIRES(is_nonbool_signed_integral_v<SignedValue>)>
-    basic_biginteger &operator=(SignedValue value) {
-        clear();
-        if (value != 0) {
-            m_vec.emplace_back(value < 0 ? -to_unsigned(value) : to_unsigned(value));
-            set_ssize(__fasts_conditional_negate<int32_t>(value < 0, 1));
-        }
-        return *this;
+template <typename T>
+T builtin_prefix_xor(T x) noexcept {
+    constexpr auto nd = std::numeric_limits<T>::digits;
+    if constexpr (nd < 32) {
+        return static_cast<T>(__builtin_prefix_xor(static_cast<uint32_t>(x)));
+    } else {
+        return __builtin_prefix_xor(x);
     }
+}
 
-    basic_biginteger &operator=(span<const char> sp) { return from_string(sp); }
+#endif
 
-    template <typename OthterStorage>
-    basic_biginteger &operator=(const basic_biginteger<OthterStorage> &other) {
-        m_vec.assign(other.begin(), other.end());
-        set_ssize(other.get_ssize());
-        return *this;
-    }
+} // namespace wjr
 
-    basic_biginteger &operator=(const biginteger_data &data) {
-        if (WJR_UNLIKELY(std::addressof(__get_ref()) == std::addressof(data))) {
-            return *this;
-        }
+#endif // WJR_X86_MATH_PREFIX_XOR_HPP__
+#endif
 
-        m_vec.assign(data.data(), data.data() + data.size());
-        set_ssize(data.get_ssize());
-        return *this;
-    }
+namespace wjr {
 
-    template <typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-    explicit operator T() const noexcept {
-        if (empty()) {
-            return static_cast<T>(0);
-        }
+template <typename T>
+constexpr T fallback_prefix_xor(T x) noexcept {
+    constexpr auto nd = std::numeric_limits<T>::digits;
+    static_assert(nd <= 64, "Type T has more than 64 bits");
 
-        if constexpr (std::is_unsigned_v<T>) {
-            return static_cast<T>(front());
-        } else {
-            const auto ret = front();
-            return is_negate() ? -ret : ret;
-        }
+    x ^= x << 1;
+    x ^= x << 2;
+    x ^= x << 4;
+    if constexpr (nd > 8) {
+        x ^= x << 8;
+    }
+    if constexpr (nd > 16) {
+        x ^= x << 16;
+    }
+    if constexpr (nd > 32) {
+        x ^= x << 32;
     }
 
-    basic_biginteger &from_string(span<const char> sp, unsigned int base = 10) noexcept {
-        (void)from_chars(sp.data(), sp.data() + sp.size(), *this, base);
-        return *this;
+    return x;
+}
+
+template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
+WJR_INTRINSIC_CONSTEXPR_E T prefix_xor(T x) noexcept {
+#if WJR_HAS_BUILTIN(PREFIX_XOR)
+    if (is_constant_evaluated() || WJR_BUILTIN_CONSTANT_P(x)) {
+        return fallback_prefix_xor(x);
     }
 
-    allocator_type &get_allocator() noexcept { return m_vec.get_allocator(); }
-    const allocator_type &get_allocator() const noexcept { return m_vec.get_allocator(); }
+    return builtin_prefix_xor(x);
+#else
+    return fallback_prefix_xor(x);
+#endif
+}
 
-    reference at(size_type pos) { return m_vec.at(pos); }
-    const_reference at(size_type pos) const { return m_vec.at(pos); }
+} // namespace wjr
 
-    reference operator[](size_type pos) noexcept { return m_vec[pos]; }
-    const_reference operator[](size_type pos) const noexcept { return m_vec[pos]; }
+#endif // WJR_MATH_PREFIX_XOR_HPP__
+#ifndef WJR_MATH_RANDOM_HPP__
+#define WJR_MATH_RANDOM_HPP__
 
-    reference front() { return m_vec.front(); }
-    const_reference front() const { return m_vec.front(); }
+#include <algorithm>
+#include <random>
 
-    reference back() { return m_vec.back(); }
-    const_reference back() const { return m_vec.back(); }
+// Already included
 
-    WJR_PURE pointer data() noexcept { return m_vec.data(); }
-    WJR_PURE const_pointer data() const noexcept { return m_vec.data(); }
+namespace wjr {
 
-    WJR_PURE iterator begin() noexcept { return m_vec.begin(); }
-    WJR_PURE const_iterator begin() const noexcept { return m_vec.begin(); }
+template <typename Engine, typename = void>
+struct __uniform_random_bit_generator_impl : std::false_type {};
 
-    WJR_PURE iterator end() noexcept { return m_vec.end(); }
-    WJR_PURE const_iterator end() const noexcept { return m_vec.end(); }
+template <typename Engine>
+struct __uniform_random_bit_generator_impl<Engine,
+                                           std::enable_if_t<has_invocable_v<Engine &>>>
+    : std::conjunction<
+          is_nonbool_unsigned_integral<std::invoke_result_t<Engine &>>,
+          std::is_same<decltype(Engine::min()), std::invoke_result_t<Engine &>>,
+          std::is_same<decltype(Engine::max()), std::invoke_result_t<Engine &>>> {};
 
-    WJR_PURE const_iterator cbegin() const noexcept { return m_vec.cbegin(); }
+template <typename Engine>
+struct uniform_random_bit_generator : __uniform_random_bit_generator_impl<Engine> {};
 
-    WJR_PURE const_iterator cend() const noexcept { return m_vec.cend(); }
+template <typename Engine>
+inline constexpr bool uniform_random_bit_generator_v =
+    uniform_random_bit_generator<Engine>::value;
 
-    WJR_PURE reverse_iterator rbegin() noexcept { return m_vec.rbegin(); }
-    WJR_PURE const_reverse_iterator rbegin() const noexcept { return m_vec.rbegin(); }
+template <typename Engine>
+struct biginteger_uniform_random_bit_generator
+    : std::conjunction<
+          __uniform_random_bit_generator_impl<Engine>,
+          std::is_same<std::invoke_result_t<Engine &>, uint64_t>,
+          std::bool_constant<Engine::min() == std::numeric_limits<uint64_t>::min()>,
+          std::bool_constant<Engine::max() == std::numeric_limits<uint64_t>::max()>> {};
 
-    WJR_PURE reverse_iterator rend() noexcept { return m_vec.rend(); }
-    WJR_PURE const_reverse_iterator rend() const noexcept { return m_vec.rend(); }
+template <typename Engine>
+inline constexpr bool biginteger_uniform_random_bit_generator_v =
+    biginteger_uniform_random_bit_generator<Engine>::value;
 
-    WJR_PURE const_reverse_iterator crbegin() const noexcept { return m_vec.crbegin(); }
-    WJR_PURE const_reverse_iterator crend() const noexcept { return m_vec.crend(); }
+template <typename Iter, typename Rand>
+void random(Iter first, Iter last, Rand &&rd) {
+    std::generate(first, last, std::ref(rd));
+}
 
-    WJR_PURE bool empty() const noexcept { return m_vec.empty(); }
-    WJR_PURE size_type size() const noexcept { return m_vec.size(); }
-    WJR_PURE size_type capacity() const noexcept { return m_vec.capacity(); }
-    WJR_PURE bool zero() const noexcept { return empty(); }
+template <typename Iter, typename Rand>
+void random_n(Iter First, size_t Count, Rand &&rd) {
+    std::generate_n(First, Count, std::ref(rd));
+}
 
-    void reserve(size_type new_capacity) noexcept { m_vec.reserve(new_capacity); }
+} // namespace wjr
 
-    void shrink_to_fit() { m_vec.shrink_to_fit(); }
+#endif // WJR_MATH_RANDOM_HPP__
 
-    /// equal to set_ssize(0)
-    void clear() { m_vec.clear(); }
+#endif // WJR_MATH_HPP__
+// Already included
+// Already included
 
-    void swap(basic_biginteger &other) noexcept { m_vec.swap(other.m_vec); }
+namespace wjr {
 
-    void conditional_negate(bool condition) noexcept {
-        set_ssize(__fasts_conditional_negate<int32_t>(condition, get_ssize()));
-    }
+template <typename Storage>
+struct is_biginteger_storage : std::false_type {};
 
-    void negate() noexcept { conditional_negate(true); }
+template <typename Storage>
+inline constexpr bool is_biginteger_storage_v = is_biginteger_storage<Storage>::value;
 
-    WJR_PURE bool is_negate() const noexcept { return get_ssize() < 0; }
+namespace biginteger_details {
 
-    void absolute() noexcept { set_ssize(__fasts_abs(get_ssize())); }
+/**
+ * @brief Remove leading zeros.
+ *
+ */
+inline uint32_t normalize(const uint64_t *ptr, uint32_t n) noexcept {
+    return reverse_find_not_n(ptr, 0, n);
+}
 
-    basic_biginteger &operator++() {
-        increment(*this);
-        return *this;
-    }
+} // namespace biginteger_details
 
-    basic_biginteger &operator--() {
-        decrement(*this);
-        return *this;
-    }
+class default_biginteger_size_reference {
+public:
+    default_biginteger_size_reference() = delete;
+    default_biginteger_size_reference(const default_biginteger_size_reference &) = delete;
+    default_biginteger_size_reference(default_biginteger_size_reference &&) = default;
+    default_biginteger_size_reference &
+    operator=(const default_biginteger_size_reference &) = delete;
+    default_biginteger_size_reference &
+    operator=(default_biginteger_size_reference &&) = default;
 
-    template <typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-    basic_biginteger &operator+=(T rhs) {
-        add(*this, *this, rhs);
-        return *this;
-    }
+    explicit default_biginteger_size_reference(int32_t &size) noexcept : m_size(&size) {}
+    ~default_biginteger_size_reference() = default;
 
-    basic_biginteger &operator+=(const biginteger_data &rhs) {
-        add(*this, *this, rhs);
+    default_biginteger_size_reference &operator=(uint32_t size) noexcept {
+        *m_size = __fasts_negate_with<int32_t>(*m_size, size);
         return *this;
     }
 
-    template <typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-    basic_biginteger &operator-=(T rhs) {
-        sub(*this, *this, rhs);
-        return *this;
-    }
+    WJR_PURE operator uint32_t() const noexcept { return __fasts_abs(*m_size); }
 
-    basic_biginteger &operator-=(const biginteger_data &rhs) {
-        sub(*this, *this, rhs);
+    default_biginteger_size_reference &operator++() noexcept {
+        *m_size = __fasts_increment(*m_size);
         return *this;
     }
 
-    template <typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
-    basic_biginteger &operator*=(T rhs) {
-        mul(*this, *this, rhs);
+    default_biginteger_size_reference &operator--() noexcept {
+        *m_size = __fasts_decrement(*m_size);
         return *this;
     }
 
-    basic_biginteger &operator*=(const biginteger_data &rhs) {
-        mul(*this, *this, rhs);
+    default_biginteger_size_reference &operator+=(uint32_t size) noexcept {
+        *m_size = __fasts_add(*m_size, size);
         return *this;
     }
 
-    basic_biginteger &operator<<=(uint32_t shift) {
-        mul_2exp(*this, *this, shift);
+    default_biginteger_size_reference &operator-=(uint32_t size) noexcept {
+        *m_size = __fasts_sub(*m_size, size);
         return *this;
     }
 
-    // extension
-
-    WJR_PURE int32_t get_ssize() const { return get_storage().get_ssize(); }
-    template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T> ||
-                                       std::is_same_v<T, int32_t>)>
-    void set_ssize(T new_size) noexcept {
-        if constexpr (std::is_unsigned_v<T>) {
-            const auto u32size = static_cast<uint32_t>(new_size);
-            WJR_ASSUME(u32size == new_size);
-            get_storage().set_ssize(__fasts_from_unsigned(u32size));
-        } else {
-            get_storage().set_ssize(new_size);
-        }
-    }
-
-    WJR_CONST static size_type get_growth_capacity(size_type old_capacity,
-                                                   size_type new_size) noexcept {
-        return vector_type::get_growth_capacity(old_capacity, new_size);
-    }
-
-    void take_storage(storage_type &other) noexcept { m_vec.take_storage(other); }
-
-    void uninitialized_construct(storage_type &other, size_type siz,
-                                 size_type cap) noexcept {
-        m_vec.uninitialized_construct(other, siz, cap);
-    }
-
-    WJR_PURE storage_type &get_storage() noexcept { return m_vec.get_storage(); }
-    WJR_PURE const storage_type &get_storage() const noexcept {
-        return m_vec.get_storage();
-    }
-
-    WJR_PURE const biginteger_data *__get_data() const noexcept {
-        return get_storage().__get_data();
-    }
-
-    WJR_PURE const biginteger_data &__get_ref() const noexcept { return *__get_data(); }
-    WJR_PURE operator const biginteger_data &() const noexcept { return __get_ref(); }
-
 private:
-    void __check_high_bit() const {
-        WJR_ASSERT(size() == 0 || back() != 0, "biginteger should not have leading zero");
-    }
-
-    vector_type m_vec;
+    int32_t *m_size;
 };
 
-template <typename Alloc>
-using default_biginteger = basic_biginteger<default_biginteger_vector_storage<Alloc>>;
-
-using biginteger = default_biginteger<memory_pool<uint64_t>>;
-using stack_biginteger = default_biginteger<math_details::weak_stack_alloc<uint64_t>>;
-
-template <typename Storage>
-void swap(basic_biginteger<Storage> &lhs, basic_biginteger<Storage> &rhs) noexcept {
-    lhs.swap(rhs);
-}
-
-namespace biginteger_details {
-
-/// @private
-template <typename S>
-WJR_PURE bool __equal_pointer(const basic_biginteger<S> *lhs,
-                              const basic_biginteger<S> *rhs) noexcept {
-    return lhs == rhs;
-}
-
 /// @private
-template <typename S0, typename S1>
-WJR_PURE bool __equal_pointer(const basic_biginteger<S0> *,
-                              const basic_biginteger<S1> *) noexcept {
-    return false;
-}
-
-/// @private
-template <typename S>
-WJR_PURE bool __equal_pointer(const basic_biginteger<S> *lhs,
-                              const biginteger_data *rhs) noexcept {
-    return lhs->__get_data() == rhs;
-}
-
-/// @private
-template <typename S>
-WJR_PURE bool __equal_pointer(const biginteger_data *lhs,
-                              const basic_biginteger<S> *rhs) noexcept {
-    return lhs == rhs->__get_data();
-}
+template <>
+struct __unref_wrapper_helper<default_biginteger_size_reference> {
+    using type = uint32_t &;
+};
 
-/// @private
-WJR_PURE inline bool __equal_pointer(const biginteger_data *lhs,
-                                     const biginteger_data *rhs) noexcept {
-    return lhs == rhs;
-}
+/**
+ * @brief data_type of biginteger
+ *
+ * @details View the data of biginteger. Used for type erasure. Manage memory allocation
+ * and release on your own.
+ *
+ */
+struct biginteger_data {
+    WJR_PURE constexpr const uint64_t *data() const noexcept { return m_data; }
+    WJR_PURE constexpr uint32_t size() const noexcept { return __fasts_abs(m_size); }
 
-template <typename S>
-from_chars_result<> __from_chars_impl(const char *first, const char *last,
-                                      basic_biginteger<S> *dst,
-                                      unsigned int base) noexcept {
+    WJR_PURE constexpr bool empty() const noexcept { return m_size == 0; }
+    WJR_PURE constexpr bool is_negate() const noexcept { return m_size < 0; }
 
-    uint8_t ch;
-    from_chars_result<> result{first, std::errc{}};
+    WJR_PURE constexpr int32_t get_ssize() const noexcept { return m_size; }
 
-    auto invalid = [&dst, &result]() {
-        dst->clear();
-        result.ec = std::errc::invalid_argument;
-        return result;
-    };
+    uint64_t *m_data = nullptr;
+    int32_t m_size = 0;
+    uint32_t m_capacity = 0;
+};
 
-    if (first == last) {
-        return invalid();
-    }
+/**
+ * @struct biginteger_data
+ * @brief The data structure for biginteger
+ *
+ */
+template <typename Alloc>
+class default_biginteger_vector_storage {
+    using _Alty = typename std::allocator_traits<Alloc>::template rebind_alloc<uint64_t>;
+    using _Alty_traits = std::allocator_traits<_Alty>;
 
-    while (convert_details::__isspace(ch = *first++) && first != last)
-        ;
+public:
+    using value_type = uint64_t;
+    using pointer = typename _Alty_traits::pointer;
+    using const_pointer = typename _Alty_traits::const_pointer;
+    using size_type = uint32_t;
+    using difference_type = int32_t;
+    using allocator_type = Alloc;
+    using storage_traits_type = vector_storage_traits<uint64_t, Alloc>;
+    using is_reallocatable = std::true_type;
 
-    int sign = 0;
-    if (ch == '-') {
-        sign = 1;
+public:
+    default_biginteger_vector_storage() noexcept = default;
 
-        if (WJR_UNLIKELY(first == last)) {
-            return invalid();
-        }
+    default_biginteger_vector_storage(const default_biginteger_vector_storage &) = delete;
+    default_biginteger_vector_storage(default_biginteger_vector_storage &&) noexcept =
+        delete;
+    default_biginteger_vector_storage &
+    operator=(const default_biginteger_vector_storage &) = delete;
+    default_biginteger_vector_storage &
+    operator=(default_biginteger_vector_storage &&) noexcept = delete;
 
-        ch = *first++;
-    }
+    ~default_biginteger_vector_storage() noexcept = default;
 
-    if (base == 0) {
-        base = 10;
-        if (ch == '0') {
-            base = 8;
-            if (WJR_UNLIKELY(first == last)) {
-                return invalid();
-            }
-            ch = *first++;
-            if (ch == 'x' || ch == 'X') {
-                base = 16;
-                if (WJR_UNLIKELY(first == last)) {
-                    return invalid();
-                }
-                ch = *first++;
-            } else {
-                if (ch == 'b' || ch == 'B') {
-                    base = 2;
-                    if (WJR_UNLIKELY(first == last)) {
-                        return invalid();
-                    }
-                    ch = *first++;
-                }
-            }
+    void destroy(_Alty &al) noexcept {
+        if (WJR_BUILTIN_CONSTANT_P(data() == nullptr) && data() == nullptr) {
+            return;
         }
-    }
 
-    auto __first = first;
+        const size_type __size = size();
 
-    while (ch == '0') {
-        if (WJR_UNLIKELY(first == last)) {
-            dst->clear();
-            result.ptr = first;
-            return result;
+        if (WJR_BUILTIN_CONSTANT_P(__size == 0) && __size == 0) {
+            return;
         }
 
-        ch = *first++;
+        destroy_n_using_allocator(data(), __size, al);
     }
 
-    const auto start = first;
-    if (base <= 10) {
-        while (ch >= '0' && ch < '0' + base) {
-            if (first == last) {
-                ++first;
-                break;
-            }
-
-            ch = *first++;
+    void destroy_and_deallocate(_Alty &al) noexcept {
+        if (WJR_BUILTIN_CONSTANT_P(capacity() == 0) && capacity() == 0) {
+            return;
         }
-    } else {
-        ch = 0;
-        while (ch < base) {
-            if (first == last) {
-                ++first;
-                break;
-            }
 
-            ch = char_converter.from(*first++);
+        if (data()) {
+            WJR_ASSERT_ASSUME_L2(capacity() != 0);
+
+            destroy(al);
+            al.deallocate(data(), capacity());
         }
     }
 
-    if (WJR_UNLIKELY(first == __first)) {
-        return invalid();
+    void uninitialized_construct(default_biginteger_vector_storage &other, size_type size,
+                                 size_type capacity, _Alty &al) {
+        if (capacity != 0) {
+            auto &storage = other.m_storage;
+            storage.m_data = al.allocate(capacity);
+            storage.m_size = __fasts_negate_with<int32_t>(m_storage.m_size, size);
+            storage.m_capacity = capacity;
+        }
     }
 
-    if (first == start) {
-        dst->clear();
-        result.ptr = first;
-        return result;
+    void take_storage(default_biginteger_vector_storage &other, _Alty &) noexcept {
+        auto &other_storage = other.m_storage;
+        m_storage = other_storage;
+        other_storage.m_data = nullptr;
+        other_storage.m_size = other_storage.m_capacity = 0;
     }
 
-    const size_t str_size = first - start;
-    size_t capacity;
-
-    switch (base) {
-    case 2: {
-        capacity = __ceil_div(str_size, 64);
-        break;
-    }
-    case 8: {
-        capacity = __ceil_div(str_size * 3, 64);
-        break;
-    }
-    case 16: {
-        capacity = __ceil_div(str_size, 16);
-        break;
-    }
-    case 4:
-    case 32: {
-        const int bits = base == 4 ? 2 : 5;
-        capacity = __ceil_div(str_size * bits, 64);
-        break;
-    }
-    case 10: {
-        // capacity = (str_size * log2(10) + 63) / 64;
-        capacity = __ceil_div(str_size * 10 / 3, 64);
-        break;
-    }
-    default: {
-        return invalid();
+    void swap_storage(default_biginteger_vector_storage &other, _Alty &) noexcept {
+        std::swap(m_storage, other.m_storage);
     }
+
+    WJR_PURE default_biginteger_size_reference size() noexcept {
+        return default_biginteger_size_reference(m_storage.m_size);
     }
 
-    dst->reserve(capacity);
-    auto ptr = dst->data();
-    int32_t dssize = biginteger_from_chars(start - 1, first - 1, ptr, base) - ptr;
-    dssize = __fasts_conditional_negate<int32_t>(sign, dssize);
-    dst->set_ssize(dssize);
-    result.ptr = first;
-    return result;
-}
+    WJR_PURE size_type size() const noexcept { return __fasts_abs(m_storage.m_size); }
+    WJR_PURE size_type capacity() const noexcept { return m_storage.m_capacity; }
 
-inline int32_t __compare_impl(const biginteger_data *lhs,
-                              const biginteger_data *rhs) noexcept {
-    const auto lssize = lhs->get_ssize();
-    const auto rssize = rhs->get_ssize();
+    WJR_PURE pointer data() noexcept { return m_storage.m_data; }
+    WJR_PURE const_pointer data() const noexcept { return m_storage.m_data; }
 
-    if (lssize != rssize) {
-        return lssize < rssize ? -1 : 1;
+    // extension
+
+    WJR_PURE int32_t get_ssize() const noexcept { return m_storage.m_size; }
+    template <typename T, WJR_REQUIRES(is_any_of_v<T, int32_t>)>
+    void set_ssize(T size) noexcept {
+        WJR_ASSERT_ASSUME(__fasts_abs(size) <= capacity());
+        m_storage.m_size = size;
     }
 
-    const int32_t ans = reverse_compare_n(lhs->data(), rhs->data(), __fasts_abs(lssize));
-    return lssize < 0 ? -ans : ans;
-}
+    WJR_PURE const biginteger_data *__get_data() const noexcept { return &m_storage; }
 
-inline int32_t __compare_ui_impl(const biginteger_data *lhs, uint64_t rhs) noexcept {
-    const int32_t lssize = lhs->get_ssize();
+private:
+    biginteger_data m_storage;
+};
 
-    if (lssize == 0) {
-        return -(rhs != 0);
-    }
+template <typename Alloc>
+struct is_biginteger_storage<default_biginteger_vector_storage<Alloc>> : std::true_type {
+};
 
-    if (lssize == 1) {
-        const uint64_t lvalue = lhs->data()[0];
-        return (lvalue != rhs ? (lvalue < rhs ? -1 : 1) : 0);
-    }
+template <typename Storage>
+class basic_biginteger;
 
-    return lssize;
-}
+namespace biginteger_details {
 
-inline int32_t __compare_si_impl(const biginteger_data *lhs, int64_t rhs) noexcept {
-    const int32_t lssize = lhs->get_ssize();
-    const int32_t rssize = rhs == 0 ? 0 : __fasts_conditional_negate<int32_t>(rhs < 0, 1);
+// const basic_biginteger<Storage>* don't need to get allocator
+// use const Storage* instead of const basic_biginteger<Storage>*
 
-    if (lssize != rssize) {
-        return lssize - rssize;
-    }
+/// @private
+template <typename S>
+from_chars_result<> __from_chars_impl(const char *first, const char *last,
+                                      basic_biginteger<S> *dst,
+                                      unsigned int base) noexcept;
 
-    if (lssize == 0) {
-        return 0;
-    }
+/// @private
+inline int32_t __compare_impl(const biginteger_data *lhs,
+                              const biginteger_data *rhs) noexcept;
 
-    const uint64_t lvalue = lhs->data()[0];
-    const uint64_t rvalue = rhs >= 0 ? to_unsigned(rhs) : -to_unsigned(rhs);
+/// @private
+inline int32_t __compare_ui_impl(const biginteger_data *lhs, uint64_t rhs) noexcept;
+
+/// @private
+inline int32_t __compare_si_impl(const biginteger_data *lhs, int64_t rhs) noexcept;
 
-    if (lvalue == rvalue) {
-        return 0;
+/// @private
+template <typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+int32_t __compare_impl(const biginteger_data *lhs, T rhs) noexcept {
+    if (WJR_BUILTIN_CONSTANT_P(rhs == 0) && rhs == 0) {
+        const int32_t ssize = lhs->get_ssize();
+        return ssize == 0 ? 0 : ssize < 0 ? -1 : 1;
     }
 
-    if (lvalue > rvalue) {
-        return lssize;
-    }
+    if constexpr (std::is_unsigned_v<T>) {
+        return __compare_ui_impl(lhs, rhs);
+    } else {
+        if (WJR_BUILTIN_CONSTANT_P(rhs >= 0) && rhs >= 0) {
+            return __compare_ui_impl(lhs, to_unsigned(rhs));
+        }
 
-    return -lssize;
+        return __compare_si_impl(lhs, rhs);
+    }
 }
 
+/// @private
 template <bool xsign, typename S>
 void __addsub_impl(basic_biginteger<S> *dst, const biginteger_data *lhs,
-                   uint64_t rhs) noexcept {
-    const int32_t lssize = lhs->get_ssize();
-    if (lssize == 0) {
-        dst->reserve(1);
-
-        if (rhs == 0) {
-            dst->set_ssize(0);
-        } else {
-            dst->front() = rhs;
-            dst->set_ssize(__fasts_conditional_negate<int32_t>(xsign, 1));
-        }
-
-        return;
-    }
+                   uint64_t rhs) noexcept;
 
-    const uint32_t lusize = __fasts_abs(lssize);
-    dst->reserve(lusize + 1);
+/// @private
+template <typename S>
+void __ui_sub_impl(basic_biginteger<S> *dst, uint64_t lhs,
+                   const biginteger_data *rhs) noexcept;
 
-    const auto dp = dst->data();
-    const auto lp = lhs->data();
+/// @private
+template <bool xsign, typename S>
+void __addsub_impl(basic_biginteger<S> *dst, const biginteger_data *lhs,
+                   const biginteger_data *rhs) noexcept;
 
-    using compare = std::conditional_t<xsign, std::less<>, std::greater<>>;
-    int32_t dssize;
+/// @private
+template <typename S>
+void __add_impl(basic_biginteger<S> *dst, const biginteger_data *lhs,
+                const biginteger_data *rhs) noexcept {
+    __addsub_impl<false>(dst, lhs, rhs);
+}
 
-    if (compare{}(lssize, 0)) {
-        const auto cf = addc_1(dp, lp, lusize, rhs);
-        dssize = __fasts_conditional_negate<int32_t>(xsign, lusize + cf);
-        if (cf) {
-            dp[lusize] = 1;
-        }
+/// @private
+template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+void __add_impl(basic_biginteger<S> *dst, const biginteger_data *lhs, T rhs) noexcept {
+    if constexpr (std::is_unsigned_v<T>) {
+        __addsub_impl<false>(dst, lhs, rhs);
     } else {
-        if (lusize == 1 && lp[0] < rhs) {
-            dp[0] = rhs - lp[0];
-            dssize = __fasts_conditional_negate<int32_t>(xsign, 1);
+        if (rhs < 0) {
+            __addsub_impl<true>(dst, lhs, -to_unsigned(rhs));
         } else {
-            (void)subc_1(dp, lp, lusize, rhs);
-            dssize = __fasts_conditional_negate<int32_t>(!xsign,
-                                                         lusize - (dp[lusize - 1] == 0));
+            __addsub_impl<false>(dst, lhs, to_unsigned(rhs));
         }
     }
+}
 
-    dst->set_ssize(dssize);
+/// @private
+template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+void __add_impl(basic_biginteger<S> *dst, T lhs, const biginteger_data *rhs) noexcept {
+    __add_impl(dst, rhs, lhs);
 }
 
+/// @private
 template <typename S>
-void __ui_sub_impl(basic_biginteger<S> *dst, uint64_t lhs,
-                   const biginteger_data *rhs) noexcept {
-    const int32_t rssize = rhs->get_ssize();
-    if (rssize == 0) {
-        dst->reserve(1);
+void __sub_impl(basic_biginteger<S> *dst, const biginteger_data *lhs,
+                const biginteger_data *rhs) noexcept {
+    __addsub_impl<true>(dst, lhs, rhs);
+}
 
-        if (lhs == 0) {
-            dst->set_ssize(0);
+/// @private
+template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+void __sub_impl(basic_biginteger<S> *dst, const biginteger_data *lhs, T rhs) noexcept {
+    if constexpr (std::is_unsigned_v<T>) {
+        __addsub_impl<true>(dst, lhs, rhs);
+    } else {
+        if (rhs < 0) {
+            __addsub_impl<false>(dst, lhs, -to_unsigned(rhs));
         } else {
-            dst->front() = lhs;
-            dst->set_ssize(1);
+            __addsub_impl<true>(dst, lhs, to_unsigned(rhs));
         }
-
-        return;
     }
+}
 
-    const uint32_t rusize = __fasts_abs(rssize);
-    dst->reserve(rusize);
-
-    const auto dp = dst->data();
-    const auto rp = rhs->data();
-    int32_t dssize;
-
-    if (rssize < 0) {
-        const auto cf = addc_1(dp, rp, rusize, lhs);
-        dssize = rusize + cf;
-        if (cf) {
-            dp[rusize] = 1;
-        }
+/// @private
+template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+void __sub_impl(basic_biginteger<S> *dst, T lhs, const biginteger_data *rhs) noexcept {
+    if constexpr (std::is_unsigned_v<T>) {
+        __ui_sub_impl(dst, lhs, rhs);
     } else {
-        // lhs >= rhs
-        if (rusize == 1 && lhs >= rp[0]) {
-            dp[0] = lhs - rp[0];
-            dssize = dp[0] != 0;
-        }
-        // lhs < rhs
-        else {
-            (void)subc_1(dp, rp, rusize, lhs);
-            dssize = __fasts_negate<int32_t>(rusize - (dp[rusize - 1] == 0));
+        if (lhs < 0) {
+            __addsub_impl<false>(dst, rhs, -to_unsigned(lhs));
+            dst->negate();
+        } else {
+            __ui_sub_impl(dst, to_unsigned(lhs), rhs);
         }
     }
-
-    dst->set_ssize(dssize);
 }
 
-template <bool xsign, typename S>
-void __addsub_impl(basic_biginteger<S> *dst, const biginteger_data *lhs,
-                   const biginteger_data *rhs) noexcept {
-    int32_t lssize = lhs->get_ssize();
-    int32_t rssize = __fasts_conditional_negate<int32_t>(xsign, rhs->get_ssize());
-    uint32_t lusize = __fasts_abs(lssize);
-    uint32_t rusize = __fasts_abs(rssize);
-
-    if (lusize < rusize) {
-        std::swap(lhs, rhs);
-        std::swap(lssize, rssize);
-        std::swap(lusize, rusize);
-    }
+/// @private
+template <typename S>
+void __mul_ui_impl(basic_biginteger<S> *dst, const biginteger_data *lhs,
+                   uint64_t rhs) noexcept;
 
-    dst->reserve(lusize + 1);
+/// @private
+template <typename S>
+void __mul_impl(basic_biginteger<S> *dst, const biginteger_data *lhs,
+                const biginteger_data *rhs) noexcept;
 
-    const auto dp = dst->data();
-    const auto lp = lhs->data();
-    const auto rp = rhs->data();
-    int32_t dssize;
+/// @private
+template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+void __mul_impl(basic_biginteger<S> *dst, const biginteger_data *lhs, T rhs) noexcept {
+    if constexpr (std::is_unsigned_v<T>) {
+        __mul_ui_impl(dst, lhs, rhs);
+    } else {
+        uint64_t value = to_unsigned(rhs);
+        bool cond = false;
 
-    if (rusize == 0) {
-        if (lp != dp) {
-            std::copy_n(lp, lusize, dp);
-            dst->set_ssize(lssize);
+        if (rhs < 0) {
+            value = -value;
+            cond = true;
         }
-        return;
-    }
 
-    // different sign
-    if ((lssize ^ rssize) < 0) {
-        const int32_t ans =
-            static_cast<int32_t>(abs_subc_s_pos(dp, lp, lusize, rp, rusize));
-        dssize = __fasts_negate_with<int32_t>(lssize, ans);
-    } else {
-        const auto cf = addc_s(dp, lp, lusize, rp, rusize);
-        dssize = __fasts_negate_with<int32_t>(lssize, lusize + cf);
-        if (cf) {
-            dp[lusize] = 1;
-        }
+        __mul_ui_impl(dst, lhs, value);
+        dst->conditional_negate(cond);
     }
-
-    dst->set_ssize(dssize);
 }
 
+/// @private
 template <typename S>
-void __mul_ui_impl(basic_biginteger<S> *dst, const biginteger_data *lhs,
-                   uint64_t rhs) noexcept {
-    const int32_t lssize = lhs->get_ssize();
-    const uint32_t lusize = __fasts_abs(lssize);
+void __sqr_impl(basic_biginteger<S> *dst, const biginteger_data *src) noexcept;
 
-    if (lusize == 0 || rhs == 0) {
-        dst->set_ssize(0);
-        return;
-    }
+/// @private
+template <typename S>
+void __addsubmul_impl(basic_biginteger<S> *dst, const biginteger_data *lhs, uint64_t rhs,
+                      int32_t xmask) noexcept;
 
-    dst->reserve(lusize + 1);
+/// @private
+template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+void __addmul_impl(basic_biginteger<S> *dst, const biginteger_data *lhs, T rhs) noexcept {
+    if constexpr (std::is_unsigned_v<T>) {
+        __addsubmul_impl(dst, lhs, rhs, 0);
+    } else {
+        uint64_t rvalue = to_unsigned(rhs);
+        int32_t xsign = 0;
 
-    const auto dp = dst->data();
-    const auto lp = lhs->data();
+        if (rhs < 0) {
+            rvalue = -rvalue;
+            xsign = -1;
+        }
 
-    const auto cf = mul_1(dp, lp, lusize, rhs);
-    const uint32_t dusize = lusize + (cf != 0);
-    if (cf != 0) {
-        dp[lusize] = cf;
+        __addsubmul_impl(dst, lhs, rvalue, xsign);
     }
-
-    dst->set_ssize(__fasts_conditional_negate<int32_t>(lssize < 0, dusize));
 }
 
-template <typename S>
-void __mul_impl(basic_biginteger<S> *dst, const biginteger_data *lhs,
-                const biginteger_data *rhs) noexcept {
-    int32_t lssize = lhs->get_ssize();
-    int32_t rssize = rhs->get_ssize();
-    uint32_t lusize = __fasts_abs(lssize);
-    uint32_t rusize = __fasts_abs(rssize);
+/// @private
+template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+void __submul_impl(basic_biginteger<S> *dst, const biginteger_data *lhs, T rhs) noexcept {
+    if constexpr (std::is_unsigned_v<T>) {
+        __addsubmul_impl(dst, lhs, rhs, -1);
+    } else {
+        uint64_t rvalue = to_unsigned(rhs);
+        int32_t xsign = -1;
+
+        if (rhs < 0) {
+            rvalue = -rvalue;
+            xsign = 0;
+        }
 
-    if (lusize < rusize) {
-        std::swap(lhs, rhs);
-        std::swap(lusize, rusize);
+        __addsubmul_impl(dst, lhs, rvalue, xsign);
     }
+}
 
-    if (WJR_UNLIKELY(rusize == 0)) {
-        dst->set_ssize(0);
-        return;
-    }
+/// @private
+template <typename S>
+void __addsubmul_impl(basic_biginteger<S> *dst, const biginteger_data *lhs,
+                      const biginteger_data *rhs, int32_t xmask) noexcept;
 
-    const int32_t mask = lssize ^ rssize;
+/// @private
+template <typename S>
+void __addmul_impl(basic_biginteger<S> *dst, const biginteger_data *lhs,
+                   const biginteger_data *rhs) noexcept {
+    __addsubmul_impl(dst, lhs, rhs, 0);
+}
 
-    int32_t dssize;
-    uint32_t dusize;
+/// @private
+template <typename S>
+void __submul_impl(basic_biginteger<S> *dst, const biginteger_data *lhs,
+                   const biginteger_data *rhs) noexcept {
+    __addsubmul_impl(dst, lhs, rhs, -1);
+}
 
-    if (rusize == 1) {
-        dst->reserve(lusize + 1);
-        const auto cf = mul_1(dst->data(), lhs->data(), lusize, rhs->data()[0]);
-        dssize = __fasts_negate_with<int32_t>(mask, lusize + (cf != 0));
-        if (cf != 0) {
-            dst->data()[lusize] = cf;
-        }
-        dst->set_ssize(dssize);
-        return;
-    }
+/// @private
+template <typename S>
+void __mul_2exp_impl(basic_biginteger<S> *dst, const biginteger_data *lhs,
+                     uint32_t shift) noexcept;
 
-    dusize = lusize + rusize;
+/// @private
+template <typename S0, typename S1>
+void __tdiv_qr_impl(basic_biginteger<S0> *quot, basic_biginteger<S1> *rem,
+                    const biginteger_data *num, const biginteger_data *div) noexcept;
 
-    using pointer = uint64_t *;
+/// @private
+template <typename S>
+void __tdiv_q_impl(basic_biginteger<S> *quot, const biginteger_data *num,
+                   const biginteger_data *div) noexcept;
 
-    auto dp = dst->data();
-    auto lp = (pointer)(lhs->data());
-    auto rp = (pointer)(rhs->data());
+/// @private
+template <typename S>
+void __tdiv_r_impl(basic_biginteger<S> *rem, const biginteger_data *num,
+                   const biginteger_data *div) noexcept;
 
-    std::optional<uninitialized<basic_biginteger<S>>> tmp;
+/// @private
+template <typename S0, typename S1>
+uint64_t __tdiv_qr_ui_impl(basic_biginteger<S0> *quot, basic_biginteger<S1> *rem,
+                           const biginteger_data *num, uint64_t div) noexcept;
 
-    unique_stack_allocator stkal(math_details::stack_alloc);
+/// @private
+template <typename S>
+uint64_t __tdiv_q_ui_impl(basic_biginteger<S> *quot, const biginteger_data *num,
+                          uint64_t div) noexcept;
 
-    if (dst->capacity() < dusize) {
-        tmp.emplace(dst->get_growth_capacity(dst->capacity(), dusize), in_place_reserve,
-                    dst->get_allocator());
-        dp = (**tmp).data();
-    } else {
-        if (dp == lp) {
-            lp = (pointer)stkal.allocate(lusize * sizeof(uint64_t));
-            if (dp == rp) {
-                rp = lp;
-            }
-            std::copy_n(dp, lusize, lp);
-        } else if (dp == rp) {
-            rp = (pointer)stkal.allocate(rusize * sizeof(uint64_t));
-            std::copy_n(dp, rusize, rp);
-        }
-    }
+/// @private
+template <typename S>
+uint64_t __tdiv_r_ui_impl(basic_biginteger<S> *rem, const biginteger_data *num,
+                          uint64_t div) noexcept;
 
-    if (WJR_UNLIKELY(lp == rp)) {
-        sqr(dp, lp, lusize);
-    } else {
-        mul_s(dp, lp, lusize, rp, rusize);
-    }
+/// @private
+template <typename S0, typename S1, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+uint64_t __tdiv_qr_impl(basic_biginteger<S0> *quot, basic_biginteger<S1> *rem,
+                        const biginteger_data *num, T div) noexcept;
 
-    const bool cf = dp[dusize - 1] == 0;
-    dssize = __fasts_negate_with<int32_t>(mask, dusize - cf);
+/// @private
+template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+uint64_t __tdiv_q_impl(basic_biginteger<S> *quot, const biginteger_data *num,
+                       T div) noexcept;
 
-    if (tmp.has_value()) {
-        *dst = **std::move(tmp);
-        tmp->reset();
-    }
+/// @private
+template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+uint64_t __tdiv_r_impl(basic_biginteger<S> *rem, const biginteger_data *num,
+                       uint64_t div) noexcept;
 
-    dst->set_ssize(dssize);
-}
+/// @private
+template <typename S0, typename S1>
+void __fdiv_qr_impl(basic_biginteger<S0> *quot, basic_biginteger<S1> *rem,
+                    const biginteger_data *num, const biginteger_data *div) noexcept;
 
+/// @private
 template <typename S>
-void __sqr_impl(basic_biginteger<S> *dst, const biginteger_data *src) noexcept {
-    int32_t sssize = src->get_ssize();
-    uint32_t susize = __fasts_abs(sssize);
-
-    if (WJR_UNLIKELY(susize == 0)) {
-        dst->set_ssize(0);
-        return;
-    }
+void __fdiv_q_impl(basic_biginteger<S> *quot, const biginteger_data *num,
+                   const biginteger_data *div) noexcept;
 
-    int32_t dssize;
-    uint32_t dusize;
+/// @private
+template <typename S>
+void __fdiv_r_impl(basic_biginteger<S> *rem, const biginteger_data *num,
+                   const biginteger_data *div) noexcept;
 
-    if (susize == 1) {
-        dst->reserve(susize + 1);
-        uint64_t num = src->data()[0];
-        uint64_t cf;
-        dst->data()[0] = mul(num, num, cf);
-        dssize = 1 + (cf != 0);
-        if (cf != 0) {
-            dst->data()[1] = cf;
-        }
-        dst->set_ssize(dssize);
-        return;
-    }
+/// @private
+template <typename S0, typename S1, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+uint64_t __fdiv_qr_impl(basic_biginteger<S0> *quot, basic_biginteger<S1> *rem,
+                        const biginteger_data *num, T div) noexcept;
 
-    dusize = susize * 2;
+/// @private
+template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+uint64_t __fdiv_q_impl(basic_biginteger<S> *quot, const biginteger_data *num,
+                       T div) noexcept;
 
-    using pointer = uint64_t *;
+/// @private
+template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+uint64_t __fdiv_r_impl(basic_biginteger<S> *rem, const biginteger_data *num,
+                       uint64_t div) noexcept;
 
-    auto dp = dst->data();
-    auto sp = (pointer)(src->data());
+/// @private
+template <typename S0, typename S1>
+void __cdiv_qr_impl(basic_biginteger<S0> *quot, basic_biginteger<S1> *rem,
+                    const biginteger_data *num, const biginteger_data *div) noexcept;
 
-    std::optional<uninitialized<basic_biginteger<S>>> tmp;
+/// @private
+template <typename S>
+void __cdiv_q_impl(basic_biginteger<S> *quot, const biginteger_data *num,
+                   const biginteger_data *div) noexcept;
 
-    unique_stack_allocator stkal(math_details::stack_alloc);
+/// @private
+template <typename S>
+void __cdiv_r_impl(basic_biginteger<S> *rem, const biginteger_data *num,
+                   const biginteger_data *div) noexcept;
 
-    if (dst->capacity() < dusize) {
-        tmp.emplace(dst->get_growth_capacity(dst->capacity(), dusize), in_place_reserve,
-                    dst->get_allocator());
-        dp = (**tmp).data();
-    } else {
-        if (dp == sp) {
-            sp = (pointer)stkal.allocate(susize * sizeof(uint64_t));
-            std::copy_n(dp, susize, sp);
-        }
-    }
+/// @private
+template <typename S0, typename S1, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+uint64_t __cdiv_qr_impl(basic_biginteger<S0> *quot, basic_biginteger<S1> *rem,
+                        const biginteger_data *num, T div) noexcept;
 
-    sqr(dp, sp, susize);
+/// @private
+template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+uint64_t __cdiv_q_impl(basic_biginteger<S> *quot, const biginteger_data *num,
+                       T div) noexcept;
 
-    const bool cf = dp[dusize - 1] == 0;
-    dssize = dusize - cf;
+/// @private
+template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+uint64_t __cdiv_r_impl(basic_biginteger<S> *rem, const biginteger_data *num,
+                       uint64_t div) noexcept;
 
-    if (tmp.has_value()) {
-        *dst = **std::move(tmp);
-        tmp->reset();
-    }
+/// @private
+template <typename S>
+void __tdiv_q_2exp_impl(basic_biginteger<S> *quot, const biginteger_data *num,
+                        uint32_t shift) noexcept;
 
-    dst->set_ssize(dssize);
-}
+/// @private
+template <typename S>
+void __tdiv_r_2exp_impl(basic_biginteger<S> *rem, const biginteger_data *num,
+                        uint32_t shift) noexcept;
 
+/// @private
 template <typename S>
-void __addsubmul_impl(basic_biginteger<S> *dst, const biginteger_data *lhs, uint64_t rhs,
-                      int32_t xmask) noexcept {
-    const int32_t lssize = lhs->get_ssize();
+void __cfdiv_q_2exp_impl(basic_biginteger<S> *quot, const biginteger_data *num,
+                         uint32_t shift, int32_t xdir) noexcept;
 
-    if (lssize == 0 || rhs == 0) {
-        return;
-    }
+/// @private
+template <typename S>
+void __cdiv_q_2exp_impl(basic_biginteger<S> *quot, const biginteger_data *num,
+                        uint32_t shift) noexcept {
+    __cfdiv_q_2exp_impl(quot, num, shift, 1);
+}
 
-    const uint32_t lusize = __fasts_abs(lssize);
-    int32_t dssize = dst->get_ssize();
+/// @private
+template <typename S>
+void __fdiv_q_2exp_impl(basic_biginteger<S> *quot, const biginteger_data *num,
+                        uint32_t shift) noexcept {
+    __cfdiv_q_2exp_impl(quot, num, shift, -1);
+}
 
-    if (dssize == 0) {
-        dst->reserve(lusize + 1);
-        const auto dp = dst->data();
-        const auto cf = mul_1(dp, lhs->data(), lusize, rhs);
-        dssize = lssize + (cf != 0);
-        if (cf != 0) {
-            dp[lusize] = cf;
-        }
+/// @private
+template <typename S>
+void __cfdiv_r_2exp_impl(basic_biginteger<S> *rem, const biginteger_data *num,
+                         uint32_t shift, int32_t xdir) noexcept;
 
-        dst->set_ssize(__fasts_negate_with(xmask, dssize));
-        return;
-    }
+/// @private
+template <typename S>
+void __cdiv_r_2exp_impl(basic_biginteger<S> *rem, const biginteger_data *num,
+                        uint32_t shift) noexcept {
+    __cfdiv_r_2exp_impl(rem, num, shift, 1);
+}
 
-    xmask ^= lssize;
-    xmask ^= dssize;
+/// @private
+template <typename S>
+void __fdiv_r_2exp_impl(basic_biginteger<S> *rem, const biginteger_data *num,
+                        uint32_t shift) noexcept {
+    __cfdiv_r_2exp_impl(rem, num, shift, -1);
+}
 
-    const uint32_t dusize = __fasts_abs(dssize);
+/// @private
+template <typename S, typename Engine,
+          WJR_REQUIRES(biginteger_uniform_random_bit_generator_v<Engine>)>
+void __urandom_bit_impl(basic_biginteger<S> *dst, uint32_t size, Engine &engine) noexcept;
 
-    uint32_t new_dusize = std::max(lusize, dusize);
-    const uint32_t min_size = std::min(lusize, dusize);
-    dst->reserve(new_dusize + 1);
+/// @private
+template <typename S, typename Engine,
+          WJR_REQUIRES(biginteger_uniform_random_bit_generator_v<Engine>)>
+void __urandom_exact_bit_impl(basic_biginteger<S> *dst, uint32_t size,
+                              Engine &engine) noexcept;
 
-    auto dp = dst->data();
-    auto lp = lhs->data();
+/// @private
+template <typename S, typename Engine,
+          WJR_REQUIRES(biginteger_uniform_random_bit_generator_v<Engine>)>
+void __urandom_impl(basic_biginteger<S> *dst, const biginteger_data *limit,
+                    Engine &engine) noexcept;
 
-    uint64_t cf;
+/// @private
+template <typename S, typename Engine,
+          WJR_REQUIRES(biginteger_uniform_random_bit_generator_v<Engine>)>
+void __urandom_exact_impl(basic_biginteger<S> *dst, const biginteger_data *limit,
+                          Engine &engine) noexcept;
 
-    // dst += abs(lhs) * abs(rhs)
-    if (xmask >= 0) {
-        cf = addmul_1(dp, lp, min_size, rhs);
+/// @private
+inline uint32_t __bit_width_impl(const biginteger_data *num) noexcept;
 
-        dp += min_size;
-        lp += min_size;
+/// @private
+inline uint32_t __ctz_impl(const biginteger_data *num) noexcept;
 
-        int32_t sdelta = lusize - dusize;
+/// @private
+template <typename S>
+void __pow_impl(basic_biginteger<S> *dst, const biginteger_data *num,
+                uint32_t exp) noexcept;
 
-        if (sdelta != 0) {
-            uint64_t cf2;
-            if (sdelta > 0) {
-                cf2 = mul_1(dp, lp, sdelta, rhs);
-            } else {
-                sdelta = -sdelta;
-                cf2 = 0;
-            }
+/// @private
+struct __powmod_iterator {
+    __powmod_iterator(const uint64_t *ptr, uint32_t size) noexcept
+        : ptr(ptr), cache(ptr[0]), size(size) {}
 
-            cf = cf2 + addc_1(dp, dp, sdelta, cf);
+    constexpr void next() noexcept {
+        if (++offset == 64) {
+            offset = 0;
+            ++pos;
+            WJR_ASSERT(pos != size);
+            cache = ptr[pos];
         }
-
-        dp[sdelta] = cf;
-        new_dusize += (cf != 0);
     }
-    // dst -= abs(lhs) * abs(rhs)
-    else {
-        cf = submul_1(dp, lp, min_size, rhs);
 
-        do {
-            if (dusize >= lusize) {
-                if (dusize != lusize) {
-                    cf = subc_1(dp + lusize, dp + lusize, dusize - lusize, cf);
-                }
+    constexpr uint64_t get() const noexcept { return (cache >> offset); }
+    constexpr bool end() const noexcept { return pos == size - 1 && get() == 1; }
 
-                if (cf != 0) {
-                    cf += negate_n(dp, dp, new_dusize) - 1;
-                    dp[new_dusize] = cf;
-                    ++new_dusize;
-                    dssize = __fasts_negate(dssize);
-                }
-            } else {
-                cf += negate_n(dp, dp, dusize) - 1;
+    const uint64_t *ptr;
+    uint64_t cache;
+    uint32_t offset = 0;
+    uint32_t pos = 0;
+    uint32_t size;
+};
 
-                const auto cf2 = cf == (uint64_t)in_place_max;
-                cf += cf2;
+/// @private
+template <typename S>
+void __powmod_impl(basic_biginteger<S> *dst, const biginteger_data *num,
+                   __powmod_iterator *iter, const biginteger_data *mod) noexcept;
 
-                const auto cf3 = mul_1(dp + dusize, lp + dusize, lusize - dusize, rhs);
-                cf = cf3 + addc_1(dp + dusize, dp + dusize, lusize - dusize, cf);
+/// @private
+template <typename S>
+void __powmod_impl(basic_biginteger<S> *dst, const biginteger_data *num,
+                   const biginteger_data *exp, const biginteger_data *mod) noexcept;
 
-                dp[new_dusize] = cf;
-                new_dusize += (cf != 0);
+/// @private
+template <typename S>
+void __powmod_impl(basic_biginteger<S> *dst, const biginteger_data *num, uint64_t exp,
+                   const biginteger_data *mod) noexcept;
 
-                if (cf2) {
-                    (void)subc_1(dp + dusize, dp + dusize, new_dusize - dusize, 1);
-                }
+} // namespace biginteger_details
 
-                dssize = __fasts_negate(dssize);
-            }
+template <typename S>
+from_chars_result<> from_chars(const char *first, const char *last,
+                               basic_biginteger<S> &dst, unsigned int base = 10) noexcept;
 
-            new_dusize = normalize(dp, new_dusize);
-        } while (0);
+template <typename Iter>
+Iter to_chars_unchecked(Iter ptr, const biginteger_data &src,
+                        unsigned int base = 10) noexcept {
+    if (src.empty()) {
+        *ptr++ = '0';
+        return ptr;
     }
 
-    dst->set_ssize(__fasts_conditional_negate<int32_t>(dssize < 0, new_dusize));
+    if (src.is_negate()) {
+        *ptr++ = '-';
+    }
+
+    return biginteger_to_chars(ptr, src.data(), src.size(), base);
 }
 
 template <typename S>
-void __addsubmul_impl(basic_biginteger<S> *dst, const biginteger_data *lhs,
-                      const biginteger_data *rhs, int32_t xmask) noexcept {
-    int32_t lssize = lhs->get_ssize();
-    int32_t rssize = rhs->get_ssize();
+std::istream &operator>>(std::istream &is, basic_biginteger<S> &dst) noexcept;
 
-    if (lssize == 0 || rssize == 0) {
-        return;
-    }
+template <typename Traits>
+std::basic_ostream<char, Traits> &operator<<(std::basic_ostream<char, Traits> &os,
+                                             const biginteger_data &src) noexcept;
 
-    uint32_t lusize = __fasts_abs(lssize);
-    uint32_t rusize = __fasts_abs(rssize);
+WJR_NODISCARD WJR_PURE inline int32_t compare(const biginteger_data &lhs,
+                                              const biginteger_data &rhs) noexcept {
+    return biginteger_details::__compare_impl(&lhs, &rhs);
+}
 
-    if (lusize < rusize) {
-        std::swap(lhs, rhs);
-        std::swap(lssize, rssize);
-        std::swap(lusize, rusize);
-    }
+template <typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+WJR_NODISCARD WJR_PURE int32_t compare(const biginteger_data &lhs, T rhs) noexcept {
+    return biginteger_details::__compare_impl(&lhs, rhs);
+}
 
-    xmask ^= rssize;
+template <typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+WJR_NODISCARD WJR_PURE int32_t compare(T lhs, const biginteger_data &rhs) noexcept {
+    return -compare(rhs, lhs);
+}
 
-    if (rusize == 1) {
-        __addsubmul_impl(dst, lhs, rhs->data()[0], xmask);
-        return;
+#define WJR_REGISTER_BIGINTEGER_COMPARE(op)                                              \
+    WJR_NODISCARD WJR_PURE inline bool operator op(                                      \
+        const biginteger_data &lhs, const biginteger_data &rhs) noexcept {               \
+        return compare(lhs, rhs) op 0;                                                   \
+    }                                                                                    \
+    template <typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>                        \
+    WJR_NODISCARD WJR_PURE bool operator op(const biginteger_data &lhs,                  \
+                                            T rhs) noexcept {                            \
+        return compare(lhs, rhs) op 0;                                                   \
+    }                                                                                    \
+    template <typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>                        \
+    WJR_NODISCARD WJR_PURE bool operator op(T lhs,                                       \
+                                            const biginteger_data &rhs) noexcept {       \
+        return compare(lhs, rhs) op 0;                                                   \
     }
 
-    xmask ^= lssize;
-
-    int32_t dssize = dst->get_ssize();
-    xmask ^= dssize;
-    uint32_t dusize = __fasts_abs(dssize);
+WJR_REGISTER_BIGINTEGER_COMPARE(==)
+WJR_REGISTER_BIGINTEGER_COMPARE(!=)
+WJR_REGISTER_BIGINTEGER_COMPARE(<)
+WJR_REGISTER_BIGINTEGER_COMPARE(>)
+WJR_REGISTER_BIGINTEGER_COMPARE(<=)
+WJR_REGISTER_BIGINTEGER_COMPARE(>=)
 
-    uint32_t tusize = lusize + rusize;
-    dst->reserve(std::max(tusize, dusize) + 1);
-    const auto dp = dst->data();
+#undef WJR_REGISTER_BIGINTEGER_COMPARE
 
-    if (dssize == 0) {
-        mul_s(dp, lhs->data(), lusize, rhs->data(), rusize);
-        tusize -= dp[tusize - 1] == 0;
-        dst->set_ssize(__fasts_conditional_negate<int32_t>(xmask < 0, tusize));
-        return;
+#define WJR_REGISTER_BIGINTEGER_ADDSUB(ADDSUB)                                           \
+    template <typename S>                                                                \
+    void ADDSUB(basic_biginteger<S> &dst, const biginteger_data &lhs,                    \
+                const biginteger_data &rhs) noexcept {                                   \
+        biginteger_details::WJR_PP_CONCAT(__, WJR_PP_CONCAT(ADDSUB, _impl))(&dst, &lhs,  \
+                                                                            &rhs);       \
+    }                                                                                    \
+    template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>            \
+    void ADDSUB(basic_biginteger<S> &dst, const biginteger_data &lhs, T rhs) noexcept {  \
+        biginteger_details::WJR_PP_CONCAT(__, WJR_PP_CONCAT(ADDSUB, _impl))(&dst, &lhs,  \
+                                                                            rhs);        \
+    }                                                                                    \
+    template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>            \
+    void ADDSUB(basic_biginteger<S> &dst, T lhs, const biginteger_data &rhs) noexcept {  \
+        biginteger_details::WJR_PP_CONCAT(__, WJR_PP_CONCAT(ADDSUB, _impl))(&dst, lhs,   \
+                                                                            &rhs);       \
     }
 
-    unique_stack_allocator stkal(math_details::stack_alloc);
-    auto tp = (uint64_t *)stkal.allocate(tusize * sizeof(uint64_t));
-
-    mul_s(tp, lhs->data(), lusize, rhs->data(), rusize);
-    tusize -= tp[tusize - 1] == 0;
-
-    auto up = dp;
-    uint32_t uusize = dusize;
-
-    if (xmask >= 0) {
-        if (uusize < tusize) {
-            up = tp;
-            uusize = tusize;
-            tp = dp;
-            tusize = dusize;
+WJR_REGISTER_BIGINTEGER_ADDSUB(add)
+WJR_REGISTER_BIGINTEGER_ADDSUB(sub)
 
-            dusize = uusize;
-        }
+#undef WJR_REGISTER_BIGINTEGER_ADDSUB
 
-        const auto cf = addc_s(dp, up, uusize, tp, tusize);
-        dp[uusize] = cf;
-        dusize = uusize + (cf != 0);
-    } else {
-        if (uusize < tusize ||
-            (uusize == tusize && reverse_compare_n(up, tp, uusize) < 0)) {
-            up = tp;
-            uusize = tusize;
-            tp = dp;
-            tusize = dusize;
+template <typename S>
+void increment(basic_biginteger<S> &dst) noexcept {
+    add(dst, dst, 1u);
+}
 
-            dusize = uusize;
+template <typename S>
+void decrement(basic_biginteger<S> &dst) noexcept {
+    sub(dst, dst, 1u);
+}
 
-            dssize = __fasts_negate(dssize);
-        }
+template <typename S>
+void negate(basic_biginteger<S> &dst) noexcept;
 
-        (void)subc_s(dp, up, uusize, tp, tusize);
-        dssize = normalize(dp, dusize);
-    }
+template <typename S>
+void absolute(basic_biginteger<S> &dst) noexcept;
 
-    dst->set_ssize(__fasts_conditional_negate<int32_t>(dssize < 0, dusize));
+template <typename S>
+void sqr(basic_biginteger<S> &dst, const biginteger_data &src) noexcept {
+    biginteger_details::__sqr_impl(&dst, &src);
 }
 
 template <typename S>
-void __mul_2exp_impl(basic_biginteger<S> *dst, const biginteger_data *lhs,
-                     uint32_t shift) noexcept {
-    int32_t lssize = lhs->get_ssize();
-
-    if (lssize == 0) {
-        dst->set_ssize(0);
+void mul(basic_biginteger<S> &dst, const biginteger_data &lhs,
+         const biginteger_data &rhs) noexcept {
+    if (WJR_BUILTIN_CONSTANT_P(std::addressof(lhs) == std::addressof(rhs)) &&
+        std::addressof(lhs) == std::addressof(rhs)) {
+        sqr(dst, lhs);
         return;
     }
 
-    uint32_t lusize = __fasts_abs(lssize);
-    uint32_t offset = shift / 64;
-    shift %= 64;
-    uint32_t dusize = lusize + offset;
-
-    dst->reserve(dusize + 1);
-    const auto dp = dst->data();
-    const auto lp = lhs->data();
+    biginteger_details::__mul_impl(&dst, &lhs, &rhs);
+}
 
-    const auto cf = lshift_n(dp + offset, lp, lusize, shift);
-    set_n(dp, 0, offset);
+template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+void mul(basic_biginteger<S> &dst, const biginteger_data &lhs, T rhs) noexcept {
+    biginteger_details::__mul_impl(&dst, &lhs, rhs);
+}
 
-    dp[dusize] = cf;
-    dusize += (cf != 0);
+template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+void mul(basic_biginteger<S> &dst, T lhs, const biginteger_data &rhs) noexcept {
+    biginteger_details::__mul_impl(&dst, &rhs, lhs);
+}
 
-    dst->set_ssize(__fasts_conditional_negate<int32_t>(lssize < 0, dusize));
+template <typename S>
+void addmul(basic_biginteger<S> &dst, const biginteger_data &lhs,
+            const biginteger_data &rhs) noexcept {
+    biginteger_details::__addmul_impl(&dst, &lhs, &rhs);
 }
 
-template <typename S0, typename S1>
-void __tdiv_qr_impl(basic_biginteger<S0> *quot, basic_biginteger<S1> *rem,
-                    const biginteger_data *num, const biginteger_data *div) noexcept {
-    WJR_ASSERT_ASSUME(!__equal_pointer(quot, rem), "quot should not be the same as rem");
+template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+void addmul(basic_biginteger<S> &dst, const biginteger_data &lhs, T rhs) noexcept {
+    biginteger_details::__addmul_impl(&dst, &lhs, rhs);
+}
 
-    const auto nssize = num->get_ssize();
-    const auto dssize = div->get_ssize();
-    const auto nusize = __fasts_abs(nssize);
-    auto dusize = __fasts_abs(dssize);
-    int32_t qssize = nusize - dusize + 1;
+template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+void addmul(basic_biginteger<S> &dst, T lhs, const biginteger_data &rhs) noexcept {
+    biginteger_details::__addmul_impl(&dst, &rhs, lhs);
+}
 
-    WJR_ASSERT(dusize != 0, "division by zero");
+template <typename S>
+void submul(basic_biginteger<S> &dst, const biginteger_data &lhs,
+            const biginteger_data &rhs) noexcept {
+    biginteger_details::__submul_impl(&dst, &lhs, &rhs);
+}
 
-    rem->reserve(dusize);
-    auto rp = rem->data();
+template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+void submul(basic_biginteger<S> &dst, const biginteger_data &lhs, T rhs) noexcept {
+    biginteger_details::__submul_impl(&dst, &lhs, rhs);
+}
 
-    // num < div
-    if (qssize <= 0) {
-        auto np = num->data();
-        if (np != rp) {
-            std::copy_n(np, nusize, rp);
-            rem->set_ssize(nssize);
-        }
+template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+void submul(basic_biginteger<S> &dst, T lhs, const biginteger_data &rhs) noexcept {
+    biginteger_details::__submul_impl(&dst, &rhs, lhs);
+}
 
-        quot->set_ssize(0);
-        return;
-    }
+template <typename S>
+void mul_2exp(basic_biginteger<S> &dst, const biginteger_data &lhs,
+              uint32_t shift) noexcept {
+    biginteger_details::__mul_2exp_impl(&dst, &lhs, shift);
+}
 
-    using pointer = uint64_t *;
+template <typename S0, typename S1>
+void tdiv_qr(basic_biginteger<S0> &quot, basic_biginteger<S1> &rem,
+             const biginteger_data &num, const biginteger_data &div) noexcept {
+    biginteger_details::__tdiv_qr_impl(&quot, &rem, &num, &div);
+}
 
-    quot->reserve(qssize);
-    auto qp = quot->data();
+template <typename S>
+void tdiv_q(basic_biginteger<S> &quot, const biginteger_data &num,
+            const biginteger_data &div) noexcept {
+    biginteger_details::__tdiv_q_impl(&quot, &num, &div);
+}
 
-    auto np = (pointer)num->data();
-    auto dp = (pointer)div->data();
+template <typename S0>
+void tdiv_r(basic_biginteger<S0> &rem, const biginteger_data &num,
+            const biginteger_data &div) noexcept {
+    biginteger_details::__tdiv_r_impl(&rem, &num, &div);
+}
 
-    unique_stack_allocator stkal(math_details::stack_alloc);
+template <typename S0, typename S1, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+uint64_t tdiv_qr(basic_biginteger<S0> &quot, basic_biginteger<S1> &rem,
+                 const biginteger_data &num, T div) noexcept {
+    return biginteger_details::__tdiv_qr_impl(&quot, &rem, &num, div);
+}
 
-    if (dp == rp || dp == qp) {
-        auto tp = (pointer)stkal.allocate(dusize * sizeof(uint64_t));
-        std::copy_n(dp, dusize, tp);
-        dp = tp;
-    }
+template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+uint64_t tdiv_q(basic_biginteger<S> &quot, const biginteger_data &num, T div) noexcept {
+    return biginteger_details::__tdiv_q_impl(&quot, &num, div);
+}
 
-    if (np == rp || np == qp) {
-        auto tp = (pointer)stkal.allocate(nusize * sizeof(uint64_t));
-        std::copy_n(np, nusize, tp);
-        np = tp;
-    }
+template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+uint64_t tdiv_r(basic_biginteger<S> &rem, const biginteger_data &num, T div) noexcept {
+    return biginteger_details::__tdiv_r_impl(&rem, &num, div);
+}
 
-    div_qr_s(qp, rp, np, nusize, dp, dusize);
+template <typename S0, typename S1>
+void fdiv_qr(basic_biginteger<S0> &quot, basic_biginteger<S1> &rem,
+             const biginteger_data &num, const biginteger_data &div) noexcept {
+    biginteger_details::__fdiv_qr_impl(&quot, &rem, &num, &div);
+}
 
-    qssize -= qp[qssize - 1] == 0;
-    dusize = normalize(rp, dusize);
+template <typename S>
+void fdiv_q(basic_biginteger<S> &quot, const biginteger_data &num,
+            const biginteger_data &div) noexcept {
+    biginteger_details::__fdiv_q_impl(&quot, &num, &div);
+}
 
-    quot->set_ssize(__fasts_conditional_negate<int32_t>((nssize ^ dssize) < 0, qssize));
-    rem->set_ssize(__fasts_conditional_negate<int32_t>(nssize < 0, dusize));
+template <typename S0>
+void fdiv_r(basic_biginteger<S0> &rem, const biginteger_data &num,
+            const biginteger_data &div) noexcept {
+    biginteger_details::__fdiv_r_impl(&rem, &num, &div);
 }
 
-template <typename S>
-void __tdiv_q_impl(basic_biginteger<S> *quot, const biginteger_data *num,
-                   const biginteger_data *div) noexcept {
-    const auto nssize = num->get_ssize();
-    const auto dssize = div->get_ssize();
-    const auto nusize = __fasts_abs(nssize);
-    const auto dusize = __fasts_abs(dssize);
-    int32_t qssize = nusize - dusize + 1;
+template <typename S0, typename S1, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+uint64_t fdiv_qr(basic_biginteger<S0> &quot, basic_biginteger<S1> &rem,
+                 const biginteger_data &num, T div) noexcept {
+    return biginteger_details::__fdiv_qr_impl(&quot, &rem, &num, div);
+}
 
-    WJR_ASSERT(dusize != 0, "division by zero");
+template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+uint64_t fdiv_q(basic_biginteger<S> &quot, const biginteger_data &num, T div) noexcept {
+    return biginteger_details::__fdiv_q_impl(&quot, &num, div);
+}
 
-    // num < div
-    if (qssize <= 0) {
-        quot->set_ssize(0);
-        return;
-    }
+template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+uint64_t fdiv_r(basic_biginteger<S> &rem, const biginteger_data &num, T div) noexcept {
+    return biginteger_details::__fdiv_r_impl(&rem, &num, div);
+}
 
-    using pointer = uint64_t *;
+template <typename S0, typename S1>
+void cdiv_qr(basic_biginteger<S0> &quot, basic_biginteger<S1> &rem,
+             const biginteger_data &num, const biginteger_data &div) noexcept {
+    biginteger_details::__cdiv_qr_impl(&quot, &rem, &num, &div);
+}
 
-    quot->reserve(qssize);
-    auto qp = quot->data();
+template <typename S>
+void cdiv_q(basic_biginteger<S> &quot, const biginteger_data &num,
+            const biginteger_data &div) noexcept {
+    biginteger_details::__cdiv_q_impl(&quot, &num, &div);
+}
 
-    auto np = (pointer)num->data();
-    auto dp = (pointer)div->data();
+template <typename S0>
+void cdiv_r(basic_biginteger<S0> &rem, const biginteger_data &num,
+            const biginteger_data &div) noexcept {
+    biginteger_details::__cdiv_r_impl(&rem, &num, &div);
+}
 
-    unique_stack_allocator stkal(math_details::stack_alloc);
+template <typename S0, typename S1, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+uint64_t cdiv_qr(basic_biginteger<S0> &quot, basic_biginteger<S1> &rem,
+                 const biginteger_data &num, T div) noexcept {
+    return biginteger_details::__cdiv_qr_impl(&quot, &rem, &num, div);
+}
 
-    if (dp == qp) {
-        auto tp = (pointer)stkal.allocate(dusize * sizeof(uint64_t));
-        std::copy_n(dp, dusize, tp);
-        dp = tp;
-    }
+template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+uint64_t cdiv_q(basic_biginteger<S> &quot, const biginteger_data &num, T div) noexcept {
+    return biginteger_details::__cdiv_q_impl(&quot, &num, div);
+}
 
-    if (np == qp) {
-        auto tp = (pointer)stkal.allocate(nusize * sizeof(uint64_t));
-        std::copy_n(np, nusize, tp);
-        np = tp;
-    }
+template <typename S, typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+uint64_t cdiv_r(basic_biginteger<S> &rem, const biginteger_data &num, T div) noexcept {
+    return biginteger_details::__cdiv_r_impl(&rem, &num, div);
+}
 
-    const auto rp = (pointer)stkal.allocate(dusize * sizeof(uint64_t));
+template <typename S>
+void tdiv_q_2exp(basic_biginteger<S> &quot, const biginteger_data &num,
+                 uint32_t shift) noexcept {
+    biginteger_details::__tdiv_q_2exp_impl(&quot, &num, shift);
+}
 
-    div_qr_s(qp, rp, np, nusize, dp, dusize);
+template <typename S>
+void tdiv_r_2exp(basic_biginteger<S> &rem, const biginteger_data &num,
+                 uint32_t shift) noexcept {
+    biginteger_details::__tdiv_r_2exp_impl(&rem, &num, shift);
+}
 
-    qssize -= qp[qssize - 1] == 0;
+template <typename S>
+void fdiv_q_2exp(basic_biginteger<S> &quot, const biginteger_data &num,
+                 uint32_t shift) noexcept {
+    biginteger_details::__fdiv_q_2exp_impl(&quot, &num, shift);
+}
 
-    quot->set_ssize(__fasts_conditional_negate<int32_t>((nssize ^ dssize) < 0, qssize));
+template <typename S>
+void cdiv_q_2exp(basic_biginteger<S> &quot, const biginteger_data &num,
+                 uint32_t shift) noexcept {
+    biginteger_details::__cdiv_q_2exp_impl(&quot, &num, shift);
 }
 
 template <typename S>
-void __tdiv_r_impl(basic_biginteger<S> *rem, const biginteger_data *num,
-                   const biginteger_data *div) noexcept {
-    const auto nssize = num->get_ssize();
-    const auto dssize = div->get_ssize();
-    const auto nusize = __fasts_abs(nssize);
-    auto dusize = __fasts_abs(dssize);
-    const int32_t qssize = nusize - dusize + 1;
+void cdiv_r_2exp(basic_biginteger<S> &rem, const biginteger_data &num,
+                 uint32_t shift) noexcept {
+    biginteger_details::__cdiv_r_2exp_impl(&rem, &num, shift);
+}
 
-    WJR_ASSERT(dusize != 0, "division by zero");
+template <typename S>
+void fdiv_r_2exp(basic_biginteger<S> &rem, const biginteger_data &num,
+                 uint32_t shift) noexcept {
+    biginteger_details::__fdiv_r_2exp_impl(&rem, &num, shift);
+}
 
-    rem->reserve(dusize);
-    auto rp = rem->data();
+template <typename S, typename Engine,
+          WJR_REQUIRES(biginteger_uniform_random_bit_generator_v<Engine>)>
+void urandom_bit(basic_biginteger<S> &dst, uint32_t size, Engine &engine) noexcept {
+    biginteger_details::__urandom_bit_impl(&dst, size, engine);
+}
 
-    // num < div
-    if (qssize <= 0) {
-        const auto np = num->data();
-        if (np != rp) {
-            std::copy_n(np, nusize, rp);
-            rem->set_ssize(nssize);
-        }
+template <typename S, typename Engine,
+          WJR_REQUIRES(biginteger_uniform_random_bit_generator_v<Engine>)>
+void urandom_exact_bit(basic_biginteger<S> &dst, uint32_t size, Engine &engine) noexcept {
+    biginteger_details::__urandom_exact_bit_impl(&dst, size, engine);
+}
 
-        return;
-    }
+template <typename S, typename Engine,
+          WJR_REQUIRES(biginteger_uniform_random_bit_generator_v<Engine>)>
+void urandom(basic_biginteger<S> &dst, const biginteger_data &limit,
+             Engine &engine) noexcept {
+    biginteger_details::__urandom_impl(&dst, &limit, engine);
+}
 
-    using pointer = uint64_t *;
+template <typename S, typename Engine,
+          WJR_REQUIRES(biginteger_uniform_random_bit_generator_v<Engine>)>
+void urandom_exact(basic_biginteger<S> &dst, const biginteger_data &limit,
+                   Engine &engine) noexcept {
+    biginteger_details::__urandom_exact_impl(&dst, &limit, engine);
+}
 
-    auto np = (pointer)num->data();
-    auto dp = (pointer)div->data();
+inline uint32_t bit_width(const biginteger_data &num) noexcept {
+    return biginteger_details::__bit_width_impl(&num);
+}
 
-    unique_stack_allocator stkal(math_details::stack_alloc);
+inline uint32_t ctz(const biginteger_data &num) noexcept {
+    return biginteger_details::__ctz_impl(&num);
+}
 
-    if (dp == rp) {
-        const auto tp = (pointer)stkal.allocate(dusize * sizeof(uint64_t));
-        std::copy_n(dp, dusize, tp);
-        dp = tp;
-    }
+template <typename S>
+void pow(basic_biginteger<S> &dst, const biginteger_data &num, uint32_t exp) noexcept {
+    biginteger_details::__pow_impl(&dst, &num, exp);
+}
 
-    if (np == rp) {
-        const auto tp = (pointer)stkal.allocate(nusize * sizeof(uint64_t));
-        std::copy_n(np, nusize, tp);
-        np = tp;
-    }
+/**
+ * @todo Need to optimize
+ */
+template <typename S>
+void powmod(basic_biginteger<S> &dst, const biginteger_data &num,
+            const biginteger_data &exp, const biginteger_data &mod) noexcept {
+    biginteger_details::__powmod_impl(&dst, &num, &exp, &mod);
+}
 
-    const auto qp = (pointer)stkal.allocate(qssize * sizeof(uint64_t));
+/**
+ * @todo Need to optimize
+ */
+template <typename S>
+void powmod(basic_biginteger<S> &dst, const biginteger_data &num, uint64_t exp,
+            const biginteger_data &mod) noexcept {
+    biginteger_details::__powmod_impl(&dst, &num, exp, &mod);
+}
 
-    div_qr_s(qp, rp, np, nusize, dp, dusize);
+template <typename Storage>
+class basic_biginteger {
 
-    dusize = normalize(rp, dusize);
+public:
+    using storage_type = Storage;
+    using vector_type = basic_vector<storage_type>;
 
-    rem->set_ssize(__fasts_conditional_negate<int32_t>(nssize < 0, dusize));
-}
+    using value_type = typename vector_type::value_type;
+    using size_type = typename vector_type::size_type;
+    using difference_type = typename vector_type::difference_type;
+    using reference = typename vector_type::reference;
+    using const_reference = typename vector_type::const_reference;
+    using pointer = typename vector_type::pointer;
+    using const_pointer = typename vector_type::const_pointer;
+    using iterator = typename vector_type::iterator;
+    using const_iterator = typename vector_type::const_iterator;
+    using reverse_iterator = typename vector_type::reverse_iterator;
+    using const_reverse_iterator = typename vector_type::const_reverse_iterator;
+    using allocator_type = typename vector_type::allocator_type;
 
-template <typename S0, typename S1>
-uint64_t __tdiv_qr_ui_impl(basic_biginteger<S0> *quot, basic_biginteger<S1> *rem,
-                           const biginteger_data *num, uint64_t div) noexcept {
-    const auto nssize = num->get_ssize();
+    static_assert(std::is_same_v<value_type, uint64_t>, "value_type must be uint64_t");
+    static_assert(std::is_same_v<pointer, uint64_t *>, "pointer must be uint64_t *");
+    static_assert(std::is_same_v<const_pointer, const uint64_t *>,
+                  "const_pointer must be const uint64_t *");
+    static_assert(std::is_same_v<size_type, uint32_t>, "size_type must be uint32_t");
+    static_assert(std::is_same_v<difference_type, int32_t>,
+                  "difference_type must be int32_t");
 
-    WJR_ASSERT(div != 0, "division by zero");
+    basic_biginteger() = default;
+    basic_biginteger(basic_biginteger &&other) = default;
+    basic_biginteger &operator=(basic_biginteger &&other) = default;
+    ~basic_biginteger() = default;
 
-    if (nssize == 0) {
-        quot->set_ssize(0);
-        rem->set_ssize(0);
-        return 0;
+    basic_biginteger(const basic_biginteger &other,
+                     const allocator_type &al = allocator_type())
+        : m_vec(other.m_vec, al) {
+        set_ssize(other.get_ssize());
     }
 
-    const auto nusize = __fasts_abs(nssize);
-    quot->reserve(nusize);
-    const auto qp = quot->data();
-    const auto np = num->data();
+    basic_biginteger(size_type n, in_place_reserve_t,
+                     const allocator_type &al = allocator_type())
+        : m_vec(n, in_place_reserve, al) {}
 
-    uint64_t remv;
-    div_qr_1(qp, remv, np, nusize, div);
+    explicit basic_biginteger(const allocator_type &al) : m_vec(al) {}
 
-    if (remv == 0) {
-        rem->set_ssize(0);
-    } else {
-        rem->reserve(1);
-        rem->front() = remv;
-        rem->set_ssize(__fasts_conditional_negate<int32_t>(nssize < 0, 1));
-    }
+    basic_biginteger(basic_biginteger &&other, const allocator_type &al)
+        : m_vec(std::move(other.m_vec), al) {}
 
-    const auto qusize = nusize - (qp[nusize - 1] == 0);
+    template <typename UnsignedValue,
+              WJR_REQUIRES(is_nonbool_unsigned_integral_v<UnsignedValue>)>
+    explicit basic_biginteger(UnsignedValue value,
+                              const allocator_type &al = allocator_type())
+        : m_vec(value != 0, value, al) {}
 
-    quot->set_ssize(__fasts_conditional_negate<int32_t>(nssize < 0, qusize));
-    return remv;
-}
+    template <typename SignedValue,
+              WJR_REQUIRES(is_nonbool_signed_integral_v<SignedValue>)>
+    explicit basic_biginteger(SignedValue value,
+                              const allocator_type &al = allocator_type())
+        : m_vec(al) {
+        if (value != 0) {
+            m_vec.emplace_back(value < 0 ? -to_unsigned(value) : to_unsigned(value));
+            set_ssize(__fasts_conditional_negate<int32_t>(value < 0, 1));
+        }
+    }
 
-template <typename S>
-uint64_t __tdiv_q_ui_impl(basic_biginteger<S> *quot, const biginteger_data *num,
-                          uint64_t div) noexcept {
-    const auto nssize = num->get_ssize();
+    explicit basic_biginteger(span<const char> sp, unsigned int base = 10,
+                              const allocator_type &al = allocator_type())
+        : m_vec(al) {
+        from_string(sp, base);
+    }
 
-    WJR_ASSERT(div != 0, "division by zero");
+    template <typename OthterStorage>
+    explicit basic_biginteger(const basic_biginteger<OthterStorage> &other,
+                              const allocator_type &al = allocator_type())
+        : m_vec(other.begin(), other.end(), al) {
+        set_ssize(other.get_ssize());
+    }
 
-    if (nssize == 0) {
-        quot->set_ssize(0);
-        return 0;
+    explicit basic_biginteger(const biginteger_data &data,
+                              const allocator_type &al = allocator_type())
+        : m_vec(data.data(), data.data() + data.size(), al) {
+        set_ssize(data.get_ssize());
     }
 
-    const auto nusize = __fasts_abs(nssize);
-    quot->reserve(nusize);
-    const auto qp = quot->data();
-    const auto np = num->data();
+    basic_biginteger &operator=(const basic_biginteger &other) {
+        if (WJR_UNLIKELY(this == std::addressof(other))) {
+            return *this;
+        }
 
-    uint64_t remv;
-    div_qr_1(qp, remv, np, nusize, div);
+        m_vec = other.m_vec;
+        set_ssize(other.get_ssize());
+        return *this;
+    }
 
-    const auto qusize = nusize - (qp[nusize - 1] == 0);
+    template <typename UnsignedValue,
+              WJR_REQUIRES(is_nonbool_unsigned_integral_v<UnsignedValue>)>
+    basic_biginteger &operator=(UnsignedValue value) {
+        clear();
+        if (value != 0) {
+            m_vec.emplace_back(value);
+        }
+        return *this;
+    }
 
-    quot->set_ssize(__fasts_conditional_negate<int32_t>(nssize < 0, qusize));
-    return remv;
-}
+    template <typename SignedValue,
+              WJR_REQUIRES(is_nonbool_signed_integral_v<SignedValue>)>
+    basic_biginteger &operator=(SignedValue value) {
+        clear();
+        if (value != 0) {
+            m_vec.emplace_back(value < 0 ? -to_unsigned(value) : to_unsigned(value));
+            set_ssize(__fasts_conditional_negate<int32_t>(value < 0, 1));
+        }
+        return *this;
+    }
 
-template <typename S>
-uint64_t __tdiv_r_ui_impl(basic_biginteger<S> *rem, const biginteger_data *num,
-                          uint64_t div) noexcept {
-    const auto nssize = num->get_ssize();
+    basic_biginteger &operator=(span<const char> sp) { return from_string(sp); }
 
-    WJR_ASSERT(div != 0, "division by zero");
+    template <typename OthterStorage>
+    basic_biginteger &operator=(const basic_biginteger<OthterStorage> &other) {
+        m_vec.assign(other.begin(), other.end());
+        set_ssize(other.get_ssize());
+        return *this;
+    }
+
+    basic_biginteger &operator=(const biginteger_data &data) {
+        if (WJR_UNLIKELY(std::addressof(__get_ref()) == std::addressof(data))) {
+            return *this;
+        }
 
-    if (nssize == 0) {
-        rem->set_ssize(0);
-        return 0;
+        m_vec.assign(data.data(), data.data() + data.size());
+        set_ssize(data.get_ssize());
+        return *this;
     }
 
-    const auto nusize = __fasts_abs(nssize);
-    const auto np = num->data();
+    template <typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+    explicit operator T() const noexcept {
+        if (empty()) {
+            return static_cast<T>(0);
+        }
 
-    uint64_t remv;
-    remv = mod_1(np, nusize, div);
+        if constexpr (std::is_unsigned_v<T>) {
+            return static_cast<T>(front());
+        } else {
+            const auto ret = front();
+            return is_negate() ? -ret : ret;
+        }
+    }
 
-    if (remv == 0) {
-        rem->set_ssize(0);
-    } else {
-        rem->reserve(1);
-        rem->front() = remv;
-        rem->set_ssize(__fasts_conditional_negate<int32_t>(nssize < 0, 1));
+    basic_biginteger &from_string(span<const char> sp, unsigned int base = 10) noexcept {
+        (void)from_chars(sp.data(), sp.data() + sp.size(), *this, base);
+        return *this;
     }
 
-    return remv;
-}
+    allocator_type &get_allocator() noexcept { return m_vec.get_allocator(); }
+    const allocator_type &get_allocator() const noexcept { return m_vec.get_allocator(); }
 
-template <typename S0, typename S1, typename T, WJR_REQUIRES_I(is_nonbool_integral_v<T>)>
-uint64_t __tdiv_qr_impl(basic_biginteger<S0> *quot, basic_biginteger<S1> *rem,
-                        const biginteger_data *num, T div) noexcept {
-    if constexpr (std::is_unsigned_v<T>) {
-        return __tdiv_qr_ui_impl(quot, rem, num, div);
-    } else {
-        uint64_t udiv = to_unsigned(div);
-        bool xsign = false;
-        if (div < 0) {
-            udiv = -udiv;
-            xsign = true;
-        }
+    reference at(size_type pos) { return m_vec.at(pos); }
+    const_reference at(size_type pos) const { return m_vec.at(pos); }
 
-        uint64_t remv = __tdiv_qr_ui_impl(quot, rem, num, udiv);
+    reference operator[](size_type pos) noexcept { return m_vec[pos]; }
+    const_reference operator[](size_type pos) const noexcept { return m_vec[pos]; }
 
-        quot->conditional_negate(xsign);
-        return remv;
-    }
-}
+    reference front() { return m_vec.front(); }
+    const_reference front() const { return m_vec.front(); }
 
-template <typename S, typename T, WJR_REQUIRES_I(is_nonbool_integral_v<T>)>
-uint64_t __tdiv_q_impl(basic_biginteger<S> *quot, const biginteger_data *num,
-                       T div) noexcept {
-    if constexpr (std::is_unsigned_v<T>) {
-        return __tdiv_q_ui_impl(quot, num, div);
-    } else {
-        uint64_t udiv = to_unsigned(div);
-        bool xsign = false;
-        if (div < 0) {
-            udiv = -udiv;
-            xsign = true;
-        }
+    reference back() { return m_vec.back(); }
+    const_reference back() const { return m_vec.back(); }
 
-        uint64_t remv = __tdiv_q_ui_impl(quot, num, udiv);
+    WJR_PURE pointer data() noexcept { return m_vec.data(); }
+    WJR_PURE const_pointer data() const noexcept { return m_vec.data(); }
 
-        quot->conditional_negate(xsign);
-        return remv;
-    }
-}
+    WJR_PURE iterator begin() noexcept { return m_vec.begin(); }
+    WJR_PURE const_iterator begin() const noexcept { return m_vec.begin(); }
 
-template <typename S, typename T, WJR_REQUIRES_I(is_nonbool_integral_v<T>)>
-uint64_t __tdiv_r_impl(basic_biginteger<S> *rem, const biginteger_data *num,
-                       uint64_t div) noexcept {
-    if constexpr (std::is_unsigned_v<T>) {
-        return __tdiv_q_ui_impl(rem, num, div);
-    } else {
-        uint64_t udiv = to_unsigned(div);
-        if (div < 0) {
-            udiv = -udiv;
-        }
+    WJR_PURE iterator end() noexcept { return m_vec.end(); }
+    WJR_PURE const_iterator end() const noexcept { return m_vec.end(); }
 
-        return __tdiv_r_ui_impl(rem, num, udiv);
-    }
-}
+    WJR_PURE const_iterator cbegin() const noexcept { return m_vec.cbegin(); }
 
-template <typename S0, typename S1>
-void __fdiv_qr_impl(basic_biginteger<S0> *quot, basic_biginteger<S1> *rem,
-                    const biginteger_data *num, const biginteger_data *div) noexcept {
+    WJR_PURE const_iterator cend() const noexcept { return m_vec.cend(); }
 
-    WJR_ASSERT_ASSUME(!__equal_pointer(quot, rem), "quot should not be the same as rem");
+    WJR_PURE reverse_iterator rbegin() noexcept { return m_vec.rbegin(); }
+    WJR_PURE const_reverse_iterator rbegin() const noexcept { return m_vec.rbegin(); }
 
-    unique_stack_allocator stkal(math_details::stack_alloc);
+    WJR_PURE reverse_iterator rend() noexcept { return m_vec.rend(); }
+    WJR_PURE const_reverse_iterator rend() const noexcept { return m_vec.rend(); }
 
-    biginteger_data tmp_div;
+    WJR_PURE const_reverse_iterator crbegin() const noexcept { return m_vec.crbegin(); }
+    WJR_PURE const_reverse_iterator crend() const noexcept { return m_vec.crend(); }
 
-    const auto dssize = div->get_ssize();
+    WJR_PURE bool empty() const noexcept { return m_vec.empty(); }
+    WJR_PURE size_type size() const noexcept { return m_vec.size(); }
+    WJR_PURE size_type capacity() const noexcept { return m_vec.capacity(); }
+    WJR_PURE bool zero() const noexcept { return empty(); }
 
-    if (__equal_pointer(div, quot) || __equal_pointer(div, rem)) {
-        const auto dusize = __fasts_abs(dssize);
-        const auto ptr = (uint64_t *)stkal.allocate(dusize * sizeof(uint64_t));
-        tmp_div = {ptr, dssize, 0};
-        std::copy_n(div->data(), dusize, ptr);
+    void reserve(size_type new_capacity) noexcept { m_vec.reserve(new_capacity); }
 
-        div = &tmp_div;
-    }
+    void shrink_to_fit() { m_vec.shrink_to_fit(); }
 
-    const auto xsize = num->get_ssize() ^ dssize;
+    /// equal to set_ssize(0)
+    void clear() { m_vec.clear(); }
 
-    __tdiv_qr_impl(quot, rem, num, div);
+    void swap(basic_biginteger &other) noexcept { m_vec.swap(other.m_vec); }
 
-    if (xsize < 0 && !rem->empty()) {
-        __sub_impl(quot, quot->__get_data(), 1u);
-        __add_impl(rem, rem->__get_data(), div);
+    void conditional_negate(bool condition) noexcept {
+        set_ssize(__fasts_conditional_negate<int32_t>(condition, get_ssize()));
     }
-}
 
-template <typename S>
-void __fdiv_q_impl(basic_biginteger<S> *quot, const biginteger_data *num,
-                   const biginteger_data *div) noexcept {
-    unique_stack_allocator stkal(math_details::stack_alloc);
-    stack_biginteger rem(stkal);
+    void negate() noexcept { conditional_negate(true); }
 
-    const auto xsize = num->get_ssize() ^ div->get_ssize();
+    WJR_PURE bool is_negate() const noexcept { return get_ssize() < 0; }
 
-    __tdiv_qr_impl(quot, &rem, num, div);
+    void absolute() noexcept { set_ssize(__fasts_abs(get_ssize())); }
 
-    if (xsize < 0 && !rem.empty()) {
-        __sub_impl(quot, quot->__get_data(), 1u);
+    basic_biginteger &operator++() {
+        increment(*this);
+        return *this;
     }
-}
 
-template <typename S>
-void __fdiv_r_impl(basic_biginteger<S> *rem, const biginteger_data *num,
-                   const biginteger_data *div) noexcept {
-    unique_stack_allocator stkal(math_details::stack_alloc);
+    basic_biginteger &operator--() {
+        decrement(*this);
+        return *this;
+    }
 
-    biginteger_data tmp_div;
+    template <typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+    basic_biginteger &operator+=(T rhs) {
+        add(*this, *this, rhs);
+        return *this;
+    }
 
-    const auto dssize = div->get_ssize();
+    basic_biginteger &operator+=(const biginteger_data &rhs) {
+        add(*this, *this, rhs);
+        return *this;
+    }
 
-    if (__equal_pointer(div, rem)) {
-        const auto dusize = __fasts_abs(dssize);
-        const auto ptr = (uint64_t *)stkal.allocate(dusize * sizeof(uint64_t));
-        tmp_div = {ptr, dssize, 0};
-        std::copy_n(div->data(), dusize, ptr);
+    template <typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+    basic_biginteger &operator-=(T rhs) {
+        sub(*this, *this, rhs);
+        return *this;
+    }
 
-        div = &tmp_div;
+    basic_biginteger &operator-=(const biginteger_data &rhs) {
+        sub(*this, *this, rhs);
+        return *this;
     }
 
-    const auto xsize = num->get_ssize() ^ dssize;
+    template <typename T, WJR_REQUIRES(is_nonbool_integral_v<T>)>
+    basic_biginteger &operator*=(T rhs) {
+        mul(*this, *this, rhs);
+        return *this;
+    }
 
-    __tdiv_r_impl(rem, num, div);
+    basic_biginteger &operator*=(const biginteger_data &rhs) {
+        mul(*this, *this, rhs);
+        return *this;
+    }
 
-    if (xsize < 0 && !rem->empty()) {
-        __add_impl(rem, rem->__get_data(), div);
+    basic_biginteger &operator<<=(uint32_t shift) {
+        mul_2exp(*this, *this, shift);
+        return *this;
     }
-}
 
-template <typename S0, typename S1, typename T, WJR_REQUIRES_I(is_nonbool_integral_v<T>)>
-uint64_t __fdiv_qr_impl(basic_biginteger<S0> *quot, basic_biginteger<S1> *rem,
-                        const biginteger_data *num, T div) noexcept {
-    if constexpr (std::is_unsigned_v<T>) {
-        const auto xssize = num->get_ssize();
+    // extension
 
-        uint64_t remv = __tdiv_qr_ui_impl(quot, rem, num, div);
+    WJR_PURE int32_t get_ssize() const { return get_storage().get_ssize(); }
+    template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T> ||
+                                       std::is_same_v<T, int32_t>)>
+    void set_ssize(T new_size) noexcept {
+        if constexpr (std::is_unsigned_v<T>) {
+            const auto u32size = static_cast<uint32_t>(new_size);
+            WJR_ASSUME(u32size == new_size);
+            get_storage().set_ssize(__fasts_from_unsigned(u32size));
+        } else {
+            get_storage().set_ssize(new_size);
+        }
+    }
 
-        if (xssize < 0 && remv != 0) {
-            WJR_ASSERT(rem->is_negate());
+    WJR_CONST static size_type get_growth_capacity(size_type old_capacity,
+                                                   size_type new_size) noexcept {
+        return vector_type::get_growth_capacity(old_capacity, new_size);
+    }
 
-            __sub_impl(quot, quot->__get_data(), 1u);
-            rem->set_ssize(1);
-            remv = div - remv;
-            rem->front() = remv;
-        }
+    void take_storage(storage_type &other) noexcept { m_vec.take_storage(other); }
 
-        return remv;
-    } else {
-        uint64_t udiv = to_unsigned(div);
-        int32_t xsign = 0;
+    void uninitialized_construct(storage_type &other, size_type siz,
+                                 size_type cap) noexcept {
+        m_vec.uninitialized_construct(other, siz, cap);
+    }
 
-        if (div < 0) {
-            udiv = -udiv;
-            xsign = -1;
-        }
+    WJR_PURE storage_type &get_storage() noexcept { return m_vec.get_storage(); }
+    WJR_PURE const storage_type &get_storage() const noexcept {
+        return m_vec.get_storage();
+    }
+
+    WJR_PURE const biginteger_data *__get_data() const noexcept {
+        return get_storage().__get_data();
+    }
+
+    WJR_PURE const biginteger_data &__get_ref() const noexcept { return *__get_data(); }
+    WJR_PURE operator const biginteger_data &() const noexcept { return __get_ref(); }
 
-        const int32_t nssize = num->get_ssize();
+private:
+    void __check_high_bit() const {
+        WJR_ASSERT(size() == 0 || back() != 0, "biginteger should not have leading zero");
+    }
 
-        uint64_t remv = __tdiv_qr_ui_impl(quot, rem, num, udiv);
+    vector_type m_vec;
+};
 
-        quot->conditional_negate(xsign);
+template <typename Alloc>
+using default_biginteger = basic_biginteger<default_biginteger_vector_storage<Alloc>>;
 
-        if ((nssize ^ xsign) < 0 && remv != 0) {
-            __sub_impl(quot, quot->__get_data(), 1u);
-            rem->set_ssize(__fasts_conditional_negate(xsign < 0, 1));
-            remv = div - remv;
-            rem->front() = remv;
-        }
+using biginteger = default_biginteger<memory_pool<uint64_t>>;
+using stack_biginteger = default_biginteger<math_details::weak_stack_alloc<uint64_t>>;
 
-        return remv;
-    }
+template <typename Storage>
+void swap(basic_biginteger<Storage> &lhs, basic_biginteger<Storage> &rhs) noexcept {
+    lhs.swap(rhs);
 }
 
-template <typename S, typename T, WJR_REQUIRES_I(is_nonbool_integral_v<T>)>
-uint64_t __fdiv_q_impl(basic_biginteger<S> *quot, const biginteger_data *num,
-                       T div) noexcept {
-    if constexpr (std::is_unsigned_v<T>) {
-        const auto xssize = num->get_ssize();
+namespace biginteger_details {
 
-        uint64_t remv = __tdiv_q_ui_impl(quot, num, div);
+/// @private
+template <typename S>
+WJR_PURE bool __equal_pointer(const basic_biginteger<S> *lhs,
+                              const basic_biginteger<S> *rhs) noexcept {
+    return lhs == rhs;
+}
 
-        if (xssize < 0 && remv != 0) {
-            __sub_impl(quot, quot->__get_data(), 1u);
-            remv = div - remv;
-        }
+/// @private
+template <typename S0, typename S1>
+WJR_PURE bool __equal_pointer(const basic_biginteger<S0> *,
+                              const basic_biginteger<S1> *) noexcept {
+    return false;
+}
 
-        return remv;
-    } else {
-        uint64_t udiv = to_unsigned(div);
-        int32_t xsign = 0;
+/// @private
+template <typename S>
+WJR_PURE bool __equal_pointer(const basic_biginteger<S> *lhs,
+                              const biginteger_data *rhs) noexcept {
+    return lhs->__get_data() == rhs;
+}
 
-        if (div < 0) {
-            udiv = -udiv;
-            xsign = -1;
-        }
+/// @private
+template <typename S>
+WJR_PURE bool __equal_pointer(const biginteger_data *lhs,
+                              const basic_biginteger<S> *rhs) noexcept {
+    return lhs == rhs->__get_data();
+}
 
-        const int32_t nssize = num->get_ssize();
+/// @private
+WJR_PURE inline bool __equal_pointer(const biginteger_data *lhs,
+                                     const biginteger_data *rhs) noexcept {
+    return lhs == rhs;
+}
 
-        uint64_t remv = __tdiv_q_ui_impl(quot, num, udiv);
+template <typename S>
+from_chars_result<> __from_chars_impl(const char *first, const char *last,
+                                      basic_biginteger<S> *dst,
+                                      unsigned int base) noexcept {
 
-        quot->conditional_negate(xsign);
+    uint8_t ch;
+    from_chars_result<> result{first, std::errc{}};
 
-        if ((nssize ^ xsign) < 0 && remv != 0) {
-            __sub_impl(quot, quot->__get_data(), 1u);
-            remv = div - remv;
-        }
+    auto invalid = [&dst, &result]() {
+        dst->clear();
+        result.ec = std::errc::invalid_argument;
+        return result;
+    };
 
-        return remv;
+    if (first == last) {
+        return invalid();
     }
-}
-
-template <typename S, typename T, WJR_REQUIRES_I(is_nonbool_integral_v<T>)>
-uint64_t __fdiv_r_impl(basic_biginteger<S> *rem, const biginteger_data *num,
-                       uint64_t div) noexcept {
-    if constexpr (std::is_unsigned_v<T>) {
-        const auto xssize = num->get_ssize();
 
-        uint64_t remv = __tdiv_r_ui_impl(rem, num, div);
+    while (convert_details::__isspace(ch = *first++) && first != last)
+        ;
 
-        if (xssize < 0 && remv != 0) {
-            WJR_ASSERT(rem->is_negate());
+    int sign = 0;
+    if (ch == '-') {
+        sign = 1;
 
-            rem->set_ssize(1);
-            remv = div - remv;
-            rem->front() = remv;
+        if (WJR_UNLIKELY(first == last)) {
+            return invalid();
         }
 
-        return remv;
-    } else {
-        uint64_t udiv = to_unsigned(div);
-        int32_t xsign = 0;
+        ch = *first++;
+    }
 
-        if (div < 0) {
-            udiv = -udiv;
-            xsign = -1;
+    if (base == 0) {
+        base = 10;
+        if (ch == '0') {
+            base = 8;
+            if (WJR_UNLIKELY(first == last)) {
+                return invalid();
+            }
+            ch = *first++;
+            if (ch == 'x' || ch == 'X') {
+                base = 16;
+                if (WJR_UNLIKELY(first == last)) {
+                    return invalid();
+                }
+                ch = *first++;
+            } else {
+                if (ch == 'b' || ch == 'B') {
+                    base = 2;
+                    if (WJR_UNLIKELY(first == last)) {
+                        return invalid();
+                    }
+                    ch = *first++;
+                }
+            }
         }
+    }
 
-        const int32_t nssize = num->get_ssize();
-
-        uint64_t remv = __tdiv_r_ui_impl(rem, num, udiv);
+    auto __first = first;
 
-        if ((nssize ^ xsign) < 0 && remv != 0) {
-            rem->set_ssize(__fasts_conditional_negate(xsign < 0, 1));
-            remv = div - remv;
-            rem->front() = remv;
+    while (ch == '0') {
+        if (WJR_UNLIKELY(first == last)) {
+            dst->clear();
+            result.ptr = first;
+            return result;
         }
 
-        return remv;
+        ch = *first++;
     }
-}
 
-template <typename S0, typename S1>
-void __cdiv_qr_impl(basic_biginteger<S0> *quot, basic_biginteger<S1> *rem,
-                    const biginteger_data *num, const biginteger_data *div) noexcept {
+    const auto start = first;
+    if (base <= 10) {
+        while (ch >= '0' && ch < '0' + base) {
+            if (first == last) {
+                ++first;
+                break;
+            }
 
-    WJR_ASSERT_ASSUME(!__equal_pointer(quot, rem), "quot should not be the same as rem");
+            ch = *first++;
+        }
+    } else {
+        ch = 0;
+        while (ch < base) {
+            if (first == last) {
+                ++first;
+                break;
+            }
 
-    unique_stack_allocator stkal(math_details::stack_alloc);
+            ch = char_converter.from(*first++);
+        }
+    }
 
-    biginteger_data tmp_div;
+    if (WJR_UNLIKELY(first == __first)) {
+        return invalid();
+    }
 
-    const auto dssize = div->get_ssize();
+    if (first == start) {
+        dst->clear();
+        result.ptr = first;
+        return result;
+    }
 
-    if (__equal_pointer(div, quot) || __equal_pointer(div, rem)) {
-        const auto dusize = __fasts_abs(dssize);
-        const auto ptr = (uint64_t *)stkal.allocate(dusize * sizeof(uint64_t));
-        tmp_div = {ptr, dssize, 0};
-        std::copy_n(div->data(), dusize, ptr);
+    const size_t str_size = first - start;
+    size_t capacity;
 
-        div = &tmp_div;
+    switch (base) {
+    case 2: {
+        capacity = __ceil_div(str_size, 64);
+        break;
+    }
+    case 8: {
+        capacity = __ceil_div(str_size * 3, 64);
+        break;
+    }
+    case 16: {
+        capacity = __ceil_div(str_size, 16);
+        break;
+    }
+    case 4:
+    case 32: {
+        const int bits = base == 4 ? 2 : 5;
+        capacity = __ceil_div(str_size * bits, 64);
+        break;
+    }
+    case 10: {
+        // capacity = (str_size * log2(10) + 63) / 64;
+        capacity = __ceil_div(str_size * 10 / 3, 64);
+        break;
+    }
+    default: {
+        return invalid();
+    }
     }
 
-    const auto xsize = num->get_ssize() ^ dssize;
+    dst->reserve(capacity);
+    auto ptr = dst->data();
+    int32_t dssize = biginteger_from_chars(start - 1, first - 1, ptr, base) - ptr;
+    dssize = __fasts_conditional_negate<int32_t>(sign, dssize);
+    dst->set_ssize(dssize);
+    result.ptr = first;
+    return result;
+}
 
-    __tdiv_qr_impl(quot, rem, num, div);
+inline int32_t __compare_impl(const biginteger_data *lhs,
+                              const biginteger_data *rhs) noexcept {
+    const auto lssize = lhs->get_ssize();
+    const auto rssize = rhs->get_ssize();
 
-    if (xsize >= 0 && !rem->empty()) {
-        __add_impl(quot, quot->__get_data(), 1u);
-        __sub_impl(rem, rem->__get_data(), div);
+    if (lssize != rssize) {
+        return lssize < rssize ? -1 : 1;
     }
-}
 
-template <typename S>
-void __cdiv_q_impl(basic_biginteger<S> *quot, const biginteger_data *num,
-                   const biginteger_data *div) noexcept {
-    unique_stack_allocator stkal(math_details::stack_alloc);
-    stack_biginteger rem(stkal);
+    const int32_t ans = reverse_compare_n(lhs->data(), rhs->data(), __fasts_abs(lssize));
+    return lssize < 0 ? -ans : ans;
+}
 
-    const auto xsize = num->get_ssize() ^ div->get_ssize();
+inline int32_t __compare_ui_impl(const biginteger_data *lhs, uint64_t rhs) noexcept {
+    const int32_t lssize = lhs->get_ssize();
 
-    __tdiv_qr_impl(quot, &rem, num, div);
+    if (lssize == 0) {
+        return -(rhs != 0);
+    }
 
-    if (xsize >= 0 && !rem.empty()) {
-        __add_impl(quot, quot->__get_data(), 1u);
+    if (lssize == 1) {
+        const uint64_t lvalue = lhs->data()[0];
+        return (lvalue != rhs ? (lvalue < rhs ? -1 : 1) : 0);
     }
+
+    return lssize;
 }
 
-template <typename S>
-void __cdiv_r_impl(basic_biginteger<S> *rem, const biginteger_data *num,
-                   const biginteger_data *div) noexcept {
-    unique_stack_allocator stkal(math_details::stack_alloc);
+inline int32_t __compare_si_impl(const biginteger_data *lhs, int64_t rhs) noexcept {
+    const int32_t lssize = lhs->get_ssize();
+    const int32_t rssize = rhs == 0 ? 0 : __fasts_conditional_negate<int32_t>(rhs < 0, 1);
 
-    biginteger_data tmp_div;
+    if (lssize != rssize) {
+        return lssize - rssize;
+    }
 
-    const auto dssize = div->get_ssize();
+    if (lssize == 0) {
+        return 0;
+    }
 
-    if (__equal_pointer(div, rem)) {
-        const auto dusize = __fasts_abs(dssize);
-        const auto ptr = (uint64_t *)stkal.allocate(dusize * sizeof(uint64_t));
-        tmp_div = {ptr, dssize, 0};
-        std::copy_n(div->data(), dusize, ptr);
+    const uint64_t lvalue = lhs->data()[0];
+    const uint64_t rvalue = rhs >= 0 ? to_unsigned(rhs) : -to_unsigned(rhs);
 
-        div = &tmp_div;
+    if (lvalue == rvalue) {
+        return 0;
     }
 
-    const auto xsize = num->get_ssize() ^ dssize;
+    if (lvalue > rvalue) {
+        return lssize;
+    }
 
-    __tdiv_r_impl(rem, num, div);
+    return -lssize;
+}
 
-    if (xsize >= 0 && !rem->empty()) {
-        __sub_impl(rem, rem->__get_data(), div);
+template <bool xsign, typename S>
+void __addsub_impl(basic_biginteger<S> *dst, const biginteger_data *lhs,
+                   uint64_t rhs) noexcept {
+    const int32_t lssize = lhs->get_ssize();
+    if (lssize == 0) {
+        dst->reserve(1);
+
+        if (rhs == 0) {
+            dst->set_ssize(0);
+        } else {
+            dst->front() = rhs;
+            dst->set_ssize(__fasts_conditional_negate<int32_t>(xsign, 1));
+        }
+
+        return;
     }
-}
 
-template <typename S0, typename S1, typename T, WJR_REQUIRES_I(is_nonbool_integral_v<T>)>
-uint64_t __cdiv_qr_impl(basic_biginteger<S0> *quot, basic_biginteger<S1> *rem,
-                        const biginteger_data *num, T div) noexcept {
-    if constexpr (std::is_unsigned_v<T>) {
-        const auto xssize = num->get_ssize();
+    const uint32_t lusize = __fasts_abs(lssize);
+    dst->reserve(lusize + 1);
 
-        uint64_t remv = __tdiv_qr_ui_impl(quot, rem, num, div);
+    const auto dp = dst->data();
+    const auto lp = lhs->data();
 
-        if (xssize >= 0 && remv != 0) {
-            WJR_ASSERT(rem->is_negate());
+    using compare = std::conditional_t<xsign, std::less<>, std::greater<>>;
+    int32_t dssize;
 
-            __add_impl(quot, quot->__get_data(), 1u);
-            rem->set_ssize(-1);
-            remv = div - remv;
-            rem->front() = remv;
+    if (compare{}(lssize, 0)) {
+        const auto cf = addc_1(dp, lp, lusize, rhs);
+        dssize = __fasts_conditional_negate<int32_t>(xsign, lusize + cf);
+        if (cf) {
+            dp[lusize] = 1;
         }
-
-        return remv;
     } else {
-        uint64_t udiv = to_unsigned(div);
-        int32_t xsign = 0;
-
-        if (div < 0) {
-            udiv = -udiv;
-            xsign = -1;
+        if (lusize == 1 && lp[0] < rhs) {
+            dp[0] = rhs - lp[0];
+            dssize = __fasts_conditional_negate<int32_t>(xsign, 1);
+        } else {
+            (void)subc_1(dp, lp, lusize, rhs);
+            dssize = __fasts_conditional_negate<int32_t>(!xsign,
+                                                         lusize - (dp[lusize - 1] == 0));
         }
+    }
 
-        const int32_t nssize = num->get_ssize();
-
-        uint64_t remv = __tdiv_qr_ui_impl(quot, rem, num, udiv);
+    dst->set_ssize(dssize);
+}
 
-        quot->conditional_negate(xsign);
+template <typename S>
+void __ui_sub_impl(basic_biginteger<S> *dst, uint64_t lhs,
+                   const biginteger_data *rhs) noexcept {
+    const int32_t rssize = rhs->get_ssize();
+    if (rssize == 0) {
+        dst->reserve(1);
 
-        if ((nssize ^ xsign) >= 0 && remv != 0) {
-            __add_impl(quot, quot->__get_data(), 1u);
-            rem->set_ssize(__fasts_conditional_negate(xsign >= 0, 1));
-            remv = div - remv;
-            rem->front() = remv;
+        if (lhs == 0) {
+            dst->set_ssize(0);
+        } else {
+            dst->front() = lhs;
+            dst->set_ssize(1);
         }
 
-        return remv;
+        return;
     }
-}
 
-template <typename S, typename T, WJR_REQUIRES_I(is_nonbool_integral_v<T>)>
-uint64_t __cdiv_q_impl(basic_biginteger<S> *quot, const biginteger_data *num,
-                       T div) noexcept {
-    if constexpr (std::is_unsigned_v<T>) {
-        const auto xssize = num->get_ssize();
+    const uint32_t rusize = __fasts_abs(rssize);
+    dst->reserve(rusize);
 
-        uint64_t remv = __tdiv_q_ui_impl(quot, num, div);
+    const auto dp = dst->data();
+    const auto rp = rhs->data();
+    int32_t dssize;
 
-        if (xssize >= 0 && remv != 0) {
-            __add_impl(quot, quot->__get_data(), 1u);
-            remv = div - remv;
+    if (rssize < 0) {
+        const auto cf = addc_1(dp, rp, rusize, lhs);
+        dssize = rusize + cf;
+        if (cf) {
+            dp[rusize] = 1;
         }
-
-        return remv;
     } else {
-        uint64_t udiv = to_unsigned(div);
-        int32_t xsign = 0;
-
-        if (div < 0) {
-            udiv = -udiv;
-            xsign = -1;
+        // lhs >= rhs
+        if (rusize == 1 && lhs >= rp[0]) {
+            dp[0] = lhs - rp[0];
+            dssize = dp[0] != 0;
         }
-
-        const int32_t nssize = num->get_ssize();
-
-        uint64_t remv = __tdiv_q_ui_impl(quot, num, udiv);
-
-        quot->conditional_negate(xsign);
-
-        if ((nssize ^ xsign) >= 0 && remv != 0) {
-            __add_impl(quot, quot->__get_data(), 1u);
-            remv = div - remv;
+        // lhs < rhs
+        else {
+            (void)subc_1(dp, rp, rusize, lhs);
+            dssize = __fasts_negate<int32_t>(rusize - (dp[rusize - 1] == 0));
         }
-
-        return remv;
     }
-}
 
-template <typename S, typename T, WJR_REQUIRES_I(is_nonbool_integral_v<T>)>
-uint64_t __cdiv_r_impl(basic_biginteger<S> *rem, const biginteger_data *num,
-                       uint64_t div) noexcept {
-    if constexpr (std::is_unsigned_v<T>) {
-        const auto xssize = num->get_ssize();
+    dst->set_ssize(dssize);
+}
 
-        uint64_t remv = __tdiv_r_ui_impl(rem, num, div);
+template <bool xsign, typename S>
+void __addsub_impl(basic_biginteger<S> *dst, const biginteger_data *lhs,
+                   const biginteger_data *rhs) noexcept {
+    int32_t lssize = lhs->get_ssize();
+    int32_t rssize = __fasts_conditional_negate<int32_t>(xsign, rhs->get_ssize());
+    uint32_t lusize = __fasts_abs(lssize);
+    uint32_t rusize = __fasts_abs(rssize);
 
-        if (xssize >= 0 && remv != 0) {
-            WJR_ASSERT(rem->is_negate());
+    if (lusize < rusize) {
+        std::swap(lhs, rhs);
+        std::swap(lssize, rssize);
+        std::swap(lusize, rusize);
+    }
 
-            rem->set_ssize(-1);
-            remv = div - remv;
-            rem->front() = remv;
-        }
+    dst->reserve(lusize + 1);
 
-        return remv;
-    } else {
-        uint64_t udiv = to_unsigned(div);
-        int32_t xsign = 0;
+    const auto dp = dst->data();
+    const auto lp = lhs->data();
+    const auto rp = rhs->data();
+    int32_t dssize;
 
-        if (div < 0) {
-            udiv = -udiv;
-            xsign = -1;
+    if (rusize == 0) {
+        if (lp != dp) {
+            std::copy_n(lp, lusize, dp);
+            dst->set_ssize(lssize);
         }
+        return;
+    }
 
-        const int32_t nssize = num->get_ssize();
-
-        uint64_t remv = __tdiv_r_ui_impl(rem, num, udiv);
-
-        if ((nssize ^ xsign) >= 0 && remv != 0) {
-            rem->set_ssize(__fasts_conditional_negate(xsign >= 0, 1));
-            remv = div - remv;
-            rem->front() = remv;
+    // different sign
+    if ((lssize ^ rssize) < 0) {
+        const int32_t ans =
+            static_cast<int32_t>(abs_subc_s_pos(dp, lp, lusize, rp, rusize));
+        dssize = __fasts_negate_with<int32_t>(lssize, ans);
+    } else {
+        const auto cf = addc_s(dp, lp, lusize, rp, rusize);
+        dssize = __fasts_negate_with<int32_t>(lssize, lusize + cf);
+        if (cf) {
+            dp[lusize] = 1;
         }
-
-        return remv;
     }
+
+    dst->set_ssize(dssize);
 }
 
 template <typename S>
-void __tdiv_q_2exp_impl(basic_biginteger<S> *quot, const biginteger_data *num,
-                        uint32_t shift) noexcept {
-    int32_t nssize = num->get_ssize();
-    uint32_t nusize = __fasts_abs(nssize);
-    uint32_t offset = shift / 64;
-
-    int32_t qssize = nusize - offset;
+void __mul_ui_impl(basic_biginteger<S> *dst, const biginteger_data *lhs,
+                   uint64_t rhs) noexcept {
+    const int32_t lssize = lhs->get_ssize();
+    const uint32_t lusize = __fasts_abs(lssize);
 
-    if (qssize <= 0) {
-        quot->set_ssize(0);
+    if (lusize == 0 || rhs == 0) {
+        dst->set_ssize(0);
         return;
     }
 
-    quot->reserve(qssize);
-    const auto qp = quot->data();
-    const auto np = num->data();
+    dst->reserve(lusize + 1);
 
-    (void)rshift_n(qp, np + offset, qssize, shift % 64);
-    qssize -= qp[qssize - 1] == 0;
+    const auto dp = dst->data();
+    const auto lp = lhs->data();
 
-    quot->set_ssize(__fasts_conditional_negate<int32_t>(nssize < 0, qssize));
+    const auto cf = mul_1(dp, lp, lusize, rhs);
+    const uint32_t dusize = lusize + (cf != 0);
+    if (cf != 0) {
+        dp[lusize] = cf;
+    }
+
+    dst->set_ssize(__fasts_conditional_negate<int32_t>(lssize < 0, dusize));
 }
 
 template <typename S>
-void __tdiv_r_2exp_impl(basic_biginteger<S> *rem, const biginteger_data *num,
-                        uint32_t shift) noexcept {
-    const int32_t nssize = num->get_ssize();
-    uint32_t nusize = __fasts_abs(nssize);
-    uint32_t offset = shift / 64;
-
-    uint32_t rusize;
+void __mul_impl(basic_biginteger<S> *dst, const biginteger_data *lhs,
+                const biginteger_data *rhs) noexcept {
+    int32_t lssize = lhs->get_ssize();
+    int32_t rssize = rhs->get_ssize();
+    uint32_t lusize = __fasts_abs(lssize);
+    uint32_t rusize = __fasts_abs(rssize);
 
-    if (nusize <= offset) {
-        rusize = nusize;
-        offset = nusize;
-        rem->reserve(rusize);
-    } else {
-        uint64_t high = num->data()[offset] & (((uint64_t)(1) << (shift % 64)) - 1);
-        if (high != 0) {
-            rusize = offset + 1;
-            rem->reserve(rusize);
-            rem->data()[offset] = high;
-        } else {
-            rusize = normalize(num->data(), offset);
-            offset = rusize;
-            rem->reserve(rusize);
-        }
+    if (lusize < rusize) {
+        std::swap(lhs, rhs);
+        std::swap(lusize, rusize);
     }
 
-    if (!__equal_pointer(rem, num)) {
-        std::copy_n(num->data(), offset, rem->data());
+    if (WJR_UNLIKELY(rusize == 0)) {
+        dst->set_ssize(0);
+        return;
     }
 
-    rem->set_ssize(__fasts_conditional_negate<int32_t>(nssize < 0, rusize));
-}
-
-template <typename S>
-void __cfdiv_q_2exp_impl(basic_biginteger<S> *quot, const biginteger_data *num,
-                         uint32_t shift, int32_t xdir) noexcept {
-    int32_t nssize = num->get_ssize();
-    uint32_t nusize = __fasts_abs(nssize);
-    uint32_t offset = shift / 64;
+    const int32_t mask = lssize ^ rssize;
 
-    int32_t qssize = nusize - offset;
+    int32_t dssize;
+    uint32_t dusize;
 
-    if (qssize <= 0) {
-        if (nssize == 0) {
-            quot->set_ssize(0);
-            return;
+    if (rusize == 1) {
+        dst->reserve(lusize + 1);
+        const auto cf = mul_1(dst->data(), lhs->data(), lusize, rhs->data()[0]);
+        dssize = __fasts_negate_with<int32_t>(mask, lusize + (cf != 0));
+        if (cf != 0) {
+            dst->data()[lusize] = cf;
         }
-
-        quot->reserve(1);
-        quot->front() = 1;
-
-        quot->set_ssize((nssize ^ xdir) < 0 ? 0 : xdir);
+        dst->set_ssize(dssize);
         return;
     }
 
-    quot->reserve(qssize + 1);
-    const auto qp = quot->data();
-    const auto np = num->data();
+    dusize = lusize + rusize;
 
-    uint64_t xmask = (nssize ^ xdir) < 0 ? 0 : (uint64_t)in_place_max;
-    uint64_t round = 0;
+    using pointer = uint64_t *;
 
-    if (xmask) {
-        // all is zero, then round is zero
-        round = find_not_n(np, 0, offset) == offset ? 0 : 1;
-    }
+    auto dp = dst->data();
+    auto lp = (pointer)(lhs->data());
+    auto rp = (pointer)(rhs->data());
 
-    round |= xmask & rshift_n(qp, np + offset, qssize, shift % 64);
-    qssize -= qp[qssize - 1] == 0;
+    std::optional<uninitialized<basic_biginteger<S>>> tmp;
 
-    if (WJR_LIKELY(round != 0)) {
-        if (WJR_LIKELY(qssize != 0)) {
-            const auto cf = addc_1(qp, qp, qssize, 1u);
-            if (cf != 0) {
-                qp[qssize] = cf;
-                ++qssize;
+    unique_stack_allocator stkal(math_details::stack_alloc);
+
+    if (dst->capacity() < dusize) {
+        tmp.emplace(dst->get_growth_capacity(dst->capacity(), dusize), in_place_reserve,
+                    dst->get_allocator());
+        dp = (**tmp).data();
+    } else {
+        if (dp == lp) {
+            lp = (pointer)stkal.allocate(lusize * sizeof(uint64_t));
+            if (dp == rp) {
+                rp = lp;
             }
-        } else {
-            qp[0] = 1;
-            qssize = 1;
+            std::copy_n(dp, lusize, lp);
+        } else if (dp == rp) {
+            rp = (pointer)stkal.allocate(rusize * sizeof(uint64_t));
+            std::copy_n(dp, rusize, rp);
         }
     }
 
-    quot->set_ssize(__fasts_conditional_negate<int32_t>(nssize < 0, qssize));
-}
+    if (WJR_UNLIKELY(lp == rp)) {
+        sqr(dp, lp, lusize);
+    } else {
+        mul_s(dp, lp, lusize, rp, rusize);
+    }
 
-template <typename S>
-void __cfdiv_r_2exp_impl(basic_biginteger<S> *rem, const biginteger_data *num,
-                         uint32_t shift, int32_t xdir) noexcept {
-    int32_t nssize = num->get_ssize();
+    const bool cf = dp[dusize - 1] == 0;
+    dssize = __fasts_negate_with<int32_t>(mask, dusize - cf);
 
-    if (nssize == 0) {
-        rem->set_ssize(0);
-        return;
+    if (tmp.has_value()) {
+        *dst = **std::move(tmp);
+        tmp->reset();
     }
 
-    uint32_t nusize = __fasts_abs(nssize);
-    uint32_t offset = shift / 64;
-    shift %= 64;
+    dst->set_ssize(dssize);
+}
 
-    uint64_t *rp;
-    auto np = (uint64_t *)(num->data());
+template <typename S>
+void __sqr_impl(basic_biginteger<S> *dst, const biginteger_data *src) noexcept {
+    int32_t sssize = src->get_ssize();
+    uint32_t susize = __fasts_abs(sssize);
 
-    if ((nssize ^ xdir) < 0) {
-        if (__equal_pointer(rem, num)) {
-            if (nusize <= offset) {
-                return;
-            }
+    if (WJR_UNLIKELY(susize == 0)) {
+        dst->set_ssize(0);
+        return;
+    }
 
-            rp = np;
-        } else {
-            const auto size = std::min<uint32_t>(nusize, offset + 1);
-            rem->reserve(size);
-            rp = rem->data();
-            std::copy_n(np, size, rp);
+    int32_t dssize;
+    uint32_t dusize;
 
-            if (nusize <= offset) {
-                rem->set_ssize(nssize);
-                return;
-            }
+    if (susize == 1) {
+        dst->reserve(susize + 1);
+        uint64_t num = src->data()[0];
+        uint64_t cf;
+        dst->data()[0] = mul(num, num, cf);
+        dssize = 1 + (cf != 0);
+        if (cf != 0) {
+            dst->data()[1] = cf;
         }
-    } else {
-        do {
-            if (nusize <= offset) {
-                break;
-            }
-
-            if (find_not_n(np, 0, offset) != offset) {
-                break;
-            }
-
-            if ((np[offset] & (((uint64_t)(1) << shift) - 1)) != 0) {
-                break;
-            }
+        dst->set_ssize(dssize);
+        return;
+    }
 
-            rem->set_ssize(0);
-            return;
-        } while (0);
+    dusize = susize * 2;
 
-        rem->reserve(offset + 1);
-        rp = rem->data();
-        np = (uint64_t *)(num->data());
+    using pointer = uint64_t *;
 
-        const auto size = std::min<uint32_t>(nusize, offset + 1);
-        (void)negate_n(rp, np, size);
-        for (uint32_t i = size; i <= offset; ++i) {
-            rp[i] = in_place_max;
-        }
+    auto dp = dst->data();
+    auto sp = (pointer)(src->data());
 
-        nssize = -nssize;
-    }
+    std::optional<uninitialized<basic_biginteger<S>>> tmp;
 
-    uint64_t hi = rp[offset] & (((uint64_t)(1) << shift) - 1);
-    rp[offset] = hi;
+    unique_stack_allocator stkal(math_details::stack_alloc);
 
-    if (hi == 0) {
-        offset = normalize(rp, offset);
+    if (dst->capacity() < dusize) {
+        tmp.emplace(dst->get_growth_capacity(dst->capacity(), dusize), in_place_reserve,
+                    dst->get_allocator());
+        dp = (**tmp).data();
     } else {
-        ++offset;
+        if (dp == sp) {
+            sp = (pointer)stkal.allocate(susize * sizeof(uint64_t));
+            std::copy_n(dp, susize, sp);
+        }
     }
 
-    rem->set_ssize(__fasts_conditional_negate<int32_t>(nssize < 0, offset));
-}
-
-template <typename S, typename Engine,
-          WJR_REQUIRES_I(biginteger_uniform_random_bit_generator_v<Engine>)>
-void __urandom_bit_impl(basic_biginteger<S> *dst, uint32_t size,
-                        Engine &engine) noexcept {
-    const uint32_t dusize = size / 64;
-    size %= 64;
-    uint32_t dssize = dusize + (size != 0);
-
-    dst->reserve(dssize);
-    const auto dp = dst->data();
+    sqr(dp, sp, susize);
 
-    do {
-        for (uint64_t i = 0; i < dusize; ++i) {
-            dp[i] = engine();
-        }
-    } while (0);
+    const bool cf = dp[dusize - 1] == 0;
+    dssize = dusize - cf;
 
-    if (size != 0) {
-        dp[dusize] = engine() >> (64 - size);
+    if (tmp.has_value()) {
+        *dst = **std::move(tmp);
+        tmp->reset();
     }
 
-    dssize = normalize(dp, dssize);
     dst->set_ssize(dssize);
 }
 
-template <typename S, typename Engine,
-          WJR_REQUIRES_I(biginteger_uniform_random_bit_generator_v<Engine>)>
-void __urandom_exact_bit_impl(basic_biginteger<S> *dst, uint32_t size,
-                              Engine &engine) noexcept {
-    if (WJR_UNLIKELY(size == 0)) {
-        dst->set_ssize(0);
+template <typename S>
+void __addsubmul_impl(basic_biginteger<S> *dst, const biginteger_data *lhs, uint64_t rhs,
+                      int32_t xmask) noexcept {
+    const int32_t lssize = lhs->get_ssize();
+
+    if (lssize == 0 || rhs == 0) {
         return;
     }
 
-    const uint32_t dusize = (size - 1) / 64;
-    size = (size - 1) % 64;
-    const uint32_t dssize = dusize + 1;
-
-    dst->reserve(dssize);
-    const auto dp = dst->data();
+    const uint32_t lusize = __fasts_abs(lssize);
+    int32_t dssize = dst->get_ssize();
 
-    do {
-        for (uint64_t i = 0; i < dusize; ++i) {
-            dp[i] = engine();
+    if (dssize == 0) {
+        dst->reserve(lusize + 1);
+        const auto dp = dst->data();
+        const auto cf = mul_1(dp, lhs->data(), lusize, rhs);
+        dssize = lssize + (cf != 0);
+        if (cf != 0) {
+            dp[lusize] = cf;
         }
-    } while (0);
-
-    do {
-        uint64_t high = (uint64_t)(1) << size;
 
-        if (size != 0) {
-            high |= engine() >> (64 - size);
-        }
+        dst->set_ssize(__fasts_negate_with(xmask, dssize));
+        return;
+    }
 
-        dp[dusize] = high;
-    } while (0);
+    xmask ^= lssize;
+    xmask ^= dssize;
 
-    dst->set_ssize(dssize);
-}
+    const uint32_t dusize = __fasts_abs(dssize);
 
-template <typename S, typename Engine,
-          WJR_REQUIRES_I(biginteger_uniform_random_bit_generator_v<Engine>)>
-void __urandom_impl(basic_biginteger<S> *dst, const biginteger_data *limit,
-                    Engine &engine) noexcept {
-    std::optional<uninitialized<math_details::unique_stack_alloc>> stkal;
-    uint32_t size = limit->size();
+    uint32_t new_dusize = std::max(lusize, dusize);
+    const uint32_t min_size = std::min(lusize, dusize);
+    dst->reserve(new_dusize + 1);
 
-    WJR_ASSERT(size != 0);
+    auto dp = dst->data();
+    auto lp = lhs->data();
 
-    if (WJR_UNLIKELY(size == 1)) {
-        std::uniform_int_distribution<uint64_t> head(0, limit->data()[0] - 1);
-        const uint64_t gen = head(engine);
+    uint64_t cf;
 
-        dst->reserve(1);
-        dst->front() = gen;
-        dst->set_ssize(gen == 0 ? 0 : 1);
-        return;
-    }
+    // dst += abs(lhs) * abs(rhs)
+    if (xmask >= 0) {
+        cf = addmul_1(dp, lp, min_size, rhs);
 
-    dst->reserve(size);
+        dp += min_size;
+        lp += min_size;
 
-    const auto dp = dst->data();
-    const uint64_t *lp = limit->data();
+        int32_t sdelta = lusize - dusize;
 
-    if (__equal_pointer(dst, limit)) {
-        stkal.emplace(math_details::stack_alloc);
-        const auto tp = (uint64_t *)(*stkal)->allocate(size * sizeof(uint64_t));
-        std::copy_n(lp, size, tp);
-        lp = tp;
-    }
+        if (sdelta != 0) {
+            uint64_t cf2;
+            if (sdelta > 0) {
+                cf2 = mul_1(dp, lp, sdelta, rhs);
+            } else {
+                sdelta = -sdelta;
+                cf2 = 0;
+            }
 
-    const uint32_t lst_pos = size - 1;
-    const uint64_t lst_val = lp[lst_pos];
-    std::uniform_int_distribution<uint64_t> head(0, lst_val);
+            cf = cf2 + addc_1(dp, dp, sdelta, cf);
+        }
 
-    while (true) {
-        uint64_t gen = head(engine);
-        uint32_t pos = lst_pos;
+        dp[sdelta] = cf;
+        new_dusize += (cf != 0);
+    }
+    // dst -= abs(lhs) * abs(rhs)
+    else {
+        cf = submul_1(dp, lp, min_size, rhs);
 
-        if (WJR_UNLIKELY(gen == lst_val)) {
-            uint64_t now;
-            do {
-                dp[pos--] = gen;
-                gen = engine();
-                now = lp[pos];
+        do {
+            if (dusize >= lusize) {
+                if (dusize != lusize) {
+                    cf = subc_1(dp + lusize, dp + lusize, dusize - lusize, cf);
+                }
 
-                if (WJR_LIKELY(gen != now)) {
-                    goto NEXT;
+                if (cf != 0) {
+                    cf += negate_n(dp, dp, new_dusize) - 1;
+                    dp[new_dusize] = cf;
+                    ++new_dusize;
+                    dssize = __fasts_negate(dssize);
                 }
+            } else {
+                cf += negate_n(dp, dp, dusize) - 1;
 
-            } while (pos);
+                const auto cf2 = cf == (uint64_t)in_place_max;
+                cf += cf2;
 
-            continue;
+                const auto cf3 = mul_1(dp + dusize, lp + dusize, lusize - dusize, rhs);
+                cf = cf3 + addc_1(dp + dusize, dp + dusize, lusize - dusize, cf);
 
-        NEXT:
+                dp[new_dusize] = cf;
+                new_dusize += (cf != 0);
 
-            if (gen > now) {
-                continue;
-            }
-        }
+                if (cf2) {
+                    (void)subc_1(dp + dusize, dp + dusize, new_dusize - dusize, 1);
+                }
 
-        dp[pos] = gen;
-        while (pos) {
-            dp[--pos] = engine();
-        }
+                dssize = __fasts_negate(dssize);
+            }
 
-        break;
+            new_dusize = normalize(dp, new_dusize);
+        } while (0);
     }
 
-    size = normalize(dp, size);
-    dst->set_ssize(size);
+    dst->set_ssize(__fasts_conditional_negate<int32_t>(dssize < 0, new_dusize));
+}
 
-    if (stkal.has_value()) {
-        stkal->reset();
+template <typename S>
+void __addsubmul_impl(basic_biginteger<S> *dst, const biginteger_data *lhs,
+                      const biginteger_data *rhs, int32_t xmask) noexcept {
+    int32_t lssize = lhs->get_ssize();
+    int32_t rssize = rhs->get_ssize();
+
+    if (lssize == 0 || rssize == 0) {
+        return;
     }
-}
 
-template <typename S, typename Engine,
-          WJR_REQUIRES_I(biginteger_uniform_random_bit_generator_v<Engine>)>
-void __urandom_exact_impl(basic_biginteger<S> *dst, const biginteger_data *limit,
-                          Engine &engine) noexcept {
-    std::optional<uninitialized<math_details::unique_stack_alloc>> stkal;
-    uint32_t size = limit->size();
+    uint32_t lusize = __fasts_abs(lssize);
+    uint32_t rusize = __fasts_abs(rssize);
 
-    if (WJR_UNLIKELY(size <= 1)) {
-        if (size == 0) {
-            dst->set_ssize(0);
-            return;
-        }
+    if (lusize < rusize) {
+        std::swap(lhs, rhs);
+        std::swap(lssize, rssize);
+        std::swap(lusize, rusize);
+    }
 
-        std::uniform_int_distribution<uint64_t> head(0, limit->data()[0]);
-        const uint64_t gen = head(engine);
+    xmask ^= rssize;
 
-        dst->reserve(1);
-        dst->front() = gen;
-        dst->set_ssize(gen == 0 ? 0 : 1);
+    if (rusize == 1) {
+        __addsubmul_impl(dst, lhs, rhs->data()[0], xmask);
         return;
     }
 
-    dst->reserve(size);
+    xmask ^= lssize;
+
+    int32_t dssize = dst->get_ssize();
+    xmask ^= dssize;
+    uint32_t dusize = __fasts_abs(dssize);
 
+    uint32_t tusize = lusize + rusize;
+    dst->reserve(std::max(tusize, dusize) + 1);
     const auto dp = dst->data();
-    const uint64_t *lp = limit->data();
 
-    if (__equal_pointer(dst, limit)) {
-        stkal.emplace(math_details::stack_alloc);
-        const auto tp = (uint64_t *)(*stkal)->allocate(size * sizeof(uint64_t));
-        std::copy_n(lp, size, tp);
-        lp = tp;
+    if (dssize == 0) {
+        mul_s(dp, lhs->data(), lusize, rhs->data(), rusize);
+        tusize -= dp[tusize - 1] == 0;
+        dst->set_ssize(__fasts_conditional_negate<int32_t>(xmask < 0, tusize));
+        return;
     }
 
-    const uint32_t lst_pos = size - 1;
-    const uint64_t lst_val = lp[lst_pos];
-    std::uniform_int_distribution<uint64_t> head(0, lst_val);
-
-    while (true) {
-        uint64_t gen = head(engine);
-        uint32_t pos = lst_pos;
+    unique_stack_allocator stkal(math_details::stack_alloc);
+    auto tp = (uint64_t *)stkal.allocate(tusize * sizeof(uint64_t));
 
-        if (WJR_UNLIKELY(gen == lst_val)) {
-            uint64_t now;
-            do {
-                dp[pos--] = gen;
-                gen = engine();
-                now = lp[pos];
-            } while (gen == now && pos);
+    mul_s(tp, lhs->data(), lusize, rhs->data(), rusize);
+    tusize -= tp[tusize - 1] == 0;
 
-            if (gen > now) {
-                continue;
-            }
-        }
+    auto up = dp;
+    uint32_t uusize = dusize;
 
-        dp[pos] = gen;
+    if (xmask >= 0) {
+        if (uusize < tusize) {
+            up = tp;
+            uusize = tusize;
+            tp = dp;
+            tusize = dusize;
 
-        while (pos) {
-            dp[--pos] = engine();
+            dusize = uusize;
         }
 
-        break;
-    }
+        const auto cf = addc_s(dp, up, uusize, tp, tusize);
+        dp[uusize] = cf;
+        dusize = uusize + (cf != 0);
+    } else {
+        if (uusize < tusize ||
+            (uusize == tusize && reverse_compare_n(up, tp, uusize) < 0)) {
+            up = tp;
+            uusize = tusize;
+            tp = dp;
+            tusize = dusize;
 
-    size = normalize(dp, size);
-    dst->set_ssize(size);
+            dusize = uusize;
 
-    if (stkal.has_value()) {
-        stkal->reset();
-    }
-}
+            dssize = __fasts_negate(dssize);
+        }
 
-/// @private
-inline uint32_t __bit_width_impl(const biginteger_data *num) noexcept {
-    const uint32_t size = num->size();
-    if (WJR_UNLIKELY(size == 0)) {
-        return 0;
+        (void)subc_s(dp, up, uusize, tp, tusize);
+        dssize = normalize(dp, dusize);
     }
 
-    return 64 * size - clz(num->data()[size - 1]);
-}
-
-/// @private
-inline uint32_t __ctz_impl(const biginteger_data *num) noexcept {
-    auto ptr = num->data();
-    uint32_t idx = 0;
-#if WJR_DEBUG_LEVEL > 0
-    const uint32_t size = num->size();
-    for (; ptr[idx] == 0 && idx < size; ++idx)
-        ;
-    WJR_ASSERT(idx != size);
-#else
-    for (; ptr[idx] == 0; ++idx)
-        ;
-#endif
-    return idx * 64 + ctz(ptr[idx]);
+    dst->set_ssize(__fasts_conditional_negate<int32_t>(dssize < 0, dusize));
 }
 
 template <typename S>
-void __pow_impl(basic_biginteger<S> *dst, const biginteger_data *num,
-                uint32_t exp) noexcept {
-    if (exp == 0) {
-        *dst = 1u;
+void __mul_2exp_impl(basic_biginteger<S> *dst, const biginteger_data *lhs,
+                     uint32_t shift) noexcept {
+    int32_t lssize = lhs->get_ssize();
+
+    if (lssize == 0) {
+        dst->set_ssize(0);
         return;
     }
 
-    const uint32_t nbits = __bit_width_impl(num);
-    const uint32_t dbits = nbits * exp;
-    const uint32_t max_dusize = (dbits + 63) / 64;
-
-    dst->reserve(max_dusize);
-    *dst = *num;
+    uint32_t lusize = __fasts_abs(lssize);
+    uint32_t offset = shift / 64;
+    shift %= 64;
+    uint32_t dusize = lusize + offset;
 
-    while (!(exp & 1)) {
-        sqr(*dst, *dst);
-        exp >>= 1;
-    }
+    dst->reserve(dusize + 1);
+    const auto dp = dst->data();
+    const auto lp = lhs->data();
 
-    if (exp == 1) {
-        return;
-    }
+    const auto cf = lshift_n(dp + offset, lp, lusize, shift);
+    set_n(dp, 0, offset);
 
-    basic_biginteger<S> tmp;
-    exp >>= 1;
-    sqr(tmp, *dst);
+    dp[dusize] = cf;
+    dusize += (cf != 0);
 
-    if (exp & 1) {
-        mul(*dst, *dst, tmp);
-    }
+    dst->set_ssize(__fasts_conditional_negate<int32_t>(lssize < 0, dusize));
+}
 
-    if (exp != 1) {
-        do {
-            exp >>= 1;
-            sqr(tmp, tmp);
+template <typename S0, typename S1>
+void __tdiv_qr_impl(basic_biginteger<S0> *quot, basic_biginteger<S1> *rem,
+                    const biginteger_data *num, const biginteger_data *div) noexcept {
+    WJR_ASSERT_ASSUME(!__equal_pointer(quot, rem), "quot should not be the same as rem");
 
-            if (exp & 1) {
-                mul(*dst, *dst, tmp);
-            }
-        } while (exp != 1);
-    }
-}
+    const auto nssize = num->get_ssize();
+    const auto dssize = div->get_ssize();
+    const auto nusize = __fasts_abs(nssize);
+    auto dusize = __fasts_abs(dssize);
+    int32_t qssize = nusize - dusize + 1;
 
-/// @private
-template <typename S>
-void __powmod_impl(basic_biginteger<S> *dst, const biginteger_data *num,
-                   __powmod_iterator *iter, const biginteger_data *mod) noexcept {
-    WJR_ASSERT(mod->size() != 0);
+    WJR_ASSERT(dusize != 0, "division by zero");
 
-    const auto size = iter->size;
+    rem->reserve(dusize);
+    auto rp = rem->data();
 
-    if (size == 0) {
-        uint64_t val;
-        if (WJR_UNLIKELY(mod->size() == 1 && mod->data()[0] == 1)) {
-            val = 0u;
-        } else {
-            val = 1u;
+    // num < div
+    if (qssize <= 0) {
+        auto np = num->data();
+        if (np != rp) {
+            std::copy_n(np, nusize, rp);
+            rem->set_ssize(nssize);
         }
 
-        *dst = val;
+        quot->set_ssize(0);
         return;
     }
 
-    tdiv_r(*dst, *num, *mod);
+    using pointer = uint64_t *;
 
-    while (!(iter->get() & 1)) {
-        sqr(*dst, *dst);
-        tdiv_r(*dst, *dst, *mod);
-        iter->next();
-    }
+    quot->reserve(qssize);
+    auto qp = quot->data();
 
-    if (iter->end()) {
-        return;
-    }
+    auto np = (pointer)num->data();
+    auto dp = (pointer)div->data();
 
-    basic_biginteger<S> tmp;
-    iter->next();
-    sqr(tmp, *dst);
-    tdiv_r(tmp, tmp, *mod);
+    unique_stack_allocator stkal(math_details::stack_alloc);
 
-    if (iter->get() & 1) {
-        mul(*dst, *dst, tmp);
-        tdiv_r(*dst, *dst, *mod);
+    if (dp == rp || dp == qp) {
+        auto tp = (pointer)stkal.allocate(dusize * sizeof(uint64_t));
+        std::copy_n(dp, dusize, tp);
+        dp = tp;
     }
 
-    if (!iter->end()) {
-        do {
-            iter->next();
-            sqr(tmp, tmp);
-            tdiv_r(tmp, tmp, *mod);
-
-            if (iter->get() & 1) {
-                mul(*dst, *dst, tmp);
-                tdiv_r(*dst, *dst, *mod);
-            }
-        } while (!iter->end());
+    if (np == rp || np == qp) {
+        auto tp = (pointer)stkal.allocate(nusize * sizeof(uint64_t));
+        std::copy_n(np, nusize, tp);
+        np = tp;
     }
-}
-
-template <typename S>
-void __powmod_impl(basic_biginteger<S> *dst, const biginteger_data *num,
-                   const biginteger_data *exp, const biginteger_data *mod) noexcept {
-    __powmod_iterator iter(exp->data(), exp->size());
-    __powmod_impl(dst, num, &iter, mod);
-}
-
-template <typename S>
-void __powmod_impl(basic_biginteger<S> *dst, const biginteger_data *num, uint64_t exp,
-                   const biginteger_data *mod) noexcept {
-    uint64_t tmp[] = {exp};
-    __powmod_iterator iter(tmp, exp == 0 ? 0 : 1);
-    __powmod_impl(dst, num, &iter, mod);
-}
-
-} // namespace biginteger_details
 
-template <typename S>
-from_chars_result<> from_chars(const char *first, const char *last,
-                               basic_biginteger<S> &dst, unsigned int base) noexcept {
-    return biginteger_details::__from_chars_impl(first, last, &dst, base);
-}
+    div_qr_s(qp, rp, np, nusize, dp, dusize);
 
-template <typename S>
-void negate(basic_biginteger<S> &dst) noexcept {
-    dst.negate();
-}
+    qssize -= qp[qssize - 1] == 0;
+    dusize = normalize(rp, dusize);
 
-template <typename S>
-void absolute(basic_biginteger<S> &dst) noexcept {
-    dst.absolute();
+    quot->set_ssize(__fasts_conditional_negate<int32_t>((nssize ^ dssize) < 0, qssize));
+    rem->set_ssize(__fasts_conditional_negate<int32_t>(nssize < 0, dusize));
 }
 
 template <typename S>
-std::istream &operator>>(std::istream &is, basic_biginteger<S> &dst) noexcept {
-    std::string str;
-    is >> str;
-    from_chars(str.data(), str.data() + str.size(), dst, 0);
-    return is;
-}
-
-template <typename Traits>
-std::basic_ostream<char, Traits> &operator<<(std::basic_ostream<char, Traits> &os,
-                                             const biginteger_data &src) noexcept {
-    std::ios_base::iostate state = std::ios::goodbit;
+void __tdiv_q_impl(basic_biginteger<S> *quot, const biginteger_data *num,
+                   const biginteger_data *div) noexcept {
+    const auto nssize = num->get_ssize();
+    const auto dssize = div->get_ssize();
+    const auto nusize = __fasts_abs(nssize);
+    const auto dusize = __fasts_abs(dssize);
+    int32_t qssize = nusize - dusize + 1;
 
-    if (const std::ostream::sentry ok(os); ok) {
-        unique_stack_allocator stkal(math_details::stack_alloc);
+    WJR_ASSERT(dusize != 0, "division by zero");
 
-        vector<char, math_details::weak_stack_alloc<char>> buffer(stkal);
-        buffer.reserve(128);
+    // num < div
+    if (qssize <= 0) {
+        quot->set_ssize(0);
+        return;
+    }
 
-        const std::ios_base::fmtflags flags = os.flags();
+    using pointer = uint64_t *;
 
-        if ((flags & std::ios::showpos) && !src.is_negate()) {
-            buffer.push_back('+');
-        }
+    quot->reserve(qssize);
+    auto qp = quot->data();
 
-        int base = 10;
+    auto np = (pointer)num->data();
+    auto dp = (pointer)div->data();
 
-        if (const auto basefield = flags & std::ios::basefield; basefield != 0) {
-            if (basefield == std::ios::oct) {
-                base = 8;
-                if (flags & std::ios::showbase) {
-                    buffer.append({'0'});
-                }
-            } else if (basefield == std::ios::hex) {
-                base = 16;
-                if (flags & std::ios::showbase) {
-                    buffer.append({'0', 'x'});
-                }
-            }
-        }
+    unique_stack_allocator stkal(math_details::stack_alloc);
 
-        (void)to_chars_unchecked(std::back_inserter(buffer), src, base);
+    if (dp == qp) {
+        auto tp = (pointer)stkal.allocate(dusize * sizeof(uint64_t));
+        std::copy_n(dp, dusize, tp);
+        dp = tp;
+    }
 
-        if (!buffer.empty()) {
-            __ostream_insert_unchecked(os, buffer.data(), buffer.size());
-        }
+    if (np == qp) {
+        auto tp = (pointer)stkal.allocate(nusize * sizeof(uint64_t));
+        std::copy_n(np, nusize, tp);
+        np = tp;
     }
 
-    os.setstate(state);
-    return os;
-}
+    const auto rp = (pointer)stkal.allocate(dusize * sizeof(uint64_t));
 
-} // namespace wjr
+    div_qr_s(qp, rp, np, nusize, dp, dusize);
 
-#endif
+    qssize -= qp[qssize - 1] == 0;
 
-#endif // WJR_BIGINTEGER_HPP__
-#ifndef WJR_JSON_LEXER_HPP__
-#define WJR_JSON_LEXER_HPP__
+    quot->set_ssize(__fasts_conditional_negate<int32_t>((nssize ^ dssize) < 0, qssize));
+}
 
-#ifndef WJR_JSON_LEXER_IMPL_HPP__
-#define WJR_JSON_LEXER_IMPL_HPP__
+template <typename S>
+void __tdiv_r_impl(basic_biginteger<S> *rem, const biginteger_data *num,
+                   const biginteger_data *div) noexcept {
+    const auto nssize = num->get_ssize();
+    const auto dssize = div->get_ssize();
+    const auto nusize = __fasts_abs(nssize);
+    auto dusize = __fasts_abs(dssize);
+    const int32_t qssize = nusize - dusize + 1;
 
-// Already included
+    WJR_ASSERT(dusize != 0, "division by zero");
 
-namespace wjr::json {
+    rem->reserve(dusize);
+    auto rp = rem->data();
 
-struct forward_lexer_storage {
-    forward_lexer_storage(span<const char> input) noexcept
-        : first(input.data()), last(input.data() + input.size()) {}
+    // num < div
+    if (qssize <= 0) {
+        const auto np = num->data();
+        if (np != rp) {
+            std::copy_n(np, nusize, rp);
+            rem->set_ssize(nssize);
+        }
 
-    const char *first;
-    const char *last;
+        return;
+    }
 
-    uint64_t prev_in_string = 0;
-    uint64_t prev_is_escape = 0;
-    uint64_t prev_is_ws = ~0ull;
+    using pointer = uint64_t *;
 
-    uint32_t idx = 0;
-};
+    auto np = (pointer)num->data();
+    auto dp = (pointer)div->data();
 
-struct dynamic_lexer_storage {
-    dynamic_lexer_storage(span<const char> input) noexcept
-        : first(input.data()), last(input.data() + input.size()) {}
+    unique_stack_allocator stkal(math_details::stack_alloc);
 
-    const char *first;
-    const char *last;
-};
+    if (dp == rp) {
+        const auto tp = (pointer)stkal.allocate(dusize * sizeof(uint64_t));
+        std::copy_n(dp, dusize, tp);
+        dp = tp;
+    }
 
-template <uint32_t token_buf_size>
-class basic_lexer {
-    static_assert(((token_buf_size & (token_buf_size - 1)) == 0 &&
-                   token_buf_size <= 65536) ||
-                      token_buf_size == (uint32_t)in_place_max,
-                  "token_buf_size must be a power of 2");
+    if (np == rp) {
+        const auto tp = (pointer)stkal.allocate(nusize * sizeof(uint64_t));
+        std::copy_n(np, nusize, tp);
+        np = tp;
+    }
 
-    constexpr static bool __is_dynamic = token_buf_size == (uint32_t)in_place_max;
-    using storage_type =
-        std::conditional_t<__is_dynamic, dynamic_lexer_storage, forward_lexer_storage>;
+    const auto qp = (pointer)stkal.allocate(qssize * sizeof(uint64_t));
 
-public:
-    constexpr basic_lexer(span<const char> input) noexcept : m_storage(input) {}
+    div_qr_s(qp, rp, np, nusize, dp, dusize);
 
-    basic_lexer() = delete;
-    constexpr basic_lexer(const basic_lexer &) = delete;
-    constexpr basic_lexer(basic_lexer &&) = default;
-    constexpr basic_lexer &operator=(const basic_lexer &) = delete;
-    constexpr basic_lexer &operator=(basic_lexer &&) = default;
-    ~basic_lexer() = default;
+    dusize = normalize(rp, dusize);
 
-    /**
-     * @brief read tokens
-     *
-     * @details Read at least token_buf_size tokens from the input.
-     * token_buf' size must be at least token_buf_size * 2 - 1.
-     *
-     * @return return the number of tokens read.
-     *
-     */
+    rem->set_ssize(__fasts_conditional_negate<int32_t>(nssize < 0, dusize));
+}
 
-    uint32_t read(uint32_t *token_buf) noexcept;
+template <typename S0, typename S1>
+uint64_t __tdiv_qr_ui_impl(basic_biginteger<S0> *quot, basic_biginteger<S1> *rem,
+                           const biginteger_data *num, uint64_t div) noexcept {
+    const auto nssize = num->get_ssize();
 
-    WJR_PURE const char *end() const noexcept { return m_storage.last; }
+    WJR_ASSERT(div != 0, "division by zero");
 
-private:
-    storage_type m_storage;
-};
+    if (nssize == 0) {
+        quot->set_ssize(0);
+        rem->set_ssize(0);
+        return 0;
+    }
 
-using dynamic_lexer = basic_lexer<in_place_max>;
+    const auto nusize = __fasts_abs(nssize);
+    quot->reserve(nusize);
+    const auto qp = quot->data();
+    const auto np = num->data();
 
-template <uint32_t token_buf_size>
-using forward_lexer = basic_lexer<token_buf_size>;
+    uint64_t remv;
+    div_qr_1(qp, remv, np, nusize, div);
 
-namespace lexer_details {
-inline uint64_t calc_backslash(uint64_t B) {
-    uint64_t maybe_escaped = B << 1;
+    if (remv == 0) {
+        rem->set_ssize(0);
+    } else {
+        rem->reserve(1);
+        rem->front() = remv;
+        rem->set_ssize(__fasts_conditional_negate<int32_t>(nssize < 0, 1));
+    }
 
-    uint64_t maybe_escaped_and_odd_bits = maybe_escaped | 0xAAAAAAAAAAAAAAAAULL;
-    uint64_t even_series_codes_and_odd_bits = maybe_escaped_and_odd_bits - B;
+    const auto qusize = nusize - (qp[nusize - 1] == 0);
 
-    return even_series_codes_and_odd_bits ^ 0xAAAAAAAAAAAAAAAAULL;
+    quot->set_ssize(__fasts_conditional_negate<int32_t>(nssize < 0, qusize));
+    return remv;
 }
-} // namespace lexer_details
 
-} // namespace wjr::json
+template <typename S>
+uint64_t __tdiv_q_ui_impl(basic_biginteger<S> *quot, const biginteger_data *num,
+                          uint64_t div) noexcept {
+    const auto nssize = num->get_ssize();
 
-#endif // WJR_JSON_LEXER_IMPL_HPP__
-// Already included
+    WJR_ASSERT(div != 0, "division by zero");
 
-#if defined(WJR_X86)
-#ifndef WJR_X86_JSON_LEXER_HPP__
-#define WJR_X86_JSON_LEXER_HPP__
+    if (nssize == 0) {
+        quot->set_ssize(0);
+        return 0;
+    }
 
-// Already included
-// Already included
-// Already included
+    const auto nusize = __fasts_abs(nssize);
+    quot->reserve(nusize);
+    const auto qp = quot->data();
+    const auto np = num->data();
 
-namespace wjr::json {
+    uint64_t remv;
+    div_qr_1(qp, remv, np, nusize, div);
 
-#if WJR_HAS_SIMD(SSSE3) && WJR_HAS_SIMD(X86_SIMD)
-#define WJR_HAS_BUILTIN_JSON_LEXER_READER_READ_BUF WJR_HAS_DEF
-#endif
+    const auto qusize = nusize - (qp[nusize - 1] == 0);
 
-#if WJR_HAS_BUILTIN(JSON_LEXER_READER_READ_BUF)
+    quot->set_ssize(__fasts_conditional_negate<int32_t>(nssize < 0, qusize));
+    return remv;
+}
 
-namespace lexer_details {
+template <typename S>
+uint64_t __tdiv_r_ui_impl(basic_biginteger<S> *rem, const biginteger_data *num,
+                          uint64_t div) noexcept {
+    const auto nssize = num->get_ssize();
 
-#if !WJR_HAS_SIMD(AVX2)
-const static __m128i lh8_mask = sse::set1_epi8(0x0f);
+    WJR_ASSERT(div != 0, "division by zero");
 
-const static __m128i lo8_lookup =
-    sse::set_epi8(0, 0, 12, 1, 4, 10, 8, 0, 0, 0, 0, 0, 0, 0, 0, 16);
-const static __m128i hi8_lookup =
-    sse::set_epi8(0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 4, 0, 2, 17, 0, 8);
-#else
-const static __m256i lh8_mask = avx::set1_epi8(0x0f);
-const static __m256i lo8_lookup =
-    avx::set_epi8(0, 0, 12, 1, 4, 10, 8, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 12, 1, 4, 10,
-                  8, 0, 0, 0, 0, 0, 0, 0, 0, 16);
-const static __m256i hi8_lookup =
-    avx::set_epi8(0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 4, 0, 2, 17, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0,
-                  4, 0, 4, 0, 2, 17, 0, 8);
-#endif
+    if (nssize == 0) {
+        rem->set_ssize(0);
+        return 0;
+    }
 
-template <typename simd>
-inline typename simd::int_type equal(typename simd::int_type x, uint8_t ch) {
-    return simd::cmpeq_epi8(x, simd::set1_epi8(ch));
-}
+    const auto nusize = __fasts_abs(nssize);
+    const auto np = num->data();
 
-template <typename simd>
-void load_simd(const char *first, typename simd::int_type *arr) {
-    constexpr auto simd_width = simd::width();
-    constexpr auto u8_width = simd_width / 8;
-    constexpr auto u8_loop = 64 / u8_width;
-    for (unsigned i = 0; i < u8_loop; ++i) {
-        arr[i] = simd::loadu((typename simd::int_type *)(first + i * u8_width));
+    uint64_t remv;
+    remv = mod_1(np, nusize, div);
+
+    if (remv == 0) {
+        rem->set_ssize(0);
+    } else {
+        rem->reserve(1);
+        rem->front() = remv;
+        rem->set_ssize(__fasts_conditional_negate<int32_t>(nssize < 0, 1));
     }
+
+    return remv;
 }
 
-} // namespace lexer_details
+template <typename S0, typename S1, typename T, WJR_REQUIRES_I(is_nonbool_integral_v<T>)>
+uint64_t __tdiv_qr_impl(basic_biginteger<S0> *quot, basic_biginteger<S1> *rem,
+                        const biginteger_data *num, T div) noexcept {
+    if constexpr (std::is_unsigned_v<T>) {
+        return __tdiv_qr_ui_impl(quot, rem, num, div);
+    } else {
+        uint64_t udiv = to_unsigned(div);
+        bool xsign = false;
+        if (div < 0) {
+            udiv = -udiv;
+            xsign = true;
+        }
 
-template <uint32_t token_buf_size>
-uint32_t basic_lexer<token_buf_size>::read(uint32_t *token_buf) noexcept {
-    using namespace lexer_details;
+        uint64_t remv = __tdiv_qr_ui_impl(quot, rem, num, udiv);
 
-    constexpr bool is_avx = WJR_HAS_SIMD(AVX2);
-    using simd = std::conditional_t<is_avx, avx, sse>;
-    using simd_int = typename simd::int_type;
-    constexpr auto simd_width = simd::width();
-    constexpr auto u8_width = simd_width / 8;
-    constexpr auto u8_loop = 64 / u8_width;
+        quot->conditional_negate(xsign);
+        return remv;
+    }
+}
 
-    constexpr uint32_t token_buf_mask = token_buf_size * 2;
+template <typename S, typename T, WJR_REQUIRES_I(is_nonbool_integral_v<T>)>
+uint64_t __tdiv_q_impl(basic_biginteger<S> *quot, const biginteger_data *num,
+                       T div) noexcept {
+    if constexpr (std::is_unsigned_v<T>) {
+        return __tdiv_q_ui_impl(quot, num, div);
+    } else {
+        uint64_t udiv = to_unsigned(div);
+        bool xsign = false;
+        if (div < 0) {
+            udiv = -udiv;
+            xsign = true;
+        }
 
-    auto first = m_storage.first;
-    const auto last = m_storage.last;
+        uint64_t remv = __tdiv_q_ui_impl(quot, num, udiv);
 
-    if (WJR_UNLIKELY(first == last)) {
-        return 0;
+        quot->conditional_negate(xsign);
+        return remv;
     }
+}
 
-    uint64_t prev_is_escape;
-    uint64_t prev_in_string;
-    uint64_t prev_is_ws;
-    uint32_t idx;
-
-    if constexpr (__is_dynamic) {
-        prev_is_escape = prev_in_string = 0;
-        prev_is_ws = ~0ull;
-        idx = 0;
+template <typename S, typename T, WJR_REQUIRES_I(is_nonbool_integral_v<T>)>
+uint64_t __tdiv_r_impl(basic_biginteger<S> *rem, const biginteger_data *num,
+                       uint64_t div) noexcept {
+    if constexpr (std::is_unsigned_v<T>) {
+        return __tdiv_q_ui_impl(rem, num, div);
     } else {
-        prev_is_escape = m_storage.prev_is_escape;
-        prev_in_string = m_storage.prev_in_string;
-        prev_is_ws = m_storage.prev_is_ws;
-        idx = m_storage.idx;
-    }
+        uint64_t udiv = to_unsigned(div);
+        if (div < 0) {
+            udiv = -udiv;
+        }
 
-    WJR_ASSERT_ASSUME_L2(first < last);
+        return __tdiv_r_ui_impl(rem, num, udiv);
+    }
+}
 
-    uint32_t count = 0;
-    bool loop;
+template <typename S0, typename S1>
+void __fdiv_qr_impl(basic_biginteger<S0> *quot, basic_biginteger<S1> *rem,
+                    const biginteger_data *num, const biginteger_data *div) noexcept {
 
-    do {
-        simd_int x[u8_loop];
+    WJR_ASSERT_ASSUME(!__equal_pointer(quot, rem), "quot should not be the same as rem");
 
-        const size_t diff = last - first;
+    unique_stack_allocator stkal(math_details::stack_alloc);
 
-        if (WJR_LIKELY(diff > 64)) {
-            load_simd<simd>(first, x);
-            first += 64;
-        } else {
-            if (diff == 64) {
-                load_simd<simd>(first, x);
-            } else {
-                char buf[64];
-                char ch;
-                switch (last[-1]) {
-                case ' ':
-                case '\n':
-                case '\r':
-                case '\t':
-                case '[':
-                case ']':
-                case '{':
-                case '}': {
-                    ch = ' ';
-                    break;
-                }
-                default: {
-                    ch = '\0';
-                    break;
-                }
-                }
+    biginteger_data tmp_div;
 
-                std::memcpy(buf, first, diff);
-                std::memset(buf + diff, ch, 64 - diff);
-                load_simd<simd>(buf, x);
-            }
+    const auto dssize = div->get_ssize();
 
-            first = last;
-            if constexpr (!__is_dynamic) {
-                count |= token_buf_mask;
-            }
-        }
+    if (__equal_pointer(div, quot) || __equal_pointer(div, rem)) {
+        const auto dusize = __fasts_abs(dssize);
+        const auto ptr = (uint64_t *)stkal.allocate(dusize * sizeof(uint64_t));
+        tmp_div = {ptr, dssize, 0};
+        std::copy_n(div->data(), dusize, ptr);
 
-        uint64_t B = 0; // backslash
+        div = &tmp_div;
+    }
 
-        for (unsigned i = 0; i < u8_loop; ++i) {
-            const auto backslash = equal<simd>(x[i], '\\');
-            B |= (uint64_t)simd::movemask_epi8(backslash) << (i * u8_width);
-        }
+    const auto xsize = num->get_ssize() ^ dssize;
 
-        uint64_t Q = 0; // quote
+    __tdiv_qr_impl(quot, rem, num, div);
 
-        for (unsigned i = 0; i < u8_loop; ++i) {
-            const auto quote = equal<simd>(x[i], '\"');
-            Q |= (uint64_t)simd::movemask_epi8(quote) << (i * u8_width);
-        }
+    if (xsize < 0 && !rem->empty()) {
+        __sub_impl(quot, quot->__get_data(), 1u);
+        __add_impl(rem, rem->__get_data(), div);
+    }
+}
 
-        uint64_t S = 0; // brackets, comma , colon
-        uint64_t W = 0; // whitespace
+template <typename S>
+void __fdiv_q_impl(basic_biginteger<S> *quot, const biginteger_data *num,
+                   const biginteger_data *div) noexcept {
+    unique_stack_allocator stkal(math_details::stack_alloc);
+    stack_biginteger rem(stkal);
 
-        for (unsigned i = 0; i < u8_loop; ++i) {
-            const auto shuf_lo8 = simd::shuffle_epi8(lo8_lookup, x[i]);
-            const auto shuf_hi8 = simd::shuffle_epi8(
-                hi8_lookup, simd::And(simd::srli_epi16(x[i], 4), lh8_mask));
+    const auto xsize = num->get_ssize() ^ div->get_ssize();
 
-            const auto result = simd::And(shuf_lo8, shuf_hi8);
-            // comma : 1
-            // colon : 2
-            // brackets : 4
-            // whitespace : 8, 16
+    __tdiv_qr_impl(quot, &rem, num, div);
 
-            uint32_t stu = simd::movemask_epi8(
-                simd::cmpeq_epi8(simd::And(result, simd::set1_epi8(7)), simd::zeros()));
-            uint32_t wsp = simd::movemask_epi8(
-                simd::cmpeq_epi8(simd::And(result, simd::set1_epi8(24)), simd::zeros()));
+    if (xsize < 0 && !rem.empty()) {
+        __sub_impl(quot, quot->__get_data(), 1u);
+    }
+}
 
-            S |= (uint64_t)(stu) << (i * u8_width);
-            W |= (uint64_t)(wsp) << (i * u8_width);
-        }
+template <typename S>
+void __fdiv_r_impl(basic_biginteger<S> *rem, const biginteger_data *num,
+                   const biginteger_data *div) noexcept {
+    unique_stack_allocator stkal(math_details::stack_alloc);
 
-        S = ~S;
-        W = ~W;
+    biginteger_data tmp_div;
 
-        {
-            if (!B) {
-                B = prev_is_escape;
-                Q &= ~B;
-                prev_is_escape = 0;
-            } else {
-                const uint64_t codeB = calc_backslash(B & ~prev_is_escape);
-                const auto escape = (codeB & B) >> 63;
-                B = codeB ^ (B | prev_is_escape);
-                Q &= ~B;
-                prev_is_escape = escape;
-            }
-        }
+    const auto dssize = div->get_ssize();
 
-        const uint64_t R = prefix_xor(Q) ^ prev_in_string;
+    if (__equal_pointer(div, rem)) {
+        const auto dusize = __fasts_abs(dssize);
+        const auto ptr = (uint64_t *)stkal.allocate(dusize * sizeof(uint64_t));
+        tmp_div = {ptr, dssize, 0};
+        std::copy_n(div->data(), dusize, ptr);
 
-        const auto WS = S | W;
-        const auto WT = shld(WS, prev_is_ws, 1);
-        const auto TW = shld(~WS, ~prev_is_ws, 1);
-        prev_is_ws = WS;
+        div = &tmp_div;
+    }
 
-        S &= ~R;
-        prev_in_string = static_cast<uint64_t>(static_cast<int64_t>(R) >> 63);
+    const auto xsize = num->get_ssize() ^ dssize;
 
-        S |= Q;
-        S |= ((TW & W) | (WT & ~W)) & ~R;
-        S &= ~(Q & ~R);
+    __tdiv_r_impl(rem, num, div);
 
-        if (S) {
-            const auto num = popcount(S);
+    if (xsize < 0 && !rem->empty()) {
+        __add_impl(rem, rem->__get_data(), div);
+    }
+}
 
-            do {
-                for (int i = 0; i < 4; ++i) {
-                    token_buf[i] = idx + ctz(S);
-                    S &= S - 1;
-                }
+template <typename S0, typename S1, typename T, WJR_REQUIRES_I(is_nonbool_integral_v<T>)>
+uint64_t __fdiv_qr_impl(basic_biginteger<S0> *quot, basic_biginteger<S1> *rem,
+                        const biginteger_data *num, T div) noexcept {
+    if constexpr (std::is_unsigned_v<T>) {
+        const auto xssize = num->get_ssize();
 
-                if (WJR_UNLIKELY(num <= 4)) {
-                    break;
-                }
+        uint64_t remv = __tdiv_qr_ui_impl(quot, rem, num, div);
 
-                for (int i = 4; i < 8; ++i) {
-                    token_buf[i] = idx + ctz(S);
-                    S &= S - 1;
-                }
+        if (xssize < 0 && remv != 0) {
+            WJR_ASSERT(rem->is_negate());
 
-                if (WJR_LIKELY(num <= 8)) {
-                    break;
-                }
+            __sub_impl(quot, quot->__get_data(), 1u);
+            rem->set_ssize(1);
+            remv = div - remv;
+            rem->front() = remv;
+        }
 
-                for (int i = 8; i < 12; ++i) {
-                    token_buf[i] = idx + ctz(S);
-                    S &= S - 1;
-                }
+        return remv;
+    } else {
+        uint64_t udiv = to_unsigned(div);
+        int32_t xsign = 0;
 
-                if (WJR_LIKELY(num <= 12)) {
-                    break;
-                }
+        if (div < 0) {
+            udiv = -udiv;
+            xsign = -1;
+        }
 
-                for (int i = 12; i < 16; ++i) {
-                    token_buf[i] = idx + ctz(S);
-                    S &= S - 1;
-                }
+        const int32_t nssize = num->get_ssize();
 
-                if (WJR_LIKELY(num <= 16)) {
-                    break;
-                }
+        uint64_t remv = __tdiv_qr_ui_impl(quot, rem, num, udiv);
 
-                for (int i = 16; i < num; ++i) {
-                    token_buf[i] = idx + ctz(S);
-                    S &= S - 1;
-                }
-            } while (0);
+        quot->conditional_negate(xsign);
 
-            token_buf += num;
-            count += num;
+        if ((nssize ^ xsign) < 0 && remv != 0) {
+            __sub_impl(quot, quot->__get_data(), 1u);
+            rem->set_ssize(__fasts_conditional_negate(xsign < 0, 1));
+            remv = div - remv;
+            rem->front() = remv;
         }
 
-        idx += 64;
+        return remv;
+    }
+}
 
-        if constexpr (!__is_dynamic) {
-            loop = (count <= token_buf_size);
-        } else {
-            loop = first != last;
-        }
+template <typename S, typename T, WJR_REQUIRES_I(is_nonbool_integral_v<T>)>
+uint64_t __fdiv_q_impl(basic_biginteger<S> *quot, const biginteger_data *num,
+                       T div) noexcept {
+    if constexpr (std::is_unsigned_v<T>) {
+        const auto xssize = num->get_ssize();
 
-    } while (WJR_LIKELY(loop));
+        uint64_t remv = __tdiv_q_ui_impl(quot, num, div);
 
-    if constexpr (!__is_dynamic) {
-        m_storage.first = first;
-        m_storage.prev_is_escape = prev_is_escape;
-        m_storage.prev_in_string = prev_in_string;
-        m_storage.prev_is_ws = prev_is_ws;
-        m_storage.idx = idx;
-    }
+        if (xssize < 0 && remv != 0) {
+            __sub_impl(quot, quot->__get_data(), 1u);
+            remv = div - remv;
+        }
 
-    if constexpr (!__is_dynamic) {
-        return count & (token_buf_mask - 1);
+        return remv;
     } else {
-        return count;
-    }
-}
-
-#endif
-
-} // namespace wjr::json
+        uint64_t udiv = to_unsigned(div);
+        int32_t xsign = 0;
 
-#endif // WJR_X86_JSON_LEXER_HPP__
-#endif
+        if (div < 0) {
+            udiv = -udiv;
+            xsign = -1;
+        }
 
-namespace wjr::json {
+        const int32_t nssize = num->get_ssize();
 
-#if !WJR_HAS_BUILTIN(JSON_LEXER_READER_READ_BUF)
+        uint64_t remv = __tdiv_q_ui_impl(quot, num, udiv);
 
-namespace lexer_details {
+        quot->conditional_negate(xsign);
 
-const static std::array<uint8_t, 256> code_table = {
-    4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 4, 4, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-    4, 4, 4, 3, 4, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-    2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-    4, 4, 4, 4, 2, 0, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-    4, 4, 4, 4, 4, 4, 4, 2, 4, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4};
+        if ((nssize ^ xsign) < 0 && remv != 0) {
+            __sub_impl(quot, quot->__get_data(), 1u);
+            remv = div - remv;
+        }
 
+        return remv;
+    }
 }
 
-template <uint32_t token_buf_size>
-uint32_t basic_lexer<token_buf_size>::read(uint32_t *token_buf) noexcept {
-    WJR_UNREACHABLE();
-    if (WJR_UNLIKELY(m_storage.first == m_storage.last)) {
-        return 0;
-    }
+template <typename S, typename T, WJR_REQUIRES_I(is_nonbool_integral_v<T>)>
+uint64_t __fdiv_r_impl(basic_biginteger<S> *rem, const biginteger_data *num,
+                       uint64_t div) noexcept {
+    if constexpr (std::is_unsigned_v<T>) {
+        const auto xssize = num->get_ssize();
 
-    using namespace lexer_details;
+        uint64_t remv = __tdiv_r_ui_impl(rem, num, div);
 
-    constexpr uint32_t token_buf_mask = token_buf_size * 2;
+        if (xssize < 0 && remv != 0) {
+            WJR_ASSERT(rem->is_negate());
 
-    auto first = m_storage.first;
-    const auto last = m_storage.last;
-    uint64_t prev_is_escape;
-    uint64_t prev_in_string;
-    uint64_t prev_is_ws;
-    uint32_t idx;
+            rem->set_ssize(1);
+            remv = div - remv;
+            rem->front() = remv;
+        }
 
-    if constexpr (__is_dynamic) {
-        prev_is_escape = prev_in_string = prev_is_ws = idx = 0;
+        return remv;
     } else {
-        prev_is_escape = m_storage.prev_is_escape;
-        prev_in_string = m_storage.prev_in_string;
-        prev_is_ws = m_storage.prev_is_ws;
-        idx = m_storage.idx;
-    }
-
-    WJR_ASSERT_ASSUME_L2(first < last);
+        uint64_t udiv = to_unsigned(div);
+        int32_t xsign = 0;
 
-    uint32_t count = 0;
-    bool loop;
+        if (div < 0) {
+            udiv = -udiv;
+            xsign = -1;
+        }
 
-    do {
-        const char *ptr;
-        char stk[64];
-        const size_t diff = last - first;
+        const int32_t nssize = num->get_ssize();
 
-        if (WJR_LIKELY(diff > 64)) {
-            ptr = first;
-            first += 64;
-        } else {
-            if (diff == 64) {
-                ptr = first;
-            } else {
-                std::memcpy(stk, first, diff);
-                std::memset(stk + diff, 0, 64 - diff);
-                ptr = stk;
-            }
+        uint64_t remv = __tdiv_r_ui_impl(rem, num, udiv);
 
-            first = last;
-            if constexpr (!__is_dynamic) {
-                count |= token_buf_mask;
-            }
+        if ((nssize ^ xsign) < 0 && remv != 0) {
+            rem->set_ssize(__fasts_conditional_negate(xsign < 0, 1));
+            remv = div - remv;
+            rem->front() = remv;
         }
 
-        uint64_t MASK[5] = {0, 0, 0, 0, 0};
-        auto &[B, Q, S, W, UNUSED] = MASK;
-
-        WJR_UNROLL(8)
-        for (int i = 0; i < 64; ++i) {
-            MASK[code_table[(uint8_t)ptr[i]]] |= 1ull << i;
-        }
+        return remv;
+    }
+}
 
-        {
-            if (!B) {
-                B = prev_is_escape;
-                Q &= ~B;
-                prev_is_escape = 0;
-            } else {
-                const uint64_t codeB = calc_backslash(B & ~prev_is_escape);
-                const auto escape = (codeB & B) >> 63;
-                B = codeB ^ (B | prev_is_escape);
-                Q &= ~B;
-                prev_is_escape = escape;
-            }
-        }
+template <typename S0, typename S1>
+void __cdiv_qr_impl(basic_biginteger<S0> *quot, basic_biginteger<S1> *rem,
+                    const biginteger_data *num, const biginteger_data *div) noexcept {
 
-        const uint64_t R = prefix_xor(Q) ^ prev_in_string;
-        S &= ~R;
-        prev_in_string = static_cast<uint64_t>(static_cast<int64_t>(R) >> 63);
+    WJR_ASSERT_ASSUME(!__equal_pointer(quot, rem), "quot should not be the same as rem");
 
-        S |= Q;
-        const auto WS = S | W;
-        const auto P = shld(WS, prev_is_ws, 1);
-        prev_is_ws = WS;
+    unique_stack_allocator stkal(math_details::stack_alloc);
 
-        S |= (P ^ W) & ~R;
-        S &= ~(Q & ~R);
+    biginteger_data tmp_div;
 
-        if (S) {
-            const auto num = popcount(S);
+    const auto dssize = div->get_ssize();
 
-            do {
-                for (int i = 0; i < 4; ++i) {
-                    token_buf[i] = idx + ctz(S);
-                    S &= S - 1;
-                }
+    if (__equal_pointer(div, quot) || __equal_pointer(div, rem)) {
+        const auto dusize = __fasts_abs(dssize);
+        const auto ptr = (uint64_t *)stkal.allocate(dusize * sizeof(uint64_t));
+        tmp_div = {ptr, dssize, 0};
+        std::copy_n(div->data(), dusize, ptr);
 
-                if (WJR_UNLIKELY(num <= 4)) {
-                    break;
-                }
+        div = &tmp_div;
+    }
 
-                for (int i = 4; i < 8; ++i) {
-                    token_buf[i] = idx + ctz(S);
-                    S &= S - 1;
-                }
+    const auto xsize = num->get_ssize() ^ dssize;
 
-                if (WJR_LIKELY(num <= 8)) {
-                    break;
-                }
+    __tdiv_qr_impl(quot, rem, num, div);
 
-                for (int i = 8; i < 12; ++i) {
-                    token_buf[i] = idx + ctz(S);
-                    S &= S - 1;
-                }
+    if (xsize >= 0 && !rem->empty()) {
+        __add_impl(quot, quot->__get_data(), 1u);
+        __sub_impl(rem, rem->__get_data(), div);
+    }
+}
 
-                if (WJR_LIKELY(num <= 12)) {
-                    break;
-                }
+template <typename S>
+void __cdiv_q_impl(basic_biginteger<S> *quot, const biginteger_data *num,
+                   const biginteger_data *div) noexcept {
+    unique_stack_allocator stkal(math_details::stack_alloc);
+    stack_biginteger rem(stkal);
 
-                for (int i = 12; i < 16; ++i) {
-                    token_buf[i] = idx + ctz(S);
-                    S &= S - 1;
-                }
+    const auto xsize = num->get_ssize() ^ div->get_ssize();
 
-                if (WJR_LIKELY(num <= 16)) {
-                    break;
-                }
+    __tdiv_qr_impl(quot, &rem, num, div);
 
-                for (int i = 16; i < num; ++i) {
-                    token_buf[i] = idx + ctz(S);
-                    S &= S - 1;
-                }
-            } while (0);
+    if (xsize >= 0 && !rem.empty()) {
+        __add_impl(quot, quot->__get_data(), 1u);
+    }
+}
 
-            token_buf += num;
-            count += num;
-        }
+template <typename S>
+void __cdiv_r_impl(basic_biginteger<S> *rem, const biginteger_data *num,
+                   const biginteger_data *div) noexcept {
+    unique_stack_allocator stkal(math_details::stack_alloc);
 
-        idx += 64;
+    biginteger_data tmp_div;
 
-        if constexpr (!__is_dynamic) {
-            loop = (count <= token_buf_size);
-        } else {
-            loop = first != last;
-        }
+    const auto dssize = div->get_ssize();
 
-    } while (WJR_LIKELY(loop));
+    if (__equal_pointer(div, rem)) {
+        const auto dusize = __fasts_abs(dssize);
+        const auto ptr = (uint64_t *)stkal.allocate(dusize * sizeof(uint64_t));
+        tmp_div = {ptr, dssize, 0};
+        std::copy_n(div->data(), dusize, ptr);
 
-    if constexpr (!__is_dynamic) {
-        m_storage.first = first;
-        m_storage.prev_is_escape = prev_is_escape;
-        m_storage.prev_in_string = prev_in_string;
-        m_storage.prev_is_ws = prev_is_ws;
-        m_storage.idx = idx;
+        div = &tmp_div;
     }
 
-    if constexpr (!__is_dynamic) {
-        return count & (token_buf_mask - 1);
-    } else {
-        return count;
+    const auto xsize = num->get_ssize() ^ dssize;
+
+    __tdiv_r_impl(rem, num, div);
+
+    if (xsize >= 0 && !rem->empty()) {
+        __sub_impl(rem, rem->__get_data(), div);
     }
 }
-#endif
 
-} // namespace wjr::json
+template <typename S0, typename S1, typename T, WJR_REQUIRES_I(is_nonbool_integral_v<T>)>
+uint64_t __cdiv_qr_impl(basic_biginteger<S0> *quot, basic_biginteger<S1> *rem,
+                        const biginteger_data *num, T div) noexcept {
+    if constexpr (std::is_unsigned_v<T>) {
+        const auto xssize = num->get_ssize();
 
-#endif // WJR_JSON_LEXER_HPP__
-#ifndef WJR_JSON_PARSER_HPP__
-#define WJR_JSON_PARSER_HPP__
+        uint64_t remv = __tdiv_qr_ui_impl(quot, rem, num, div);
 
-#include <bitset>
-#include <charconv>
+        if (xssize >= 0 && remv != 0) {
+            WJR_ASSERT(rem->is_negate());
 
-// Already included
-// Already included
+            __add_impl(quot, quot->__get_data(), 1u);
+            rem->set_ssize(-1);
+            remv = div - remv;
+            rem->front() = remv;
+        }
 
-namespace wjr::json {
-
-enum error_code : unsigned int {
-    SUCCESS,
-    FAILURE,
-};
-
-struct in_place_token_null_t {};
-struct in_place_token_true_t {};
-struct in_place_token_false_t {};
-struct in_place_token_number_t {};
-struct in_place_token_string_t {};
-struct in_place_token_left_bracket_t {};
-struct in_place_token_left_brace_t {};
-struct in_place_token_left_brace_string_t {};
-struct in_place_token_right_bracket_back_bracket_t {};
-struct in_place_token_right_bracket_back_brace_t {};
-struct in_place_token_right_bracket_back_root_t {};
-struct in_place_token_right_brace_back_bracket_t {};
-struct in_place_token_right_brace_back_brace_t {};
-struct in_place_token_right_brace_back_root_t {};
-
-struct in_place_token_success_t {};
-
-template <error_code ec>
-struct in_place_token_failure_t {};
-
-struct in_place_token_repeat_t {};
-
-inline constexpr in_place_token_null_t in_place_token_null{};
-inline constexpr in_place_token_true_t in_place_token_true{};
-inline constexpr in_place_token_false_t in_place_token_false{};
-inline constexpr in_place_token_number_t in_place_token_number{};
-inline constexpr in_place_token_string_t in_place_token_string{};
-inline constexpr in_place_token_left_bracket_t in_place_token_left_bracket{};
-inline constexpr in_place_token_left_brace_t in_place_token_left_brace{};
-inline constexpr in_place_token_left_brace_string_t in_place_token_left_brace_string{};
-inline constexpr in_place_token_right_bracket_back_bracket_t
-    in_place_token_right_bracket_back_bracket{};
-inline constexpr in_place_token_right_bracket_back_brace_t
-    in_place_token_right_bracket_back_brace{};
-inline constexpr in_place_token_right_bracket_back_root_t
-    in_place_token_right_bracket_back_root{};
-inline constexpr in_place_token_right_brace_back_bracket_t
-    in_place_token_right_brace_back_bracket{};
-inline constexpr in_place_token_right_brace_back_brace_t
-    in_place_token_right_brace_back_brace{};
-inline constexpr in_place_token_right_brace_back_root_t
-    in_place_token_right_brace_back_root{};
-
-inline constexpr in_place_token_success_t in_place_token_success{};
-
-template <error_code ec>
-inline constexpr in_place_token_failure_t<ec> in_place_token_failure{};
-
-inline constexpr in_place_token_repeat_t in_place_token_repeat{};
-
-template <uint32_t token_buf_size>
-class forward_token_reader {
-public:
-    forward_token_reader(span<const char> sp, uint32_t *token_buf)
-        : token_first(token_buf), token_last(token_buf), token_buf(token_buf),
-          first(sp.data()), lexer(sp) {}
+        return remv;
+    } else {
+        uint64_t udiv = to_unsigned(div);
+        int32_t xsign = 0;
 
-    WJR_INTRINSIC_INLINE bool operator()(uint32_t &token) {
-        if (WJR_LIKELY(token_first != token_last)) {
-            token = *token_first++;
-            return true;
+        if (div < 0) {
+            udiv = -udiv;
+            xsign = -1;
         }
 
-        return read_more(token);
-    }
+        const int32_t nssize = num->get_ssize();
 
-    WJR_PURE const char *begin() const noexcept { return first; }
-    WJR_PURE const char *end() const noexcept { return lexer.end(); }
+        uint64_t remv = __tdiv_qr_ui_impl(quot, rem, num, udiv);
 
-private:
-    WJR_NOINLINE bool read_more(uint32_t &token) {
-        uint32_t count = lexer.read(token_buf);
-        if (WJR_UNLIKELY(count == 0)) {
-            return false;
+        quot->conditional_negate(xsign);
+
+        if ((nssize ^ xsign) >= 0 && remv != 0) {
+            __add_impl(quot, quot->__get_data(), 1u);
+            rem->set_ssize(__fasts_conditional_negate(xsign >= 0, 1));
+            remv = div - remv;
+            rem->front() = remv;
         }
 
-        token_first = token_buf;
-        token_last = token_buf + count;
-        token = *token_first++;
-        return true;
+        return remv;
     }
+}
 
-    uint32_t *token_first;
-    uint32_t *token_last;
-    uint32_t *token_buf;
-    const char *first;
-    basic_lexer<token_buf_size> lexer;
-};
-
-/**
- * @details Return true if parsing needs to be terminated.
- *
- */
-struct empty_parser {
-    bool operator()(in_place_token_null_t, const char *, const char *) { return false; }
+template <typename S, typename T, WJR_REQUIRES_I(is_nonbool_integral_v<T>)>
+uint64_t __cdiv_q_impl(basic_biginteger<S> *quot, const biginteger_data *num,
+                       T div) noexcept {
+    if constexpr (std::is_unsigned_v<T>) {
+        const auto xssize = num->get_ssize();
 
-    bool operator()(in_place_token_true_t, const char *, const char *) { return false; }
+        uint64_t remv = __tdiv_q_ui_impl(quot, num, div);
 
-    bool operator()(in_place_token_false_t, const char *, const char *) { return false; }
+        if (xssize >= 0 && remv != 0) {
+            __add_impl(quot, quot->__get_data(), 1u);
+            remv = div - remv;
+        }
 
-    bool operator()(in_place_token_number_t, const char *, const char *) { return false; }
+        return remv;
+    } else {
+        uint64_t udiv = to_unsigned(div);
+        int32_t xsign = 0;
 
-    bool operator()(in_place_token_string_t, const char *, const char *) { return false; }
+        if (div < 0) {
+            udiv = -udiv;
+            xsign = -1;
+        }
 
-    bool operator()(in_place_token_left_bracket_t) { return false; }
+        const int32_t nssize = num->get_ssize();
 
-    bool operator()(in_place_token_left_brace_t) { return false; }
+        uint64_t remv = __tdiv_q_ui_impl(quot, num, udiv);
 
-    bool operator()(in_place_token_left_brace_string_t, const char *, const char *) {
-        return false;
-    }
+        quot->conditional_negate(xsign);
 
-    bool operator()(in_place_token_right_bracket_back_bracket_t) { return false; }
+        if ((nssize ^ xsign) >= 0 && remv != 0) {
+            __add_impl(quot, quot->__get_data(), 1u);
+            remv = div - remv;
+        }
 
-    bool operator()(in_place_token_right_bracket_back_brace_t, const char *,
-                    const char *) {
-        return false;
+        return remv;
     }
+}
 
-    bool operator()(in_place_token_right_bracket_back_root_t) { return false; }
+template <typename S, typename T, WJR_REQUIRES_I(is_nonbool_integral_v<T>)>
+uint64_t __cdiv_r_impl(basic_biginteger<S> *rem, const biginteger_data *num,
+                       uint64_t div) noexcept {
+    if constexpr (std::is_unsigned_v<T>) {
+        const auto xssize = num->get_ssize();
 
-    bool operator()(in_place_token_right_brace_back_bracket_t) { return false; }
+        uint64_t remv = __tdiv_r_ui_impl(rem, num, div);
 
-    bool operator()(in_place_token_right_brace_back_brace_t, const char *, const char *) {
-        return false;
-    }
+        if (xssize >= 0 && remv != 0) {
+            WJR_ASSERT(rem->is_negate());
 
-    bool operator()(in_place_token_right_brace_back_root_t) { return false; }
+            rem->set_ssize(-1);
+            remv = div - remv;
+            rem->front() = remv;
+        }
 
-    void operator()(in_place_token_success_t) {}
+        return remv;
+    } else {
+        uint64_t udiv = to_unsigned(div);
+        int32_t xsign = 0;
 
-    template <error_code E>
-    void operator()(in_place_token_failure_t<E>) {}
+        if (div < 0) {
+            udiv = -udiv;
+            xsign = -1;
+        }
 
-    bool operator()(in_place_token_repeat_t) { return false; }
-};
+        const int32_t nssize = num->get_ssize();
 
-struct check_parser : empty_parser {
-    using empty_parser::operator();
+        uint64_t remv = __tdiv_r_ui_impl(rem, num, udiv);
 
-    bool operator()(in_place_token_null_t, const char *first, const char *last) {
-        if (WJR_LIKELY(last - first == 4 && std::memcmp(first, "null", 4) == 0)) {
-            return false;
+        if ((nssize ^ xsign) >= 0 && remv != 0) {
+            rem->set_ssize(__fasts_conditional_negate(xsign >= 0, 1));
+            remv = div - remv;
+            rem->front() = remv;
         }
 
-        ec = FAILURE;
-        return true;
+        return remv;
     }
+}
 
-    bool operator()(in_place_token_true_t, const char *first, const char *last) {
-        if (WJR_LIKELY(last - first == 4 && std::memcmp(first, "true", 4) == 0)) {
-            return false;
-        }
+template <typename S>
+void __tdiv_q_2exp_impl(basic_biginteger<S> *quot, const biginteger_data *num,
+                        uint32_t shift) noexcept {
+    int32_t nssize = num->get_ssize();
+    uint32_t nusize = __fasts_abs(nssize);
+    uint32_t offset = shift / 64;
 
-        ec = FAILURE;
-        return true;
+    int32_t qssize = nusize - offset;
+
+    if (qssize <= 0) {
+        quot->set_ssize(0);
+        return;
     }
 
-    bool operator()(in_place_token_false_t, const char *first, const char *last) {
-        if (WJR_LIKELY(last - first == 5 && std::memcmp(first + 1, "alse", 4) == 0)) {
-            return false;
-        }
+    quot->reserve(qssize);
+    const auto qp = quot->data();
+    const auto np = num->data();
 
-        ec = FAILURE;
-        return true;
-    }
+    (void)rshift_n(qp, np + offset, qssize, shift % 64);
+    qssize -= qp[qssize - 1] == 0;
 
-    WJR_INTRINSIC_INLINE bool operator()(in_place_token_number_t, const char *first,
-                                         const char *last) {
-        constexpr auto __matches = [](uint8_t ch) { return '0' <= ch && ch <= '9'; };
+    quot->set_ssize(__fasts_conditional_negate<int32_t>(nssize < 0, qssize));
+}
 
-        WJR_ASSERT_ASSUME_L2(first < last);
+template <typename S>
+void __tdiv_r_2exp_impl(basic_biginteger<S> *rem, const biginteger_data *num,
+                        uint32_t shift) noexcept {
+    const int32_t nssize = num->get_ssize();
+    uint32_t nusize = __fasts_abs(nssize);
+    uint32_t offset = shift / 64;
 
-        if (*first == '-') {
-            if (++first == last) {
-                goto FAILED;
-            }
-        }
+    uint32_t rusize;
 
-        if (*first++ == '0') {
-            if (first == last) {
-                return false;
-            }
+    if (nusize <= offset) {
+        rusize = nusize;
+        offset = nusize;
+        rem->reserve(rusize);
+    } else {
+        uint64_t high = num->data()[offset] & (((uint64_t)(1) << (shift % 64)) - 1);
+        if (high != 0) {
+            rusize = offset + 1;
+            rem->reserve(rusize);
+            rem->data()[offset] = high;
         } else {
-            if (first == last) {
-                return false;
-            }
-
-            do {
-                if (WJR_UNLIKELY(!__matches(*first))) {
-                    goto NEXT0;
-                }
-            } while (++first != last);
-            return false;
-        NEXT0 : {}
+            rusize = normalize(num->data(), offset);
+            offset = rusize;
+            rem->reserve(rusize);
         }
+    }
 
-        if (*first == '.') {
-            if (++first == last) {
-                goto FAILED;
-            }
-
-            if (WJR_UNLIKELY(!__matches(*first))) {
-                goto FAILED;
-            }
-
-            while (++first != last) {
-                if (WJR_UNLIKELY(!__matches(*first))) {
-                    goto NEXT1;
-                }
-            }
-            return false;
-        NEXT1 : {}
-        }
+    if (!__equal_pointer(rem, num)) {
+        std::copy_n(num->data(), offset, rem->data());
+    }
 
-        switch (*first) {
-        case 'e':
-        case 'E': {
-            break;
-        }
-        default: {
-            goto FAILED;
-        }
-        }
+    rem->set_ssize(__fasts_conditional_negate<int32_t>(nssize < 0, rusize));
+}
 
-        if (++first == last) {
-            goto FAILED;
-        }
+template <typename S>
+void __cfdiv_q_2exp_impl(basic_biginteger<S> *quot, const biginteger_data *num,
+                         uint32_t shift, int32_t xdir) noexcept {
+    int32_t nssize = num->get_ssize();
+    uint32_t nusize = __fasts_abs(nssize);
+    uint32_t offset = shift / 64;
 
-        if (*first == '+' || *first == '-') {
-            if (++first == last) {
-                goto FAILED;
-            }
-        }
+    int32_t qssize = nusize - offset;
 
-        if (WJR_UNLIKELY(!__matches(*first))) {
-            goto FAILED;
+    if (qssize <= 0) {
+        if (nssize == 0) {
+            quot->set_ssize(0);
+            return;
         }
 
-        while (++first != last) {
-            if (WJR_UNLIKELY(!__matches(*first))) {
-                goto FAILED;
-            }
-        }
+        quot->reserve(1);
+        quot->front() = 1;
 
-        return false;
-    FAILED : {
-        ec = FAILURE;
-        return true;
-    }
+        quot->set_ssize((nssize ^ xdir) < 0 ? 0 : xdir);
+        return;
     }
 
-    WJR_INTRINSIC_INLINE bool operator()(in_place_token_string_t, const char *first,
-                                         const char *last) {
-        while (first != last) {
-            uint8_t ch = *first++;
-            if (WJR_UNLIKELY(ch < 32 || ch == 127)) {
-                goto FAILED;
-            }
+    quot->reserve(qssize + 1);
+    const auto qp = quot->data();
+    const auto np = num->data();
 
-            if (WJR_UNLIKELY(ch == '\\')) {
-                if (WJR_UNLIKELY(first == last)) {
-                    goto FAILED;
-                }
+    uint64_t xmask = (nssize ^ xdir) < 0 ? 0 : (uint64_t)in_place_max;
+    uint64_t round = 0;
 
-                ch = *first++;
-                switch (ch) {
-                case '"':
-                case '\\':
-                case '/':
-                case 'b':
-                case 'f':
-                case 'n':
-                case 'r':
-                case 't': {
-                    break;
-                }
-                case 'u': {
-                    if (WJR_UNLIKELY(first + 4 > last)) {
-                        goto FAILED;
-                    }
+    if (xmask) {
+        // all is zero, then round is zero
+        round = find_not_n(np, 0, offset) == offset ? 0 : 1;
+    }
 
-                    for (int i = 0; i < 4; ++i) {
-                        ch = *first++;
-                        if (WJR_UNLIKELY(!('0' <= ch && ch <= '9') &&
-                                         !('a' <= ch && ch <= 'f') &&
-                                         !('A' <= ch && ch <= 'F'))) {
-                            goto FAILED;
-                        }
-                    }
+    round |= xmask & rshift_n(qp, np + offset, qssize, shift % 64);
+    qssize -= qp[qssize - 1] == 0;
 
-                    break;
-                }
-                default: {
-                    goto FAILED;
-                }
-                }
+    if (WJR_LIKELY(round != 0)) {
+        if (WJR_LIKELY(qssize != 0)) {
+            const auto cf = addc_1(qp, qp, qssize, 1u);
+            if (cf != 0) {
+                qp[qssize] = cf;
+                ++qssize;
             }
+        } else {
+            qp[0] = 1;
+            qssize = 1;
         }
-
-        return false;
-
-    FAILED : {
-        ec = FAILURE;
-        return true;
-    }
-    }
-
-    template <error_code E>
-    void operator()(in_place_token_failure_t<E>) {
-        ec = E;
     }
 
-    error_code ec = SUCCESS;
-};
-
-/**
- * @param parser Return type of
- * success_t/failure_t/left_bracket_t/right_bracket_t/left_brace_t/right_brace_t must be
- * void. Otherwise, return type must be bool.
- *
- */
-template <typename TokenReader, typename Parser>
-WJR_NOINLINE void reader_parse(TokenReader &reader, Parser &parser) {
-    unique_stack_allocator stkal(math_details::stack_alloc);
-
-    struct stack {
-        uint8_t type;
-        const char *first;
-        const char *last;
-    };
-
-    stack *stk = static_cast<stack *>(stkal.allocate(512 * sizeof(stack)));
-    stack *current = stk;
-    uint8_t type;
+    quot->set_ssize(__fasts_conditional_negate<int32_t>(nssize < 0, qssize));
+}
 
-    uint32_t token, next_token;
-    const char *const ptr = reader.begin();
-    const char *const last = reader.end();
-    const auto size = last - ptr;
+template <typename S>
+void __cfdiv_r_2exp_impl(basic_biginteger<S> *rem, const biginteger_data *num,
+                         uint32_t shift, int32_t xdir) noexcept {
+    int32_t nssize = num->get_ssize();
 
-    // empty json
-    if (WJR_UNLIKELY(!reader(token))) {
-        return parser(in_place_token_failure<FAILURE>);
+    if (nssize == 0) {
+        rem->set_ssize(0);
+        return;
     }
 
-REPEAT_TOKEN : {
-    switch (ptr[token]) {
-    case 'n': {
-        if (WJR_UNLIKELY(!reader(next_token))) {
-            next_token = size;
-        }
-
-        if (WJR_UNLIKELY(parser(in_place_token_null, ptr + token, ptr + next_token))) {
-            return;
-        }
-
-        break;
-    }
-    case 't': {
-        if (WJR_UNLIKELY(!reader(next_token))) {
-            next_token = size;
-        }
+    uint32_t nusize = __fasts_abs(nssize);
+    uint32_t offset = shift / 64;
+    shift %= 64;
 
-        if (WJR_UNLIKELY(parser(in_place_token_true, ptr + token, ptr + next_token))) {
-            return;
-        }
+    uint64_t *rp;
+    auto np = (uint64_t *)(num->data());
 
-        break;
-    }
-    case 'f': {
-        if (WJR_UNLIKELY(!reader(next_token))) {
-            next_token = size;
-        }
+    if ((nssize ^ xdir) < 0) {
+        if (__equal_pointer(rem, num)) {
+            if (nusize <= offset) {
+                return;
+            }
 
-        if (WJR_UNLIKELY(parser(in_place_token_false, ptr + token, ptr + next_token))) {
-            return;
-        }
+            rp = np;
+        } else {
+            const auto size = std::min<uint32_t>(nusize, offset + 1);
+            rem->reserve(size);
+            rp = rem->data();
+            std::copy_n(np, size, rp);
 
-        break;
-    }
-    case '0':
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-    case '8':
-    case '9':
-    case '-': {
-        if (WJR_UNLIKELY(!reader(next_token))) {
-            next_token = size;
+            if (nusize <= offset) {
+                rem->set_ssize(nssize);
+                return;
+            }
         }
+    } else {
+        do {
+            if (nusize <= offset) {
+                break;
+            }
 
-        type = 0;
-        goto NUMBER;
-    }
-    case '"': {
-        if (WJR_UNLIKELY(!reader(next_token))) {
-            next_token = size;
-        }
+            if (find_not_n(np, 0, offset) != offset) {
+                break;
+            }
 
-        type = 0;
-        goto STRING;
-    }
-    case '[': {
-        if (WJR_UNLIKELY(parser(in_place_token_left_bracket))) {
-            return;
-        }
+            if ((np[offset] & (((uint64_t)(1) << shift) - 1)) != 0) {
+                break;
+            }
 
-        goto ARRAY;
-    }
-    case '{': {
-        if (WJR_UNLIKELY(parser(in_place_token_left_brace))) {
+            rem->set_ssize(0);
             return;
-        }
+        } while (0);
 
-        goto OBJECT;
-    }
-    default: {
-        return parser(in_place_token_failure<FAILURE>);
-    }
-    }
+        rem->reserve(offset + 1);
+        rp = rem->data();
+        np = (uint64_t *)(num->data());
 
-REPEAT_TOKEN_NEXT:
+        const auto size = std::min<uint32_t>(nusize, offset + 1);
+        (void)negate_n(rp, np, size);
+        for (uint32_t i = size; i <= offset; ++i) {
+            rp[i] = in_place_max;
+        }
 
-    if (next_token == size) {
-        return parser(in_place_token_success);
+        nssize = -nssize;
     }
 
-    // non-repeated callback
-    if (parser(in_place_token_repeat)) {
-        return parser(in_place_token_failure<FAILURE>);
-    }
+    uint64_t hi = rp[offset] & (((uint64_t)(1) << shift) - 1);
+    rp[offset] = hi;
 
-    // non-structural token, must be followed by space
-    switch (ptr[next_token]) {
-    case ' ':
-    case '\n':
-    case '\t':
-    case '\r': {
-        if (!reader(token)) {
-            return parser(in_place_token_success);
-        }
-        break;
-    }
-    default: {
-        return parser(in_place_token_failure<FAILURE>);
-    }
+    if (hi == 0) {
+        offset = normalize(rp, offset);
+    } else {
+        ++offset;
     }
 
-    goto REPEAT_TOKEN;
+    rem->set_ssize(__fasts_conditional_negate<int32_t>(nssize < 0, offset));
 }
 
-ARRAY : {
-    if (WJR_UNLIKELY(!reader(token))) {
-        return parser(in_place_token_failure<FAILURE>);
-    }
+template <typename S, typename Engine,
+          WJR_REQUIRES_I(biginteger_uniform_random_bit_generator_v<Engine>)>
+void __urandom_bit_impl(basic_biginteger<S> *dst, uint32_t size,
+                        Engine &engine) noexcept {
+    const uint32_t dusize = size / 64;
+    size %= 64;
+    uint32_t dssize = dusize + (size != 0);
 
-    switch (ptr[token]) {
-    case 'n': {
-        if (WJR_UNLIKELY(!reader(next_token))) {
-            return parser(in_place_token_failure<FAILURE>);
-        }
+    dst->reserve(dssize);
+    const auto dp = dst->data();
 
-        if (WJR_UNLIKELY(parser(in_place_token_null, ptr + token, ptr + next_token))) {
-            return;
+    do {
+        for (uint64_t i = 0; i < dusize; ++i) {
+            dp[i] = engine();
         }
+    } while (0);
 
-        break;
+    if (size != 0) {
+        dp[dusize] = engine() >> (64 - size);
     }
-    case 't': {
-        if (WJR_UNLIKELY(!reader(next_token))) {
-            return parser(in_place_token_failure<FAILURE>);
-        }
 
-        if (WJR_UNLIKELY(parser(in_place_token_true, ptr + token, ptr + next_token))) {
-            return;
-        }
+    dssize = normalize(dp, dssize);
+    dst->set_ssize(dssize);
+}
 
-        break;
+template <typename S, typename Engine,
+          WJR_REQUIRES_I(biginteger_uniform_random_bit_generator_v<Engine>)>
+void __urandom_exact_bit_impl(basic_biginteger<S> *dst, uint32_t size,
+                              Engine &engine) noexcept {
+    if (WJR_UNLIKELY(size == 0)) {
+        dst->set_ssize(0);
+        return;
     }
-    case 'f': {
-        if (WJR_UNLIKELY(!reader(next_token))) {
-            return parser(in_place_token_failure<FAILURE>);
-        }
 
-        if (WJR_UNLIKELY(parser(in_place_token_false, ptr + token, ptr + next_token))) {
-            return;
-        }
+    const uint32_t dusize = (size - 1) / 64;
+    size = (size - 1) % 64;
+    const uint32_t dssize = dusize + 1;
 
-        break;
-    }
-    case '0':
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-    case '8':
-    case '9':
-    case '-': {
-        if (WJR_UNLIKELY(!reader(next_token))) {
-            return parser(in_place_token_failure<FAILURE>);
-        }
+    dst->reserve(dssize);
+    const auto dp = dst->data();
 
-        type = 1;
-        goto NUMBER;
-    }
-    case '"': {
-        if (WJR_UNLIKELY(!reader(next_token))) {
-            return parser(in_place_token_failure<FAILURE>);
+    do {
+        for (uint64_t i = 0; i < dusize; ++i) {
+            dp[i] = engine();
         }
+    } while (0);
 
-        type = 1;
-        goto STRING;
-    }
-    case '[': {
-        if (WJR_UNLIKELY(parser(in_place_token_left_bracket))) {
-            return;
-        }
+    do {
+        uint64_t high = (uint64_t)(1) << size;
 
-        (current++)->type = 0;
-        goto ARRAY;
-    }
-    case '{': {
-        if (WJR_UNLIKELY(parser(in_place_token_left_brace))) {
-            return;
+        if (size != 0) {
+            high |= engine() >> (64 - size);
         }
 
-        (current++)->type = 0;
-        goto OBJECT;
-    }
-    case ']': {
-        goto ARRAY_BACK;
-    }
-    case '}': {
-        return parser(in_place_token_failure<FAILURE>);
-    }
-    default: {
-        return parser(in_place_token_failure<FAILURE>);
-    }
-    }
+        dp[dusize] = high;
+    } while (0);
+
+    dst->set_ssize(dssize);
 }
 
-ARRAY_ELEMENT_SPACE:
-    switch (ptr[next_token]) {
-    case ' ':
-    case '\n':
-    case '\t':
-    case '\r': {
-        if (WJR_UNLIKELY(!reader(next_token))) {
-            return parser(in_place_token_failure<FAILURE>);
-        }
+template <typename S, typename Engine,
+          WJR_REQUIRES_I(biginteger_uniform_random_bit_generator_v<Engine>)>
+void __urandom_impl(basic_biginteger<S> *dst, const biginteger_data *limit,
+                    Engine &engine) noexcept {
+    std::optional<uninitialized<math_details::unique_stack_alloc>> stkal;
+    uint32_t size = limit->size();
 
-        break;
-    }
-    }
+    WJR_ASSERT(size != 0);
 
-ARRAY_ELEMENT : {
-    switch (ptr[next_token]) {
-    case ',': {
-        break;
+    if (WJR_UNLIKELY(size == 1)) {
+        std::uniform_int_distribution<uint64_t> head(0, limit->data()[0] - 1);
+        const uint64_t gen = head(engine);
+
+        dst->reserve(1);
+        dst->front() = gen;
+        dst->set_ssize(gen == 0 ? 0 : 1);
+        return;
     }
-    case ']': {
-    ARRAY_BACK:
-        if (current == stk) {
-            if (parser(in_place_token_right_bracket_back_root) ||
-                parser(in_place_token_repeat)) {
-                return;
-            }
 
-            if (reader(token)) {
-                goto REPEAT_TOKEN;
-            }
+    dst->reserve(size);
 
-            return parser(in_place_token_success);
-        }
+    const auto dp = dst->data();
+    const uint64_t *lp = limit->data();
 
-        if (WJR_UNLIKELY(!reader(next_token))) {
-            return parser(in_place_token_failure<FAILURE>);
-        }
+    if (__equal_pointer(dst, limit)) {
+        stkal.emplace(math_details::stack_alloc);
+        const auto tp = (uint64_t *)(*stkal)->allocate(size * sizeof(uint64_t));
+        std::copy_n(lp, size, tp);
+        lp = tp;
+    }
 
-        type = (--current)->type;
+    const uint32_t lst_pos = size - 1;
+    const uint64_t lst_val = lp[lst_pos];
+    std::uniform_int_distribution<uint64_t> head(0, lst_val);
 
-        if (type == 0) {
-            if (WJR_UNLIKELY(parser(in_place_token_right_bracket_back_bracket))) {
-                return;
-            }
+    while (true) {
+        uint64_t gen = head(engine);
+        uint32_t pos = lst_pos;
 
-            goto ARRAY_ELEMENT;
-        } else {
-            if (WJR_UNLIKELY(parser(in_place_token_right_bracket_back_brace,
-                                    current->first, current->last))) {
-                return;
-            }
+        if (WJR_UNLIKELY(gen == lst_val)) {
+            uint64_t now;
+            do {
+                dp[pos--] = gen;
+                gen = engine();
+                now = lp[pos];
 
-            goto OBJECT_ELEMENT;
-        }
-    }
-    default: {
-        return parser(in_place_token_failure<FAILURE>);
-    }
-    }
+                if (WJR_LIKELY(gen != now)) {
+                    goto NEXT;
+                }
 
-    if (WJR_UNLIKELY(!reader(token))) {
-        return parser(in_place_token_failure<FAILURE>);
-    }
+            } while (pos);
 
-    switch (ptr[token]) {
-    case 'n': {
-        if (WJR_UNLIKELY(!reader(next_token))) {
-            return parser(in_place_token_failure<FAILURE>);
-        }
+            continue;
 
-        if (WJR_UNLIKELY(parser(in_place_token_null, ptr + token, ptr + next_token))) {
-            return;
-        }
+        NEXT:
 
-        break;
-    }
-    case 't': {
-        if (WJR_UNLIKELY(!reader(next_token))) {
-            return parser(in_place_token_failure<FAILURE>);
+            if (gen > now) {
+                continue;
+            }
         }
 
-        if (WJR_UNLIKELY(parser(in_place_token_true, ptr + token, ptr + next_token))) {
-            return;
+        dp[pos] = gen;
+        while (pos) {
+            dp[--pos] = engine();
         }
 
         break;
     }
-    case 'f': {
-        if (WJR_UNLIKELY(!reader(next_token))) {
-            return parser(in_place_token_failure<FAILURE>);
-        }
-
-        if (WJR_UNLIKELY(parser(in_place_token_false, ptr + token, ptr + next_token))) {
-            return;
-        }
 
-        break;
-    }
-    case '0':
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-    case '8':
-    case '9':
-    case '-': {
-        if (WJR_UNLIKELY(!reader(next_token))) {
-            return parser(in_place_token_failure<FAILURE>);
-        }
+    size = normalize(dp, size);
+    dst->set_ssize(size);
 
-        type = 1;
-        goto NUMBER;
+    if (stkal.has_value()) {
+        stkal->reset();
     }
-    case '"': {
-        if (WJR_UNLIKELY(!reader(next_token))) {
-            return parser(in_place_token_failure<FAILURE>);
-        }
+}
 
-        type = 1;
-        goto STRING;
-    }
-    case '[': {
-        if (WJR_UNLIKELY(parser(in_place_token_left_bracket))) {
-            return;
-        }
+template <typename S, typename Engine,
+          WJR_REQUIRES_I(biginteger_uniform_random_bit_generator_v<Engine>)>
+void __urandom_exact_impl(basic_biginteger<S> *dst, const biginteger_data *limit,
+                          Engine &engine) noexcept {
+    std::optional<uninitialized<math_details::unique_stack_alloc>> stkal;
+    uint32_t size = limit->size();
 
-        (current++)->type = 0;
-        goto ARRAY;
-    }
-    case '{': {
-        if (WJR_UNLIKELY(parser(in_place_token_left_brace))) {
+    if (WJR_UNLIKELY(size <= 1)) {
+        if (size == 0) {
+            dst->set_ssize(0);
             return;
         }
 
-        (current++)->type = 0;
-        goto OBJECT;
-    }
-    case ']': {
-        return parser(in_place_token_failure<FAILURE>);
-    }
-    case '}': {
-        return parser(in_place_token_failure<FAILURE>);
-    }
-    default: {
-        return parser(in_place_token_failure<FAILURE>);
-    }
-    }
-
-    goto ARRAY_ELEMENT_SPACE;
-}
-
-OBJECT : {
-    if (WJR_UNLIKELY(!reader(token))) {
-        return parser(in_place_token_failure<FAILURE>);
-    }
-
-    switch (ptr[token]) {
-    case '"': {
-        break;
-    }
-    case '}': {
-        goto OBJECT_BACK;
-    }
-    default: {
-        return parser(in_place_token_failure<FAILURE>);
-    }
-    }
-
-    if (WJR_UNLIKELY(!reader(next_token))) {
-        return parser(in_place_token_failure<FAILURE>);
-    }
+        std::uniform_int_distribution<uint64_t> head(0, limit->data()[0]);
+        const uint64_t gen = head(engine);
 
-    if (WJR_UNLIKELY(next_token - token < 2 ||
-                     parser(in_place_token_left_brace_string, ptr + token + 1,
-                            ptr + next_token - 1))) {
+        dst->reserve(1);
+        dst->front() = gen;
+        dst->set_ssize(gen == 0 ? 0 : 1);
         return;
     }
 
-    switch (ptr[next_token]) {
-    case ' ':
-    case '\n':
-    case '\r':
-    case '\t': {
-        if (WJR_UNLIKELY(!reader(next_token))) {
-            return parser(in_place_token_failure<FAILURE>);
-        }
-
-        break;
-    }
-    }
+    dst->reserve(size);
 
-    if (WJR_UNLIKELY(ptr[next_token] != ':')) {
-        return parser(in_place_token_failure<FAILURE>);
-    }
+    const auto dp = dst->data();
+    const uint64_t *lp = limit->data();
 
-    if (WJR_UNLIKELY(!reader(token))) {
-        return parser(in_place_token_failure<FAILURE>);
+    if (__equal_pointer(dst, limit)) {
+        stkal.emplace(math_details::stack_alloc);
+        const auto tp = (uint64_t *)(*stkal)->allocate(size * sizeof(uint64_t));
+        std::copy_n(lp, size, tp);
+        lp = tp;
     }
 
-    switch (ptr[token]) {
-    case 'n': {
-        if (WJR_UNLIKELY(!reader(next_token))) {
-            return parser(in_place_token_failure<FAILURE>);
-        }
-
-        if (WJR_UNLIKELY(parser(in_place_token_null, ptr + token, ptr + next_token))) {
-            return;
-        }
+    const uint32_t lst_pos = size - 1;
+    const uint64_t lst_val = lp[lst_pos];
+    std::uniform_int_distribution<uint64_t> head(0, lst_val);
 
-        break;
-    }
-    case 't': {
-        if (WJR_UNLIKELY(!reader(next_token))) {
-            return parser(in_place_token_failure<FAILURE>);
-        }
+    while (true) {
+        uint64_t gen = head(engine);
+        uint32_t pos = lst_pos;
 
-        if (WJR_UNLIKELY(parser(in_place_token_true, ptr + token, ptr + next_token))) {
-            return;
-        }
+        if (WJR_UNLIKELY(gen == lst_val)) {
+            uint64_t now;
+            do {
+                dp[pos--] = gen;
+                gen = engine();
+                now = lp[pos];
+            } while (gen == now && pos);
 
-        break;
-    }
-    case 'f': {
-        if (WJR_UNLIKELY(!reader(next_token))) {
-            return parser(in_place_token_failure<FAILURE>);
+            if (gen > now) {
+                continue;
+            }
         }
 
-        if (WJR_UNLIKELY(parser(in_place_token_false, ptr + token, ptr + next_token))) {
-            return;
+        dp[pos] = gen;
+
+        while (pos) {
+            dp[--pos] = engine();
         }
 
         break;
     }
-    case '0':
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-    case '8':
-    case '9':
-    case '-': {
-        if (WJR_UNLIKELY(!reader(next_token))) {
-            return parser(in_place_token_failure<FAILURE>);
-        }
 
-        type = 2;
-        goto NUMBER;
-    }
-    case '"': {
-        if (WJR_UNLIKELY(!reader(next_token))) {
-            return parser(in_place_token_failure<FAILURE>);
-        }
+    size = normalize(dp, size);
+    dst->set_ssize(size);
 
-        type = 2;
-        goto STRING;
+    if (stkal.has_value()) {
+        stkal->reset();
     }
-    case '[': {
-        if (WJR_UNLIKELY(parser(in_place_token_left_bracket))) {
-            return;
-        }
+}
 
-        (current++)->type = 1;
-        goto ARRAY;
+/// @private
+inline uint32_t __bit_width_impl(const biginteger_data *num) noexcept {
+    const uint32_t size = num->size();
+    if (WJR_UNLIKELY(size == 0)) {
+        return 0;
     }
-    case '{': {
-        if (WJR_UNLIKELY(parser(in_place_token_left_brace))) {
-            return;
-        }
 
-        (current++)->type = 1;
-        goto OBJECT;
-    }
-    case ']': {
-        return parser(in_place_token_failure<FAILURE>);
-    }
-    case '}': {
-        return parser(in_place_token_failure<FAILURE>);
-    }
-    default: {
-        return parser(in_place_token_failure<FAILURE>);
-    }
-    }
+    return 64 * size - clz(num->data()[size - 1]);
 }
 
-OBJECT_ELEMENT_SPACE:
-    switch (ptr[next_token]) {
-    case ' ':
-    case '\n':
-    case '\t':
-    case '\r': {
-        if (WJR_UNLIKELY(!reader(next_token))) {
-            return parser(in_place_token_failure<FAILURE>);
-        }
+/// @private
+inline uint32_t __ctz_impl(const biginteger_data *num) noexcept {
+    auto ptr = num->data();
+    uint32_t idx = 0;
+#if WJR_DEBUG_LEVEL > 0
+    const uint32_t size = num->size();
+    for (; ptr[idx] == 0 && idx < size; ++idx)
+        ;
+    WJR_ASSERT(idx != size);
+#else
+    for (; ptr[idx] == 0; ++idx)
+        ;
+#endif
+    return idx * 64 + ctz(ptr[idx]);
+}
 
-        break;
-    }
+template <typename S>
+void __pow_impl(basic_biginteger<S> *dst, const biginteger_data *num,
+                uint32_t exp) noexcept {
+    if (exp == 0) {
+        *dst = 1u;
+        return;
     }
 
-OBJECT_ELEMENT : {
-    switch (ptr[next_token]) {
-    case ',': {
-        break;
+    const uint32_t nbits = __bit_width_impl(num);
+    const uint32_t dbits = nbits * exp;
+    const uint32_t max_dusize = (dbits + 63) / 64;
+
+    dst->reserve(max_dusize);
+    *dst = *num;
+
+    while (!(exp & 1)) {
+        sqr(*dst, *dst);
+        exp >>= 1;
     }
-    case '}': {
-    OBJECT_BACK:
-        if (WJR_UNLIKELY(current == stk)) {
-            if (parser(in_place_token_right_brace_back_root) ||
-                parser(in_place_token_repeat)) {
-                return;
-            }
 
-            if (reader(token)) {
-                goto REPEAT_TOKEN;
-            }
+    if (exp == 1) {
+        return;
+    }
 
-            return parser(in_place_token_success);
-        }
+    basic_biginteger<S> tmp;
+    exp >>= 1;
+    sqr(tmp, *dst);
 
-        if (WJR_UNLIKELY(!reader(next_token))) {
-            return parser(in_place_token_failure<FAILURE>);
-        }
+    if (exp & 1) {
+        mul(*dst, *dst, tmp);
+    }
 
-        type = (--current)->type;
+    if (exp != 1) {
+        do {
+            exp >>= 1;
+            sqr(tmp, tmp);
 
-        if (type == 0) {
-            if (WJR_UNLIKELY(parser(in_place_token_right_brace_back_bracket))) {
-                return;
+            if (exp & 1) {
+                mul(*dst, *dst, tmp);
             }
+        } while (exp != 1);
+    }
+}
 
-            goto ARRAY_ELEMENT;
-        } else {
-            if (WJR_UNLIKELY(parser(in_place_token_right_brace_back_brace, current->first,
-                                    current->last))) {
-                return;
-            }
+/// @private
+template <typename S>
+void __powmod_impl(basic_biginteger<S> *dst, const biginteger_data *num,
+                   __powmod_iterator *iter, const biginteger_data *mod) noexcept {
+    WJR_ASSERT(mod->size() != 0);
 
-            goto OBJECT_ELEMENT;
+    const auto size = iter->size;
+
+    if (size == 0) {
+        uint64_t val;
+        if (WJR_UNLIKELY(mod->size() == 1 && mod->data()[0] == 1)) {
+            val = 0u;
+        } else {
+            val = 1u;
         }
-    }
-    default: {
-        return parser(in_place_token_failure<FAILURE>);
-    }
-    }
 
-    if (WJR_UNLIKELY(!reader(token))) {
-        return parser(in_place_token_failure<FAILURE>);
+        *dst = val;
+        return;
     }
 
-    switch (ptr[token]) {
-    case '"': {
-        break;
-    }
-    default: {
-        return parser(in_place_token_failure<FAILURE>);
-    }
-    }
+    tdiv_r(*dst, *num, *mod);
 
-    if (WJR_UNLIKELY(!reader(next_token))) {
-        return parser(in_place_token_failure<FAILURE>);
+    while (!(iter->get() & 1)) {
+        sqr(*dst, *dst);
+        tdiv_r(*dst, *dst, *mod);
+        iter->next();
     }
 
-    if (WJR_UNLIKELY(next_token - token < 2 ||
-                     parser(in_place_token_left_brace_string, ptr + token + 1,
-                            ptr + next_token - 1))) {
+    if (iter->end()) {
         return;
     }
 
-    switch (ptr[next_token]) {
-    case ' ':
-    case '\n':
-    case '\r':
-    case '\t': {
-        if (WJR_UNLIKELY(!reader(next_token))) {
-            return parser(in_place_token_failure<FAILURE>);
-        }
+    basic_biginteger<S> tmp;
+    iter->next();
+    sqr(tmp, *dst);
+    tdiv_r(tmp, tmp, *mod);
 
-        break;
-    }
+    if (iter->get() & 1) {
+        mul(*dst, *dst, tmp);
+        tdiv_r(*dst, *dst, *mod);
     }
 
-    if (WJR_UNLIKELY(ptr[next_token] != ':')) {
-        return parser(in_place_token_failure<FAILURE>);
-    }
+    if (!iter->end()) {
+        do {
+            iter->next();
+            sqr(tmp, tmp);
+            tdiv_r(tmp, tmp, *mod);
 
-    if (WJR_UNLIKELY(!reader(token))) {
-        return parser(in_place_token_failure<FAILURE>);
+            if (iter->get() & 1) {
+                mul(*dst, *dst, tmp);
+                tdiv_r(*dst, *dst, *mod);
+            }
+        } while (!iter->end());
     }
+}
 
-    switch (ptr[token]) {
-    case 'n': {
-        if (WJR_UNLIKELY(!reader(next_token))) {
-            return parser(in_place_token_failure<FAILURE>);
-        }
+template <typename S>
+void __powmod_impl(basic_biginteger<S> *dst, const biginteger_data *num,
+                   const biginteger_data *exp, const biginteger_data *mod) noexcept {
+    __powmod_iterator iter(exp->data(), exp->size());
+    __powmod_impl(dst, num, &iter, mod);
+}
 
-        if (WJR_UNLIKELY(parser(in_place_token_null, ptr + token, ptr + next_token))) {
-            return;
-        }
+template <typename S>
+void __powmod_impl(basic_biginteger<S> *dst, const biginteger_data *num, uint64_t exp,
+                   const biginteger_data *mod) noexcept {
+    uint64_t tmp[] = {exp};
+    __powmod_iterator iter(tmp, exp == 0 ? 0 : 1);
+    __powmod_impl(dst, num, &iter, mod);
+}
 
-        break;
-    }
-    case 't': {
-        if (WJR_UNLIKELY(!reader(next_token))) {
-            return parser(in_place_token_failure<FAILURE>);
-        }
+} // namespace biginteger_details
 
-        if (WJR_UNLIKELY(parser(in_place_token_true, ptr + token, ptr + next_token))) {
-            return;
-        }
+template <typename S>
+from_chars_result<> from_chars(const char *first, const char *last,
+                               basic_biginteger<S> &dst, unsigned int base) noexcept {
+    return biginteger_details::__from_chars_impl(first, last, &dst, base);
+}
 
-        break;
-    }
-    case 'f': {
-        if (WJR_UNLIKELY(!reader(next_token))) {
-            return parser(in_place_token_failure<FAILURE>);
-        }
+template <typename S>
+void negate(basic_biginteger<S> &dst) noexcept {
+    dst.negate();
+}
 
-        if (WJR_UNLIKELY(parser(in_place_token_false, ptr + token, ptr + next_token))) {
-            return;
-        }
+template <typename S>
+void absolute(basic_biginteger<S> &dst) noexcept {
+    dst.absolute();
+}
 
-        break;
-    }
-    case '0':
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-    case '8':
-    case '9':
-    case '-': {
-        if (WJR_UNLIKELY(!reader(next_token))) {
-            return parser(in_place_token_failure<FAILURE>);
-        }
+template <typename S>
+std::istream &operator>>(std::istream &is, basic_biginteger<S> &dst) noexcept {
+    std::string str;
+    is >> str;
+    from_chars(str.data(), str.data() + str.size(), dst, 0);
+    return is;
+}
 
-        type = 2;
-        goto NUMBER;
-    }
-    case '"': {
-        if (WJR_UNLIKELY(!reader(next_token))) {
-            return parser(in_place_token_failure<FAILURE>);
-        }
+template <typename Traits>
+std::basic_ostream<char, Traits> &operator<<(std::basic_ostream<char, Traits> &os,
+                                             const biginteger_data &src) noexcept {
+    std::ios_base::iostate state = std::ios::goodbit;
 
-        type = 2;
-        goto STRING;
-    }
-    case '[': {
-        if (WJR_UNLIKELY(parser(in_place_token_left_bracket))) {
-            return;
-        }
+    if (const std::ostream::sentry ok(os); ok) {
+        unique_stack_allocator stkal(math_details::stack_alloc);
 
-        (current++)->type = 1;
-        goto ARRAY;
-    }
-    case '{': {
-        if (WJR_UNLIKELY(parser(in_place_token_left_brace))) {
-            return;
-        }
+        vector<char, math_details::weak_stack_alloc<char>> buffer(stkal);
+        buffer.reserve(128);
 
-        (current++)->type = 1;
-        goto OBJECT;
-    }
-    case ']': {
-        return parser(in_place_token_failure<FAILURE>);
-    }
-    case '}': {
-        return parser(in_place_token_failure<FAILURE>);
-    }
-    default: {
-        return parser(in_place_token_failure<FAILURE>);
-    }
-    }
+        const std::ios_base::fmtflags flags = os.flags();
 
-    goto OBJECT_ELEMENT_SPACE;
-}
+        if ((flags & std::ios::showpos) && !src.is_negate()) {
+            buffer.push_back('+');
+        }
 
-NUMBER:
-    if (WJR_UNLIKELY(parser(in_place_token_number, ptr + token, ptr + next_token))) {
-        return;
-    }
+        int base = 10;
 
-    if (type == 1) {
-        goto ARRAY_ELEMENT_SPACE;
-    } else if (type == 2) {
-        goto OBJECT_ELEMENT_SPACE;
-    } else {
-        goto REPEAT_TOKEN_NEXT;
-    }
+        if (const auto basefield = flags & std::ios::basefield; basefield != 0) {
+            if (basefield == std::ios::oct) {
+                base = 8;
+                if (flags & std::ios::showbase) {
+                    buffer.append({'0'});
+                }
+            } else if (basefield == std::ios::hex) {
+                base = 16;
+                if (flags & std::ios::showbase) {
+                    buffer.append({'0', 'x'});
+                }
+            }
+        }
 
-STRING:
-    if (WJR_UNLIKELY(
-            next_token - token < 2 ||
-            parser(in_place_token_string, ptr + token + 1, ptr + next_token - 1))) {
-        return;
-    }
+        (void)to_chars_unchecked(std::back_inserter(buffer), src, base);
 
-    if (type == 1) {
-        goto ARRAY_ELEMENT_SPACE;
-    } else if (type == 2) {
-        goto OBJECT_ELEMENT_SPACE;
-    } else {
-        goto REPEAT_TOKEN_NEXT;
+        if (!buffer.empty()) {
+            __ostream_insert_unchecked(os, buffer.data(), buffer.size());
+        }
     }
-}
-
-template <typename Parser>
-WJR_INTRINSIC_INLINE void parse(span<const char> sp, Parser &parser) {
-    constexpr uint32_t token_buf_size = 1024;
-
-    unique_stack_allocator stkal(math_details::stack_alloc);
-
-    uint32_t *token_buf = static_cast<uint32_t *>(
-        stkal.allocate((token_buf_size * 2 - 1) * sizeof(uint32_t)));
 
-    forward_token_reader<token_buf_size> reader(sp, token_buf);
-    reader_parse(reader, parser);
+    os.setstate(state);
+    return os;
 }
 
-} // namespace wjr::json
+} // namespace wjr
+
+#endif
 
-#endif // WJR_JSON_PARSER_HPP__
+#endif // WJR_BIGINTEGER_HPP__
 // Already included
 // Already included
 // Already included
\ No newline at end of file
diff --git a/include/wjr/assert.hpp b/include/wjr/assert.hpp
index 05b74901..a3e7afcd 100644
--- a/include/wjr/assert.hpp
+++ b/include/wjr/assert.hpp
@@ -59,45 +59,32 @@ WJR_NORETURN extern void __assert_failed(const char *expr, const char *file,
 // LCOV_EXCL_START
 
 /// @private
-class __assert_handler_t {
-private:
-    WJR_NORETURN static void fn(const char *expr, const char *file, const char *func,
-                                int line) noexcept {
-        __assert_failed(expr, file, func, line);
-    }
-
-    template <typename... Args>
-    WJR_NORETURN WJR_NOINLINE static void fn(const char *expr, const char *file,
-                                             const char *func, int line,
-                                             Args &&...args) noexcept {
-        std::cerr << "Additional information: ";
-        (void)(std::cerr << ... << std::forward<Args>(args));
-        std::cerr << '\n';
-        __assert_failed(expr, file, func, line);
-    }
-
-public:
-    template <typename... Args>
-    WJR_NORETURN void operator()(const char *expr, const char *file, const char *func,
-                                 int line, Args &&...args) const noexcept {
-        fn(expr, file, func, line, std::forward<Args>(args)...);
-    }
-};
-
-inline constexpr __assert_handler_t __assert_handler{};
+template <typename... Args>
+WJR_NORETURN WJR_NOINLINE void __assert_handler(const char *expr, const char *file,
+                                                const char *func, int line,
+                                                Args &&...args) noexcept {
+    std::cerr << "Additional information: ";
+    (void)(std::cerr << ... << std::forward<Args>(args));
+    std::cerr << '\n';
+    __assert_failed(expr, file, func, line);
+}
+
+/// @private
+WJR_NORETURN inline void __assert_handler(const char *expr, const char *file,
+                                          const char *func, int line) noexcept {
+    __assert_failed(expr, file, func, line);
+}
 
 // LCOV_EXCL_STOP
 
-#define WJR_ASSERT_CHECK_I_HANDLER(handler, expr, ...)                                   \
+#define WJR_ASSERT_CHECK_I(expr, ...)                                                    \
     do {                                                                                 \
         if (WJR_UNLIKELY(!(expr))) {                                                     \
-            handler(#expr, WJR_FILE, WJR_CURRENT_FUNCTION, WJR_LINE, ##__VA_ARGS__);     \
+            ::wjr::__assert_handler(#expr, WJR_FILE, WJR_CURRENT_FUNCTION, WJR_LINE,     \
+                                    ##__VA_ARGS__);                                      \
         }                                                                                \
     } while (0)
 
-#define WJR_ASSERT_CHECK_I(...)                                                          \
-    WJR_ASSERT_CHECK_I_HANDLER(::wjr::__assert_handler, __VA_ARGS__)
-
 // do nothing
 #define WJR_ASSERT_UNCHECK_I(expr, ...)                                                  \
     do {                                                                                 \
diff --git a/include/wjr/container/intrusive/list.hpp b/include/wjr/container/intrusive/list.hpp
index c63f7fd6..2d7babd5 100644
--- a/include/wjr/container/intrusive/list.hpp
+++ b/include/wjr/container/intrusive/list.hpp
@@ -60,12 +60,6 @@ inline constexpr bool is_list_tag_v = is_list_tag<Tag>::value;
 template <typename Tag>
 using list_obj_t = typename Tag::obj_type;
 
-template <typename Tag, WJR_REQUIRES(is_list_tag_v<Tag>)>
-constexpr list_obj_t<Tag> *get(list_node<Tag> *node) noexcept;
-
-template <typename Tag, WJR_REQUIRES(is_list_tag_v<Tag>)>
-constexpr const list_obj_t<Tag> *get(const list_node<Tag> *node) noexcept;
-
 template <typename T>
 class list_node_const_iterator {
     using node_type = list_node<T>;
@@ -230,22 +224,22 @@ struct list_node {
 
     template <typename U = Tag, WJR_REQUIRES(is_list_tag_v<U>)>
     constexpr list_obj_t<U> *operator->() noexcept {
-        return wjr::get(this);
+        return static_cast<list_obj_t<Tag> *>(this);
     }
 
     template <typename U = Tag, WJR_REQUIRES(is_list_tag_v<U>)>
     constexpr const list_obj_t<U> *operator->() const noexcept {
-        return wjr::get(this);
+        return static_cast<const list_obj_t<Tag> *>(this);
     }
 
     template <typename U = Tag, WJR_REQUIRES(is_list_tag_v<U>)>
     constexpr list_obj_t<U> &operator*() noexcept {
-        return *wjr::get(this);
+        return *operator->();
     }
 
     template <typename U = Tag, WJR_REQUIRES(is_list_tag_v<U>)>
     constexpr const list_obj_t<U> &operator*() const noexcept {
-        return *wjr::get(this);
+        return *operator->();
     }
 
     list_node *m_prev;
@@ -316,16 +310,6 @@ constexpr void replace_uninit(list_node<T> *from, list_node<T> *to) noexcept {
     from->m_next->m_prev = to;
 }
 
-template <typename Tag, WJR_REQUIRES_I(is_list_tag_v<Tag>)>
-constexpr list_obj_t<Tag> *get(list_node<Tag> *node) noexcept {
-    return static_cast<list_obj_t<Tag> *>(node);
-}
-
-template <typename Tag, WJR_REQUIRES_I(is_list_tag_v<Tag>)>
-constexpr const list_obj_t<Tag> *get(const list_node<Tag> *node) noexcept {
-    return static_cast<const list_obj_t<Tag> *>(node);
-}
-
 } // namespace wjr
 
 #endif // WJR_CONTAINER_INTRUSIVE_LIST_HPP__
\ No newline at end of file
diff --git a/include/wjr/math/convert.hpp b/include/wjr/math/convert.hpp
index ac560f66..916ee976 100644
--- a/include/wjr/math/convert.hpp
+++ b/include/wjr/math/convert.hpp
@@ -11,6 +11,7 @@
 #include <wjr/math/div.hpp>
 #include <wjr/math/precompute-chars-convert.hpp>
 #include <wjr/memory/copy.hpp>
+#include <wjr/math/stack_allocator.hpp>
 
 #if defined(WJR_X86)
 #include <wjr/x86/math/convert.hpp>
diff --git a/include/wjr/math/details.hpp b/include/wjr/math/details.hpp
index cc082e93..6a4dc663 100644
--- a/include/wjr/math/details.hpp
+++ b/include/wjr/math/details.hpp
@@ -14,12 +14,8 @@ class de_bruijn {
     constexpr static uint8_t mv = digits == 32 ? 27 : 58;
     constexpr de_bruijn() noexcept : lookup(), lookupr() { initialize(); }
 
-    WJR_INTRINSIC_CONSTEXPR int get(T idx) const noexcept {
-        return lookup[(idx * seed) >> mv];
-    }
-    WJR_INTRINSIC_CONSTEXPR int getr(T idx) const noexcept {
-        return lookupr[(idx * seed) >> mv];
-    }
+    constexpr int get(T idx) const noexcept { return lookup[(idx * seed) >> mv]; }
+    constexpr int getr(T idx) const noexcept { return lookupr[(idx * seed) >> mv]; }
 
 private:
     constexpr void initialize() noexcept {
@@ -42,7 +38,7 @@ inline constexpr de_bruijn<uint64_t, 0x03f7'9d71'b4ca'8b09> de_bruijn64 = {};
 // preview ...
 
 template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-WJR_CONST WJR_INTRINSIC_CONSTEXPR bool is_zero_or_single_bit(T n) noexcept {
+WJR_CONST constexpr bool is_zero_or_single_bit(T n) noexcept {
     return (n & (n - 1)) == 0;
 }
 
@@ -52,12 +48,12 @@ WJR_CONST WJR_INTRINSIC_CONSTEXPR bool is_zero_or_single_bit(T n) noexcept {
  * @note `n & -n` is the lowest bit of n.
  */
 template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-WJR_CONST WJR_INTRINSIC_CONSTEXPR T lowbit(T n) noexcept {
+WJR_CONST constexpr T lowbit(T n) noexcept {
     return n & -n;
 }
 
 template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-WJR_CONST WJR_INTRINSIC_CONSTEXPR T clear_lowbit(T n) noexcept {
+WJR_CONST constexpr T clear_lowbit(T n) noexcept {
     return n & (n - 1);
 }
 
@@ -74,39 +70,35 @@ WJR_CONST constexpr decltype(auto) to_unsigned(Value value) noexcept {
 // preview :
 
 template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-WJR_CONST WJR_INTRINSIC_CONSTEXPR bool __has_high_bit(T n) noexcept {
+WJR_CONST constexpr bool __has_high_bit(T n) noexcept {
     return n >> (std::numeric_limits<T>::digits - 1);
 }
 
 template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-WJR_CONST WJR_INTRINSIC_CONSTEXPR T __ceil_div(T n, type_identity_t<T> div) noexcept {
+WJR_CONST constexpr T __ceil_div(T n, type_identity_t<T> div) noexcept {
     return (n + div - 1) / div;
 }
 
 template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-WJR_CONST WJR_INTRINSIC_CONSTEXPR T __align_down(T n,
-                                                 type_identity_t<T> alignment) noexcept {
+WJR_CONST constexpr T __align_down(T n, type_identity_t<T> alignment) noexcept {
     WJR_ASSERT_ASSUME_L2(is_zero_or_single_bit(alignment));
     return n & (-alignment);
 }
 
 template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-WJR_CONST WJR_INTRINSIC_CONSTEXPR T
-__align_down_offset(T n, type_identity_t<T> alignment) noexcept {
+WJR_CONST constexpr T __align_down_offset(T n, type_identity_t<T> alignment) noexcept {
     WJR_ASSERT_ASSUME_L2(is_zero_or_single_bit(alignment));
     return n & (alignment - 1);
 }
 
 template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-WJR_CONST WJR_INTRINSIC_CONSTEXPR T __align_up(T n,
-                                               type_identity_t<T> alignment) noexcept {
+WJR_CONST constexpr T __align_up(T n, type_identity_t<T> alignment) noexcept {
     WJR_ASSERT_ASSUME_L2(is_zero_or_single_bit(alignment));
     return (n + alignment - 1) & (-alignment);
 }
 
 template <typename T, WJR_REQUIRES(is_nonbool_unsigned_integral_v<T>)>
-WJR_CONST WJR_INTRINSIC_CONSTEXPR T
-__align_up_offset(T n, type_identity_t<T> alignment) noexcept {
+WJR_CONST constexpr T __align_up_offset(T n, type_identity_t<T> alignment) noexcept {
     WJR_ASSERT_ASSUME_L2(is_zero_or_single_bit(alignment));
     return (-n) & (alignment - 1);
 }
diff --git a/include/wjr/math/div-impl.hpp b/include/wjr/math/div-impl.hpp
index 2cdc637a..cab5d681 100644
--- a/include/wjr/math/div-impl.hpp
+++ b/include/wjr/math/div-impl.hpp
@@ -3,8 +3,8 @@
 
 #include <utility>
 
-#include <wjr/tuple.hpp>
-#include <wjr/type_traits.hpp>
+#include <wjr/math/integral_constant.hpp>
+#include <wjr/math/uint128_t.hpp>
 
 namespace wjr {
 
@@ -24,12 +24,11 @@ div128by64to64(uint64_t &rem, uint64_t lo, uint64_t hi,
 WJR_INLINE_CONSTEXPR20 uint64_t div128by64to64(uint64_t &rem, uint64_t lo, uint64_t hi,
                                                uint64_t div) noexcept;
 
-inline tuple<uint64_t, uint64_t>
-div128by64to128(uint64_t &rem, uint64_t lo, uint64_t hi,
-                const div2by1_divider<uint64_t> &divider) noexcept;
+inline uint128_t div128by64to128(uint64_t &rem, uint64_t lo, uint64_t hi,
+                                 const div2by1_divider<uint64_t> &divider) noexcept;
 
-inline tuple<uint64_t, uint64_t> div128by64to128(uint64_t &rem, uint64_t lo, uint64_t hi,
-                                                 uint64_t div) noexcept;
+inline uint128_t div128by64to128(uint64_t &rem, uint64_t lo, uint64_t hi,
+                                 uint64_t div) noexcept;
 
 WJR_INTRINSIC_CONSTEXPR20 void div_qr_1(uint64_t *dst, uint64_t &rem, const uint64_t *src,
                                         size_t n,
diff --git a/include/wjr/math/div.hpp b/include/wjr/math/div.hpp
index 0707565f..ac24461d 100644
--- a/include/wjr/math/div.hpp
+++ b/include/wjr/math/div.hpp
@@ -69,7 +69,7 @@ WJR_INLINE_CONSTEXPR20 uint64_t div128by64to64(uint64_t &rem, uint64_t lo, uint6
     return div128by64to64_impl(rem, lo, hi, wjr::div2by1_divider<uint64_t>(div));
 }
 
-WJR_INLINE_CONSTEXPR20 tuple<uint64_t, uint64_t>
+inline uint128_t
 div128by64to128_noshift(uint64_t &rem, uint64_t lo, uint64_t hi,
                         const div2by1_divider_noshift<uint64_t> &divider) noexcept {
     const auto divisor = divider.get_divisor();
@@ -82,10 +82,10 @@ div128by64to128_noshift(uint64_t &rem, uint64_t lo, uint64_t hi,
 
     q0 = divider.divide(lo, hi);
     rem = hi;
-    return std::make_pair(q0, q1);
+    return {q0, q1};
 }
 
-inline tuple<uint64_t, uint64_t>
+inline uint128_t
 div128by64to128_shift(uint64_t &rem, uint64_t lo, uint64_t hi,
                       const div2by1_divider<uint64_t> &divider) noexcept {
     const auto shift = divider.get_shift();
@@ -101,12 +101,11 @@ div128by64to128_shift(uint64_t &rem, uint64_t lo, uint64_t hi,
     q0 = div.divide(u0, u2);
 
     rem = u2 >> shift;
-    return std::make_pair(q0, q1);
+    return {q0, q1};
 }
 
-inline tuple<uint64_t, uint64_t>
-div128by64to128_impl(uint64_t &rem, uint64_t lo, uint64_t hi,
-                     const div2by1_divider<uint64_t> &divider) noexcept {
+inline uint128_t div128by64to128_impl(uint64_t &rem, uint64_t lo, uint64_t hi,
+                                      const div2by1_divider<uint64_t> &divider) noexcept {
     if (divider.get_shift() == 0) {
         return div128by64to128_noshift(rem, lo, hi, divider);
     }
@@ -118,9 +117,8 @@ div128by64to128_impl(uint64_t &rem, uint64_t lo, uint64_t hi,
  not optimize for divider that is power of 2,
  manually consider whether it needs to be optimized
 */
-inline tuple<uint64_t, uint64_t>
-div128by64to128(uint64_t &rem, uint64_t lo, uint64_t hi,
-                const div2by1_divider<uint64_t> &divider) noexcept {
+inline uint128_t div128by64to128(uint64_t &rem, uint64_t lo, uint64_t hi,
+                                 const div2by1_divider<uint64_t> &divider) noexcept {
     return div128by64to128_impl(rem, lo, hi, divider);
 }
 
@@ -128,8 +126,8 @@ div128by64to128(uint64_t &rem, uint64_t lo, uint64_t hi,
  not optimize for divider that is power of 2,
  manually consider whether it needs to be optimized
 */
-inline tuple<uint64_t, uint64_t> div128by64to128(uint64_t &rem, uint64_t lo, uint64_t hi,
-                                                 uint64_t div) noexcept {
+inline uint128_t div128by64to128(uint64_t &rem, uint64_t lo, uint64_t hi,
+                                 uint64_t div) noexcept {
     return div128by64to128_impl(rem, lo, hi, div2by1_divider<uint64_t>(div));
 }
 
diff --git a/include/wjr/math/mul.hpp b/include/wjr/math/mul.hpp
index f5bfd118..12136398 100644
--- a/include/wjr/math/mul.hpp
+++ b/include/wjr/math/mul.hpp
@@ -9,12 +9,11 @@
 #include <wjr/math/add.hpp>
 #include <wjr/math/bignum-config.hpp>
 #include <wjr/math/bit.hpp>
-#include <wjr/math/div-impl.hpp>
 #include <wjr/math/integral_constant.hpp>
 #include <wjr/math/shift.hpp>
-#include <wjr/math/stack_allocator.hpp>
 #include <wjr/math/sub.hpp>
 #include <wjr/memory/safe_array.hpp>
+#include <wjr/tuple.hpp>
 
 #if defined(WJR_X86)
 #include <wjr/x86/math/mul.hpp>
diff --git a/include/wjr/math/uint128_t.hpp b/include/wjr/math/uint128_t.hpp
new file mode 100644
index 00000000..08ff823d
--- /dev/null
+++ b/include/wjr/math/uint128_t.hpp
@@ -0,0 +1,98 @@
+#ifndef WJR_MATH_UINT128_T_HPP__
+#define WJR_MATH_UINT128_T_HPP__
+
+#include <wjr/type_traits.hpp>
+
+namespace wjr {
+
+/**
+ * @brief temporary uint128_t for divide 128
+ *
+ * @todo implement more functions
+ *
+ */
+struct uint128_t {
+    WJR_CONSTEXPR20 uint128_t() noexcept = default;
+    constexpr uint128_t(const uint128_t &) noexcept = default;
+    constexpr uint128_t(uint128_t &&) noexcept = default;
+    constexpr uint128_t &operator=(const uint128_t &) noexcept = default;
+    constexpr uint128_t &operator=(uint128_t &&) noexcept = default;
+    ~uint128_t() noexcept = default;
+
+    constexpr uint128_t(uint64_t lo, uint64_t hi) noexcept : lo(lo), hi(hi) {}
+
+    template <size_t I>
+    constexpr uint64_t &get() & noexcept {
+        if constexpr (I == 0) {
+            return lo;
+        } else {
+            return hi;
+        }
+    }
+
+    template <size_t I>
+    constexpr const uint64_t &get() const & noexcept {
+        if constexpr (I == 0) {
+            return lo;
+        } else {
+            return hi;
+        }
+    }
+
+    template <size_t I>
+    constexpr uint64_t &&get() && noexcept {
+        if constexpr (I == 0) {
+            return std::move(lo);
+        } else {
+            return std::move(hi);
+        }
+    }
+
+    template <size_t I>
+    constexpr const uint64_t &&get() const && noexcept {
+        if constexpr (I == 0) {
+            return std::move(lo);
+        } else {
+            return std::move(hi);
+        }
+    }
+
+    uint64_t lo;
+    uint64_t hi;
+};
+
+} // namespace wjr
+
+namespace std {
+
+template <>
+struct tuple_size<wjr::uint128_t> : std::integral_constant<size_t, 2> {};
+
+template <size_t I>
+struct tuple_element<I, wjr::uint128_t> {
+    using type = uint64_t;
+};
+
+template <size_t I>
+WJR_NODISCARD constexpr uint64_t &get(wjr::uint128_t &u) noexcept {
+    return u.get<I>();
+}
+
+template <size_t I>
+WJR_NODISCARD constexpr const uint64_t &get(const wjr::uint128_t &u) noexcept {
+    return u.get<I>();
+}
+
+template <size_t I>
+WJR_NODISCARD constexpr uint64_t &&get(wjr::uint128_t &&u) noexcept {
+    return std::move(u).get<I>();
+}
+
+template <size_t I>
+WJR_NODISCARD constexpr const uint64_t &&get(const wjr::uint128_t &&u) noexcept {
+    return std::move(u).get<I>();
+}
+
+} // namespace std
+
+#endif // WJR_MATH_UINT128_T_HPP__
\ No newline at end of file
diff --git a/include/wjr/memory/memory_pool.hpp b/include/wjr/memory/memory_pool.hpp
index f04275f4..8f8e5dfb 100644
--- a/include/wjr/memory/memory_pool.hpp
+++ b/include/wjr/memory/memory_pool.hpp
@@ -2,8 +2,6 @@
 #define WJR_MEMORY_MEMORY_POOL_HPP__
 
 #include <wjr/container/intrusive/list.hpp>
-#include <wjr/crtp/trivially_allocator_base.hpp>
-#include <wjr/math/clz.hpp>
 #include <wjr/memory/details.hpp>
 
 namespace wjr {
@@ -24,9 +22,8 @@ class __default_alloc_template__ {
         char client_data[1];
     };
 
-    struct __list_node : list_node<> {};
-
     struct malloc_chunk {
+        struct __list_node : list_node<> {};
 
         malloc_chunk() noexcept { init(&head); }
         ~malloc_chunk() noexcept {
@@ -52,12 +49,11 @@ class __default_alloc_template__ {
         __list_node head;
     };
 
-    static WJR_INTRINSIC_CONSTEXPR WJR_CONST size_t __round_up(size_t bytes) noexcept {
+    WJR_CONST static constexpr size_t __round_up(size_t bytes) noexcept {
         return (((bytes) + 2048 - 1) & ~(2048 - 1));
     }
 
-    static WJR_INTRINSIC_CONSTEXPR WJR_CONST uint8_t
-    __get_index(uint16_t bytes) noexcept {
+    WJR_CONST static constexpr uint8_t __get_index(uint16_t bytes) noexcept {
         if (bytes <= 256) {
             return memory_pool_details::__ctz_table[(bytes - 1) >> 3];
         }
@@ -65,7 +61,7 @@ class __default_alloc_template__ {
         return memory_pool_details::__ctz_table[(bytes - 1) >> 9] + 6;
     }
 
-    static WJR_INTRINSIC_CONSTEXPR WJR_CONST uint16_t __get_size(uint8_t idx) noexcept {
+    WJR_CONST static constexpr uint16_t __get_size(uint8_t idx) noexcept {
         return (uint16_t)(1) << (idx + 3);
     }
 
@@ -99,7 +95,7 @@ class __default_alloc_template__ {
         }
 
         // n must be > 0
-        allocation_result<void *> allocate(size_t n) noexcept {
+        WJR_INTRINSIC_INLINE allocation_result<void *> allocate(size_t n) noexcept {
             if (WJR_LIKELY(n <= 16384)) {
                 return __small_allocate(n);
             }
diff --git a/include/wjr/tuple.hpp b/include/wjr/tuple.hpp
index 747a73a1..3c222cf1 100644
--- a/include/wjr/tuple.hpp
+++ b/include/wjr/tuple.hpp
@@ -63,15 +63,14 @@ class tuple_impl;
 
 template <size_t... Indexs, typename... Args>
 class WJR_EMPTY_BASES tuple_impl<std::index_sequence<Indexs...>, Args...>
-    : capture_leaf<std::tuple_element_t<Indexs, tuple<Args...>>,
+    : capture_leaf<Args,
                    enable_base_identity_t<
                        Indexs, tuple_impl<std::index_sequence<Indexs...>, Args...>>>...,
       enable_special_members_of_args_base<
           tuple_impl<std::index_sequence<Indexs...>, Args...>,
-          capture_leaf<
-              std::tuple_element_t<Indexs, tuple<Args...>>,
-              enable_base_identity_t<
-                  Indexs, tuple_impl<std::index_sequence<Indexs...>, Args...>>>...> {
+          capture_leaf<Args, enable_base_identity_t<
+                                 Indexs, tuple_impl<std::index_sequence<Indexs...>,
+                                                    Args...>>>...> {
     using Sequence = std::index_sequence<Indexs...>;
 
     template <size_t Idx>
@@ -79,9 +78,8 @@ class WJR_EMPTY_BASES tuple_impl<std::index_sequence<Indexs...>, Args...>
                                 enable_base_identity_t<Idx, tuple_impl>>;
 
     using Mybase2 = enable_special_members_of_args_base<
-        tuple_impl<std::index_sequence<Indexs...>, Args...>,
-        capture_leaf<std::tuple_element_t<Indexs, tuple<Args...>>,
-                     enable_base_identity_t<Indexs, tuple_impl>>...>;
+        tuple_impl<Sequence, Args...>,
+        capture_leaf<Args, enable_base_identity_t<Indexs, tuple_impl>>...>;
 
     constexpr static size_t Size = sizeof...(Args);
 
diff --git a/include/wjr/type_traits.hpp b/include/wjr/type_traits.hpp
index cb8027f7..6a146add 100644
--- a/include/wjr/type_traits.hpp
+++ b/include/wjr/type_traits.hpp
@@ -176,14 +176,6 @@ using uint_t = typename __uint_selector<n>::type;
 template <size_t n>
 using int_t = typename __int_selector<n>::type;
 
-#if WJR_HAS_FEATURE(INT128)
-using int128_t = int_t<128>;
-#endif
-
-#if WJR_HAS_FEATURE(INT128)
-using uint128_t = uint_t<128>;
-#endif
-
 template <size_t n, bool __s>
 using usint_t = std::conditional_t<__s, int_t<n>, uint_t<n>>;
 
diff --git a/src/wjr/math/div.cpp b/src/wjr/math/div.cpp
index acbe345b..8f5486ab 100644
--- a/src/wjr/math/div.cpp
+++ b/src/wjr/math/div.cpp
@@ -1,4 +1,5 @@
 #include <wjr/math/div.hpp>
+#include <wjr/math/stack_allocator.hpp>
 
 namespace wjr {
 
diff --git a/src/wjr/math/mul.cpp b/src/wjr/math/mul.cpp
index b1745cb4..dc956b68 100644
--- a/src/wjr/math/mul.cpp
+++ b/src/wjr/math/mul.cpp
@@ -1,5 +1,6 @@
 #include <wjr/math/div.hpp>
 #include <wjr/math/mul.hpp>
+#include <wjr/math/stack_allocator.hpp>
 
 namespace wjr {
 
diff --git a/src/wjr/x86/math/mul.cpp b/src/wjr/x86/math/mul.cpp
index 385d14e0..3215887f 100644
--- a/src/wjr/x86/math/mul.cpp
+++ b/src/wjr/x86/math/mul.cpp
@@ -1,6 +1,3 @@
-#include <cstddef>
-#include <cstdint>
-
 #include <wjr/assert.hpp>
 #include <wjr/x86/math/mul-impl.hpp>